Rechercher une page de manuel

Chercher une autre page de manuel:

gcc

Autres langues

Langue: fr

Autres versions - même langue

Version: 03/09/2002 (fedora - 25/11/07)

Section: 1 (Commandes utilisateur)

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-sortiefichier-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 uniquement quand le drapeau -pedantic est utilisé.
-Wdisabled-optimization
Avertir si une passe d'optimisation requise est désactivée. Cet avertissement n'indique généralement pas qu'il y ait quelque chose d'anormal dans votre code ; il indique simplement que les optimiseurs de GCC n'ont pas été capables de traiter le code correctement. Souvent, le problème vient du fait que votre code est trop gros ou trop complexe ; GCC refusera d'optimiser des programmes quand l'optimisation elle-même est susceptible de prendre un temps excessif.
-Werror
Traiter les avertissements comme des erreurs.

Options pour déboguer votre programme ou GCC

GCC possède diverses options spéciales qui sont utilisées pour déboguer soit votre programme, soit GCC :

-g
Produire des informations de débogage dans le format natif du système d'exploitation (stabs, COFF, XCOFF, ou DWARF). GDB peut manipuler ces informations de débogage.

Sur la plupart des systèmes utilisant le format stabs, -g autorise l'utilisation d'informations de débogage supplémentaires que seul GDB peut utiliser ; ces informations supplémentaires améliorent le débogage avec GDB mais vont probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme. Si vous voulez contrôler avec certitude s'il faut générer des informations supplémentaires, utilisez -gstabs+, -gstabs, -gxcoff+, -gxcoff, -gdwarf-1+, -gdwarf-1 ou -gvms (voir plus bas).

À la différence de la plupart des autres compilateurs C, GCC vous permet d'utiliser -g avec -O. Les raccourcis empruntés par du code optimisé peuvent occasionnellement produire des résultats surprenants : certaines variables que vous aviez déclarées peuvent ne plus exister du tout ; le flux de contrôle peut brièvement se déplacer à un endroit inattendu, quelques instructions peuvent ne pas être exécutées car elles calculent des résultats de constantes ou leurs valeurs étaient déjà à portée de main ; quelques instructions peuvent s'exécuter dans des endroits différents car elles ont été déplacées hors de boucles.

Néanmoins, cela prouve qu'il est possible de déboguer une sortie optimisée. Cela rend possible l'usage de l'optimiseur pour des programmes qui peuvent êtres bogués.

Les options suivantes sont utiles quand GCC est généré avec la capacité de traiter plus d'un format de débogage.

-ggdb
Produire des informations de débogage destinées à être utilisées par GDB. Cela signifie qu'il faut utiliser le format le plus expressif disponible (DWARF 2, stabs, ou le format natif si aucun des deux n'est supporté), en incluant si possible les extensions GDB.
-gstabs
Produire des informations de débogage dans le format stabs (s'il est supporté) sans extension GDB. C'est le format utilisé par DBX sur la plupart des systèmes BSD. Sur les systèmes MIPS, Alpha et System V Release 4, cette option produit une sortie de débogage au format stabs qui n'est pas comprise par DBX ou SDB. Sur les systèmes System V Release 4, cette option requiert l'assembleur GNU.
-gstabs+
Produire des informations de débogage dans le format stabs (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme.
-gcoff
Produire des informations de débogage dans le format COFF (s'il est supporté). C'est le format utilisé par SDB sur la plupart des systèmes System V antérieurs à System V Release 4.
-gxcoff
Produire des informations de débogage dans le format XCOFF (s'il est supporté). C'est le format utilisé par le débogueur DBX sur les systèmes IBM RS/6000.
-gxcoff+
Produire des informations de débogage dans le format XCOFF (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme, et peut provoquer l'échec sur erreur des assembleurs différents de l'assembleur GNU (GAS)
-gdwarf
Produire des informations de débogage dans le format DWARF version 1 (s'il est supporté). C'est le format utilisé par SDB sur la plupart des systèmes System V Release 4.
-gdwarf+
Produire des informations de débogage dans le format DWARF version 1 (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme.
-gdwarf-2
Produire des informations de débogage dans le format DWARF version 2 (s'il est supporté). C'est le format utilisé par DBX sur IRIX 6.
-gvms
Produire des informations de débogage dans le format VMS (s'il est supporté). C'est le format utilisé par DEBUG sur les systèmes VMS.
-gniveau
-ggdbniveau
-gstabsniveau
-gcoffniveau
-gxcoffniveau
-gvmsniveau
Requérir de l'information de débogage et utiliser également niveau pour spécifier le niveau d'information requis. Le niveau par défaut est 2.

Le niveau 1 produit un minimum d'informations, suffisantes pour créer des piles d'appels (backtraces) dans des parties du programme que vous n'avez pas l'intention de déboguer. Ceci inclut les descriptions des fonctions et des variables externes, mais aucune information sur les variables locales ni sur les numéros de ligne.

Le niveau 3 inclut des informations supplémentaires, telles que les définitions de macros présentes dans le programme. Certains débogueurs supportent le développement des macros quand vous utilisez -g3.

Notez qu'afin d'éviter une confusion entre DWARF1 niveau de débogage 2 et DWARF2, ni -gdwarf ni -gdwarf-2 n'acceptent un niveau de débogage concaténé. Utilisez à la place une option -gniveau additionnelle pour changer le niveau de débogage pour DWARF1 ou DWARF2.

-p
Générer du code supplémentaire pour écrire des informations de profilage convenant au programme d'analyse « prof ». Vous devez utiliser cette option quand vous compilez les fichiers sources pour lesquels vous voulez obtenir des données, et vous devez également l'utiliser lors de l'édition des liens.
-pg
Générer du code supplémentaire pour écrire des informations de profilage convenant au programme d'analyse « gprof ». Vous devez utiliser cette option quand vous compilez les fichiers sources pour lesquels vous voulez obtenir des données, et vous devez également l'utiliser lors de l'édition des liens.
-Q
Faire afficher par le compilateur le nom de chaque fonction lors de sa compilation, et afficher certaines statistiques sur chaque passe quand il a terminé.
-ftime-report
Faire afficher par le compilateur certaines statistiques sur le temps consommé par chaque passe quand il a terminé.
-fmem-report
Faire afficher par le compilateur certaines statistiques sur l'allocation de mémoire permanente quand il a terminé.
-fprofile-arcs
Traiter les arcs durant la compilation pour générer des données de recouvrement ou pour un ordonnancement de blocs sur base du profil. Durant l'exécution, le programme enregistre le nombre de fois que chaque branchement est exécuté et le nombre de fois qu'il est emprunté. Quand le programme compilé se termine, il sauve ses données dans un fichier appelé nom-source.da pour chaque fichier source.

Pour l'ordonnancement de blocs sur base du profil, compilez le programme avec -fprofile-arcs plus les options d'optimisation et de génération de code, générez les informations de profil sur les arcs en exécutant le programme avec une charge de travail sélectionnée, et recompilez ensuite le programme avec les mêmes options d'optimisation et de génération de code plus -fbranch-probabilities.

L'autre utilisation de -fprofile-arcs est destinée à « gcov », quand il est utilisé avec l'option -ftest-coverage.

Avec -fprofile-arcs, pour chaque fonction de votre programme, GCC crée un graphe de flux du programme, et trouve ensuite un arbre de recouvrement minimum pour le graphe. Seuls les arcs non présents dans l'arbre doivent être traités : le compilateur ajoute du code pour compter le nombre de fois que ces arcs sont exécutés. Quand un arc est la seule sortie ou la seule entrée d'un bloc, le code d'instrumentation peut être ajouté au bloc ; sinon, un nouveau bloc de base doit être créé pour détenir le code d'instrumentation.

-ftest-coverage
Créer des fichiers de données pour l'utilitaire de couverture de code « gcov ». Le nom du fichier de données commence par le nom de votre fichier source :
nom-source.bb
Une correspondance des blocs de base vers les numéros de ligne, qu'utilise « gcov » pour associer le nombre d'exécutions des blocs de base avec les numéros de ligne.
nom-source.bbg
Une liste de tous les arcs du graphe de flux du programme. Cela permet à « gcov » de reconstruire le graphe de flux du programme, de sorte qu'il peut calculer tous les blocs de base et le nombre d'exécutions d'arcs à partir de l'information contenue dans le fichier « nom-source.da ».

Utilisez -ftest-coverage avec -fprofile-arcs ; cette dernière option ajoute l'instrumentation au programme, qui écrit ensuite les nombres d'exécutions dans un autre fichier de données :
nom-source.da
Nombres d'exécutions d'arcs au moment de l'exécution, utilisés en complément des informations sur les arcs dans le fichier « nom-source.bbg ».

Les données de couverture seront mieux associés avec les fichiers source si -ftest-coverage est utilisé sans optimisation.
-dlettres
Dire de créer des déchargements (images mémoire, dumps) de débogage durant la compilation aux moments spécifiés par lettres. Ceci est utilisé pour déboguer le compilateur. Les noms de fichiers pour la plupart des déchargements sont produits en concaténant un numéro de passe et un mot au nom du fichier source (p.ex. foo.c.00.rtl ou foo.c.01.sibling). Voici les lettres utilisables, et leur signification :
A
Annoter la sortie de l'assembleur avec diverses informations de débogage.
b
Décharger après le calcul des probabilités de branchement, dans fichier.14.bp.
B
Décharger après le réordonnancement de blocs, dans fichier.29.bbro.
c
Décharger après la combinaison des instructions, dans fichier.16.combine.
C
Décharger après la première conversion if, dans fichier.17.ce.
d
Décharger après l'ordonnancement des branchements différés, dans fichier.31.dbr.
D
Décharger toutes les définitions de macro, à la fin du prétraitement, en plus de la sortie normale.
e
Décharger après les optimisations SSA, dans fichier.04.ssa et fichier.07.ussa.
E
Décharger après la seconde conversion if, dans fichier.26.ce2.
f
Décharger après l'analyse de vie, dans fichier.15.life.
F
Décharger après la purge des codes « ADDRESSOF », dans fichier.09.addressof.
g
Décharger après l'allocation de registres globale, dans fichier.21.greg.
h
Décharger après la finalisation du code de traitement EH, dans fichier.02.eh.
k
Décharger après la conversion reg-vers-pile, dans fichier.28.stack.
o
Décharger après le post-reload CSE et d'autres optimisations, dans fichier.22.postreload.
G
Décharger après le GCSE, dans fichier.10.gcse.
i
Décharger après les optimisations d'appel de fonction soeur, dans fichier.01.sibling.
j
Décharger après la première optimisation de saut, dans fichier.03.jump.
k
Décharger après la conversion des registres vers la pile, dans fichier.32.stack.
l
Décharger après l'allocation de registres locale, dans fichier.20.lreg.
L
Décharger après l'optimisation des boucles, dans fichier.11.loop.
M
Décharger après la passe de réorganisation dépendante de la machine, dans fichier.30.mach.
n
Décharger après la renumérotation des registres, dans fichier.25.rnreg.
N
Décharger après la passe de déplacement des registres, dans fichier.18.regmove.
r
Décharger après la génération de RTL, dans fichier.00.rtl.
R
Décharger après la seconde passe d'ordonnancement des instructions, dans fichier.27.sched2.
s
Décharger après le CSE (ce qui inclut l'optimisation de saut qui suit parfois le CSE), dans fichier.08.cse.
S
Décharger après la première passe d'ordonnancement des instructions, dans fichier.19.sched.
t
Décharger après la seconde passe de CSE (ce qui inclut l'optimisation de saut qui suit parfois le CSE), dans fichier.12.cse2.
w
Décharger après la seconde passe de flux, dans fichier.23.flow2.
X
Décharger après l'élimination de code mort SSA, dans fichier.06.dce.
z
Décharger après la passe de peephole, dans fichier.24.peephole2.
a
Produire tous les dumps listés ci-dessus.
m
Afficher des statistiques sur l'utilisation de la mémoire, à la fin de l'exécution, sur la sortie d'erreur standard.
p
Annoter la sortie de l'assembleur avec un commentaire indiquent quels motif et alternative ont été utilisés. La longueur de chaque instruction est également écrite.
P
Décharger le RTL dans la sortie de l'assembleur en tant que commentaire avant chaque instruction. Active également l'annotation -dp.
v
Pour chacun des autres fichiers de déchargement indiqués (sauf pour fichier.00.rtl), décharger une représentation du graphe de flux de contrôle convenant à une visualisation via VCG dans fichier.pass.vcg.
x
Uniquement générer le RTL pour une fonction au lieu de la compiler. Habituellement utilisé avec r.
y
Décharger de l'information de débogage durant le parsage (analyse syntaxique), sur la sortie d'erreur standard.
-fdump-unnumbered
Lors de déchargements de débogage (voyez l'option -d ci-dessus), ne pas sortir les numéros d'instructions et les numéros de lignes. Cela permet de faciliter l'utilisation de diff sur les déchargements de débogage lors des invocations du compilateur avec des options différentes, en particulier avec et sans -g.
-fdump-translation-unit (C et C++ uniquement)
-fdump-translation-unit-options (C et C++ uniquement)
Décharger une représentation de la structure d'arbre de l'unité de traduction entière dans un fichier. Le nom du fichier est créé en concaténant .tu au nom du fichier source. Si la forme -options est utilisée, options contrôle les détails du déchargement comme décrits par les options -fdump-tree.
-fdump-class-hierarchy (C++ uniquement)
-fdump-class-hierarchy-options (C++ uniquement)
Décharger une représentation de la hiérarchie de chaque classe et de la composition de la table des fonctions virtuelles dans un fichier. Le nom du fichier est créé en concaténant .class au nom du fichier source. Si la forme -options est utilisée, options contrôle les détails du déchargement comme décrits par les options -fdump-tree.
-fdump-tree-interrupteur (C++ uniquement)
-fdump-tree-interrupteur-options
(C++ uniquement)" 4 Contrôler le déchargement lors des différentes étapes du traitement de l'arbre de langage intermédiaire dans un fichier. Le nom du fichier est créé en concaténant un suffixe spécifique à l'interrupteur au nom du fichier source. Si la forme -options est utilisée, options est une liste d'options séparées par des - qui contrôlent les détails du déchargement. Toutes les options ne sont pas applicables à tous les déchargements ; celles qui ne sont pas significatives seront ignorées. Les options suivantes sont disponibles :
address
Afficher l'adresse de chaque noeud. Habituellement, ce n'est pas significatif car cela change en fonction de l'environnement et du fichier source. Son usage principal est l'attachement d'un fichier de déchargement à un environnement de débogage.
slim
Interdire le déchargement des membres d'une portée ou du corps d'une fonction, simplement parce que cette portée a été atteinte. Ne décharger ces éléments que lorsqu'ils sont directement accessibles par un autre chemin.
all
Activer toutes les options.

Les déchargements d'arbre suivants sont possibles :
original
Décharger avant n'importe quelle optimisation basée sur l'arbre, dans fichier.original.
optimized
Décharger après toute optimisation basée sur l'arbre, dans fichier.optimized.
inlined
Décharger après une mise en ligne de fonction, dans fichier.inlined.
-fpretend-float
Quand on exécute un compilateur croisé (cross-compiler), prétendre que la machine cible utilise le même format de flottants que la machine hôte. Ceci provoque une sortie incorrecte des constantes flottantes réelles, mais la séquence réelle d'instructions sera probablement la même que celle que donnerait GCC s'il tournait sur la machine cible.
-save-temps
Stocker les fichiers intermédiaires « temporaires » habituels de façon permanente ; les placer dans le répertoire courant et les nommer sur base du fichier source. Donc, compiler foo.c avec -c -save-temps produirait les fichiers foo.i et foo.s, aussi bien que foo.o. Cela crée un fichier de sortie prétraité foo.i bien que le compilateur utilise maintenant normalement un préprocesseur intégré.
-time
Rapporter le temps CPU consommé par chaque sous-processus de la séquence de compilation. Pour les fichiers sources C, elle est constituée par le compilateur proprement dit et l'assembleur (plus l'éditeur de liens si une édition des liens est effectuée). La sortie ressemble à ceci :
         # cc1 0.12 0.01
         # as 0.00 0.01
 
 

Le premier nombre de chaque ligne est le « temps utilisateur », c.-à-d. le temps occupé à exécuter le programme en lui-même. Le second nombre est le « temps système », c.-à-d. le temps occupé à exécuter des routines du système d'exploitation pour le programme. Les deux nombres sont exprimés en secondes.

-print-file-name=bibliothèque
Afficher le nom de fichier absolu complet du fichier de bibliothèque qui serait utilisé lors de l'édition des liens et ne rien faire d'autre. Avec cette option, GCC ne compile ni ne lie quoi que ce soit ; il affiche simplement le nom du fichier.
-print-multi-directory
Afficher le nom de répertoire correspondant au groupe de bibliothèques sélectionné par d'autres interrupteurs présents sur la ligne de commandes. Ce répertoire est supposé être contenu dans GCC_EXEC_PREFIX.
-print-multi-lib
Afficher la correspondance entre les noms de répertoires comportant plusieurs bibliothèques, et les interrupteurs du compilateur qui les activent. Le nom du répertoire est séparé des interrupteurs par ;, et chaque interrupteur commence par un @} au lieu du @samp{-, sans espace entre les différents interrupteurs. C'est supposé faciliter le traitement par le shell.
-print-prog-name=programme
Comme -print-file-name, mais recherche un programme comme cpp.
-print-libgcc-file-name
Identique à -print-file-name=libgcc.a.

C'est utile quand vous utilisez -nostdlib ou -nodefaultlibs mais que vous voulez lier avec libgcc.a. Vous pouvez faire

       gcc -nostdlib <fichiers>... `gcc -print-libgcc-file-name`
 
 
-print-search-dirs
Afficher le nom du répertoire d'installation configuré et une liste de répertoires de programmes et de bibliothèques où gcc effectuera sa recherche -- et ne rien faire d'autre.

C'est utile quand gcc affiche le message d'erreur installation problem, cannot exec cpp0: No such file or directory (problème d'installation, ne peut effectuer un exec cpp0 : Aucun fichier ou répertoire de ce type). Pour résoudre ceci, vous pouvez placer cpp0 et les autres composants du compilateur là où gcc les pressent (NdT : du verbe pressentir), ou bien fixer la variable d'environnement GCC_EXEC_PREFIX au nom du répertoire où vous les avez installés. N'oubliez pas le « / » de queue.

-dumpmachine
Afficher la machine cible du compilateur (par exemple i686-pc-linux-gnu) -- et ne rien faire d'autre.
-dumpversion
Afficher la version du compilateur (par exemple, 3.0) -- et ne rien faire d'autre.
-dumpspecs
Afficher les specs intégrées du compilateur -- et ne rien faire d'autre. (C'est utilisé quand GCC lui-même est en cours de construction.)

Options contrôlant l'optimisation

Ces options contrôles différentes sortes d'optimisations :

-O
-O1
Optimiser. La compilation optimisante prend un peu plus de temps, et beaucoup plus de mémoire pour une grande fonction.

Sans -O, le but du compilateur est de réduire le coût dû à la compilation et de permettre au débogage de produire les résultats escomptés. Les instructions sont indépendantes : si vous stoppez le programme sur un point d'arrêt (breakpoint) entre des instructions, vous pouvez ensuite attribuer une nouvelle valeur à n'importe quelle variable ou modifier l'indicateur d'instruction courante (program counter) pour le faire pointer vers n'importe quelle autre instruction de la fonction et obtenir exactement les mêmes résultats que ceux que vous pourriez escompter en partant du code source.

Avec -O, le compilateur essaie de réduire la taille du code et le temps d'exécution, sans effectuer d'optimisation nécessitant beaucoup de temps de compilation.

-O2
Optimiser encore plus. GCC effectue pratiquement toutes les optimisations supportées qui n'impliquent pas un compromis espace/vitesse. Le compilateur n'effectue pas de déroulement des boucles ou de mise en ligne de fonctions quand vous spécifiez -O2. Comparée à -O, cette option augmente à la fois le temps de compilation et la performance du code généré.

-O2 active toutes les optimisations optionnelles à l'exception du déroulement des boucles, de la mise en ligne de fonctions, et du renommage de registres. Il active également l'option -fforce-mem sur toutes les machines, et élimine le pointeur de cadre sur les machines pour lesquelles faire de la sorte n'interfère pas avec le débogage.

Notez s.v.p. l'avertissement présenté sous -fgcse concernant l'invocation de -O2 pour des programmes utilisant des gotos calculés.

-O3
Optimiser toujours plus. -O3 active toutes les optimisations spécifiées par -O2 et active également les options -finline-functions et -frename-registers.
-O0
Ne pas optimiser.
-Os
Optimiser pour la taille. -Os active toutes les optimisations de -O2 qui n'augmentent typiquement pas la taille du code. Il effectue également des optimisations supplémentaires destinées à réduire la taille du code.

Si vous utilisez de multiples options -O, avec ou sans numéro de niveau, seule la dernière option de ce type sera prise en compte.

Les options de la forme -fdrapeau spécifient des drapeaux dépendants de la machine. La plupart des drapeaux ont à la fois les formes positive et négative ; la forme négative de -ffoo serait -fno-foo. Dans la table ci-dessous, seule une des formes est listée -- celle qui n'est activée par défaut. Vous pouvez imaginer l'autre forme en supprimant no- ou en l'ajoutant.

-ffloat-store
Ne pas stocker les variables flottantes dans des registres, et inhiber d'autres options qui pourrait interférer sur le fait qu'un flottant soit extrait d'un registre ou à partir de la mémoire.

Cette option empêche une précision excessive non désirable sur des machines telles que le 68000 où les registres flottants (du 68881) gardent plus de précision qu'un « double » est supposé avoir. Idem pour l'architecture x86. Pour la plupart des programmes, l'excès de précision ne fait que du bien, mais certains programmes se basent sur la définition précise du flottant IEEE. Utilisez -ffloat-store pour de tels programmes, après les avoir modifiés afin qu'ils stockent tous les calculs intermédiaires pertinents dans des variables.

-fno-default-inline
Ne pas rendre les fonctions membres en ligne par défaut simplement parce qu'elles sont définies à l'intérieur de la portée de la classe (C++ uniquement). Autrement, si vous spécifiez -O, les fonctions membres définies à l'intérieur de la portée de la classe sont compilées en ligne par défaut, c.-à-d. que vous n'êtes pas obligé d'ajouter inline devant le nom de la fonction membre.
-fno-defer-pop
Toujours dépiler les arguments de chaque appel de fonction dès que la fonction se termine. Pour les machines qui doivent dépiler les arguments après un appel de fonction, le compilateur laisse normalement les arguments s'accumuler sur la pile pour plusieurs appels de fonctions, et les dépile tous en une seule fois.
-fforce-mem
Force les opérandes mémoire à être copiés dans des registres avant de les employer dans des opérations arithmétiques. Ceci peut produire un meilleur code en faisant de toutes les références mémoire des sous-expressions potentiellement communes. Quand elles ne sont pas des sous-expressions communes, la combinaison d'instructions devrait éliminer le chargement séparé dans des registres. L'option -O2 active cette option.
-fforce-addr
Force les constantes d'adresse mémoire à être copiées dans des registres avant d'effectuer des opérations arithmétiques sur elles. Ceci peut produire du meilleur code exactement comme pourrait le faire -fforce-mem.
-fomit-frame-pointer
Ne pas conserver de pointeur de cadre dans un registre pour les fonctions qui n'en ont pas besoin. Ceci évite les instructions pour sauver, mettre à jour et restaurer les pointeurs de cadre ; cela permet aussi de libérer un registre supplémentaire qui pourra dès lors être disponible dans de nombreuses fonctions. Cela rend également le débogage impossible sur certaines machines.

Sur certaines machines, telles que le VAX, ce fanion n'a aucun effet, car la séquence standard d'appel traite automatiquement le pointeur de cadre, et rien n'est sauvé en prétendant qu'il n'existe pas. La macro de description de machine « FRAME_POINTER_REQUIRED » contrôle si une machine cible supporte de drapeau.

-foptimize-sibling-calls
Optimiser les appels de fonction soeur et récursifs terminaux.
-ftrapv
Cette option génère des interruptions pour le dépassement signé pour les opérations d'addition, de soustraction et de multiplication.
-fno-inline
Ne pas tenir compte du mot-clé « inline ». Normalement, cette option est utilisée pour empêcher le compilateur d'étendre des fonctions en ligne. Notez que si vous n'effectuez pas de compilation optimisante, aucune fonction ne sera développée en ligne.
-finline-functions
Intégrer toutes les fonctions simples dans leurs appelants. Le compilateur détermine heuristiquement quelles fonctions sont suffisamment simples pour valoir la peine d'être intégrées de cette façon.

Si tous les appels à une fonction donnée sont intégrés, et si la fonction est déclarée « static », alors la fonction ne fait normalement pas partie de la sortie de l'assembleur et ce de son pleindroit.

-finline-limit=n
Par défaut, gcc limite la taille des fonctions qui peuvent être mises en ligne. Ce drapeau permet de contrôle de cette limite pour les fonctions qui sont explicitement marquées comme étant en ligne (c.-à-d. marquées par le mot-clé inline ou définies dans la définition de classe en c++). n est la taille des fonctions qui peuvent être mises en ligne en nombre de pseudo-instructions (traitement des paramètres exclus). La valeur par défaut pour n est 600. Augmenter cette valeur peut résulter en un code plus « en ligne » au prix d'un temps de compilation et d'une consommation mémoire supérieurs. La baisser rend généralement la compilation plus rapide, et moins de code sera mis en ligne (ce qui signifie vraisemblablement des programmes plus lents). Cette option est particulièrement utile pour les programmes qui utilisent fortement la mise en ligne comme ceux basés sur les modèles récursifs en C++.

Note : le concept de pseudo-instruction représente, dans ce contexte particulier, une mesure abstraite de la taille d'une fonction. En aucune façon, il ne représente un nombre d'instructions d'assemblage et sa signification exacte pourrait de ce fait varier d'une version à une autre.

-fkeep-inline-functions
Même si les appels à une fonction donnée sont intégrés, et que la fonction est déclarée « static », produire néanmoins une version séparée de la fonction appelable à l'exécution. Cette option n'affecte pas les fonctions « extern inline ».
-fkeep-static-consts
Émettre des variables déclarées « static const » quand l'optimisation n'est pas activée, même si les variables ne sont pas référencées.

GCC active cette option par défaut. Si vous voulez forcer le compilateur à vérifier si la variable était référencée, que l'optimisation soit activée ou non, utilisez l'option -fno-keep-static-consts.

-fmerge-constants
Essayer de fusionner les constantes identiques (les constantes chaînes de caractères et les constantes flottantes) par delà les unités de compilation.

Cette option est utilisée par défaut pour la compilation optimisée si l'assembleur et l'éditeur de liens le supportent. Utilisez -fno-merge-constants pour interdire ce comportement.

-fmerge-all-constants
Essayer de fusionner les constantes identiques, et les variables identiques.

Cette option implique -fmerge-constants. En plus de -fmerge-constants, cela tient p.ex. même compte des tableaux initialisés avec des constantes ou des variables initialisées avec des constantes, de type intégral ou flottant. Des langages comme C ou C++ requièrent que chaque variable non automatique dispose d'un emplacement pour son usage exclusif, de sorte que l'utilisation de cette option résultera en un comportement non conforme.

-fno-function-cse
Ne pas placer d'adresse de fonction dans des registres ; faire contenir explicitement dans chaque instruction qui appelle une fonction constante l'adresse de cette fonction.

Cette option résulte en un code moins efficace, mais certaines bidouilles étranges qui altèrent la sortie de l'assembleur peuvent être embrouillées si cette option n'est pas utilisée.

-ffast-math
Spécifie -fno-math-errno, -funsafe-math-optimizations, et -fno-trapping-math.

Cette option provoque la définition de la macro du préprocesseur « __FAST_MATH__ ».

Cette option ne devrait jamais être activée par une option -O car elle peut résulter en une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications ISO ou IEEE pour les fonctions mathématiques.

-fno-math-errno
Ne pas définir ERRNO après l'appel de fonctions mathématiques qui sont exécutées en une seule instruction, comme p.ex. sqrt. Un programme qui se base sur les exceptions IEEE pour le traitement des erreurs mathématiques pourrait utiliser ce drapeau pour la vitesse tout en maintenant la compatibilité arithmétique IEEE.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le défaut est -fmath-errno.

-funsafe-math-optimizations
Permettre les optimisations pour l'arithmétique flottante qui (a) supposent que les arguments et les résultats sont valides et (b) peuvent violer les standards IEEE ou ANSI. Quand elles sont utilisées au moment de l'édition des liens, elles peuvent inclure des bibliothèques ou des fichiers de démarrage qui modifient le mot de contrôle par défaut de la FPU ou d'autres optimisations similaires.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le comportement par défaut est celui de -fno-unsafe-math-optimizations.

-fno-trapping-math
Compiler du code supposant que les opérations flottantes ne peuvent pas générer d'interruptions visibles par l'utilisateur. Définir cette option peut également accélérer si l'on se base sur l'arithmétique IEEE « non-stop », par exemple.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le comportement par défaut est celui de -ftrapping-math.

Les options suivantes contrôlent des optimisations spécifiques. L'option -O2 active toutes ces optimisations sauf -funroll-loops et -funroll-all-loops. Sur la plupart des machines, l'option -O active les options -fthread-jumps et -fdelayed-branch, mais des machines spécifiques peuvent les traiter différemment.

Vous pouvez utiliser les drapeaux suivants dans les rares cas où vous désirez régler avec précision les optimisations à effectuer.

Toutes les optimisations effectuées par GCC n'ont pas forcément d'options -f permettant leur contrôle.

-fstrength-reduce
Effectuer les optimisations de réduction de force des boucles et d'élimination des variables d'itération.
-fthread-jumps
Effectuer des optimisations où l'on vérifie si un saut se branche vers un emplacement où une autre comparaison englobée par la première est trouvée. Si c'est le cas, le premier branchement est redirigé soit vers la destination du second branchement, soit sur le point le suivant immédiatement, en fonction de la valeur de vérité de la condition.
-fcse-follow-jumps
Dans l'élimination de sous-expressions communes, parcourir les instructions de saut quand la cible du saut n'est atteinte pas aucun autre chemin. Par exemple, quand CSE rencontre une instruction « if » possédant une clause « else », CSE suivra le saut quand la condition testée est fausse.
-fcse-skip-blocks
C'est similaire à -fcse-follow-jumps, mais fait suivre par le CSE les sauts conditionnels au-dessus de blocs. Quand CSE rencontre une simple instruction « if » sans clause else, -fcse-skip-blocks fait suivre par CSE les sauts autour du corps du « if ».
-frerun-cse-after-loop
Relancer l'élimination des sous-expressions communes après avoir effectué les optimisations de boucles.
-frerun-loop-opt
Lancer deux fois l'optimiseur de boucles.
-fgcse
Effectuer une passe globale d'élimination des sous-expressions communes. Cette passe effectue également une propagation globale de constantes et de copies.

Note : Lors de la compilation d'un programme utilisant des gotos calculés, une extension GCC, vous pouvez obtenir une meilleure performance à l'exécution si vous désactivez la passe d'élimination des sous-expressions communes globales en ajoutant -fno-gcse sur la ligne de commandes.

-fgcse-lm
Quand -fgcse-lm est activé, l'élimination des sous-expressions communes globales essaiera de déplacer les chargements (instructions load) qui ne sont invalidés que par des instructions de mémorisation (instructions store).
-fgcse-sm
Quand -fgcse-sm est activé, une passe de déplacement des « store » est exécutée après l'élimination des sous-expressions communes globales. Cette passe essaiera de déplacer les « store » en dehors des boucles. Quand cette option est utilisée en conjonction avec -fgcse-lm, les boucles contenant une séquence load/store peuvent être remplacées par un « load » avant la boucle et un « store » après la boucle.
-fdelete-null-pointer-checks
Utiliser une analyse des flux de données globale pour identifier et éliminer les contrôles inutiles de pointeurs null. Le compilateur suppose que le déréférencement d'un pointeur null aurait arrêté le programme. Si un pointeur est contrôlé après avoir déjà été déréférencé, il ne peut être null.

Dans certains environnements, cette supposition n'est pas vraie, et les programmes peuvent sans risque déréférencer des pointeurs null. Utilisez -fno-delete-null-pointer-checks pour désactiver cette optimisation pour les programmes qui dépendent de ce comportement.

-fexpensive-optimizations
Effectuer un certain nombre d'optimisations mineures qui sont relativement coûteuses.
-foptimize-register-move
-fregmove
Essayer de réattribuer des numéros de registres dans les instructions move et comme opérandes d'autres instructions simples pour maximiser le nombre d'attachements à des registres. C'est spécialement utile sur les machines utilisant des instructions à deux opérandes. GCC active cette optimisation par défaut avec -O2 ou supérieur.

Notez que -fregmove et -foptimize-register-move constituent la même optimisation.

-fdelayed-branch
Si supporté par la machine cible, essayer de réordonner les instructions pour exploiter des slots d'instructions disponibles après des instructions de branchement différés.
-fschedule-insns
Si supporté par la machine cible, tente de réordonner les instructions pour éliminer les pertes de vitesse à l'exécution dues à des données requises indisponibles. Cela aide les machines ayant des flottants ou des instructions de chargement en mémoire lents, en autorisant d'autres instructions à être exécutées avant que le résultat du chargement ou de l'instruction flottante ne soit requis.
-fschedule-insns2
Similaire à -fschedule-insns, mais requiert une passe supplémentaire d'ordonnancement des instructions après que l'allocation des registres ait été effectuée. C'est spécialement utile sur des machines avec un nombre de registres relativement petit et où les instructions de chargement en mémoire prennent plus d'un cycle.
-ffunction-sections
-fdata-sections
Placer chaque fonction ou élément de données dans sa propre section dans le fichier de sortie si la cible supporte des sections arbitraires. Le nom de la fonction ou le nom de l'élément de données détermine le nom de la section dans le fichier de sortie.

Utilisez ces options sur des systèmes où l'éditeur de liens peut effectuer des optimisations pour améliorer la localisation des références dans l'espace d'instructions. Les processeurs HPPA exécutant HP-UX et les processeurs Sparc exécutant Solaris 2 disposent d'éditeurs de liens prenant en charge de telles optimisations. D'autres systèmes utilisant le format objet ELF en plus de AIX pourraient disposer de ces optimisations dans le futur.

N'utilisez ces options que lorsqu'il y a des bénéfices importants à faire de la sorte. Quand vous spécifiez ces options, l'assembleur et l'éditeur de liens créeront des fichiers objets et exécutables plus gros, et qui seront également plus lents. Vous ne pourrez pas utiliser « gprof » sur tous les systèmes si vous spécifiez cette option, et vous pourriez avoir des problèmes lors du débogage si vous utilisez cette option conjointement avec -g.

-fcaller-saves
Permet à des valeurs d'être allouées dans des registres qui seront écrasés lors d'appels de fonction, en émettant des instructions supplémentaires pour sauver et restaurer les registres autour de tels appels. Une telle allocation est effectuée uniquement quand elle semble produire du meilleur code que celui qui serait produit autrement.

Cette option est toujours activée par défaut sur certaines machines, en l'occurrence celles qui n'ont d'habitude pas de registres préservés lors de l'appel à utiliser à la place.

Sur toutes les machines, les niveaux d'optimisation 2 et supérieurs activent ce drapeau par défaut.

-funroll-loops
Dérouler les boucles dont le nombre d'itérations peut être déterminé au moment de la compilation ou en entrant dans la boucle. -funroll-loops implique à la fois -fstrength-reduce et -frerun-cse-after-loop. Cette option crée un code de plus grande taille, et peut (ou pas) le rendre plus rapide.
-funroll-all-loops
Dérouler toutes les boucles, même si leur nombre d'itérations est indéterminé au moment de l'entrée dans la boucle. Cela ralentit habituellement les programmes. -funroll-all-loops implique les mêmes options que -funroll-loops.
-fprefetch-loop-arrays
Si c'est supporté par la machine cible, générer des instructions de préchargement mémoire afin d'améliorer la performance des boucles qui accèdent à des grands tableaux.
-fmove-all-movables
Forcer tous les calculs invariants dans les boucles à être déplacés en dehors de la boucle.
-freduce-all-givs
Forcer toutes les variables d'induction générale dans les boucles à subir la réduction de force des boucles.

Note : Quand vous compilez des programmes écrits en Fortran, -fmove-all-movables et -freduce-all-givs sont activés par défaut quand vous utilisez l'optimiseur.

Ces options peuvent générer un code meilleur ou moins bon. Les résultats sont fortement dépendants de la structure des boucles à l'intérieur du code source.

Ces deux options vont être supprimées un jour ou l'autre, une fois qu'elles auront aidé à déterminer l'efficacité de différentes approches d'amélioration des optimisations de boucles.

Faites nous s'il vous plaît savoir (<gcc@gcc.gnu.org> et <fortran@gnu.org>) comment l'utilisation de ces options affecte la performance de votre code de production. Nous sommes très intéressés en du code qui tourne plus lentement quand ces options sont activées.

-fno-peephole
-fno-peephole2
Désactiver toute optimisation peephole spécifique à la machine. La différence entre -fno-peephole et -fno-peephole2 se situe dans la façon dont elles sont implémentées dans le compilateur ; certaines cibles utilisent l'une, des autres l'autre, et quelques unes les deux.
-fbranch-probabilities
Après avoir exécuté un programme compilé avec -fprofile-arcs, vous pouvez le compiler une deuxième fois en utilisant -fbranch-probabilities, pour améliorer les optimisations basées sur le nombre de fois que chaque branchement a été emprunté. Quand le programme compilé avec -fprofile-arcs se termine, il sauve les nombres d'exécutions d'arcs dans un fichier appelé nom-source.da pour chaque fichier source. Les informations contenues dans ce fichier de données sont très dépendantes de la structure du code généré, et vous devez donc utiliser le même code source et les mêmes options d'optimisation lors des deux compilations.

Avec -fbranch-probabilities, GCC appose une note REG_EXEC_COUNT sur la première instruction de chaque bloc de base, et une note REG_BR_PROB sur chaque JUMP_INSN et CALL_INSN. Celles-ci peuvent être utilisées pour améliorer l'optimisation. Actuellement, elles ne sont utilisées qu'à un seul endroit : dans reorg.c, au lieu de deviner quel chemin un branchement est le plus susceptible d'emprunter, les valeurs REG_BR_PROB sont utilisées pour déterminer avec exactitude quel chemin est emprunté le plus souvent.

-fno-guess-branch-probability
Ne pas deviner les probabilités de branchement en utilisant un modèle
 aléatoire.

Parfois, gcc choisira un modèle aléatoire pour deviner les probabilités de branchement, quand aucun autre n'est disponible que ce soit depuis la rétroaction de profilage (-fprofile-arcs) ou depuis __builtin_expect. Cela signifie que différents lancements du compilateur sur le même programme peuvent produire du code objet différent.

Dans un système temps-réel « réel », différents lancements du compilateur ne peuvent pas produire du code au comportement différent ; la minimisation du non déterminisme est primordiale. Cet interrupteur permet aux utilisateurs de réduire le non déterminisme, éventuellement au prix d'une optimisation inférieure.

-fstrict-aliasing
Permet au compilateur de supposer les règles d'aliasing les plus strictes applicables au langage en cours de compilation. Pour C (et C++), ceci active les optimisations basées sur le type des expressions. En particulier, un objet d'un type est supposé ne jamais résider à la même adresse qu'un objet d'un type différent, à moins que les types ne soient pratiquement identiques. Par exemple, un « unsigned int » peut devenir un alias d'un « int », mais pas d'un « void* » ou d'un « double ». Un type caractère peut devenir un alias de n'importe quel autre type.

Faites spécialement attention à du code comme celui-ci :

         union a_union {
           int i;
           double d;
         };
 
 
         int f() {
           a_union t;
           t.d = 3.0;
           return t.i;
         }
 
 
La pratique consistant à lire à partir d'un membre d'une union différent de celui le plus récemment écrit (appelée « type-punning ») est courante. Même avec -fstrict-aliasing, le type-punning est autorisé, à condition que la mémoire soit accédée via le type union. De la sorte, le code ci-dessus fonctionnera comme prévu. Ce ne sera pas forcément le cas pour ce code-ci :
         int f() {
           a_union t;
           int* ip;
           t.d = 3.0;
           ip = &t.i;
           return *ip;
         }
 
 

Chaque langage souhaitant effectuer une analyse d'alias spécifique au langage devrait définir une fonction qui calcule, pour un noeud d'« arbre » donné, un jeu d'alias pour ce noeud. Les noeuds faisant partie de différents jeux d'alias ne sont pas autorisés comme alias. Comme exemple, voyez la fonction frontale C « c_get_alias_set ».

-falign-functions
-falign-functions=n
Aligner le début des fonctions à la première puissance de deux supérieure à n, en passant jusqu'à n octets. Par exemple, -falign-functions=32 aligne les fonctions à la prochaine limite de 32 octets, mais -falign-functions=24 alignerait à la prochaine limite de 32 octets uniquement si cela peut être fait en passant jusqu'à 23 octets.

-fno-align-functions et -falign-functions=1 sont équivalents et signifient que les fonctions ne seront pas alignées.

Certains assembleurs ne supportent ce drapeau que lorsque n est une puissance de deux ; dans ce cas, il est arrondi au chiffre supérieur.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-falign-labels
-falign-labels=n
Aligner toutes les cibles de branchement à des limites de puissances de deux, passant jusqu'à n octets comme -falign-functions. Cette option peut facilement ralentir le code, car il doit insérer des opérations factices jusqu'à ce que la cible du branchement soit atteinte dans le flux habituel du code.

Si -falign-loops ou -falign-jumps sont applicables et plus grands que cette valeur, alors leurs valeurs sont utilisées à laplace.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine qui est très certainement 1, ce qui signifie aucun alignement.

-falign-loops
-falign-loops=n
Aligner les boucles à des limites de puissances de deux, passant jusqu'à n octets comme -falign-functions. On espère que la boucle sera exécutée plusieurs fois, ce qui se fera pour toute exécution des opérations factices.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-falign-jumps
-falign-jumps=n
Aligner les cibles de branchement à des limites de puissances de deux, pour les cibles de branchement où les cibles ne peuvent être atteintes que par un saut, en passant jusqu'à n octets comme -falign-functions. Dans ce cas, aucune opération factice ne doit être exécutée.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-fssa
Effectuer des optimisations dans la forme Static Single Assignment (affectation statique simple). Le graphe de flux de chaque fonction est traduit sous la forme SSA, les optimisations sont effectuées, et le graphe de flux est retraduit à partir de la forme SSA. Les utilisateurs ne devraient pas spécifier cette option, car elle n'est pas encore prête pour une utilisation en production.
-fssa-ccp
Effectuer une Sparse Conditional Constant Propagation (Ndt : propagation conditionnelle clairsemée de constantes ?) dans la forme SSA. Requiert -fssa. Comme -fssa, c'est une fonctionnalité expérimentale.
-fssa-dce
Effectuer une élimination agressive du code mort de la forme SSA. Requiert -fssa. Comme -fssa, c'est une fonctionnalité expérimentale.
-fsingle-precision-constant
Traiter les constantes flottantes en tant que constantes en simple précision au lieu de les convertir implicitement en constantes en double précision.
-frename-registers
Essayer d'éviter des fausses dépendances dans le code ordonnancé en utilisant des registres libres après l'allocation des registres. Cette optimisation bénéficiera le plus aux processeurs possédant beaucoup de registres. Elle peut néanmoins rendre le débogage impossible, puisque les variables ne résideront plus dans un « registre maison ».
-fno-cprop-registers
Après l'allocation des registres et le découpage des instructions subséquent, nous effectuons une passe de copie-propagation pour essayer de réduire les dépendances d'ordonnancement et éliminer occasionnellement la copie.
--param nom=valeur
À certains endroits, GCC utilise différentes constantes pour contrôler la quantité d'optimisation qui est effectuée. Par exemple, GCC ne mettra pas en ligne des fonctions contenant plus qu'un certain nombre d'instructions. Vous pouvez contrôler certaines de ces constantes sur la ligne de commandes en utilisant l'option --param.

Dans chaque cas, la valeur est un entier. Les choix permis pour nom sont donnés dans la table suivante :

max-delay-slot-insn-search
Le nombre maximum d'instructions à considérer quand on recherche une instruction pour remplir une tranche de temps. Si l'on recherche plus que ce nombre arbitraire d'instructions, les économies de temps réalisées en remplissant la tranche de temps seront minimales, et il faut donc arrêter la recherche. Des valeurs plus grandes signifient une optimisation plus agressive, augmentant le temps de compilation avec probablement une petite amélioration dans le temps d'exécution de l'exécutable.
max-delay-slot-live-search
Quand on essaie de remplir les tranches de temps, le nombre maximum d'instructions à considérer quand on recherche un bloc possédant une information d'activité de registre valide. Augmenter cette valeur choisie arbitrairement signifie une optimisation plus agressive, augmentant le temps de compilation. Ce paramètre devrait être supprimé quand le code de tranche de temps sera réécrit pour maintenir le graphe du flux de contrôle.
max-gcse-memory
La quantité maximale approximative de mémoire qui sera allouée dans le but d'effectuer l'optimisation d'élimination des sous-expressions communes globales. Si plus de mémoire que spécifié est requise, l'optimisation ne sera pas effectuée.
max-gcse-passes
Le nombre maximum de passes de GCSE à exécuter.
max-pending-list-length
Le nombre maximum de passes de dépendances en attente qu'autorisera l'ordonnanceur avant de vider l'état courant et de recommencer. Des grosses fonctions avec peu de branchements ou d'appels peuvent créer des listes excessivement larges qui consomment inutilement de la mémoire et des ressources.
max-inline-insns
Si une fonction contient plus que ce nombre d'instructions, elle ne sera pas mise en ligne. Cette option est exactement équivalente à -finline-limit.

Options contrôlant le préprocesseur

Ces options contrôlent le préprocesseur C, qui est exécuté sur chaque fichier source C avant la compilation réelle.

Si vous utilisez l'option -E, rien n'est fait à part le prétraitement. Certaines de ces options n'ont de sens que combinées avec -E car elles rendent la sortie du préprocesseur inadaptée à une compilation réelle.

Vous pouvez utiliser -Wp,option pour passer outre le pilote du compilateur et passer l'option directement au préprocesseur. Si l'option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules. Néanmoins, beaucoup d'options sont modifiées, traduites ou interprétées par le pilote du compilateur avant d'être passées au préprocesseur, et -Wp contourne résolument cette phase. L'interface directe du préprocesseur n'est pas documentée et est sujette à des changements, et vous devriez par conséquent éviter d'utiliser -Wp à chaque fois que c'est possible et laisser le pilote traiter lui-même les options.

-D nom
Prédéfinir la macro nom, possédant la définition « 1 ».
-D nom=définition
Prédéfinir la macro nom, possédant la définition définition. Il n'y a aucune restriction quant au contenu de la définition, mais si vous invoquez le préprocesseur depuis un shell ou un programme de type shell, vous pourriez être dans l'obligation d'utiliser la syntaxe de protection du shell pour protéger les caractères comme les espaces qui y ont une signification spéciale.

Si vous voulez définir une macro du type fonction sur la ligne de commandes, écrivez sa liste d'arguments avec les parenthèses entourantes avant le signe égal (s'il y en a un). Les parenthèses sont significatives dans la plupart des shells, et vous devrez donc protéger l'option. -D'nom(args...)=définition' fonctionne avec sh et csh.

Les options -D et -U sont traitées dans leur ordre d'apparition sur la ligne de commandes. Toutes les options -imacros fichier et -include fichier sont traitées après toutes les options -D et -U.

-U nom
Annuler toute définition précédente de nom, qu'elle soit intégrée ou fournie à l'aide d'une option -D.
-undef
Ne pas prédéfinir de macro spécifique au système. Les macros prédéfinies habituelles restent définies.
-I rép
Ajouter le répertoire rép à la liste des répertoires où chercher les fichiers d'en-tête. Les répertoires nommés avec -I sont parcourus avant les répertoires d'inclusion système standard.

Il est dangereux de spécifier un répertoire d'inclusion système standard dans une option -I. Cela fait échouer le traitement spécial des en-têtes système. Cela peut également faire échouer les réparations des en-têtes système bogués qu'effectue GCC lors de son installation.

-o fichier
Écrire la sortie dans le fichier. C'est la même chose que de spécifier fichier comme second argument non-option pour cpp. gcc a une interprétation différente du second argument non-option ; vous devez donc utiliser -o pour spécifier le fichier de sortie.
-Wall
Active tous les avertissements optionnels qui sont désirables pour du code normal. Actuellement, il s'agit de -Wcomment et -Wtrigraphs. Notez que beaucoup des avertissements du préprocesseur sont activés par défaut et n'ont pas d'option permettant de les contrôler.
-Wcomment
-Wcomments
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 //. (Les deux formes ont le même effet.)
-Wtrigraphs
Avertir quand des trigraphes sont rencontrés. Cette option n'avait auparavant d'effet que si -trigraphs était également spécifié, mais fonctionne maintenant indépendamment. Des avertissements ne sont pas fournis pour les trigraphes présents à l'intérieur de commentaires, car ils n'affectent pas la signification du programme.
-Wtraditional
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 des constructions problématiques qui devraient être évitées.
-Wimport
Avertir la première fois qu'un #import est utilisé.
-Wundef
Avertir quand un identificateur qui n'est pas une macro est rencontré dans une directive #if, en dehors de defined. De tels identificateurs sont remplacés par zéro.
-Werror
Traiter les avertissements comme des erreurs pures et dures. Le code source qui déclenche des avertissements sera rejeté.
-Wsystem-headers
Afficher des messages d'avertissement pour du code des en-têtes système. Ils sont normalement inutiles pour trouver des bogues dans votre propre code, et par conséquent supprimés. Si vous êtes responsable de la bibliothèque système, vous pourriez vouloir les visualiser.
-w
Supprimer tous les avertissements, même ceux que GNU CPP émet par défaut.
-pedantic
Émettre tous les diagnostics obligatoires listés dans le standard C. Certains d'entre eux sont laissés de côté par défaut, car ils se déclenchent fréquemment dans du code inoffensif.
-pedantic-errors
Émettre tous les diagnostics obligatoires, et les traiter comme des erreurs. Cela inclut les diagnostics obligatoires que GCC émet sans -pedantic, mais traite comme des avertissements.
-M
Au lieu de sortir les résultats du prétraitement, générer une règle convenant à make qui décrit les dépendances du fichier source principal. Le préprocesseur génère une règle make contenant le nom du fichier objet pour ce fichier source, un signe deux-points, et le nom de tous les fichiers inclus, y compris ceux provenant des options de ligne de commandes -include ou -imacros.

À moins que cela ne soit spécifié explicitement (avec -MT ou -MQ), le nom du fichier objet est constitué du nom de base du fichier source où le suffixe éventuel est remplacé par le suffixe de fichier objet. S'il y a beaucoup de fichiers inclus, alors la règle est découpée en plusieurs lignes en utilisant \-newline. La règle n'a pas de commande.

Cette option ne supprime pas la sortie de débogage du préprocesseur, comme -dM. Pour éviter de mélanger une telle sortie de débogage avec les règles de dépendances, vous devriez spécifier explicitement le fichier de sortie des dépendances avec -MF, ou utiliser une variable d'environnement comme DEPENDENCIES_OUTPUT. La sortie de débogage sera toujours envoyée dans le flux de sortie normal comme de coutume.

Passer -M au pilote implique -E.

-MM
Comme -M, mais ne pas mentionner les fichiers d'en-tête qui sont trouvés dans les répertoires d'en-tête système, ni les fichiers d'en-tête qui sont inclus, directement ou indirectement, depuis un tel en-tête.

Cela implique que le choix de crochets pointus (< et >) ou de guillemets dans une directive #include ne détermine pas en lui-même si l'en-tête apparaîtra dans la sortie de dépendances de -MM. C'est un léger changement dans la sémantique depuis les versions 3.0 et antérieures de GCC.

-MF fichier
@anchor{-MF} Quand utilisé avec -M ou -MM, spécifie un fichier où écrire les dépendances. Si aucun interrupteur -MF n'est fourni, le préprocesseur envoie les règles au même endroit où il aurait envoyé la sortie prétraitée.

Quand il est utilisé avec les options du pilote -MD ou -MMD, -MF surcharge le fichier de sortie des dépendances par défaut.

-MG
Quand utilisé avec -M ou -MM, -MG indique de traiter les fichiers d'en-tête manquants comme des fichiers générés, et supposer qu'ils résident dans le même répertoire que le fichier source. Cela supprime la sortie prétraitée, puisqu'un fichier d'en-tête manquant constitue normalement une erreur.

Cette fonctionnalité est utilisée dans la mise à jour automatique de makefiles.

-MP
Cette option indique à CPP d'ajouter une cible « phony » pour chaque dépendance autre que le fichier principal, ne les faisant dépendre de ce fait de rien du tout. Ces règles factices surmontent des erreurs que vous donne make si vous supprimez des fichiers d'en-tête sans mettre à jour le Makefile pour qu'il concorde.

Voici une sortie typique :

         test.o: test.c test.h
 
 
         test.h:
 
 
-MT cible
Changer la cible de la règle émise lors de la génération des dépendances. Par défaut, CPP prend le nom du fichier d'entrée principal, chemin inclus, supprime tout suffixe de fichier comme .c, et concatène le suffixe de fichier objet habituel de la plate-forme. Le résultat constitue la cible.

Une option -MT définira la cible pour qu'elle soit exactement la chaîne de caractères que vous spécifiez. Si vous voulez plusieurs cibles, vous pouvez les spécifier comme un unique argument de -MT, ou utiliser plusieurs options -MT.

Par exemple, -MT '$(objpfx)foo.o' pourrait donner

         $(objpfx)foo.o: foo.c
 
 
-MQ cible
Comme -MT, mais protège les caractères qui sont spéciaux pour Make. -MQ '$(objpfx)foo.o' donne
         $$(objpfx)foo.o: foo.c
 
 
La cible par défaut est automatiquement protégée, comme si elle avait été fournie avec -MQ.
-MD
-MD est équivalent à -M -MF fichier, sauf que -E n'est pas impliqué. Le pilote détermine le fichier en fonction de l'utilisation éventuelle d'une option -o est donnée. Si c'est le cas, le pilote utilise son argument mais avec un suffixe .d ; sinon, il prend le nom de base du fichier d'entrée et lui applique un suffixe .d.

Si -MD est utilisé en conjonction avec -E, tout interrupteur -o est censé spécifier le fichier de sortie des dépendances (sauf @pxref{-MF}), mais s'il est utilisé sans -E, chaque -o est censé spécifier un fichier objet cible.

Puisque -E n'est pas impliqué, -MD peut être utilisé pour générer un fichier de sortie de dépendances comme effet de bord du processus de compilation.

-MMD
Comme -MD, sauf que seuls les fichiers d'en-tête utilisateurs sont mentionnés, et pas les fichiers d'en-tête système.
-x c
-x c++
-x objective-c
-x assembler-with-cpp
Spécifier le langage source : C, C++, Objective-C, ou assembleur. Cela n'a rien à voir avec la conformité aux standards ou avec des extensions ; cela sélectionne simplement à quelle syntaxe de base on doit s'attendre. Si vous ne fournissez aucune de ces options, cpp déduira le langage à partir de l'extension du fichier source : .c, .cc, .m ou .S. Certaines autres extensions habituelles pour le C++ et l'assembleur sont également reconnues. Si cpp ne reconnaît pas l'extension, il traitera le fichier comme étant du C ; c'est le mode le plus générique.

Note : De précédentes versions de cpp acceptaient une option -lang qui sélectionnait à la fois le langage et le niveau de conformité aux standards. Cette option a été supprimée, car elle entre en conflit avec l'option -l.

-std=standard
-ansi
Spécifier le standard auquel le code devrait se conformer. Actuellement, cpp ne connaît que les standards du C ; d'autres standards de languages seront ajoutés dans le futur.

Le standard peut être :

"iso9899:1990"
"c89"
Le standard C ISO de 1990. c89 est le raccourci habituel pour cette version du standard.

L'option -ansi est équivalente à -std=c89.

"iso9899:199409"
Le standard C 1990, comme amendé en 1994.
"iso9899:1999"
"c99"
"iso9899:199x"
"c9x"
La standard C ISO révisé, publié en décembre 1999. Avant sa publication, il était connu sous le nom C9X.
"gnu89"
Le standard C 1990 plus les extensions GNU. C'est le standard par défaut.
"gnu99"
"gnu9x"
Le standard C 1999 plus les extensions GNU.
-I-
Diviser le chemin d'inclusion. Tout répertoire spécifié avec une option -I avant -I- n'est parcouru que pour les en-têtes requis avec « #include "fichier" » ; il n'est pas parcouru pour des « #include <fichier> ». Si des répertoires additionnels sont spécifiés par des options -I après le -I-, ces répertoires sont parcourus pour chaque directive #include.

De plus, -I- empêche l'utilisation du répertoire courant (où est situé le fichier d'entrée actuel) comme premier répertoire de recherche pour « #include "fichier" ».

-nostdinc
Ne pas chercher les fichiers d'en-tête dans les répertoires standard du système. Seuls les répertoires que vous avez spécifiés avec des options -I (et le répertoire courant, si c'est approprié) sont parcourus.
-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++.)
-include fichier
Traiter fichier comme si « #include "fichier" » était apparu comme première ligne du fichier source principal. Néanmoins, le premier répertoire parcouru pour trouver fichier est le répertoire de travail du préprocesseur plutôt que le répertoire contenant le fichier source principal. S'il n'est pas trouvé là, il est recherché dans le reste de la chaîne de recherche « #include "..." » comme de coutume.

Si plusieurs options -include sont fournies, les fichiers sont inclus dans leur ordre d'apparition sur la ligne de commandes.

-imacros fichier
Exactement comme -include, sauf que toute sortie produite lors de l'analyse du fichier est jetée. Les macros qu'il définit restent définies. Cela vous permet d'obtenir toutes les macros d'un en-tête sans devoir également traiter ses déclarations.

Tous les fichiers spécifiés par -imacros sont traités avant tous les fichiers spécifiés par -include.

-idirafter répertoire
Rechercher des fichiers d'en-tête dans le répertoire, mais après que les répertoires spécifiés par -I et les répertoires système standard aient été épuisés. répertoire est traité comme un répertoire d'inclusion système.
-iprefix préfixe
Spécifier le préfixe des options -iwithprefix ultérieures. Si le préfixe représente un répertoire, vous devriez inclure le / final.
-iwithprefix répertoire
-iwithprefixbefore répertoire
Concaténer répertoire au préfixe spécifié précédemment avec -iprefix, et ajouter le répertoire résultant au chemin de recherche d'inclusion. -iwithprefixbefore le place au même endroit que le ferait -I ; -iwithprefix le place au même endroit que -idirafter.

L'utilisation de ces options est découragée.

-isystem répertoire
Rechercher des fichiers d'en-tête dans le répertoire, après tous les répertoires spécifiés par -I, mais avant les répertoires système standard. Le marquer comme étant un répertoire système, afin qu'il ait droit au même traitement spécial que celui qui s'applique aux répertoires système standard.
-fpreprocessed
Indiquer au préprocesseur que le fichier d'entrée a déjà été prétraité. Cela supprime certaines choses comme l'expansion des macros, la conversion des trigraphes, le découpage de sauts de ligne protégés (escaped newline splicing), et le traitement de la plupart des directives. Le préprocesseur reconnaît et supprime toujours les commentaires, afin que vous puissiez passer au compilateur un fichier prétraité avec -C sans conséquence fâcheuse. Dans ce mode, le préprocesseur intégré est un peu plus qu'un analyseur lexical pour les frontaux.

-fpreprocessed est implicite si le fichier d'entrée possède l'une des extensions .i, .ii ou .mi. Ce sont les extensions que GCC utilise pour les fichiers prétraités créés par -save-temps.

-ftabstop=largeur
Fixer la distance entre les taquets de tabulation. Cela aide le préprocesseur à rapporter des numéros de colonnes corrects dans les avertissements ou erreurs, même si des tabulations apparaissent sur la ligne. Si la valeur est plus petite que 1 ou plus grande que 100, l'option est ignorée. La distance par défaut est 8.
-fno-show-column
Ne pas afficher les numéros des colonnes dans les diagnostics. Cela peut être nécessaire si les diagnostics sont exploités par un programme qui ne comprend pas les numéros de colonnes, comme dejagnu.
-A prédicat=réponse
Faire une assertion de prédicat prédicat et de réponse réponse. Cette forme est préférée à la forme plus ancienne -A prédicat(réponse), qui est toujours supportée, car n'utilisant pas les caractères spéciaux du shell.
-A -prédicat=réponse
Annuler une assertion de prédicat prédicat et de réponse réponse.
-A-
Annuler toutes les assertions prédéfinies et toutes les assertions précédant cette option sur la ligne de commandes. Supprimer également la définition de toutes les macros prédéfinies et de toutes les macros préalablement spécifiées sur la ligne de commandes. (C'est une excroissance historique et cela pourrait changer dans le futur.)
-dCARS
CARS est une séquence constituée d'un ou de plusieurs des caractères suivants, non précédés d'une espace. D'autres caractères sont interprétés par le compilateur lui-même, ou réservés pour des versions futures de GCC, et sont par conséquent ignorés silencieusement. Si vous spécifiez des caractères dont les comportements ne sont pas compatibles, le résultat est indéfini.
M
Au lieu de la sortie normale, générer une liste de directives #define pour toutes les macros définies durant l'exécution du préprocesseur, macros prédéfinies comprises. Cela vous donne un moyen de découvrir ce qui est prédéfini dans votre version du préprocesseur. En supposant que vous n'avez pas de fichier foo.h, la commande
         touch foo.h; cpp -dM foo.h
 
 
affichera toutes les macros prédéfinies.
D
Comme M sauf en deux endroits : il n'inclut pas les macros prédéfinies, et il sort à la fois les directives #define et le résultat du prétraitement. Les deux types de sortie vont dans le fichier de sortie standard.
N
Comme D, mais n'émet que le nom des macros, et pas leur développement.
I
Produire des directives #include en plus du résultat du prétraitement.
-P
Empêcher la génération de marqueurs de ligne dans la sortie du préprocesseur. Cela pourrait être utile quand on exécute le préprocesseur sur quelque chose qui n'est pas du code C, et qui sera envoyé à un programme qui pourrait être embrouillé à cause des marqueurs de ligne.
-C
Ne pas éliminer les commentaires. Tous les commentaires sont passés dans le fichier de sortie, sauf ceux présents dans les directives traitées, qui sont effacés en même temps que la directive.

Vous devriez vous attendre à des effets de bord quand vous utilisez -C ; cette option force le préprocesseur à traiter les commentaires comme des éléments lexicaux à part entière. Par exemple, les commentaires apparaissant au début de ce qui serait une ligne de directive ont pour effet de transformer cette ligne en une ligne de code source ordinaire, puisque le premier élément lexical de la ligne n'est plus un #.

-gcc
Définir les macros __GNUC__, __GNUC_MINOR__ et __GNUC_PATCHLEVEL__. Elles sont définies automatiquement quand vous utilisez gcc -E ; vous pouvez les désactiver dans ce cas avec -no-gcc.
-traditional
Essayer d'imiter le comportement du C à l'ancienne, en opposition avec le C ISO.
-trigraphs
Prendre en charge les séquences de trigraphes. Ce sont des séquences de trois caractères, débutant toutes par ??, qui sont définies par le C ISO pour représenter des caractères uniques. Par exemple, ??/ signifie \, de sorte que '??/n' est une constante caractère qui représente un saut de ligne. Par défaut, GCC ignore les trigraphes, mais dans les modes de conformité aux standards, il les convertit. Voyez les options -std et -ansi.

Les neufs trigraphes et leur valeur de remplacement sont :

      Trigraphe    :  ??(  ??)  ??<  ??>  ??=  ??/  ??'  ??!  ??-
      Remplacement :    [    ]    {    }    #    \    ^    |    ~
 
 
-remap
Activer du code spécial pour s'accomoder de systèmes de fichiers qui ne permettent que des noms de fichiers très courts, comme MS-DOS.
-$
Interdire l'utilisation du $ dans les identificateurs. Le standard C autorise les implémentations à définir des caractères supplémentaires pouvant apparaître dans les identificateurs. Par défaut, GNU CPP autorise le $, une extension habituelle.
-h
--help
--target-help
Afficher du texte décrivant toutes les options de ligne de commandes au lieu de prétraiter quoi que ce soit.
-v
Mode verbeux. Afficher le numéro de version de GNU CPP au début de l'exécution, et rapporter la forme finale du chemin d'inclusion.
-H
Afficher le nom de chaque fichier d'en-tête utilisé, en plus d'autres activités normales. Chaque nom est indenté pour montrer sa profondeur dans la pile de #include.
-version
--version
Afficher le numéro de version de GNU CPP. Avec un tiret, continuer le prétraitement comme de coutume. Avec deux tirets, s'arrêter immédiatement.

Passer des options à l'assembleur

Vous pouvez passer des options à l'assembleur.

-Wa,option
Passer l'option à l'assembleur. Si option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules.

Options pour l'édition des liens

Ces options entre en jeu quand le compilateur lie des fichiers objets dans un fichier de sortie exécutable. Elles n'ont aucune signification si le compilateur n'effectue pas de phase d'édition des liens.

nom-fichier-objet
Un nom de fichier qui ne se termine pas par un suffixe spécial reconnu est supposé nommer un fichier objet ou une bibliothèque. (Les fichiers objets sont distingués des bibliothèques par l'éditeur de liens en fonction du contenu du fichier.) Si une phase d'édition des liens est effectuée, ces fichiers objets sont utilisés comme entrée pour l'éditeur de liens.
-c
-S
-E
Si une de ces options est utilisée, alors l'éditeur de liens n'est pas lancé, et les noms de fichiers objets ne devraient pas être utilisés comme arguments.
-lbibliothèque
-l bibliothèque
Rechercher la bibliothèque nommée bibliothèque lors de l'édition des liens. (La seconde alternative avec la bibliothèque spécifiée comme argument séparé n'est destinée qu'à la conformité POSIX et n'est pas recommandée.)

L'ordre d'écriture de cette option dans la ligne de commandes est important ; l'éditeur de liens recherche et traite les bibliothèques et les fichiers objets dans l'ordre dans lequel ils sont spécifiés. Donc, foo.o -lz bar.o recherche la bibliothèque z après le fichier foo.o mais avant bar.o. Si bar.o se réfère à des fonctions de z, ces fonctions ne peuvent être chargées.

L'éditeur de liens recherche la bibliothèque dans une liste standard de répertoires, bibliothèque qui est en fait un fichier s'appelant libbibliothèque.a. L'éditeur de liens utilise ensuite ce fichier comme s'il avait été spécifié précisément par son nom.

Les répertoires de recherche incluent divers répertoires standard du système, plus tous ceux que vous avez spécifiés avec -L.

Normalement, les fichiers trouvés de cette façon sont des fichiers de bibliothèque -- fichiers archives dont les membres sont des fichiers objets. L'éditeur de liens manipule un fichier archive en l'examinant pour trouver les membres qui ont déjà été référencés mais pas encore définis. Néanmoins, si l'éditeur de liens trouve un fichier objet ordinaire au lieu d'une bibliothèque, le fichier objet est lié de la façon habituelle. La seule différence entre utiliser une option -l et spécifier un nom de fichier est que -l entoure bibliothèque avec lib et .a et cherche dans plusieurs répertoires.

-lobjc
Vous avez besoin de ce cas particulier de l'option -l pour effectuer l'édition des liens d'un programme Objective-C.
-nostartfiles
Ne pas utiliser les fichiers de démarrage standard du système pendant l'édition des liens. Les bibliothèques standard sont utilisées normalement, à moins que -nostdlib ou -nodefaultlibs soit utilisé.
-nodefaultlibs
Ne pas utiliser les bibliothèques systèmes standard pendant l'édition de liens. Seules les bibliothèques que vous spécifiez seront passées à l'éditeur de liens. Les fichiers de démarrage standard sont utilisés normalement, à moins que -nostartfiles ne soit utilisé. Le compilateur peut générer des appels à memcmp, memset et memcpy pour les environnements System V (et C ISO), ou à bcopy et bzero pour les environnements BSD. Ces entrées sont habituellement résolues en entrées dans la libc. Ces points d'entrée devraient être fournis par un autre mécanisme quand cette option est spécifiée.
-nostdlib
Ne pas utiliser les fichiers de démarrage et les bibliothèques standard du système lors de l'édition de liens. Aucun fichier de démarrage et seules les bibliothèques que vous spécifiez seront passés à l'éditeur de liens. Le compilateur peut générer des appels à memcmp, memset et memcpy pour les environnements System V (et C ISO), ou à bcopy et bzero pour les environnements BSD. Ces entrées sont habituellement résolues en entrées dans la libc. Ces points d'entrée devraient être fournis par un autre mécanisme quand cette option est spécifiée.

Une des bibliothèques standard court-circuitée par -nostdlib et -nodefaultlibs est libgcc.a, une bibliothèque de sous-routines internes qu'utilise GCC pour surmonter les imperfections de machines particulières, ou pour des besoins spéciaux de certains langages.

Dans la plupart des cas, vous avez besoin de libgcc.a même si vous voulez éviter les autres bibliothèques standard. En d'autres termes, quand vous spécifiez -nostdlib ou -nodefaultlibs, vous devriez habituellement tout de même spécifier -lgcc. Cela permet d'assurer qu'il n'y a pas de références non résolues à des sous-routines de bibliothèque internes à GCC. (Par exemple __main, utilisé pour s'assurer que les constructeurs C++ seront appelés.)

-s
Supprimer toutes les informations concernant la table de symboles et les relogements de l'exécutable.
-static
Sur les systèmes supportant l'édition des liens dynamique, ceci empêche d'effectuer une édition de liens en utilisant des bibliothèques partagées. Sur les autres systèmes, cette option n'a aucun effet.
-shared
Produire un objet partagé qui peut être lié avec d'autres objets pour former un exécutable. Tous les systèmes ne supportent pas cette option. Pour obtenir des résultats prévisibles, vous devez également spécifier le même jeu d'options que celui qui a été utilisé pour générer le code (-fpic, -fPIC, ou des sous-options de modèles spécifiques) quand vous spécifiez cette option.[1]
-shared-libgcc
-static-libgcc
Sur les systèmes fournissant libgcc en tant que bibliothèque partagée, ces options forcent l'utilisation de la version partagée ou statique respectivement. Si aucune version partagée de libgcc n'a été construite quand le compilateur a été configuré, ces options n'ont pas d'effet.

Il y a plusieurs situations dans lesquelles une application devrait utiliser la libgcc partagée au lieu de la version statique. La plus habituelle d'entre elles est quand les applications veulent lancer et capturer des exceptions au travers de différentes bibliothèques partagées. Dans ce cas, chacune des bibliothèques ainsi que l'application elle-même devraient utiliser la libgcc partagée.

Par conséquent, les pilotes G++ et GCJ ajoutent automatiquement -shared-libgcc à chaque fois que vous construisez une bibliothèque partagée ou un exécutable principal, car les programmes C++ et Java utilisent typiquement les exceptions, et donc c'est la bonne chose à faire.

Si, par contre, vous utilisez le pilote GCC pour créer des bibliothèques partagées, vous pouvez vous rendre compte qu'elles ne seront pas toujours liées avec la libgcc partagée. Si GCC détecte, au moment de sa configuration, que vous disposez d'un éditeur de liens GNU qui ne supporte pas l'option --eh-frame-hdr, il liera la version partagée de libgcc aux bibliothèques partagées par défaut. Sinon, il tirera parti de l'éditeur de liens et supprimera l'optimisation de liaison avec la version partagée de libgcc, en liant avec la version statique de libgcc par défaut. Cela permet aux exceptions de se propager au travers de telles bibliothèques partagées, sans encourir de coûts de relogement au moment du chargement de la bibliothèque.

Néanmoins, si une bibliothèque ou l'exécutable principal est supposé(e) lancer ou capturer des exceptions, vous devez le (la) lier en utilisant le pilote G++ ou GCJ, de façon appropriée pour les langages utilisés dans le programme, ou en utilisant l'option -shared-libgcc, de sorte qu'il (elle) soit lié(e) avec la libgcc partagée.

-symbolic
Lier les références à des symboles globaux en construisant un objet partagé. Avertir des références non résolues (à moins que l'option ne soit surchargée par l'option de l'éditeur de liens -Xlinker -z -Xlinker defs). Seul un petit nombre de systèmes supportent cette option.
-Xlinker option
Passer l'option à l'éditeur de liens. Vous pouvez utiliser ceci pour fournir des options d'édition des liens spécifiques au système que GCC ne reconnaît pas.

Si vous voulez passer une option qui prend un argument, vous devez utiliser -Xlinker deux fois, la première pour l'option et la seconde pour l'argument. Par exemple, pour passer -assert definitions, vous devez écrire -Xlinker -assert -Xlinker definitions. Cela ne fonctionne pas d'écrire -Xlinker ``-assert definitions'', car cela passe la chaîne de caractères entière comme un seul argument, ce qui n'est pas ce à quoi s'attend l'éditeur de liens.

-Wl,option
Passer l'option à l'éditeur de liens. Si option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules.
-u symbole
Prétendre que le symbole symbole est non défini, pour obliger la liaison avec les modules de bibliothèques pour le définir. Vous pouvez utiliser -u de multiples fois avec différents symboles pour forcer le chargement de modules de bibliothèques additionnels.

Options de recherche dans les répertoires

Ces options spécifient les répertoires où chercher les fichiers d'en-tête, les bibliothèques et les parties du compilateur :

-Irép
Ajouter le répertoire rép à la liste des répertoires où chercher les fichiers d'en-tête. Ceci peut être utilisé pour surcharger un fichier d'en-tête système, en le substituant par votre propre version, puisque ces répertoires sont parcourus avant les répertoires des fichiers d'en-tête système. Néanmoins, vous ne devriez pas utiliser cette option pour ajouter des répertoires contenant des fichiers d'en-tête système fournis par un vendeur (utilisez -isystem pour cela). Si vous utilisez plus d'une option -I, les répertoires sont examinés de gauche à droite ; les répertoires système standard viennent par après.

Si un répertoire d'inclusion système standard, ou un répertoire spécifié avec -isystem, est également spécifié avec -I, il ne sera parcouru que dans la position requise par -I. De plus, il ne sera pas considéré être un répertoire d'inclusion système. Si ce répertoire contient réellement des en-têtes système, il y a de fortes chances pour qu'ils soient détériorés. Par exemple, si la procédure d'installation de GCC a édité les en-têtes de /usr/include pour corriger des bogues, -I/usr/include trouvera les en-têtes originaux bogués au lieu des corrigés. GCC émettra un avertissement quand un répertoire d'inclusion système est masqué de cette manière.

-I-
Tous les répertoires spécifiés avec des options -I avant l'option -I- sont parcourus uniquement pour le cas des #include "fichier" ; ils ne sont pas parcourus pour des #include <fichier>.

Si des répertoires additionnels sont spécifiés par des options -I après le -I-, ces répertoires sont parcourus pour toutes les directives #include. (D'ordinaire tous les répertoires -I sont utilisés de cette façon.)

En plus, l'option -I- empêche l'utilisation du répertoire courant (où est situé le fichier d'entrée actuel) comme premier répertoire de recherche pour #include "fichier". Il n'y a aucune manière d'annuler cet effet de -I-. Avec -I., vous pouvez spécifier de chercher dans le répertoire qui était courant au moment de l'invocation du compilateur. Ce n'est pas exactement ce que fait le préprocesseur par défaut, mais c'est souvent satisfaisant.

-I- n'empêche pas l'utilisation des fichiers d'en-tête standard du système. Donc, -I- et -nostdinc sont indépendants.

-Lrép
Ajouter le répertoire rép à la liste des répertoires à parcourir pour les options -l.
-Bpréfixe
Cette option spécifie où trouver les exécutables, les bibliothèques, les fichiers inclus et les fichiers de données du compilateur lui-même.

Le programme pilote du compilateur lance un ou plusieurs des sous-programmes cpp, cc1, as ou ld. Il essaie d'utiliser préfixe comme préfixe pour chaque programme qu'il essaie de lancer, à la fois avec et sans machine/version/.

Pour chaque sous-programme à lancer, le pilote du compilateur essaie d'abord le préfixe -B, s'il est présent. Si ce nom n'est pas trouvé, ou si -B n'était pas spécifié, le pilote essaie deux préfixes standard, qui sont /usr/lib/gcc/ et /usr/local/lib/gcc-lib/. Si aucun des deux ne résulte en un nom de fichier qui est trouvé, le nom du programme non modifié est recherché en utilisant les répertoires spécifiés dans votre variable d'environnement PATH.

Le compilateur vérifiera si le chemin fourni par -B référence un répertoire et ajoutera si nécessaire un caractère séparateur de répertoires à la fin du chemin.

Les préfixes -B qui spécifient effectivement des noms de répertoires s'appliquent également aux bibliothèques de l'éditeur de liens, car le compilateur traduit ces options en options -L pour l'éditeur de liens. Ils s'appliquent également aux fichiers d'inclusion du préprocesseur, car le compilateur traduit ces options en options -isystem pour le préprocesseur. Dans ce cas, le compilateur concatène include au préfixe.

Le fichier de support à l'exécution libgcc.a peut également être recherché en utilisant le préfixe -B si nécessaire. S'il n'est pas trouvé ici, les deux préfixes standard ci-dessus sont essayés, et c'est tout. Le fichier n'est pas pris en compte lors de l'édition des liens s'il n'est pas trouvé d'une de ces façons.

Une autre façon de spécifier un préfixe similaire au préfixe -B est d'utiliser la variable d'environnement GCC_EXEC_PREFIX.

À titre d'exception, si le chemin fourni par -B est [rép/]stageN/, où N est un nombre dans l'intervalle 0 à 9, alors il sera remplacé par [rép/]include. Cela aide à l'amorçage du compilateur.

-specs=fichier
Traiter fichier après que le compilateur ait lu dans le fichier de specs standard, pour surcharger les « défauts » qu'utilise le programme pilote de gcc pour déterminer quels interrupteurs passer à cc1, cc1plus, as, ld, etc. Plus d'un -specs=fichier peut être spécifié sur la ligne de commandes, et ces options sont traitées dans l'ordre, de gauche à droite.

Spécifier la machine cible et la version du compilateur

Par défaut, GCC compile du code pour le même type de machine que celui que vous utilisez. Néanmoins, il peut également être installé comme compilateur croisé, pour compiler pour un autre type de machine. En fait, plusieurs configurations différentes de GCC, pour différentes machines cibles, peuvent être installées côte à côte. Ensuite, vous spécifiez laquelle utiliser avec l'option -b.

En plus, des anciennes et des nouvelles versions de GCC peuvent être installées côte à côte. L'une d'entre elles (probablement la plus récente) sera utilisée par défaut, mais vous pourriez également parfois devoir en utiliser une autre.

-b machine
L'argument machine spécifie la machine cible pour la compilation. Ceci est utile si vous avez installé GCC en tant que compilateur croisé.

La valeur à utiliser pour machine est la même que celle spécifiée au moment de la configuration de GCC comme compilateur croisé. Par exemple, si un compilateur croisé a été configuré avec configure i386v, signifiant compiler pour un 80386 faisant tourner System V, alors vous devrez spécifier -b i386v pour lancer ce compilateur croisé.

Quand vous ne spécifiez pas -b, cela signifie normalement que vous compilez pour le même type de machine que celui que vous utilisez.

-V version
L'argument version spécifie quelle version de GCC utiliser. C'est utile quand de multiples versions sont installées. Par exemple, version pourrait être 2.0, signifiant exécuter GCC version 2.0.

La version par défaut, quand vous ne spécifiez pas -V, est la dernière version de GCC que vous avez installée.

Les options -b et -V fonctionnent actuellement en contrôlant une partie du nom de fichier utilisé pour les fichiers exécutables, et des bibliothèques utilisées pour la compilation. Une version donnée de GCC, pour une machine cible donnée, est normalement conservée dans le répertoire /usr/local/lib/gcc-lib/machine/version.

Donc, des sites peuvent personnaliser l'effet de -b ou -V en changeant les noms de ces répertoires, ou en ajoutant des liens alternatifs (ou des liens symboliques). Si, dans le répertoire /usr/local/lib/gcc-lib/, le fichier 80386 est un lien vers le fichier i386v, alors -b 80386 devient un alias pour -b i386v.

Les options -b ou -V ne changent pas complètement d'un compilateur à l'autre ; le programme pilote haut-niveau de gcc que vous avez invoqué initialement continue à tourner et invoque les autres exécutables (préprocesseur, compilateur lui-même, assembleur et éditeur de liens) qui font le vrai boulot. Néanmoins, puisque aucun travail réel n'est effectué par le pilote du programme, cela importe généralement peu que le programme pilote utilisé ne soit pas celui pour la cible spécifiée. Il arrive souvent que l'interface vers d'autres exécutables change de façon incompatible entre différentes versions du compilateur, et donc, à moins que la version spécifiée ne soit très proche de celle du pilote (par exemple, -V 3.0 avec un programme pilote provenant de GCC version 3.0.1), l'utilisation de -V peut ne pas fonctionner ; par exemple, utiliser -V 2.95.2 ne fonctionnera pas avec un programme pilote provenant de GCC 3.0.

Le seul endroit où le programme pilote dépend de la machine cible se situe dans l'analyse grammaticale et le traitement des options spéciales spécifiques à une machine. Néanmoins, c'est contrôlé par un fichier qui est trouvé, avec les autres exécutables, dans le répertoire affecté aux version et machine cible spécifiées. Ainsi, un unique programme pilote installé s'adapte à n'importe quelle machine spécifié, et à des versions du compilateur suffisamment similaires.

L'exécutable du programme pilote contrôle néanmoins une chose importante : les version et machine cible par défaut. Donc, vous pouvez installer différentes instances du programme pilote, compilé pour différentes cibles ou versions, sous différents noms.

Par exemple, si le pilote pour la version 2.0 est installée en tant que ogcc et que la version 2.1 est installée en tant que gcc, alors la commande gcc utilisera la version 2.1 par défaut, alors que ogcc utilisera la 2.0 par défaut. Néanmoins, vous pouvez choisir l'une des versions en utilisant l'option -V.

Modèles matériels et configurations

Nous avons déjà discuté de l'option standard -b qui choisit entre différents compilateurs installés pour des machines cibles complètement différentes, comme VAX vs. 68000 vs. 80386.

En plus, chacune de ces types de machine cible peut disposer des ses propres options spéciales, débutant par -m, pour choisir entre plusieurs modèles matériels ou configurations -- par exemple, 68010 vs 68020, coprocesseur flottant ou non. Une version installée unique du compilateur peut compiler pour n'importe quel modèle ou configuration, en fonction des options spécifiées.

Certaines configurations du compilateur supportent également des options spéciales supplémentaires, habituellement pour la compatibilité avec d'autres compilateurs sur la même plate-forme.

Ces options sont définies par la macro de description de machine « TARGET_SWITCHES ». Les options par défaut sont également définies par cette macro, ce qui vous permet de modifier les valeurs par défaut.

Options M680x0

Voici les options -m définies pour les séries 68000. Les valeurs par défaut pour ces options dépendent du style de 68000 qui a été sélectionné quand le compilateur a été configuré ; les valeurs par défaut pour la plupart des choix sont données ci-dessous.

-m68000
-mc68000
Générer une sortie pour un 68000. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68000.

Utilisez cette option pour les microcontrôleurs possédant un coeur 68000 ou EC000, ce qui inclut les 68008, 68302, 68306, 68307, 68322, 68328 et les 68356.

-m68020
-mc68020
Générer une sortie pour un 68020. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68020.
-m68881
Générer une sortie contenant des instructions 68881 instructions pour flottants. C'est le comportement par défaut pour la plupart des systèmes à base de 68020 à moins que --nfp n'ait été spécifié lors de la configuration du compilateur.
-m68030
Générer une sortie pour un 68030. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68030.
-m68040
Générer une sortie pour un 68040. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68040.

Cette option interdit l'utilisation des instructions 68881/68882 qui doivent être émulées de façon logicielle sur les 68040. Utilisez cette option si votre 68040 ne possède pas de code permettant d'émuler ces instructions.

-m68060
Générer une sortie pour un 68060. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68060.

Cette option interdit l'utilisation d'instructions 68881/68882 qui doivent être émulées par logiciel sur les 68060. Utilisez cette option si votre 68060 ne possède pas de code pour émuler ces instructions.

-mcpu32
Générer une sortie pour un CPU32. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de CPU32.

Utilisez cette option pour les microcontrôleurs possédant un coeur CPU32 ou CPU32+, ce qui inclut les 68330, 68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 et les 68360.

-m5200
Générer une sortie pour un processeur de la famille 520X « coldfire ». C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 520X.

Utilisez cette option pour les microcontrôleurs possédant un coeur 5200, ce qui inclut les MCF5202, MCF5203, MCF5204 et les MCF5202.

-m68020-40
Générer une sortie pour un 68040, sans utiliser une seule des nouvelles instructions. Ceci résulte en un code qui peut tourner relativement efficacement sur un 68020/68881, un 68030 ou encore un 68040. Le code généré utilise les instructions 68881 qui sont émulées sur le 68040.
-m68020-60
Générer une sortie pour un 68060, sans utiliser une seule des nouvelles instructions. Ceci résulte en un code qui peut tourner relativement efficacement sur un 68020/68881, un 68030 ou encore un 68040. Le code généré utilise les instructions 68881 qui sont émulées sur le 68060.
-mfpa
Générer une sortie contenant des instructions Sun FPA pour flottants.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : Les bibliothèques requises ne sont pas disponibles pour toutes les cibles m68k. Normalement, les facilités offertes par le compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. Les cibles embarquées m68k-*-aout et m68k-*-coff fournissent un support logiciel des flottants.
-mshort
Considérer que le type « int » a 16 bits de largeur, comme « short int ».
-mnobitfield
Ne pas utiliser les instructions utilisant des champs-bits. Les options -m68000, -mcpu32 et -m5200 impliquent -mnobitfield.
-mbitfield
Utiliser les instructions utilisant des champs-bits. L'option -m68020 implique -mbitfield. C'est le comportement par défaut si vous utilisez une configuration prévue pour un 68020.
-mrtd
Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant avec l'instruction « rtd », qui dépile ses arguments en sortant. Ceci fait économiser une instruction à l'appelant qui ne doit alors pas dépiler les arguments.

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

De plus, vous devez fournir des prototypes de fonction pour toutes les fonctions qui prennent un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En outre, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

L'instruction « rtd » est supportée par les processeurs 68010, 68020, 68030, 68040, 68060 et CPU32, mais pas par le 68000 ou le 5200.

-malign-int
-mno-align-int
Contrôler si GCC aligne les variables « int », « long », « long long », « float », « double » et « long double » à des limites de 32 bits (-malign-int) ou à des limites de 16 bits (-mno-align-int). L'alignement des variables à des limites de 32 bits produit du code tournant légèrement plus rapidement sur des processeurs possédant des bus 32 bits, aux dépens d'une plus grosse consommation mémoire.

Avertissement : si vous utilisez l'interrupteur -malign-int, GCC alignera les structures contenant les types cités ci-dessus différemment de la plupart des spécifications d'interface binaire applicative (ABI) pour le m68k.

-mpcrel
Utiliser le mode d'adressage relatif au p.c. du 68000 directement, au lieu d'utiliser une table de décalage globale. Actuellement, cette option implique -fpic, permettant un décalage d'au plus 16 bits pour l'adressage relatif au p.c. -fPIC n'est pas actuellement supporté avec -mpcrel, bien que cela puisse se faire pour les processeurs 68020 et supérieurs.
-mno-strict-align
-mstrict-align
Ne pas permettre (permettre) que des références mémoire non alignées soient traitées par le système.

Options M68hc1x

Voici les options -m définies pour les microcontrôleurs 68hc11 et 68hc12. Les valeurs par défaut pour ces options dépendent du style de microcontrôleur qui a été sélectionné quand le compilateur a été configuré ; les valeurs par défaut pour la plupart des choix sont données ci-dessous.

-m6811
-m68hc11
Générer une sortie pour un 68HC11. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68HC11.
-m6812
-m68hc12
Générer une sortie pour un 68HC12. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68HC12.
-mauto-incdec
Activer l'utilisation des modes d'adressage de pré et post auto-incrémentation du 68HC12.
-mshort
Considérer que le type « int » a 16 bits de largeur, comme « short int ».
-msoft-reg-count=nombre
Spécifier le nombre de pseudo-registres logiciels qui sont utilisés pour la génération de code. Le nombre maximum est de 32. L'utilisation de plus de pseudo-registres logiciels peut résulter ou non en un meilleur code en fonction du programme. La valeur par défaut est 4 pour le 68HC11 et 2 pour le 68HC12.

Options VAX

Ces options -m sont définies pour le VAX :

-munix
Ne pas produire certaines instructions de saut (« aobleq » etc.) que l'assembleur Unix pour VAX ne peut traiter sur une grande portée.
-mgnu
Produire ces instructions de saut, en supposant que vous assemblerez avec l'assembleur GNU.
-mg
Produire du code pour le format g des nombres flottants au lieu du format d.

Options SPARC

Ces interrupteurs -m sont supportés sur la SPARC:

-mno-app-regs
-mapp-regs
Spécifiez -mapp-regs pour générer une sortie qui utilise les registres globaux 2 à 4, qui sont réservés par l'ABI SPARC SVR4 pour les applications. C'est le comportement par défaut.

Pour être totalement conforme à l'ABI SVR4 au prix d'une certaine perte de performance, spécifiez -mno-app-regs. Vous devriez compiler les bibliothèques et les logiciels système avec cette option.

-mfpu
-mhard-float
Générer une sortie contenant des instructions flottantes.
-mno-fpu
-msoft-float
Générer une sortie contenant les appels de bibliothèque pour flottants. Attention : les bibliothèques requises ne sont pas disponibles pour toutes les cibles SPARC. Normalement, les facilités offertes par le compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. Les cibles embarquées sparc-*-aout et sparclite-*-* fournissent un support logiciel des flottants.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

-mhard-quad-float
Générer une sortie contenant des instructions flottantes utilisant des quads (mots « quadruples », soit long double).
-msoft-quad-float
Générer une sortie contenant des appels de bibliothèque pour les instructions flottantes utilisant des quads (long double). Les fonctions appelées sont celles spécifiées dans l'ABI SPARC. C'est le comportement par défaut.

Au moment de l'écriture de cette page de manuel, il n'existe aucune implémentation sparc qui possède un support matériel pour les instructions flottantes utilisant des quads. Elles invoquent toutes un gestionnaire d'interruptions pour une de ces instructions, et ensuite le gestionnaire d'interruptions émule l'effet de l'instruction. À cause de la surcharge due au gestionnaire d'interruptions, ceci est beaucoup plus lent que d'appeler les routines de la bibliothèque ABI. L'option -msoft-quad-float est donc utilisée par défaut.

-mno-flat
-mflat
Avec -mflat, le compilateur ne génère pas d'instructions save/restore (sauver/restaurer) et utilisera une convention d'appel « plate » ou à fenêtre d'un registre. Ce modèle utilise %i7 comme pointeur de cadre et est compatible avec le modèle normal de fenêtre de registres. Les code de chacun d'entre eux peuvent être entremêlés. Les registres locaux et les registres d'entrée (0--5) sont toujours traités comme des registres « sauvés lors de l'appel » et seront sauvés sur la pile si nécessaire.

Avec -mno-flat (utilisée par défaut), le compilateur émet des instructions save/restore (sauf pour les fonctions feuilles) et est le mode de fonctionnement normal.

-mno-unaligned-doubles
-munaligned-doubles
Supposer que les doubles ont un alignement de 8 octets. C'est le comportement par défaut.

Avec -munaligned-doubles, GCC suppose que les doubles n'ont un alignement de 8 octets que s'ils sont contenus dans un autre type, ou s'ils ont une adresse absolue. Sinon, il suppose qu'ils ont un alignement de 4 octets. Spécifier cette option évite quelques rares problèmes de compatibilité avec du code généré par d'autres compilateurs. Ce n'est pas le comportement par défaut car cela résulte en une baisse de performance, spécialement pour le code flottant.

-mno-faster-structs
-mfaster-structs
Avec -mfaster-structs, le compilateur suppose que les structures devraient avoir un alignement de 8 octets. Cela permet l'utilisation de paires d'instructions « ldd » et « std » pour les copies dans l'affectation de structures, au lieu du double de paires « ld » et « st ». Néanmoins, l'utilisation de cet alignement modifié viole directement l'ABI Sparc. Ce n'est donc prévu que pour être utilisé sur des cibles où le développeur admet que son code résultant ne sera pas directement en ligne avec les règles de l'ABI.
-mv8
-msparclite
Ces deux options sélectionnent des variantes de l'architecture SPARC.

Par défaut (à moins d'être spécialement configuré pour la SPARClite Fujitsu), GCC génère du code pour la variante v7 de l'architecture SPARC.

-mv8 vous fournira du code SPARC v8. La seule différence avec le code v7 est que le compilateur émet les instructions de multiplication et de division entières qui existent dans SPARC v8 mais pas dans SPARC v7.

-msparclite vous fournira du code SPARClite. Cela ajoute les instructions de multiplication entière, de « integer divide step and scan (ffs) » qui existent sur la SPARClite mais pas sur la SPARC v7.

Ces options sont dépréciées et seront supprimées dans une future version de GCC. Elles ont été remplacées par -mcpu=xxx.

-mcypress
-msupersparc
Ces deux options sélectionnent le processeur pour lequel le code est optimisé.

Avec -mcypress (le processeur par défaut), le compilateur optimise le code pour la puce Cypress CY7C602, qui est utilisée dans les séries SparcStation/SparcServer 3xx, ainsi que pour les plus anciennes SparcStation 1, 2, IPX etc.

Avec -msupersparc, le compilateur optimise le code pour le processeur SuperSparc, qui est utilisé dans les séries SparcStation 10, 1000 et 2000. Ce drapeau active également l'utilisation du jeu d'instructions complet SPARC v8.

Ces options sont dépréciées et seront supprimées dans une future version de GCC. Elles ont été remplacées par -mcpu=xxx.

-mcpu=type-cpu
Fixer le jeu d'instructions, le jeu de registres et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont v7, cypress, v8, supersparc, sparclite, hypersparc, sparclite86x, f930, f934, sparclet, tsc701, v9 et ultrasparc.

Les paramètres d'ordonnancement des instructions par défaut sont utilisés pour les valeurs qui sélectionnent une architecture et pas une implémentation. Ce sont v7, v8, sparclite, sparclet, v9.

Voici une liste de chaque architecture supportée et de leurs implémentations supportées :

             v7 :             cypress
             v8 :             supersparc, hypersparc
             sparclite :      f930, f934, sparclite86x
             sparclet  :      tsc701
             v9 :             ultrasparc
 
 
-mtune=type-cpu
Fixer les paramètres d'ordonnancement des instructions pour le type de machine type-cpu, mais ne pas fixer le jeu d'instructions ou le jeu de registres comme le ferait l'option -mcpu=type-cpu.

Les mêmes valeurs pour -mcpu=type-cpu peuvent être utilisées pour -mtune=type-cpu, mais les seules valeurs utiles sont celles qui sélectionnent une implémentation de cpu particulière. Ce sont cypress, supersparc, hypersparc, f930, f934, sparclite86x, tsc701 et ultrasparc.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus pour le processeur SPARCLET.

-mlittle-endian
Générer du code pour un processeur tournant en mode petit-boutiste.
-mlive-g0
Traiter le registre « %g0 » comme un registre normal. GCC continuera à le corrompre si nécessaire mais ne supposera pas qu'il vaut toujours 0.
-mbroken-saverestore
Générer du code qui n'utilise pas des formes non triviales des instructions « save » et « restore ». Des versions anciennes du processeur SPARCLET ne traitent pas correctement les instructions « save » et « restore » utilisées avec des arguments. Elles les traitent correctement sans argument. Une instruction « save » utilisée sans argument incrémente le pointeur de fenêtre actuel mais n'alloue pas de nouveau pointeur de pile. On suppose que le gestionnaire d'interruptions du débordement de fenêtre traitera correctement ce cas comme le feraient les gestionnaires d'interruptions.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus pour les processeurs SPARC V9 dans les environnements 64 bits.

-mlittle-endian
Générer du code pour un processeur tournant en mode petit-boutiste.
-m32
-m64
Générer du code pour un environnement 32 ou 64 bits respectivement. L'environnement 32 bits établit les int, long et pointeurs à 32 bits. L'environnement 64 bits établit les int à 32 bits et les long et les pointeurs à 64 bits.
-mcmodel=medlow
Générer du code pour le modèle de code Medium/Low : le programme doit être lié dans les 32 bits bas de l'espace d'adressage. Les pointeurs ont 64 bits. Les programmes peuvent subir une édition de liens statique ou dynamique.
-mcmodel=medmid
Générer du code pour le modèle de code Medium/Middle : le programme doit être lié dans les 44 bits inférieurs de l'espace d'adressage, le segment de texte doit occuper moins de 2 Go, et le segment de données doit se situer à l'intérieur des 2 Go du segment de texte. Les pointeurs font 64 bits.
-mcmodel=medany
Générer du code pour le modèle de code Medium/Anywhere : le programme peut être lié n'importe où dans l'espace d'adressage, le segment de texte doit occuper moins de 2 Go, et le segment de données doit se situer à l'intérieur des 2 Go du segment de texte. Les pointeurs font 64 bits.
-mcmodel=embmedany
Générer du code pour le modèle de code Medium/Anywhere pour les systèmes embarqués : supposer un segment de texte 32 bits et un segment de données 32 bits, les deux débutant n'importe où (déterminé au moment de l'édition des liens). Le registre %g4 pointe sur la base du segment de données. Les pointeurs font toujours 64 bits. Les programmes sont liés statiquement, le PIC (code indépendant de la position) n'est pas supporté.
-mstack-bias
-mno-stack-bias
Avec -mstack-bias, GCC suppose que le pointeur de pile, et le pointeur de cadre s'il existe, sont décalés de -2047 qui doit être rajouté lors de la création de références au cadre de pile. Sinon, supposer qu'aucun décalage de la sorte n'est présent.

Options Convex

Ces options -m sont définies pour le Convex:

-mc1
Générer une sortie pour C1. Le code tournera sur n'importe quelle machine Convex. Le symbole de préprocesseur « __convex__c1__ » est défini.
-mc2
Générer une sortie pour C2. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C2. Le symbole de préprocesseur « __convex__c2__ » est défini.
-mc32
Générer une sortie pour C32xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C32. Le symbole de préprocesseur « __convex__c32__ » est défini.
-mc34
Générer une sortie pour C34xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C34. Le symbole de préprocesseur « __convex__c34__ » est défini.
-mc38
Générer une sortie pour C38xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C38. Le symbole de préprocesseur « __convex__c38__ » est défini.
-margcount
Générer du code qui place un compte du nombre d'arguments dans le mot précédant chaque liste d'arguments. C'est compatible avec le CC habituel, et certains programmes peuvent avoir besoin du mot de comptage d'arguments. GDB et d'autres débogueurs de niveau source n'en ont pas besoin ; cette info se trouve dans la table des symboles.
-mnoargcount
Omettre le mot de comptage d'arguments. C'est le comportement par défaut.
-mvolatile-cache
Permettre aux références volatiles d'être mises en cache. C'est le comportement par défaut.
-mvolatile-nocache
Les références volatiles contournent le cache de données, allant directement en mémoire. Ce n'est nécessaire que pour du code multi-processeurs qui n'utilise pas d'instructions standard de synchronisation. Créer des références non volatiles vers des emplacements volatils ne fonctionnera pas nécessairement.
-mlong32
Le type long fait 32 bits, le même que le type int. C'est le comportement par défaut.
-mlong64
Le type long fait 64 bits, le même que le type long long. Cette option est inutile, car aucun support de bibliothèque n'existe pour elle.

Options AMD29K

Ces options -m sont définies pour l'AMD Am29000:

-mdw
Générer du code qui suppose que le bit « DW » est positionné, c.-à-d. que les opérations sur les octets et les demi-mots sont directement supportées par le matériel. C'est le comportement par défaut.
-mndw
Générer du code qui suppose que le bit « DW » n'est pas positionné.
-mbw
Générer du code qui suppose que le système supporte les opérations d'écriture d'octet et de demi-mot. C'est le comportement par défaut.
-mnbw
Générer du code qui suppose que les systèmes ne supportent pas les opérations d'écriture d'octet et de demi-mot. -mnbw implique -mndw.
-msmall
Utiliser un modèle de mémoire restreint qui suppose que toutes les adresses de fonction sont ou bien dans un seul segment de 256 Ko, ou bien à une adresse absolue de moins de 256 Ko. Cela permet à l'instruction « call » d'être utilisée au lieu d'une séquence « const », « consth », « calli ».
-mnormal
Utiliser le modèle de mémoire normal : générer des instructions « call » uniquement quand les fonctions appelantes sont dans le même fichier, et des instructions « calli » sinon. Cela fonctionne si chaque fichier occupe moins de 256 Ko mais permet à l'exécutable entier d'être plus grand que 256 Ko. C'est le comportement par défaut.
-mlarge
Toujours utiliser des instructions « calli ». Spécifiez cette option si vous vous attendez à ce qu'un seul fichier se compile en plus de 256 Ko de code.
-m29050
Générer du code pour l'Am29050.
-m29000
Générer du code pour l'Am29000. C'est le comportement par défaut.
-mkernel-registers
Générer des références aux registres « gr64-gr95 » plutôt qu'aux registres « gr96-gr127 ». Cette option peut être utilisée lors de la compilation d'un noyau qui veut un ensemble de registres globaux disjoint de celui utilisé par le code en mode utilisateur.

Notez que quand cette option est utilisée, les noms de registres dans les drapeaux -f doivent utiliser les noms normaux en mode utilisateur.

-muser-registers
Utiliser l'ensemble normal de registres globaux, « gr96-gr127 ». C'est le comportement par défaut.
-mstack-check
-mno-stack-check
Insérer (ne pas insérer) un appel à « __msp_check » après chaque ajustement de pile. C'est souvent utilisé dans le code du noyau.
-mstorem-bug
-mno-storem-bug
-mstorem-bug s'occupe des processeurs 29k qui ne peuvent traiter la distinction entre une instruction mtsrim et une instruction storem (la plupart des puces 29000 à l'heure actuelle, mais pas la 29050).
-mno-reuse-arg-regs
-mreuse-arg-regs
-mno-reuse-arg-regs indique au compilateur de n'utiliser que les registres des arguments d'entrée pour les arguments de sortie. Cela aide à détecter une fonction avec moins d'arguments que le nombre présent dans sa déclaration.
-mno-impure-text
-mimpure-text
-mimpure-text, utilisé en plus de -shared, indique au compilateur de ne pas passer -assert pure-text à l'éditeur de liens lors de la liaison d'un objet partagé.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.
-mno-multm
Ne pas générer d'instructions multm ou multmu. C'est utile pour certains systèmes embarqués qui ne possèdent pas de gestionnaire d'interruptions pour ces instructions.

Options ARM

Ces options -m sont définies pour les architectures Advanced RISC Machines (ARM) :

-mapcs-frame
Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure ARM pour toutes les fonctions, même si ce n'est pas strictement nécessaire pour une correcte exécution du code. Spécifier -fomit-frame-pointer avec cette option empêchera la génération de cadres de pile pour les fonctions feuilles. -mno-apcs-frame est utilisé par défaut.
-mapcs
C'est un synonyme pour -mapcs-frame.
-mapcs-26
Générer du code pour un processeur fonctionnant avec un indicateur d'instruction courante de 26 bits, et se conformant aux standards d'appel de fonction pour l'option APCS 26 bits. Cette option remplace les options -m2 et -m3 de précédentes versions du compilateur.
-mapcs-32
Générer du code pour un processeur fonctionnant avec un indicateur d'instruction courante de 32 bits, et se conformant aux standards d'appel de fonction pour l'option APCS 32 bits. Cette option remplace l'option -m6 de précédentes versions du compilateur.
-mthumb-interwork
Générer du code qui supporte l'appel entre les jeux d'instructions ARM et Thumb. Sans cette option, les deux jeux d'instructions ne peuvent être utilisés fiablement dans un programme. L'option par défaut est -mno-thumb-interwork, puisqu'un code légèrement plus gros est généré quand -mthumb-interwork est spécifié.
-mno-sched-prolog
Empêcher le réordonnancement des instructions du prologue de la fonction, ou la fusion de ces instructions avec des instructions du corps de la fonction. Cela signifie que toutes les fonctions commenceront par une suite d'instructions reconnaissable (ou en fait une choisie parmi un petit ensemble de différents prologues de fonction), et cette information peut être utilisée pour localiser le début si des fonctions sont à l'intérieur d'un morceau de code exécutable. -msched-prolog est utilisé par défaut.
-mhard-float
Générer une sortie contenant des instructions flottantes. C'est le comportement par défaut.
-msoft-float
Générer une sortie contenant des appels de bibliothèques pour flottants. Avertissement : les bibliothèques requises ne sont pas disponibles pour toutes les cibles ARM. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

-mlittle-endian
Générer du code pour un processeur tournant en mode petit-boutiste. C'est le comportement par défaut pour toutes les configurations standard.
-mbig-endian
Générer du code pour un processeur tournant en mode gros-boutiste. Le comportement par défaut est de compiler du code pour un processeur petit-boutiste.
-mwords-little-endian
Cette option ne s'applique que lors de la génération de code pour des processeurs gros-boutistes. Générer du code pour un ordre des mots petit-boutiste, mais pour un ordre des octets gros-boutistes, c.-à-d. un ordre d'octets de la forme 32107654. Note : cette option ne devrait être utilisée que si vous avez besoin de la compatibilité avec du code pour des processeurs ARM gros-boutistes généré par des versions du compilateur antérieures à 2.8.
-malignment-traps
Générer du code qui ne provoquera pas d'interruption si le MMU a activé les interruptions d'alignement. Sur les architectures ARM antérieures à ARMv4, il n'existait pas d'instruction permettant d'accéder à des objets de taille d'un demi-mot stockés en mémoire. Néanmoins, quand on lit quelque chose de la mémoire, une fonctionnalité de l'architecture ARM permet d'utiliser un chargement d'un mot, même si l'adresse n'est pas alignée, et le coeur du processeur fera tourner (rotate) les données pendant leur chargement. Cette option indique au compilateur que de tels accès mal alignés provoqueront une interruption MMU et qu'il devrait au lieu de cela synthétiser les accès en une série d'accès octets. Le compilateur peut toujours utiliser des accès mots pour charger des données d'un demi-mot s'il sait que l'adresse est alignée à une limite de mot.

Cette option est ignorée lors de la compilation pour l'architecture ARM 4 ou suivantes, puisque ces processeurs disposent d'instructions permettant d'accéder directement à des objets d'un demi-mot en mémoire.

-mno-alignment-traps
Générer du code qui suppose que le MMU ne provoquera pas d'interruption en cas d'accès non aligné. Cela produit un meilleur code quand le jeu d'instructions cible ne possède pas d'opérations mémoire sur les demi-mots (c.-à-d. des implémentations antérieures à ARMv4).

Notez que vous ne pouvez pas utiliser cette option pour accéder à des objets mots non alignés, car le processeur n'ira quérir qu'un objet de 32 bits aligné de la mémoire.

Le réglage par défaut sur la plupart des cibles est -mno-alignment-traps, puisque cela produit du meilleur code quand il n'y a pas d'instructions mémoire disponibles pour les demi-mots.

-mshort-load-bytes
-mno-short-load-words
Ce sont des synonymes dépréciés pour -malignment-traps.
-mno-short-load-bytes
-mshort-load-words
Ce sont des synonymes dépréciés pour -mno-alignment-traps.
-mbsd
Cette option s'applique uniquement au RISC iX. Émuler le compilateur natif du mode BSD. C'est le comportement par défaut si -ansi n'est pas spécifié.
-mxopen
Cette option s'applique uniquement au RISC iX. Émuler le compilateur natif du mode X/Open.
-mno-symrename
Cette option s'applique uniquement au RISC iX. Ne pas lancer le post-processeur de l'assembleur, symrename, après que le code ait été assemblé. Il est normalement nécessaire de modifier certains symboles standard en préparation de l'édition des liens avec la bibliothèque C RISC iX ; cette option supprime cette passe. Le post-processeur n'est jamais exécuté quand le compilateur est construit pour la compilation croisée.
-mcpu=nom
Ceci spécifie le nom du processeur ARM cible. GCC utilise ce nom pour déterminer quel type d'instructions il peut émettre lors de la génération de code assembleur. Les noms autorisés sont : arm2, arm250, arm3, arm6, arm60, arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700, arm700i, arm710, arm710c, arm7100, arm7500, arm7500fe, arm7tdmi, arm8, strongarm, strongarm110, strongarm1100, arm8, arm810, arm9, arm9e, arm920, arm920t, arm940t, arm9tdmi, arm10tdmi, arm1020t et xscale.
-mtune=nom
Cette option est très similaire à l'option -mcpu=, sauf qu'au lieu de spécifier le type de processeur cible réel, et donc restreindre les instructions pouvant être utilisées, il spécifie que GCC devrait ajuster la performance du code comme si la cible était du type spécifié dans cette option, mais devra toujours choisir les instructions qu'il va générer en fonction du processeur spécifié par une option -mcpu=. Pour certaines implémentations ARM, une meilleure performance peut être obtenue en utilisant cette option.
-march=nom
Ceci spécifie le nom de l'architecture ARM cible. GCC utilise ce nom pour déterminer quel type d'instructions il peut émettre lors de la génération de code assembleur. Cette option peut être utilisée en conjonction avec, ou sans l'option -mcpu=. Les noms autorisés sont : armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5te.
-mfpe=nombre
-mfp=nombre
Cela spécifie la version de l'émulation flottante disponible sur la cible. Les valeurs permises sont 2 et 3. -mfp= est un synonyme pour -mfpe=, dans un but de compatibilité avec des versions plus anciennes de GCC.
-mstructure-size-boundary=n
La taille de toutes les structures et unions sera arrondie vers le haut à un multiple du nombre de bits fixés par cette option. Les valeurs permises sont 8 et 32. La valeur par défaut varie pour différentes chaînes d'outils. Pour la chaîne d'outils destinée à COFF, la valeur par défaut est 8. Spécifier le plus grand nombre peut produire du code plus rapide, plus efficace, mais peut également augmenter la taille du programme. Les deux valeurs sont potentiellement incompatibles. Du code compilé avec une valeur ne fonctionnera pas forcément avec du code ou des bibliothèques compilés avec l'autre valeur, s'ils s'échangent des informations en utilisant des structures ou des unions.
-mabort-on-noreturn
Générer un appel à la fonction « abort » à la fin d'une fonction « noreturn ». Il sera exécuté si la fonction essaie de revenir à l'appelant.
-mlong-calls
-mno-long-calls
Indiquer au compilateur d'effectuer des appels de fonction en chargeant d'abord l'adresse de la fonction dans un registre, et en effectuant ensuite un appel de sous-routine sur ce registre. Cet interrupteur est nécessaire si la fonction cible se trouvera au-delà des 64 mégaoctets de possibilité d'adressage de l'instruction d'appel de sous-routine basée sur un décalage.

Même si cet interrupteur est activé, tous les appels de fonction ne seront pas transformés en appels longs. L'heuristique est que les fonctions statiques, les fonctions possédant l'attribut short-call, les fonctions situées à l'intérieur de la portée d'une directive #pragma no_long_calls, et les fonctions dont les définitions ont déjà été compilées à l'intérieur de l'unité de compilation courante ne seront pas converties en appels longs. L'exception à cette règle est que les définitions de fonction faibles, les fonctions possédant l'attribut long-call ou l'attribut section, et les fonctions situées à l'intérieur de la portée d'une directive #pragma long_calls, seront toujours transformées en appels longs.

Cette fonctionnalité n'est pas activée par défaut. Spécifier -mno-long-calls restaurera le comportement par défaut, comme le fait de placer les appels de fonction dans la portée d'une directive #pragma long_calls_off. Notez que ces interrupteurs n'ont aucun effet sur la façon dont le compilateur génère du code pour traiter les appels de fonction via des pointeurs de fonction.

-mnop-fun-dllimport
Désactiver le support de l'attribut « dllimport ».
-msingle-pic-base
Traiter le registre utilisé pour l'adressage PIC comme étant en lecture seule, plutôt que de le charger dans le prologue pour chaque fonction. Le système d'exécution est responsable de l'initialisation de ce registre avec une valeur appropriée avant que l'exécution ne débute.
-mpic-register=reg
Spécifier le registre à utiliser pour l'adressage PIC. Celui par défaut est R10 à moins que la vérification de la pile ne soit activée, quand R9 est utilisé.
-mpoke-function-name
Écrire le nom de chaque fonction dans la section de texte, précédant directement le prologue de la fonction. Le code généré est similaire à ceci :
              t0
                  .ascii "arm_poke_function_name", 0
                  .align
              t1
                  .word 0xff000000 + (t1 - t0)
              arm_poke_function_name
                  mov     ip, sp
                  stmfd   sp!, {fp, ip, lr, pc}
                  sub     fp, ip, #4
 
 

Quand on génère une pile d'appels, le code peut examiner la valeur de « pc » stockée en « fp + 0 ». Si la fonction de trace regarde ensuite à l'emplacement « pc - 12 » et que les 8 bits supérieurs sont positionnés, alors on sait qu'il y a un nom de fonction imbriquée précédant immédiatement cet emplacement, et de longueur « ((pc[-3]) & 0xff000000) ».

-mthumb
Générer du code pour le jeu d'instructions Thumb 16 bits. Le comportement par défaut est d'utiliser le jeu d'instructions ARM 32 bits.
-mtpcs-frame
Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure Thumb pour toutes les fonctions non feuilles. (Une fonction feuille est une fonction qui n'appelle aucune autre fonction). Le défaut est -mno-tpcs-frame.
-mtpcs-leaf-frame
Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure Thumb pour toutes les fonctions feuilles. (Une fonction feuille est une fonction qui n'appelle aucune autre fonction). Le défaut est -mno-apcs-leaf-frame.
-mcallee-super-interworking
Donner à toutes les fonctions visibles en dehors du fichier en cours de compilation un en-tête de jeu d'instructions ARM qui passe dans le mode Thumb avant d'exécuter le reste de la fonction. Cela permet à ces fonctions d'être appelées à partir de code non-interfonctionnel.
-mcaller-super-interworking
Permettre aux appels via des pointeurs de fonction (incluant les fonctions virtuelles) de s'exécuter correctement que le code cible ait été compilé pour l'interfonctionnalité ou pas. Si cette option est activée, il en résulte une légère surcharge lors de l'exécution d'un pointeur de fonction.

Options MN10200

Ces options -m sont définies pour les architectures Matsushita MN10200 :

-mrelax
Indiquer à l'éditeur de liens qu'il doit effectuer une passe d'optimisation de relaxation pour raccourcir les branchements, les appels et les adresses mémoire absolues. Cette option n'a d'effet que lorsqu'elle est utilisée sur la ligne de commandes au moment de l'étape finale de l'édition des liens.

Cette option empêche le débogage symbolique.

Options MN10300

Ces options -m sont définies pour les architectures Matsushita MN10300 :

-mmult-bug
Générer du code pour éviter les bogues dans les instructions de multiplication des processeurs MN10300. Utilisé par défaut.
-mno-mult-bug
Ne pas générer de code pour éviter les bogues dans les instructions de multiplication des processeurs MN10300.
-mam33
Générer du code qui utilise des fonctionnalités spécifiques au processeur AM33.
-mno-am33
Ne pas générer de code qui utilise des fonctionnalités spécifiques au processeur AM33. Utilisé par défaut.
-mno-crt0
Ne pas lier dans le fichier objet C d'initialisation à l'exécution.
-mrelax
Indiquer à l'éditeur de liens qu'il doit effectuer une passe d'optimisation de relaxation pour raccourcir les branchements, les appels et les adresses mémoire absolues. Cette option n'a d'effet que lorsqu'elle est utilisée sur la ligne de commandes au moment de l'étape finale de l'édition des liens.

Cette option interdit tout débogage symbolique.

Options M32R/D

Ces options -m sont définies pour les architectures Mitsubishi M32R/D :

-m32rx
Générer du code pour le M32R/X.
-m32r
Générer du code pour le M32R. Utilisé par défaut.
-mcode-model=small
Supposer que tous les objets résident à l'intérieur des 16 Mo inférieurs de mémoire (de sorte que leurs adresses puissent être chargées avec l'instruction « ld24 »), et supposer que toutes les sous-routines sont accessibles par l'instruction « bl ». C'est le comportement par défaut.

L'adressabilité d'un objet particulier peut être fournie via l'attribut « modèle ».

-mcode-model=medium
Supposer que les objets peuvent se situer n'importe où dans l'espace d'adressage 32 bits (le compilateur générera des instructions « seth/add3 » pour charger leurs adresses), et supposer que toutes les sous-routines sont accessibles par l'instruction « bl ».
-mcode-model=large
Supposer que les objets peuvent se situer n'importe où dans l'espace d'adressage 32 bits (le compilateur générera des instructions « seth/add3 » pour charger leurs adresses), et supposer que les sous-routines ne peuvent pas être accessibles par l'instruction « bl » (le compilateur générera la séquence d'instructions beaucoup plus lente « seth/add3/jl »).
-msdata=none
Désactiver l'utilisation de la petite zone de données. Les variables seront placées dans .data, bss ou .rodata (à moins que l'attribut « section » n'ait été spécifié). C'est le comportement par défaut.

La petite zone de données est constituée des sections .sdata et .sbss. Les objets peuvent être explicitement placés dans la petite zone de données avec l'attribut « section » utilisant l'une de ces sections.

-msdata=sdata
Placer les petites données globales statiques dans la petite zone de données, mais ne pas générer de code spécial pour les référencer.
-msdata=use
Placer les petites données globales statiques dans la petite zone de données, et générer des instructions spéciales pour les référencer.
-G nombre
Placer les objets globaux et les objets statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. La valeur par défaut pour nombre est 8. L'option -msdata doit valoir sdata ou use pour que cette option ait un quelconque effet.

Tous les modules devraient être compilés avec la même valeur pour -G nombre. Compiler avec des valeurs différentes de nombre pourra fonctionner ou bien pas ; si ça ne fonctionne pas, l'éditeur de liens émettra un message d'erreur -- du code incorrect ne sera pas généré.

Options M88K

Ces options -m sont définies pour les architectures Motorola 88k :

-m88000
Générer du code fonctionnant bien à la fois sur le m88100 et le m88110.
-m88100
Générer du code fonctionnant le mieux sur le m88100, mais tournant également sur le m88110.
-m88110
Générer du code fonctionnant le mieux sur le m88100, mais pouvant ne pas tourner sur le m88110.
-mbig-pic
Option obsolète à supprimer lors de la prochaine révision. Utilisez -fPIC.
-midentify-revision
Inclure une directive « ident » dans la sortie de l'assembleur enregistrant le nom du fichier source, les nom et version du compilateur, l'horodate, et les drapeaux de compilation utilisés.
-mno-underscores
Dans la sortie de l'assembleur, émettre des noms de symboles sans ajouter un caractère de soulignement au début de chaque nom. Le comportement par défaut est d'utiliser un caractère de soulignement comme préfixe pour chaque nom.
-mocs-debug-info
-mno-ocs-debug-info
Inclure (ou pas) de l'information de débogage supplémentaire (sur les registres utilisés dans chaque cadre de pile) comme spécifié dans le Standard de Compatibilité Objet 88open, « OCS ». Cette information additionnelle permet le débogage de code dans lequel le pointeur de cadre a été éliminé. Le comportement par défaut pour DG/UX, SVr4 et Delta 88 SVr3.2 est d'inclure cette information ; d'autres configurations 88k omettent cette information par défaut.
-mocs-frame-position
Durant l'émission d'information de débogage COFF sur les variables automatiques et les paramètres conservés dans la pile, utiliser le décalage à partir de l'adresse de cadre canonique, qui est le pointeur de pile (registre 31) à l'entrée de la fonction. Les configurations DG/UX, SVr4, Delta88 SVr3.2 et BCS utilisent -mocs-frame-position ; d'autres configurations 88k utilisent -mno-ocs-frame-position par défaut.
-mno-ocs-frame-position
Durant l'émission d'information de débogage COFF sur les variables automatiques et les paramètres conservés dans la pile, utiliser le décalage à partir du registre de pointeur de cadre (registre 30). Quand cette option a cours, le pointeur de cadre n'est pas éliminé lorsque de l'information de débogage est requise par l'interrupteur -g.
-moptimize-arg-area
Préserver de l'espace en réorganisant le cadre de pile. Cette option génère du code qui ne respecte pas les spécifications 88open, mais qui utilise moins de mémoire.
-mno-optimize-arg-area
Ne pas réorganiser le cadre de pile pour préserver de l'espace. C'est le comportement par défaut. Le code généré se conforme à la spécification, mais utilise moins de mémoire.
-mshort-data-nombre
Générer des références de données plus petites en les rendant relatives à « r0 », ce qui permet de charger une valeur en utilisant une seule instruction (plutôt que les deux habituelles). Vous contrôlez quelles références de données sont affectées en spécifiant nombre avec cette option. Par exemple, si vous spécifiez -mshort-data-512, alors les références de données affectées sont celles impliquant des déplacements de moins de 512 octets. -mshort-data-num n'a pas d'effet pour un nombre plus grand que 64 Ko.
-mserialize-volatile
-mno-serialize-volatile
Générer (ou pas) du code pour garantir la cohérence séquentielle des références mémoire volatiles. Par défaut, la cohérence est garantie.

L'ordre des références mémoire créées par le processeur MC88110 ne correspond pas toujours à l'ordre des instructions requérant ces références. En particulier, une instruction de chargement (load) peut s'exécuter avant une instruction de stockage (store) la précédant. Un tel réordonnancement viole la cohérence séquentielle des références mémoire volatiles quand il y a de multiples processeur. Quand la cohérence doit être garantie, GCC génère des instructions spéciales, si nécessaire, pour forcer l'exécution dans le bon ordre.

Le processeur MC88100 ne réordonne pas les références mémoire et fournit de ce fait toujours la cohérence séquentielle. Néanmoins, par défaut, GCC génère les instructions spéciales pour garantir la cohérence même quand vous utilisez le -m88100, afin que le code puisse tourner sur un processeur MC88110. Si vous prévoyez ne faire tourner votre code que sur le processeur MC88100, vous pouvez utiliser -mno-serialize-volatile.

Le code supplémentaire généré pour garantir la cohérence peut affecter la performance de votre application. Si vous savez que vous pouvez outrepasser sans dommage cette garantie, vous pouvez utiliser -mno-serialize-volatile.

-msvr4
-msvr3
Activer (-msvr4) ou désactiver (-msvr3) les extensions du compilateur relatives à System V release 4 (SVr4). Cela contrôle les points suivants :
1.
La variante de syntaxe assembleur à émettre.
2.
-msvr4 fait reconnaître au préprocesseur C #pragma weak qui est utilisé sur System V release 4.
3.
-msvr4 fait émettre à GCC des directives de déclaration additionnelles utilisées sur SVr4.

-msvr4 est utilisé par défaut pour les configurations m88k-motorola-sysv4 et m88k-dg-dgux m88k. -msvr3 est utilisé par défaut pour toutes les autres configurations m88k.
-mversion-03.00
Cette option est obsolète, et est ignorée.
-mno-check-zero-division
-mcheck-zero-division
Générer (ou pas) du code pour garantir que la division entière par zéro est détectée. Par défaut, la détection est garantie.

Certains modèles du processeur MC88100 ne parviennent pas à détecter la division entière par zéro dans certaines conditions. Par défaut, lors de la compilation de code pouvant tourner sur un tel processeur, GCC génère du code qui traque explicitement les diviseurs nuls, et provoque une interruption avec le numéro d'exception 503 quand l'un d'entre eux est détecté. L'utilisation de mno-check-zero-division supprime une telle vérification pour du code généré sur un processeur MC88100.

GCC suppose que le processeur MC88110 détecte correctement toutes les instances de la division entière par zéro. Quand -m88110 est spécifié, aucun contrôle explicite de diviseurs nuls n'est généré, et -mcheck-zero-division ainsi que -mno-check-zero-division sont ignorés.

-muse-div-instruction
Utiliser l'instruction div pour la division entière signée sur le processeur MC88100. Par défaut, l'instruction div n'est pas utilisée.

Sur le processeur MC88100, l'instruction de division entière signée (div) est interrompue par le système d'exploitation en cas d'opérande négatif. Le système d'exploitation effectue l'opération de façon transparente, mais a un coût élevé en terme de temps d'exécution. Par défaut, lors de la compilation de code pouvant tourner sur un processeur MC88100, GCC émule la division entière signée en utilisant l'instruction de division entière non signée (divu), évitant de ce fait la grande pénalité due à la gestion d'une interruption par le système d'exploitation. Une telle émulation possède ses propres coûts, moins importants, en terme de temps et d'espace. Dans la mesure où les opérations de division entière signée importantes de votre code sont effectuées sur deux opérandes non négatifs, il peut être souhaitable d'utiliser l'instruction div directement.

Sur le processeur MC88110, l'instruction div (également connue sous le nom d'instruction divs) traite les opérandes négatifs sans être interrompue par le système d'exploitation. Quand -m88110 est spécifié, -muse-div-instruction est ignoré, et l'instruction div est utilisée pour la division entière signée.

Notez que le résultat de la division de « INT_MIN » par -1 n'est pas défini. En particulier, le comportement d'une telle division peut différer en fonction de l'utilisation éventuelle de -muse-div-instruction.

-mtrap-large-shift
-mhandle-large-shift
Inclure du code pour détecter les décalages de bits de plus de 31 bits ; respectivement, capturer de tels décalages ou émettre du code pour les traiter correctement. Par défaut, GCC ne prend aucune mesure spéciale pour les grands décalages de bits.
-mwarn-passed-structs
Avertir quand une fonction passe une « struct » comme argument ou comme résultat. Les conventions de passage de structures ont changé durant l'évolution du langage C, et sont souvent la source de problèmes de portabilité. Par défaut, GCC n'émet pas de tels avertissements.

Options IBM RS/6000 et PowerPC

Ces options -m sont définies pour les IBM RS/6000 et les PowerPC:

-mpower
-mno-power
-mpower2
-mno-power2
-mpowerpc
-mno-powerpc
-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mpowerpc64
-mno-powerpc64
GCC supporte deux infrastructures de jeux d'instructions proches pour le RS/6000 et le PowerPC. Le jeu d'instructions POWER est composé des instructions supportées par la puce rios utilisée dans les systèmes RS/6000 originaux, et le jeu d'instructions PowerPC constitue l'architecture des microprocesseurs Motorola MPC5xx, MPC6xx, MPC8xx, et des microprocesseurs IBM 4xx.

Aucune architecture n'est un sous-ensemble d'une autre. Néanmoins, il y a un grand sous-ensemble commun d'instructions supportée par les deux. Un registre MQ est inclus dans les processeurs supportant l'architecture POWER.

Vous pouvez utiliser ces options pour spécifier quelles instructions sont disponibles sur le processeur que vous utilisez. La valeur par défaut pour ces options est déterminée lorsque vous configurez GCC. Spécifier -mcpu=type-cpu surcharge la spécification de ces options. Nous recommandons l'utilisation de l'option -mcpu=type-cpu plutôt que les options listées ci-dessus.

L'option -mpower permet à GCC de générer des instructions qui ne se retrouvent que dans l'architecture POWER, et d'utiliser le registre MQ. Spécifier -mpower2 implique -power, et permet également à GCC de générer des instructions qui sont présentes dans l'architecture POWER2, mais pas dans l'architecture POWER originale.

L'option -mpowerpc permet à GCC de générer des instructions qui ne se trouvent que dans le sous-ensemble 32 bits de l'architecture PowerPC. Spécifier -mpowerpc-gpopt implique -mpowerpc et permet également à GCC d'utiliser les instructions optionnelles d'architecture PowerPC du groupe General Purpose (à usage général), ce qui inclut la racine carrée flottante. Spécifier -mpowerpc-gfxopt implique -mpowerpc et permet également à GCC d'utiliser les instructions optionnelles d'architecture PowerPC du groupe Graphics, ce qui inclut le « select » flottant.

L'option -mpowerpc64 permet à GCC de générer les instructions 64 bits additionnelles qui se trouvent dans l'architecture PowerPC64, et de traiter les GPRs en tant que quantités 64 bits (double mots). GCC utilise -mno-powerpc64 par défaut.

Si vous spécifiez -mno-power et -mno-powerpc, GCC n'utilisera que les instructions provenant du sous-ensemble commun aux deux architectures, plus certains appels spéciaux AIX en mode commun, et n'utilisera pas le registre MQ. Spécifier -mpower et -mpowerpc permet à GCC d'utiliser n'importe quelle instruction de l'une quelconque des architectures, et d'utiliser le registre MQ ; spécifiez ceci pour le Motorola MPC601.

-mnew-mnemonics
-mold-mnemonics
Sélectionner quels mnémoniques utiliser dans le code assembleur généré. Avec -mnew-mnemonics, GCC utilise les mnémoniques assembleur définis pour l'architecture PowerPC. Avec -mold-mnemonics, il utilise les mnémoniques assembleur définis pour l'architecture POWER. Les instructions définies pour une seule architecture n'ont qu'un seul mnémonique ; GCC utilise ce mnémonique quelle que soit l'option spécifiée.

GCC utilise par défaut les mnémoniques appropriés à l'architecture utilisée. Spécifier -mcpu=type-cpu surcharge parfois la valeur de cette option. À moins que vous ne construisiez un compilateur croisé, vous ne devriez spécifier ni -mnew-mnemonics, ni -mold-mnemonics, mais devriez à la place accepter le comportement par défaut

-mcpu=type-cpu
Fixer le type d'architecture, l'utilisation des registres, le choix des mnémoniques, et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont rios, rios1, rsc, rios2, rs64a, 601, 602, 603, 603e, 604, 604e, 620, 630, 740, 7400, 7450, 750, power, power2, powerpc, 403, 505, 801, 821, 823, 860 et common.

-mcpu=common sélectionne un processeur complètement générique. Du code généré avec cette option tournera sur tout processeur POWER ou PowerPC. GCC n'utilisera que les instructions du sous-ensemble commun aux deux architectures, et n'utilisera pas le registre MQ. GCC suppose un modèle de processeur générique approprié à des fins d'ordonnancement.

-mcpu=power, -mcpu=power2, -mcpu=powerpc, et -mcpu=powerpc64 spécifient des types de machine d'architecture POWER, POWER2, PowerPC 32 bits pur (c.-à-d. pas MPC601), et PowerPC 64 bits, avec un modèle de processeur générique approprié à des fins d'ordonnancement.

Les autres options spécifient un processeur spécifique. Du code généré avec ces options tournera le mieux sur ce processeur, et peut ne pas tourner du tout sur d'autres.

Les options -mcpu activent ou désactivent automatiquement d'autres options -m de la façon suivante :

common
-mno-power, -mno-powerc
power
power2
rios1
rios2
rsc
-mpower, -mno-powerpc, -mno-new-mnemonics
powerpc
rs64a
602
603
603e
604
620
630
740
7400
7450
750
505
-mno-power, -mpowerpc, -mnew-mnemonics
601
-mpower, -mpowerpc, -mnew-mnemonics
403
821
860
-mno-power, -mpowerpc, -mnew-mnemonics, -msoft-float
-mtune=type-cpu
Fixer les paramètres d'ordonnancement des instructions pour le type de machine type-cpu, mais ne pas fixer le type d'architecture, l'utilisation des registres ou le choix des mnémoniques comme le ferait -mcpu=type-cpu. Les valeurs de type-cpu utilisées par -mtune sont les mêmes que celles de -mcpu. Si ces deux options sont spécifiées de concert, le code généré utilisera l'architecture, les registres et les mnémoniques définis par -mcpu, mais les paramètres d'ordonnancement fixés par -mtune.
-maltivec
-mno-altivec
Ces interrupteurs activent ou désactivent l'utilisation des fonctions intégrées qui donnent accès au jeu d'instructions AltiVec. Vous pourriez également devoir utiliser -mabi=altivec pour ajuster l'ABI courante avec les améliorations AltiVec.
-mfull-toc
-mno-fp-in-toc
-mno-sum-in-toc
-mminimal-toc
Modifier la génération de la TOC (Table Of Contents, table des matières), qui est créée pour chaque fichier exécutable. L'option -mfull-toc est sélectionnée par défaut. Dans ce cas, GCC allouera au moins une entrée dans la TOC pour chaque référence de variable non automatique dans votre programme. GCC placera également des constantes flottantes dans la TOC. Néanmoins, seules 16384 entrées sont disponibles dans la TOC.

Si vous recevez un message d'erreur de la part de l'éditeur de liens disant que vous avez dépassé l'espace disponible dans la TOC, vous pouvez réduire l'espace de TOC utilisé avec les options -mno-fp-in-toc et -mno-sum-in-toc. -mno-fp-in-toc empêche GCC de placer des constantes flottantes dans la TOC et -mno-sum-in-toc force GCC à générer du code pour calculer la somme d'une adresse et d'une constante au moment de l'exécution au lieu de placer cette somme dans la TOC. Vous pouvez spécifier l'une de ces options ou les deux en même temps. Chacune oblige GCC à produire un code très légèrement plus lent et gros afin d'épargner de l'espace dans la TOC.

Si vous êtes toujours à court d'espace dans la TOC même quand vous spécifiez ces deux options, spécifiez -mminimal-toc à la place. Cette option force GCC à ne créer qu'une entrée dans la TOC pour chaque fichier. Quand vous spécifiez cette option, GCC produira du code qui sera plus lent et plus gros mais qui utilisera extrêmement peu d'espace dans la TOC. Vous pourriez n'utiliser cette option que pour des fichiers contenant du code moins fréquemment exécuté.

-maix64
-maix32
Activer l'ABI et la convention d'appel AIX 64 bits : les pointeurs 64 bits, le type « long » 64 bits, et l'infrastructure nécessaire pour les supporter. Spécifier -maix64 implique -mpowerpc64 et -mpowerpc, alors que -maix32 désactive l'ABI 64 bits et implique -mno-powerpc64. GCC utilise -maix32 par défaut.
-mxl-call
-mno-xl-call
Sur AIX, passer les arguments flottants à des fonctions prototypées au-delà de la zone de sauvegarde des registres (Register Save Area, RSA) sur la pile en plus des arguments FPRs (frame pointer, cadre de pile). La convention d'appel AIX a été étendue mais n'a pas été initialement documentée pour traiter un cas obscur du C K&R d'un appel de fonction qui prend l'adresse de ses arguments avec moins d'arguments que déclaré. Les compilateurs AIX XL accèdent aux arguments flottants qui ne tiennent pas dans la RSA de la pile quand une sous-routine est compilée sans optimisation. Puisque toujours stocker les arguments flottants sur la pile est inefficace et rarement nécessaire, cette option n'est pas activée par défaut et n'est nécessaire que lors d'appel de sous-routines compilées par les compilateurs AIX XL sans optimisation.
-mpe
Supporter l'IBM RS/6000 SP Parallel Environment (PE, environnement parallèle). Lier une application écrite pour utiliser le passage de messages avec un code de démarrage spécial pour permettre à l'application de pouvoir s'exécuter. Le système doit disposer du PE installé à l'endroit standard (/usr/lpp/ppe.poe/), ou le fichier de specs doit être surchargé avec l'option -specs= pour spécifier la localisation du répertoire approprié. L'Environnement Parallèle ne supporte pas les threads, de sorte que les options -mpe et -pthread sont incompatibles.
-msoft-float
-mhard-float
Générer du code qui n'utilise pas (qui utilise) le groupe de registres flottants. Une émulation logicielle des flottants est fournie si vous utilisez l'option -msoft-float, et passez l'option à GCC lors de l'édition des liens.
-mmultiple
-mno-multiple
Générer du code qui utilise (qui n'utilise pas) les instructions de chargement de plusieurs mots (load multiple word) et les instructions de stockage de plusieurs mots (store multiple word). Ces instructions sont générées par défaut sur les systèmes POWER, et ne sont pas générées sur les systèmes PowerPC. N'utilisez pas -mmultiple sur des systèmes PowerPC petit-boutistes, car ces instructions ne fonctionnent pas quand le processeur fonctionne en mode petit-boutiste. Les exceptions sont PPC740 et PPC750 qui permettent l'utilisation des instructions en mode petit-boutiste.
-mstring
-mno-string
Générer du code qui utilise (qui n'utilise pas) les instructions de chargement de chaînes de caractères (load string), et les instructions de stockage de mot de chaîne (store string word) afin d'épargner de multiples registres et d'effectuer de petits déplacements de blocs. Ces instructions sont générées par défaut sur les systèmes POWER, et ne sont pas générées sur les systèmes PowerPC. N'utilisez pas -mstring sur des systèmes PowerPC petit-boutistes, car ces instructions ne fonctionnent pas quand le processeur fonctionne en mode petit-boutiste. Les exceptions sont PPC740 et PPC750 qui permettent l'utilisation des instructions en mode petit-boutiste.
-mupdate
-mno-update
Générer du code qui utilise (qui n'utilise pas) les instructions de chargement ou de stockage qui mettent à jour le registre de base en lui donnant pour valeur l'adresse de l'emplacement mémoire calculé. Ces instructions sont générées par défaut. Si vous utilisez -mno-update, il y a un petit délai entre le moment où le pointeur de pile est mis à jour, et celui où l'adresse du cadre précédent est stockée, ce qui signifie que le code qui traverse le cadre de pile lors d'interruptions ou de signaux peut voir ses données corrompues.
-mfused-madd
-mno-fused-madd
Générer du code qui utilise (qui n'utilise pas) les instructions flottantes de multiplication (multiply) et d'accumulation (accumulate). Ces instructions sont générées par défaut si des flottants « matériels » sont utilisés.
-mno-bit-align
-mbit-align
Sur System V.4 et les systèmes PowerPC embarqués, forcer (ne pas forcer) les structures et les unions contenant des champs-bit à être alignées au type de base du champ-bit.

Par exemple, une structure ne contenant rien à part 8 champs-bit « unsigned » de longueur 1 serait alignée à une limite de 4 octets et aurait une taille de 4 octets. En utilisant -mno-bit-align, la structure serait alignée à une limite de 1 octet et aurait une taille de 1 octet.

-mno-strict-align
-mstrict-align
Sur System V.4 et les systèmes PowerPC embarqués, ne pas supposer (supposer) que les références mémoire non alignées peuvent être traitées par le système.
-mrelocatable
-mno-relocatable
Sur les systèmes PowerPC embarqués, générer du code qui permet (ne permet pas) au programme d'être relogé à une adresse différente au moment de l'exécution. Si vous utilisez -mrelocatable sur un module, tous les objets liés avec lui doivent être compilés avec -mrelocatable ou -mrelocatable-lib.
-mrelocatable-lib
-mno-relocatable-lib
Sur les systèmes PowerPC embarqués, générer du code qui permet (ne permet pas) au programme d'être relogé à une adresse différente au moment de l'exécution. Les modules compilés avec -mrelocatable-lib peuvent être liés aussi bien avec des modules compilés sans -mrelocatable et -mrelocatable-lib, qu'avec des modules compilés avec les options -mrelocatable.
-mno-toc
-mtoc
Sur System V.4 et les systèmes PowerPC embarqués, ne pas supposer (supposer) que le registre 2 contient un pointeur vers une zone globale pointant vers les adresses utilisées dans le programme.
-mlittle
-mlittle-endian
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le processeur en mode petit-boutiste. L'option -mlittle-endian est identique à -mlittle.
-mbig
-mbig-endian
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le processeur en mode gros-boutiste. L'option -mbig-endian est identique à -mbig.
-mcall-sysv
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code utilisant des conventions d'appel qui adhèrent au document de travail de mars 1995 de l'Application Binary Interface System V, complément pour le processeur PowerPC. C'est le comportement par défaut à moins que vous n'ayez configuré GCC en utilisant powerpc-*-eabiaix.
-mcall-sysv-eabi
Spécifier les options -mcall-sysv et -meabi.
-mcall-sysv-noeabi
Spécifier les options -mcall-sysv et -mno-eabi.
-mcall-aix
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code utilisant des conventions d'appel qui sont similaires à celles utilisées sur AIX. C'est le comportement par défaut à moins que vous n'ayez configuré GCC en utilisant powerpc-*-eabiaix.
-mcall-solaris
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le système d'exploitation Solaris.
-mcall-linux
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour les systèmes GNU basés sur Linux.
-mcall-gnu
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour les systèmes GNU basés sur Hurd.
-mcall-netbsd
Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le système d'exploitation NetBSD.
-maix-struct-return
Retourner toutes les structures en mémoire (comme spécifié par l'ABI AIX).
-msvr4-struct-return
Retourner les structures de moins de 8 octets dans des registres (comme spécifié par l'ABI SVR4).
-mabi=altivec
Étendre l'ABI courante avec les extensions AltiVec de l'ABI. Cela ne modifie pas l'ABI par défaut ; au lieu de cela, les extensions AltiVec de l'ABI sont ajoutées à l'ABI courante.
-mabi=no-altivec
Désactiver les extensions AltiVec de l'ABI pour l'ABI courante.
-mprototype
-mno-prototype
Sur System V.4 et les systèmes PowerPC embarqués, supposer que tous les appels à des fonctions prenant un nombre variable d'arguments sont correctement prototypées. Sinon, le compilateur doit insérer une instruction avant chaque appel non prototypé pour allumer ou éteindre le bit 6 du registre de code de condition (CR) afin d'indiquer si des valeurs flottantes ont été passées dans les registres flottants au cas où la fonction prendrait un nombre variable d'arguments. Avec -mprototype, seuls les appels à des fonctions prototypées à nombre variable d'arguments allumeront ou éteindront le bit.
-msim
Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé sim-crt0.o, et que les bibliothèques C standard sont libsim.a et libc.a. Utilisé par défaut pour les configurations powerpc-*-eabisim.
-mmvme
Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libmvme.a et libc.a.
-mads
Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libads.a et libc.a.
-myellowknife
Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libyk.a et libc.a.
-mvxworks
Sur System V.4 et les systèmes PowerPC embarqués, spécifier que vous compilez pour un système VxWorks.
-memb
Sur les systèmes PowerPC embarqués, allumer le bit PPC_EMB dans l'en-tête de drapeaux ELF pour indiquer que des relogements étendus eabi sont utilisés.
-meabi
-mno-eabi
Sur System V.4 et les systèmes PowerPC embarqués, adhérer (ou pas) à la Embedded Applications Binary Interface (eabi) qui constitue un ensemble de modifications aux spécifications System V.4. Sélectionner -meabi signifie que la pile est alignée à une limite de 8 octets, une fonction « __eabi » est appelée à partir de « main » pour établir l'environnement eabi, et l'option -msdata peut utiliser à la fois « r2 » et « r13 » pour pointer sur deux petites zones de données séparées. Sélectionner -mno-eabi signifie que la pile est alignée à une limite de 16 octets, ne pas appeler une fonction d'initialisation à partir de « main », et l'option -msdata n'utilisera que « r13 » pour pointer sur une unique petite zone de données. L'option -meabi est activée par défaut si vous avez configuré GCC en utilisant l'une des options powerpc*-*-eabi*.
-msdata=eabi
Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques « const » initialisées dans la section .sdata2, vers laquelle pointe le registre « r2 ». Placer les petites données globales statiques non-« const » initialisées dans la section .sdata, vers laquelle pointe le registre « r13 ». Placer les petites données globales statiques non initialisées dans la section .sbss, qui est adjacente à la section .sdata. L'option -msdata=eabi est incompatible avec l'option -mrelocatable. L'option -msdata=eabi active également l'option -memb.
-msdata=sysv
Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques dans la section .sdata, vers laquelle pointe le registre « r13 ». Placer les petites données globales statiques non initialisées dans la section .sbss, qui est adjacente à la section .sdata. L'option -msdata=sysv est incompatible avec l'option -mrelocatable.
-msdata=default
-msdata
Sur System V.4 et les systèmes PowerPC embarqués, si -meabi est utilisé, compiler du code comme pour -msdata=eabi, sinon compiler du code comme pour -msdata=sysv.
-msdata-data
Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques dans la section .sdata. Placer les petites données globales statiques non initialisées dans la section .sbss. Néanmoins, ne pas utiliser le registre « r13 » pour adresser les petites données. C'est le comportement par défaut à moins que d'autres options -msdata ne soient utilisées.
-msdata=none
-mno-sdata
Sur les systèmes PowerPC embarqués, placer toutes les données globales statiques initialisées dans la section .data, et toutes les données non initialisées dans la section .bss.
-G nombre
Sur les systèmes PowerPC embarqués, placer les éléments globaux et statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. Par défaut, nombre est 8. L'interrupteur -G nombre est également passé à l'éditeur de liens. Tous les modules devraient être compilés avec la même valeur pour -G nombre.
-mregnames
-mno-regnames
Sur System V.4 et les systèmes PowerPC embarqués, émettre (ou pas) des noms de registres dans la sortie en langage assembleur en utilisant des formes symboliques.
-pthread
Ajouter le support pour le multithreading en utilisant la bibliothèque pthreads. Cette option définit des drapeaux pour le préprocesseur et l'éditeur des liens.

Options IBM RT

Ces options -m sont définies pour le PC IBM RT :

-min-line-mul
Utiliser une séquence de code en ligne pour les multiplications d'entiers. C'est le comportement par défaut.
-mcall-lib-mul
Appeler « lmul$$ » pour la multiplication d'entiers.
-mfull-fp-blocks
Générer des blocs de données flottantes de taille complète, incluant le montant minimal d'espace de scratch (gribouillage) recommandé par IBM. C'est le comportement par défaut.
-mminimum-fp-blocks
Ne pas inclure d'espace de scratch supplémentaire dans les blocs de données flottantes. Cela résulte en un code plus court, mais en une exécution plus lente, puisque l'espace de scratch doit être alloué dynamiquement.
-mfp-arg-in-fpregs
Utiliser une séquence d'appel incompatible avec la convention d'appel d'IBM dans lequel les arguments flottants sont passés dans des registres flottants. Notez que « varargs.h » et « stdarg.h » ne fonctionneront pas avec des opérandes flottants si cette option est spécifiée.
-mfp-arg-in-gregs
Utiliser la convention d'appel normale pour les arguments flottants. C'est le comportement par défaut.
-mhc-struct-return
Retourner les structures de plus d'un mot en mémoire, plutôt que dans un registre. Ceci fournit la compatibilité avec le compilateur MetaWare HighC (hc). Utilisez l'option -fpcc-struct-return pour la compatibilité avec le compilateur Portable C Compiler (pcc).
-mnohc-struct-return
Retourner certaines structures de plus d'un mot dans des registres, quand c'est opportun. C'est le comportement par défaut. Pour la compatibilité avec les compilateurs fournis par IBM, utilisez ou bien -fpcc-struct-return ou bien -mhc-struct-return.

Options MIPS

Ces options -m sont définies pour la famille d'ordinateurs MIPS :

-march=type-cpu
Supposer les valeurs par défaut pour le type de machine type-cpu lors de la génération d'instructions. Les choix pour type-cpu sont r2000, r3000, r3900, r4000, r4100, r4300, r4400, r4600, r4650, r5000, r6000, r8000 et orion. De plus, les r2000, r3000, r4000, r5000 et r6000 peuvent être abrégés en r2k (ou r2K), r3k, etc.
-mtune=type-cpu
Supposer les valeurs par défaut pour le type de machine type-cpu lors de l'ordonnancement des instructions. Les choix pour type-cpu sont r2000, r3000, r3900, r4000, r4100, r4300, r4400, r4600, r4650, r5000, r6000, r8000 et orion. De plus, r2000, r3000, r4000, r5000 et r6000 peuvent être abrégées en r2k (ou r2K), r3k, etc. Bien qu'utiliser un type-cpu spécifique règle les choses de façon appropriée pour cette puce particulière, le compilateur ne générera pas de code qui ne répond pas au niveau 1 de l'ISA MIPS (Instruction Set Architecture, architecture de jeu d'instructions) si aucun interrupteur -mipsX ou -mabi n'est utilisé.
-mcpu=type-cpu
Revient à spécifier -march et -mtune de concert.
-mips1
Émettre des instructions pour le niveau 1 de l'ISA MIPS. C'est le comportement par défaut. r3000 est le type-cpu par défaut à ce niveau ISA.
-mips2
Émettre des instructions pour le niveau 2 de l'ISA MIPS (instructions de branchement probable, racine carrée). r6000 est le type-cpu par défaut à ce niveau ISA.
-mips3
Émettre des instructions pour le niveau 3 de l'ISA MIPS (instructions 64 bits). r4000 est le type-cpu par défaut à ce niveau ISA.
-mips4
Émettre des instructions pour le niveau 4 de l'ISA MIPS (instructions de déplacement conditionnel, prérecherche, de FPU améliorée). r8000 est le type-cpu par défaut à ce niveau ISA.
-mfp32
Supposer que 32 registres flottants 32 bits sont disponibles. C'est le comportement par défaut.
-mfp64
Supposer que 32 registres flottants 64 bits sont disponibles. C'est le comportement par défaut quand l'option -mips3 est utilisée.
-mfused-madd
-mno-fused-madd
Générer du code qui utilise (n'utilise pas) les instructions de multiplication (multiply) et d'accumulation (accumulate) flottantes, quand elles sont disponibles. Ces instructions sont générées par défaut si elles sont disponibles, mais cela peut être indésirable si la précision supplémentaire cause certains problèmes, ou sur certaines puces dans le mode où les nombres dénormalisés sont arrondis vers zéro lorsque ces nombres dénormalisés générés par des instructions de multiplication et d'accumulation flottantes déclenchent des exceptions.
-mgp32
Supposer que 32 registres 32 bits à usage général sont disponibles. C'est le comportement par défaut.
-mgp64
Supposer que 32 registres 64 bits à usage général sont disponibles. C'est le comportement par défaut quand l'option -mips3 est utilisée.
-mint64
Forcer les types int et long à avoir 64 bits de large. Voyez -mlong32 pour en savoir plus sur la largeur par défaut, et sur la largeur des pointeurs.
-mlong64
Forcer les types long à avoir 64 bits de large. Voyez -mlong32 pour en savoir plus sur la largeur par défaut, et sur la largeur des pointeurs.
-mlong32
Forcer les types long, int et pointeurs à avoir 32 bits de large.

Si aucune des options -mlong32, -mlong64 ou -mint64 n'est utilisée, la taille des ints, longs et pointeurs dépend de l'ABI et de l'ISA choisies. Pour -mabi=32 et -mabi=n32, les ints et longs font 32 bits de large. Pour -mabi=64, les ints font 32 bits, et les longs font 64 bits de large. Pour -mabi=eabi et -mips1 ou -mips2, les ints et les longs font 32 bits de large. Pour -mabi=eabi et des ISAs plus élevées, les ints font 32 bits, et les longs font 64 bits de large. La largeur des types pointeurs est le minimum de la largeur des longs et de la largeur des registres à usage général (qui dépend à son tour de l'ISA).

-mabi=32
-mabi=o64
-mabi=n32
-mabi=64
-mabi=eabi
Générer du code pour l'ABI indiquée. Le niveau d'instructions par défaut est -mips1 pour 32, -mips3 pour n32 et -mips4 sinon. Inversement, avec -mips1 ou -mips2, l'ABI par défaut est 32 ; sinon, l'ABI par défaut est 64.
-mmips-as
Générer du code pour l'assembleur MIPS, et invoquer mips-tfile pour ajouter des informations de débogage normales. C'est le comportement par défaut pour toutes les plate-formes sauf pour la plate-forme de référence OSF/1, utilisant le format objet OSF/rose. Si l'un des deux interrupteurs -gstabs ou -gstabs+ est utilisé, le programme mips-tfile encapsulera le stabs à l'intérieur d'ECOFF MIPS.
-mgas
Générer du code pour l'assembleur GNU. C'est le comportement par défaut pour la plate-forme de référence OSF/1, utilisant le format objet OSF/rose. C'est également utilisé par défaut si l'option de configuration --with-gnu-as est employée.
-msplit-addresses
-mno-split-addresses
Générer du code pour charger les parties haute et basse des constantes adresses séparément. Cela permet à GCC d'optimiser les chargements redondants des bits de poids forts des adresses. Cette optimisation requiert GNU as et GNU ld. Cette optimisation est activée par défaut pour certaines cibles embarquées où GNU as et GNU ld sont standard.
-mrnames
-mno-rnames
L'interrupteur -mrnames indique de produire du code utilisant les noms logiciels MIPS pour les registres, au lieu des noms matériels (p.ex. a0 au lieu de $4). Le seul assembleur connu qui supporte cette option est l'assembleur Algorithmics.
-mgpopt
-mno-gpopt
L'interrupteur -mgpopt indique d'écrire toutes les déclarations de données avant les instructions dans la section de texte ; ceci permet à l'assembleur MIPS de générer des références mémoire d'un mot au lieu d'utiliser deux mots pour les éléments de données globaux courts ou statiques. C'est activé par défaut si l'optimisation est sélectionnée.
-mstats
-mno-stats
Pour chaque fonction non en ligne traitée, l'interrupteur -mstats oblige le compilateur à émettre une ligne dans le fichier standard d'erreurs pour afficher des statistiques sur le programme (nombre de registres sauvegardés, taille de la pile, etc.).
-mmemcpy
-mno-memcpy
L'interrupteur -mmemcpy fait appeler à tous les déplacements de blocs la fonction de chaînes de caractères appropriée (memcpy ou bcopy) au lieu d'éventuellement générer du code en ligne.
-mmips-tfile
-mno-mips-tfile
L'interrupteur -mno-mips-tfile interdit au compilateur de post-traiter le fichier objet avec le programme mips-tfile après que l'assembleur MIPS l'ait généré pour ajouter un support au débogage. Si mips-tfile n'est pas lancé, alors aucune variable locale ne sera accessible au débogueur. De plus, les objets stage2 et stage3 verront les noms des fichiers temporaires passés à l'assembleur en étant embarqués dans le fichier objet, ce qui signifie que les objets ne seront pas comparés comme étant égaux. L'interrupteur -mno-mips-tfile ne devrait être utilisé que lorsqu'il y a des bogues dans le programme mips-tfile qui empêchent la compilation.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.
-mhard-float
Générer une sortie contenant des instructions flottantes. C'est le comportement par défaut si vous utilisez les sources non modifiées.
-mabicalls
-mno-abicalls
Émettre (ou ne pas émettre) les pseudo-opérations .abicalls, .cpload et .cprestore que certains portages System V.4 utilisent pour du code indépendant de la position.
-mlong-calls
-mno-long-calls
Effectuer tous les appels avec l'instruction JALR, qui requiert le chargement d'une adresse de fonction dans un registre avant l'appel. Vous devez utiliser cet interrupteur si vous appelez des fonctions situées hors du segment de 512 Mo actuel sans utiliser de pointeurs de fonction pour ce faire.
-mhalf-pic
-mno-half-pic
Placer les pointeurs vers des références externes dans la section de données, et les charger, plutôt que de placer les références dans la section de texte.
-membedded-pic
-mno-embedded-pic
Générer du code PIC convenant à certains systèmes embarqués. Tous les appels sont effectués en utilisant l'adresse relative au PC, et toutes les données sont adressées en utilisant le registre $gp. Pas plus de 65536 octets de données globales peuvent être utilisés. Ceci requiert GNU as et GNU ld qui font la plus grosse partie du travail. Cela fonctionne actuellement sur les cibles qui utilisent ECOFF ; cela ne fonctionne pas avec ELF.
-membedded-data
-mno-embedded-data
Allouer des variables dans la section de données accessibles en lecture uniquement en premier lieu si c'est possible, sinon dans la petite section de données si c'est possible, sinon dans les données. Cela donne du code légèrement plus lent que le code par défaut, mais réduit la taille en RAM requise lors de l'exécution, ce qui peut donc être préféré pour certains systèmes embarqués.
-muninit-const-in-rodata
-mno-uninit-const-in-rodata
Quand il est utilisé de concert avec -membedded-data, il stockera toujours les variables const non initialisées dans la section de données accessibles en lecture uniquement.
-msingle-float
-mdouble-float
L'interrupteur -msingle-float indique à gcc de supposer que le coprocesseur flottant ne supporte que les opérations en simple précision, comme sur la puce r4650. L'interrupteur -mdouble-float permet à gcc d'utiliser les opérations en double précision. C'est le comportement par défaut.
-mmad
-mno-mad
Autoriser l'utilisation des instructions mad, madu et mul, comme sur la puce r4650.
-m4650
Activer -msingle-float, -mmad et, du moins à l'heure actuelle, -mcpu=r4650.
-mips16
-mno-mips16
Permettre les instructions 16 bits.
-mentry
Utiliser les pseudo-opérations entry et exit. Cette option ne peut être utilisée qu'avec -mips16.
-EL
Compiler du code pour le processeur en mode petit-boutiste. Les bibliothèques requises sont censées exister.
-EB
Compiler du code pour le processeur en mode gros-boutiste. Les bibliothèques requises sont censées exister.
-G nombre
Placer les éléments globaux et statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. Ceci permet à l'assembleur d'émettre des instructions de référence mémoire d'un mot basées sur le pointeur global (gp ou $28), au lieu des deux mots habituels. Par défaut, nombre vaut 8 quand l'assembleur MIPS est utilisé, et 0 quand l'assembleur GNU est utilisé. L'interrupteur -G nombre est également transmis à l'assembleur et à l'éditeur de liens. Tous les modules devraient être compilés avec la même valeur pour -G nombre.
-nocpp
Indiquer à l'assembleur MIPS de ne pas exécuter son préprocesseur sur les fichiers assembleur utilisateurs (possédant le suffixe .s) lors de leur assemblage.
-mfix7000
Passer une option à gas qui provoquera l'insertion de nops (instructions factices) si la lecture du registre destination d'une instruction mfhi ou mflo se produit dans les deux instructions suivantes.
-no-crt0
Ne pas inclure le crt0 par défaut.
-mflush-func=fonc
-mno-flush-func
Spécifie la fonction à appeler pour vider les caches I et D, ou ne pas appeler de telles fonctions. Si elle est appelée, la fonction doit prendre les mêmes arguments que la fonction « _flush_func() » habituelle, c.-à-d. l'adresse de l'intervalle mémoire pour lequel le cache est en cours de vidage, la taille de l'intervalle mémoire, et le nombre 3 (pour vider les deux caches). La fonction par défaut dépend de la cible pour laquelle gcc a été configuré, mais est habituellement soit _flush_func soit __cpu_flush.

Ces options sont définies par la macro de description de machine « TARGET_SWITCHES ». Les options par défaut sont également définies par cette macro, qui vous permet de les modifier.

Options Intel 386 et AMD x86-64

Ces options -m sont définies pour les familles d'ordinateurs i386 et x86-64 :

-mcpu=type-cpu
Optimaliser pour type-cpu tout ce qui s'applique au code généré, sauf en ce qui concerne l'ABI et le jeu d'instructions disponibles. Les choix possibles pour type-cpu sont i386, i486, i586, i686, pentium, pentium-mmx, pentiumpro, pentium2, pentium3, pentium4, k6, k6-2, k6-3, athlon, athlon-tbird, athlon-4, athlon-xp et athlon-mp.

Bien qu'utiliser un type-cpu spécifique réglera les choses de façon appropriée pour cette puce particulière, le compilateur ne générera pas de code ne tournant pas sur le i386 si l'option -march=type-cpu n'est pas utilisée. i586 est équivalent à pentium et i686 est équivalent à pentiumpro. k6 et athlon sont les puces d'AMD concurrentes de celles d'Intel.

-march=type-cpu
Générer des instructions pour le type de machine type-cpu. Les choix pour type-cpu sont les mêmes que pour -mcpu. De plus, spécifier -march=type-cpu implique -mcpu=type-cpu.
-m386
-m486
-mpentium
-mpentiumpro
Ces options sont des synonymes pour -mcpu=i386, -mcpu=i486, -mcpu=pentium et -mcpu=pentiumpro respectivement. Ces synonymes sont dépréciés.
-mfpmath=unité
Générer des arithmétiques flottantes pour l'unité sélectionnée. Les choix pour unité sont :
387
Utiliser le coprocesseur flottant 387 standard présent sur la majorité des puces et émulé sinon. Du code compilé avec cette option s'exécutera presque partout. Les résultats temporaires sont calculés en précision 80 bits au lieu de la précision spécifiée par le type, ce qui résulte en des résultats légèrement différents si on les compare avec ceux de la plupart des autres puces. Voyez -ffloat-store pour une description plus détaillée.

C'est le choix par défaut pour le compilateur i386.

sse
Utiliser les instructions flottantes scalaires présentes dans le jeu d'instructions SSE. Ce jeu d'instructions est supporté par le Pentium 3 et d'autres puces plus récentes, dans la ligne de produits AMD depuis les puces Athlon-4, Athlon-xp et Athlon-mp. La version plus ancienne du jeu d'instructions SSE ne supporte que les arithmétiques en simple précision, et les arithmétiques en précision double et étendue sont donc toujours effectuées en utilisant le 387. La version plus récente, présente uniquement sur le Pentium 4 et les futures puces AMD x86-64, supporte également les arithmétiques double précision.

Pour l'i387, vous devez utiliser les interrupteurs -march=type-cpu, -msse ou -msse2 pour activer les extensions SSE et rendre cette option utile. Pour le compilateur x86-64, ces extensions sont activées par défaut.

Le code résultant devrait être beaucoup plus rapide dans la majorité des cas et éviter les problèmes d'instabilité numérique du code 387, mais peut briser du code existant qui s'attend à ce que les variables temporaires aient 80 bits.

C'est le choix par défaut pour le compilateur x86-64.

sse,387
Essayer d'utiliser les deux jeux d'instructions simultanément. Cela double effectivement le nombre de registres disponibles et également les ressources à l'exécution sur des puces disposant d'unités d'exécution séparées pour les instructions 387 et SSE. Utilisez cette option avec précaution, car elle est toujours expérimentale, étant donné que l'allocateur de registres de gcc ne modélise pas bien les unités fonctionnelles séparées, ce qui génère des performances instables.
-masm=dialecte
Produire des instructions asm utilisant le dialecte sélectionné. Les choix supportés sont intel et att (le dialecte par défaut).
-mieee-fp
-mno-ieee-fp
Contrôler si le compilateur utilise ou pas les comparaisons flottantes IEEE. Celles-ci traitent correctement le cas où le résultat d'une comparaison n'est pas ordonné.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

Sur les machines où une fonction retourne des résultats flottants dans la pile de registres 80387, certains codes opératoires flottants peuvent être émis même si -msoft-float est utilisé.

-mno-fp-ret-in-387
Ne pas utiliser les registres de la FPU pour les valeurs de retour des fonctions.

La convention d'appel habituelle retourne les valeurs de retour de fonction des types « float » et « double » dans un registre de la FPU, même s'il n'y a pas de FPU, l'idée sous-jacente étant que le système d'exploitation devrait émuler une FPU.

L'option -mno-fp-ret-in-387 fait renvoyer de telles valeurs dans des registres CPU ordinaires à la place.

-mno-fancy-math-387
Certains émulateurs 387 ne supportent pas les instructions « sin », « cos » et « sqrt » pour le 387. Spécifiez cette option pour éviter de générer ces instructions. C'est utilisé par défaut sous FreeBSD, OpenBSD et NetBSD. Cette option est surchargée quand -march indique que le cpu cible aura toujours une FPU et que l'instruction ne nécessite pas d'émulation. À partir de la révision 2.6.1, ces instructions ne sont pas générées à moins que vous utilisiez également l'interrupteur -funsafe-math-optimizations.
-malign-double
-mno-align-double
Contrôler si GCC aligne les variables « double », « long double » et « long long » à des limites de deux ou de un mots. Aligner les variables « double » à des limites de deux mots produira du code tournant un peu plus rapidement sur un Pentium aux dépens d'une plus grosse consommation mémoire.

Avertissement : si vous utilisez l'interrupteur -malign-double, les structures contenant les types prémentionnés seront alignées différemment de ce qui est édicté dans les spécifications d'interface binaire applicative publiées pour le 386.

-m128bit-long-double
Contrôler la taille du type « long double ». L'interface d'application binaire i386 spécifie que sa taille doit être de 12 octets, alors que les architectures modernes (Pentium et supérieurs) préfèrent que « long double » soit aligné à des limites de 8 ou 16 octets. C'est impossible à atteindre avec des doubles d'une longueur de 12 octets lors des accès à des tableaux.

Avertissement : si vous utilisez l'interrupteur -m128bit-long-double, les structures et les tableaux contenant des « long double » verront leur taille modifiée. De plus, la convention d'appel de fonction pour les fonctions prenant des « long double » sera modifiée.

-m96bit-long-double
Fixer la taille de « long double » à 96 bits comme requis par l'ABI. C'est le comportement par défaut.
-msvr3-shlib
-mno-svr3-shlib
Contrôler si GCC place des variables locales non initialisées dans les segments « bss » ou « data ». -msvr3-shlib les place dans « bss ». Ces options ne sont significatives que sous System V Release 3.
-mrtd
Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant avec l'instruction « ret » nombre, qui dépile ses arguments en sortant. Ceci épargne une instruction à l'appelant qui ne doit alors pas dépiler les arguments.

Vous pouvez spécifier qu'une fonction individuelle est appelée avec cette séquence d'appel avec l'attribut de fonction stdcall. Vous pouvez également surcharger l'option -mrtd en utilisant l'attribut de fonction cdecl.

Avertissement : cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

Vous devez également fournir des prototypes de fonction pour toutes les fonctions prenant un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En plus, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

-mregparm=nombre
Contrôler le nombre de registres qui sont utilisés pour passer des arguments entiers. Par défaut, aucun registre n'est utilisé pour passer des arguments, et au plus 3 registres peuvent être utilisés. Vous pouvez contrôler ce comportement pour une fonction spécifique en utilisant l'attribut de fonction regparm.

Avertissement : si vous utilisez cet interrupteur, et que nombre est non nul, alors vous devez construire tous les modules avec la même valeur, ce qui inclut toutes les bibliothèques, y compris les bibliothèques systèmes et les modules de démarrage.

-mpreferred-stack-boundary=nombre
Essayer de garder la limite de la pile alignée à des limites de 2 exposant nombre octets. Si -mpreferred-stack-boundary n'est pas spécifié, la limite par défaut est 4 (16 octets ou 128 bits), sauf lors d'une optimisation pour la taille du code (-Os), auquel cas l'alignement par défaut est l'alignement correct minimum (4 octets pour les x86, et 8 octets pour les x86-64).

Sur Pentium et PentiumPro, les valeurs « double » et « long double » devraient être alignées à des limites de 8 octets (voyez -malign-double) ou souffriront sinon de pénalités significatives en termes de temps d'exécution. Sur Pentium III, le type de données « __m128 » de la Streaming SIMD Extension (SSE) souffre de pénalités similaires s'il n'est pas aligné à une limite de 16 octets.

Pour s'assurer de l'alignement correct de ces valeurs sur la pile, la limite de la pile doit être alignée comme requis par toutes les valeurs stockées sur la pile. En outre, chaque fonction doit être générée de sorte qu'elle garde la pile alignée. Ainsi, appeler une fonction compilée avec une frontière de pile préférée plus haute à partir d'une fonction compilée avec une frontière de pile préférée plus basse alignera probablement mal la pile. Il est recommandé que les bibliothèques utilisant des rappels (callbacks) emploient toujours le réglage par défaut.

Cet alignement supplémentaire consomme de l'espace supplémentaire sur la pile, et accroît généralement la taille du code. Le code qui est sensible à l'utilisation d'espace de la pile, comme les systèmes embarqués et les noyaux de systèmes d'exploitation, pourrait vouloir réduire l'alignement préféré à -mpreferred-stack-boundary=2.

-mmmx
-mno-mmx
-msse
-mno-sse
-msse2
-mno-sse2
-m3dnow
-mno-3dnow
Ces interrupteurs activent ou désactivent l'utilisation des fonctions intégrées permettant un accès direct aux extensions MMX, SSE et 3Dnow du jeu d'instructions.
-mpush-args
-mno-push-args
Utiliser des opérations PUSH pour stocker les paramètres sortants. Cette méthode est plus courte et habituellement aussi rapide que la méthode utilisant des opérations SUB/MOV et est activée par défaut. Dans certains cas, la désactiver peut améliorer la performance grâce à un ordonnancement amélioré et à des dépendances réduites.
-maccumulate-outgoing-args
Si cette option est activée, la quantité maximale d'espace requis pour les arguments sortants sera calculée dans le prologue de la fonction. C'est plus rapide sur la plupart des CPUs modernes performance grâce à des dépendances réduites, un ordonnancement amélioré et une utilisation de la pile réduite quand la frontière de pile préférée n'est pas égale à 2. L'inconvénient est un accroissement respectable de la taille du code. Cet interrupteur implique -mno-push-args.
-mthreads
Supporter un traitement des exceptions fiable en présence de threads (thread-safe) sur Mingw32. Le code qui se base sur le traitement des exceptions fiable en présence de threads doit compiler et lier tout le code avec l'option -mthreads. Lors de la compilation, -mthreads définit -D_MT ; lors de l'édition des liens, il lie avec une bibliothèque assistante spéciale pour les threads -lmingwthrd qui nettoie les données de traitement des exceptions pour chaque thread.
-mno-align-stringops
Ne pas aligner la destination d'opérations sur des chaînes de caractères en ligne. Cet interrupteur réduit la taille du code et améliore la performance au cas où la destination serait déjà alignée, mais gcc ne le sait pas.
-minline-all-stringops
Par défaut, GCC ne met en ligne les opérations sur des chaînes de caractères que lorsqu'il sait que la destination est alignée à des limites d'au moins 4 octets. Ceci permet plus de mise en ligne, accroît la taille du code, mais peut améliorer la performance du code qui dépend de memcpy, strlen et memset rapides pour les courtes longueurs.
-momit-leaf-frame-pointer
Ne pas conserver le pointeur de cadre dans un registre pour les fonctions feuilles. Ceci évite les instructions pour sauver, établir et restaurer les pointeurs de cadre, et libère un registre supplémentaire qui sera disponible dans les fonctions feuilles. L'option -fomit-frame-pointer supprime le pointeur de cadre pour toutes les fonctions où cela pourrait compliquer le débogage.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus sur les processeurs AMD x86-64 dans les environnements 64 bits.

-m32
-m64
Générer du code pour un environnement 32 ou 64 bits. L'environnement 32 bits fixe les int, long et pointeurs à 32 bits et génère du code qui tourne sur tout système i386. L'environnement 64 bits fixe les int, long et pointeurs à 64 bits et génère du code destiné à l'architecture AMD x86-64.
-mno-red-zone
Ne pas utiliser de zone dite « rouge » pour le code x86-64. La zone rouge est mandatée par l'ABI x86-64, elle est formée d'une zone de 128 octets située au-delà de l'emplacement du pointeur de pile qui ne sera pas modifiée par des gestionnaires de signaux ou d'interruptions et peut donc être utilisée pour des données temporaires sans devoir ajuster le pointeur de pile. Le drapeau -mno-red-zone désactive cette zone rouge.
-mcmodel=small
Générer du code pour le modèle de code restreint : le programme et ses symboles doivent être liés dans les 2 GB inférieurs de l'espace d'adressage. Les pointeurs font 64 bits. Les programmes peuvent être liés statiquement ou dynamiquement. C'est le modèle de code par défaut.
-mcmodel=kernel
Générer du code pour le modèle de code du noyau. Le noyau s'exécute dans les 2 GB négatifs de l'espace d'adressage. Ce modèle doit être utilisé pour le code du noyau Linux.
-mcmodel=medium
Générer du code pour le modèle intermédiaire : le programme est lié dans les 2 GB inférieurs de l'espace d'adressage mais les symboles peuvent être situés n'importe où dans l'espace d'adressage. Les programmes peuvent être liés statiquement ou dynamiquement, mais la construction de bibliothèques partagées n'est pas possible avec ce modèle.
-mcmodel=large
Générer du code pour le modèle étendu : ce modèle ne fait aucune supposition quant aux adresses et à la taille des sections. Actuellement, GCC n'implémente pas ce modèle.

Options HPPA

Ces options -m sont définies pour la famille d'ordinateurs HPPA :

-march=type-architecture
Générer du code pour l'architecture spécifiée. Les choix possibles pour type-architecture sont 1.0 pour PA 1.0, 1.1 pour PA 1.1, et 2.0 pour les processeurs PA 2.0. Référez-vous à /usr/lib/sched.models sur un système HP-UX pour déterminer l'option d'architecture correcte pour votre machine. Du code compilé pour des architectures de numéro inférieur bas tournera sur des architectures de numéro supérieur, mais pas l'inverse.

Le support PA 2.0 requiert actuellement gas snapshot 19990413 ou ultérieur. La prochaine version de binutils (actuellement 2.9.1) contiendra probablement le support PA 2.0.

-mpa-risc-1-0
-mpa-risc-1-1
-mpa-risc-2-0
Synonymes pour -march=1.0, -march=1.1 et -march=2.0 respectivement.
-mbig-switch
Générer du code convenant aux grandes tables de branchements. N'utilisez cette option que si l'assembleur/éditeur de liens se plaint de branchements hors d'atteinte dans une table de branchements.
-mjump-in-delay
Remplir les tranches de temps d'appels de fonction avec des instructions de saut inconditionnel en modifiant le pointeur de retour pour que l'appel de fonction soit la cible du saut conditionnel.
-mdisable-fpregs
Empêcher l'utilisation des registres flottants de quelque manière que ce soit. C'est nécessaire pour compiler des noyaux qui effectuent une commutation de contexte paresseuse des registres flottants. Si vous utilisez cette option et essayez d'effectuer des opérations flottantes, le compilateur échouera.
-mdisable-indexing
Empêcher le compilateur d'utiliser les modes d'adressage indexés. Cela évite quelques rares problèmes obscurs lors de la compilation de code généré par MIG sous MACH.
-mno-space-regs
Générer du code qui suppose que la cible ne dispose pas de registres d'espace. Cela permet à GCC de générer des appels indirects plus rapides, et d'utiliser des modes d'adressage indexés sans multiplicateur.
-mfast-indirect-calls
Générer du code qui suppose que les appels ne traversent jamais les frontières spatiales. Cela permet à GCC d'émettre du code qui effectue des appels indirects plus rapides.

Cette option ne fonctionnera pas en présence de bibliothèques partagées ou de fonctions imbriquées.

-mlong-load-store
Générer des séquences de chargement et de stockage de 3 instructions comme c'est parfois requis par l'éditeur de liens de HP-UX 10. C'est équivalent à l'option +k pour les compilateurs HP.
-mportable-runtime
Utiliser les conventions d'appel portables proposées par HP pour les systèmes ELF.
-mgas
Activer l'utilisation des directives assembleur comprises par le seul GAS.
-mschedule=type-cpu
Ordonnance le code en fonction des contraintes pour le type de machine type-cpu. Les choix possibles pour type-cpu sont 700, 7100, 7100LC, 7200 et 8000. Référez-vous à /usr/lib/sched.models sur un système HP-UX pour déterminer l'option d'ordonnancement correcte pour votre machine.
-mlinker-opt
Autoriser la passe d'optimisation dans l'éditeur de liens de HPUX. Notez que cela rend le débogage symbolique impossible. Cela déclenche également un bogue dans les éditeurs de liens de HPUX 8 et HPUX 9 où ils fournissent des messages d'erreur erronés lors de l'édition des liens de certains programmes.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne sont pas disponibles pour toutes les cibles HPPA. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. La cible embarquée hppa1.1-*-pro fournit un support logiciel des flottants.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

Options Intel 960

Ces options -m sont définies pour les implémentations Intel 960 :

-mtype-cpu
Supposer les valeurs par défaut pour le type de machine type-cpu pour certaines des autres options, incluant l'ordonnancement des instructions, le support des flottants, et les modes d'adressage. Les choix pour type-cpu sont ka, kb, mc, ca, cf, sa et sb. Le type de cpu par défaut est kb.
-mnumerics
-msoft-float
L'option -mnumerics indique que le processeur supporte les instructions flottantes. L'option -msoft-float indique que le support des flottants ne devrait pas être présupposé.
-mleaf-procedures
-mno-leaf-procedures
Essayer (ne pas essayer) de modifier les procédures feuilles pour qu'elles soient appelables avec l'instruction « bal » aussi bien qu'avec « call ». Il en résultera un code plus efficace pour les appels explicites quand l'instruction « bal » peut être substituée par l'assembleur ou l'éditeur de liens, mais un code moins efficace dans d'autres cas, comme pour les appels via des pointeurs de fonction, ou quand on utilise un éditeur de liens ne supportant pas cette optimisation.
-mtail-call
-mno-tail-call
Faire (ou pas) des tentatives supplémentaires (en plus de celles des parties du compilateur indépendantes de la machine) d'optimiser les appels récursifs terminaux grâce à des branchements. Cela n'est pas conseillé, car la détection des cas où ce n'est pas valide n'est pas totalement achevée. -mno-tail-call est utilisé par défaut.
-mcomplex-addr
-mno-complex-addr
Supposer (ou ne pas supposer) que l'utilisation d'un mode d'adressage complexe génère un gain sur cette implémentation du i960. Des modes d'adressage complexes peuvent ne pas valoir le coup sur les séries K, mais ils le valent nettement sur les séries C. -mcomplex-addr est actuellement utilisé par défaut pour tous les processeurs sauf le CB et le CC.
-mcode-align
-mno-code-align
Aligner le code à des limites de 8 octets pour une recherche plus rapide (ou ne pas s'en soucier). Actuellement activé par défaut uniquement sur les implémentations de la série C.
-mic-compat
-mic2.0-compat
-mic3.0-compat
Permettre la compatibilité avec l'iC960 v2.0 ou v3.0.
-masm-compat
-mintel-asm
Permettre la compatibilité avec l'assembleur iC960.
-mstrict-align
-mno-strict-align
Permettre (ou pas) des accès non alignés.
-mold-align
Permettre la compatibilité au niveau alignement des structures avec la version 1.3 de la version Intel de gcc (basée sur gcc 1.37). Cette option implique -mstrict-align.
-mlong-double-64
Implémenter le type long double comme des nombres flottants 64 bits. Sans cette option, long double est implémenté par des nombres flottants 80 bits. La seule raison pour laquelle c'est supporté est qu'il n'y a pas encore de support des long double 128 bits dans fp-bit.c. Cette option n'est donc utile que pour les personnes utilisant des cibles flottantes logicielles. Sinon, nous recommandons de ne pas l'utiliser.

Options DEC Alpha

Ces options -m sont définies pour les implémentations DEC Alpha :

-mno-soft-float
-msoft-float
Utiliser (ne pas utiliser) les instructions flottantes matérielles pour les opérations flottantes. Quand -msoft-float est spécifié, des fonctions de libgcc.a seront utilisées pour effectuer des opérations flottantes. À moins qu'elles ne soient remplacées par des routines qui émulent les opérations flottantes, ou qu'elles soient compilées pour faire en sorte qu'elles appellent de telles routines d'émulation, ces routines émettront des opérations flottantes. Si vous compilez pour un Alpha ne disposant pas des opérations flottantes, vous devez vous assurer que la bibliothèque est construite de façon telle qu'elle ne les appelle pas.

Notez que les implémentations Alpha sans opérations flottantes sont requises pour avoir des registres flottants.

-mfp-reg
-mno-fp-regs
Générer du code qui utilise (n'utilise pas) le jeu de registres flottants. -mno-fp-regs implique -msoft-float. Si le jeu de registres flottants n'est pas utilisé, les opérandes flottants sont passés dans des registres entiers comme s'ils étaient des entiers et les résultats flottants sont passés dans « $0 » au lieu de « $f0 ». C'est une séquence d'appel non standard, et chaque fonction possédant un argument ou une valeur de retour flottante qui est appelée par du code compilé avec -mno-fp-regs doit donc également être compilée avec cette option.

Une utilisation typique de cette option est la création d'un noyau qui n'utilise aucun registre flottant, et donc n'a besoin ni d'en sauver, ni d'en restaurer.

-mieee
L'architecture Alpha implémente des flottants matériels optimisés pour obtenir une performance maximale. Elle est en grande partie conforme au standard des flottants IEEE. Néanmoins, pour une conformité totale, une assistance logicielle est nécessaire. Cette option génère du code entièrement conforme à IEEE sauf que le drapeau-inexact n'est pas maintenu (voyez ci-dessous). Si cette option est activée, la macro « _IEEE_FP » du préprocesseur CPP est définie durant la compilation. Le code résultant est moins efficace mais est capable de supporter correctement les nombres dénormalisés et les valeurs IEEE exceptionnelles comme pas-un-nombre (NaN) et plus ou moins l'infini. D'autres compilateurs Alpha appellent cette option -ieee_with_no_inexact.
-mieee-with-inexact
Comme -mieee, sauf que le code généré maintient aussi le drapeau-inexact IEEE. Activer cette option rend le code généré totalement compatible avec les maths IEEE. En plus de « _IEEE_FP », « _IEEE_FP_EXACT » est défini comme macro du préprocesseur. Sur certaines implémentations Alpha, le code résultant peut s'exécuter beaucoup plus lentement que le code généré par défaut. Puisqu'il n'y a très peu de code qui dépend du drapeau-inexact, vous ne devriez normalement pas spécifier cette option. D'autres compilateurs Alpha appellent cette option -ieee_with_inexact.
-mfp-trap-mode=mode-interruption
Cette option contrôle quelles interruptions relatives aux flottants il faut activer. D'autres compilateurs Alpha appellent cette option -fptm mode-interruption. Le mode d'interruption peut valoir l'une des quatre valeurs suivantes :
n
C'est le réglage par défaut (normal). Les seules interruptions qui sont activées sont celles qui ne peuvent être désactivées en logiciel (p.ex. l'interruption due à une division par zéro).
u
En plus des interruptions activées par n, les interruptions dues aux dépassements négatifs de capacité (underflow) sont également activées.
su
Comme su, mais les instructions sont marquées comme étant sûres pour l'achèvement (completion) de logiciels (voyez le manuel d'architecture Alpha pour les détails).
sui
Comme su, mais les interruptions « inexactes » sont également activées.
-mfp-rounding-mode=mode-arrondi
Sélectionner le mode d'arrondi IEEE. D'autres compilateurs Alpha appellent cette option -fprm mode-arrondi. Le mode-arrondi peut être :
n
Mode d'arrondi IEEE normal. Les nombres flottants sont arrondis vers le nombre machine le plus proche, ou vers le nombre machine pair en cas d'égalité.
m
Arrondir vers moins l'infini.
c
Mode d'arrondi coupé. Les nombres flottants sont arrondis vers zéro.
d
Mode d'arrondi dynamique. Un champ du registre de contrôle flottant (fpcr, voyez le manuel de référence de l'architecture Alpha) contrôle le mode d'arrondi en cours. La bibliothèque C initialise ce registre pour un arrondi vers plus l'infini. Donc, à moins que votre programme ne modifie le fpcr, d correspond à l'arrondi vers plus l'infini.
-mtrap-precision=précision-interruption
Dans l'architecture Alpha, les interruptions flottantes sont imprécises. Cela signifie que sans une assistance logicielle, il est impossible se remettre d'une interruption flottante et l'exécution du programme doit normalement être terminée. GCC peut générer du code qui assiste les gestionnaires d'interruptions du système d'exploitation pour déterminer l'endroit exact où s'est produit une interruption flottante. En fonction des besoins d'une application, différents niveaux de précision peuvent être sélectionnés :
p
Précision au programme. Cette option est la précision par défaut et signifie qu'un gestionnaire d'interruptions ne peut identifier que le programme qui a causé une exception flottante.
f
Précision à la fonction. Le gestionnaire d'interruptions peut déterminer la fonction qui a causé une exception flottante.
i
Précision à l'instruction. Le gestionnaire d'interruptions peut déterminer l'instruction exacte qui a causé une exception flottante.

D'autres compilateurs Alpha fournissent les options équivalentes appelées -scope_safe et -resumption_safe.
-mieee-conformant
Cette option marque le code généré comme étant conforme à IEEE. Vous ne devez pas utiliser cette option à moins que vous ne spécifiiez également -mtrap-precision=i et -mfp-trap-mode=su ou -mfp-trap-mode=sui. Son seul effet est d'émettre la ligne .eflag 48 dans le prologue de la fonction du fichier assembleur généré. Sous DEC Unix, cela a pour effet que les routines de bibliothèque mathématique conformes à IEEE seront intégrées lors de l'édition des liens.
-mbuild-constants
Normalement, GCC examine une constante entière 32 ou 64 bits pour voir s'il peut la construire à partir de constantes plus petites en deux ou trois instructions. S'il le peut, il émettra la constante comme un littéral et générera du code pour la charger à l'exécution à partir du segment de données.

Utilisez cette option pour indiquer à GCC de construire toutes les constantes entières en utilisant du code, même si cela prend plus d'instructions (le maximum est six).

Vous utiliseriez cette option typiquement pour construire un chargeur dynamique de bibliothèques partagées. Étant lui-même une bibliothèque partagée, il doit se reloger en mémoire avant qu'il puisse trouver les variables et les constantes dans son propre segment de données.

-malpha-as
-mgas
Indiquer s'il faut générer du code pouvant être assemblé par l'assembleur fourni par le vendeur (-malpha-as) ou par l'assembleur GNU -mgas.
-mbwx
-mno-bwx
-mcix
-mno-cix
-mfix
-mno-fix
-mmax
-mno-max
Indiquer si GCC doit générer du code pour utiliser les jeux d'instructions optionnels BWX, CIX, FIX et MAX. Le comportement par défaut est d'utiliser les jeux d'instructions supportés par le type de CPU spécifié via l'option -mcpu=, ou celui du CPU pour lequel GCC a été construit si aucun n'a été spécifié.
-mfloat-vax
-mfloat-ieee
Générer du code qui utilise (n'utilise pas) l'arithmétique flottante VAX F et G au lieu de la simple ou double précision IEEE.
-mexplicit-relocs
-mno-explicit-relocs
Des assembleurs Alpha anciens ne fournissaient aucun dispositif permettant de générer des relogements de symboles à l'exception des macros assembleur. Une de ces macros ne permet pas un ordonnancement optimal des instructions. Les binutils GNU supportent depuis la version 2.12 une nouvelle syntaxe qui permet au compilateur d'indiquer explicitement quels relogements devraient s'appliquer à quelles instructions. Cette option est principalement utile pour le débogage, car GCC détecte les capacités de l'assembleur quand il est construit et règle le défaut en conséquence.
-msmall-data
-mlarge-data
Quand -mexplicit-relocs est utilisé, les données statiques accessibles via des relogements relatifs-à-gp. Quand -msmall-data est utilisé, les objets faisant jusqu'à 8 octets de long sont placés dans une petite zone de données (les sections « .sdata » et « .sbss ») et peuvent être accédées via des relogements sur 16 bits par rapport au registre « $gp ». Ceci limite la taille de la petite zone de données à 64 Ko, mais permet aux variables d'être directement accessibles via une seule instruction.

L'option par défaut est -mlarge-data. Avec elle, la zone de données est limitée à un peu moins de 2 Go. Des programmes requérant plus de 2 Go de données doivent utiliser « malloc » ou « mmap » pour allouer les données dans le tas plutôt que dans le segment de données du programme.

Lors de la génération de code de bibliothèques partagées, -fpic implique -msmall-data et -fPIC implique -mlarge-data.

-mcpu=type-cpu
Fixer le jeu d'instructions et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Vous pouvez spécifier soit un nom du style EV, soit le numéro de puce correspondant. GCC supporte les paramètres d'ordonnancement des instructions pour les familles de processeurs EV4, EV5 et EV6 et choisira les valeurs par défaut pour le jeu d'instructions à partir du processeur que vous spécifiez. Si vous ne spécifiez pas de type de processeur, GCC utilisera par défaut le processeur pour lequel le compilateur a été construit.

Les valeurs supportées pour type-cpu sont

ev4
ev45
21064
Organise pour un EV4 et ne possède pas d'extensions au jeu d'instructions.
ev5
21164
Organise pour un EV5 et ne possède pas d'extensions au jeu d'instructions.
ev56
21164a
Organise pour un EV5 et supporte l'extension BWX.
pca56
21164pc
21164PC
Organise pour un EV5 et supporte les extensions BWX et MAX.
ev6
21264
Organise pour un EV6 et supporte les extensions BWX, FIX et MAX.
ev67
21264a
Organise pour un EV6 et supporte les extensions BWX, CIX, FIX et MAX.
-mtune=type-cpu
Fixer uniquement les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Le jeu d'instructions n'est pas modifié.
-mmemory-latency=temps
Fixer la latence que devrait supposer l'ordonnanceur pour les références mémoire typiques comme vues par l'application. Ce nombre est fortement dépendant des modèles d'accès mémoire utilisés par l'application, et de la taille de la cache externe sur la machine.

Les options valides pour temps sont

nombre
Un nombre décimal représentant les cycles d'horloge.
L1
L2
L3
main
Le compilateur conserve des estimations du nombre de cycles d'horloge pour du matériel « typique » EV4 & EV5 pour les caches de niveaux 1, 2 et 3 (appelées également Dcache, Scache et Bcache), ainsi que pour la mémoire principale. Notez que L3 n'est valide que pour EV5.

Options DEC Alpha/VMS

Ces options -m sont définies pour les implémentations DEC Alpha/VMS :

-mvms-return-codes
Retourner des codes de condition VMS depuis main. Le comportement défaut consisté à retourner des codes de condition (p.ex. d'erreur) de style POSIX.

Options Clipper

Ces options -m sont définies pour les implémentations Clipper :

-mc300
Produire du code pour un processeur Clipper C300. C'est le comportement par défaut.
-mc400
Produire du code pour un processeur Clipper C400, c.-à-d. utiliser les registres flottants f8--f15.

Options H8/300

Ces options -m sont définies pour les implémentations H8/300 :

-mrelax
Raccourcir certaines références mémoire au moment de l'édition des liens, quand c'est possible ; utilise l'option -relax de l'éditeur de liens.
-mh
Générer du code pour le H8/300H.
-ms
Générer du code pour le H8/S.
-ms2600
Générer du code pour le H8/S2600. Cet interrupteur doit être utilisé avec -ms.
-mint32
Faire de « int » une valeur 32 bits par défaut.
-malign-300
Sur le H8/300H et H8/S, utiliser les mêmes règles d'alignement que pour le H8/300. Le comportement par défaut pour les H8/300H et H8/S est d'aligner les longs et les flottants à des limites de 4 octets. -malign-300 provoque leur alignement à des limites de 2 octets. Cette option n'a pas d'effet sur le H8/300.

Options SH

Ces options -m sont définies pour les implémentations SH :

-m1
Générer du code pour le SH1.
-m2
Générer du code pour le SH2.
-m3
Générer du code pour le SH3.
-m3e
Générer du code pour le SH3e.
-m4-nofpu
Générer du code pour le SH4 sans unité flottante.
-m4-single-only
Générer du code pour le SH4 avec une unité flottante ne supportant que l'arithmétique simple précision.
-m4-single
Générer du code pour le SH4 en supposant que l'unité flottante est en mode simple précision par défaut.
-m4
Générer du code pour le SH4.
-mb
Compiler du code pour le processeur en mode gros-boutiste.
-ml
Compiler du code pour le processeur en mode petit-boutiste.
-mdalign
Aligner les doubles à des limites de 64 bits. Notez que cela modifie les conventions d'appel, et certaines fonctions de la bibliothèque C standard ne fonctionneront donc pas à moins que vous ne la recompiliez d'abord avec -mdalign.
-mrelax
Raccourcir certaines références mémoire au moment de l'édition des liens, quand c'est possible ; utilise l'option -relax de l'éditeur de liens.
-mbigtable
Utiliser des décalages de 32 bits dans les tables de branchements. Le comportement par défaut est d'utiliser des décalages de 16 bits.
-mfmovd
Permettre l'utilisation de l'instruction « fmovd ».
-mhitachi
Se conformer aux conventions d'appel définies par Hitachi.
-mnomacsave
Marquer le registre « MAC » comme étant corrompu par l'appel, même si -mhitachi est fourni.
-mieee
Accroître la conformité IEEE du code flottant.
-misize
Décharger la taille et la localisation de l'instruction dans le code assembleur.
-mpadstruct
Cette option est dépréciée. Elle bourre les structures jusqu'à un multiple de 4 octets, ce qui est incompatible avec l'ABI SH.
-mspace
Optimiser pour l'espace au lieu de la vitesse. Impliqué par -Os.
-mprefergot
Lors de la génération de code indépendant de la position, émettre des appels de fonction en utilisant la table de décalages globale (Global Offset Table, GOT) au lieu de la table de liaison de procédures (Procedure Linkage Table).
-musermode
Générer un appel de fonction de bibliothèque pour invalider les entrées du cache d'instructions, après avoir corrigé un trampoline (NdT : bloc de code permettant de préparer un contexte d'appel pour une autre fonction). Cet appel de fonction de bibliothèque ne suppose pas qu'il puisse écrire dans l'espace d'adressage mémoire complet. C'est le comportement par défaut quand la cible est « sh-*-linux* ».

Options pour System V

Ces options additionnelles sont disponibles sur System V Release 4 pour la compatibilité avec les autres compilateurs sur ces systèmes :

-G
Créer un objet partagé. Il est recommandé d'utiliser -symbolic ou -shared à la place.
-Qy
Identifier les versions de chaque outil utilisé par le compilateur, dans une directive d'assemblage « .ident » dans la sortie.
-Qn
Ne pas ajouter de directives « .ident » dans le fichier de sortie (c'est le comportement par défaut).
-YP,répertoires
Rechercher les bibliothèques spécifiées avec -l dans les répertoires répertoires, et aucun autre.
-Ym,répertoire
Recherche le préprocesseur M4 dans le répertoire répertoire. L'assembleur utilise cette option.

Options TMS320C3x/C4x

Ces options -m sont définies pour les implémentations TMS320C3x/C4x :

-mcpu=type-cpu
Fixer le jeu d'instructions, le jeu de registres, et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont c30, c31, c32, c40 et c44. Le type de machine par défaut est c40 qui indique de générer du code pour le TMS320C40.
-mbig-memory
-mbig
-msmall-memory
-msmall
Générer du code pour le modèle de mémoire étendu ou restreint. Le modèle de mémoire restreint supposait que toutes les données tenaient dans une page de 64 Ko. Au moment de l'exécution, le registre de page de données (Data Page, DP) doit pointer vers la page de 64 K contenant les sections de programme .bss et .data. Le modèle de mémoire étendu est utilisé par défaut et requiert le rechargement du registre DP pour chaque accès mémoire direct.
-mbk
-mno-bk
Permettre (interdire) l'allocation d'opérandes entiers généraux dans le registre de comptage de blocs BK.
-mdb
-mno-db
Activer (désactiver) la génération de code utilisant les instructions Decrement And Branch (décrémenter et brancher), DBcond(D). C'est activé par défaut pour le C4x. Par sécurité, c'est désactivé pour le C3x, puisque le nombre maximum d'itérations sur le C3x est 2^{23 + 1} (mais qui itère des boucles plus de 2^{23} fois sur le C3x ? ). Notez que GCC essaiera de renverser une boucle afin qu'il puisse utiliser l'instruction de décrémentation et de branchement, mais abandonnera s'il y a plus d'une référence mémoire dans la boucle. Une boucle dont le compteur de boucle est décrémenté peut donc générer du code légèrement plus efficace, dans les cas où l'instruction RPTB ne peut être utilisée.
-mdp-isr-reload
-mparanoid
Forcer la sauvegarde du registre DP à l'entrée d'une routine de service d'interruption (ISR), son rechargement à ce moment dans la section de données, et sa restauration à la sortie de l'ISR. Cela ne devrait pas être requis sauf si quelqu'un a violé le modèle de mémoire restreint en modifiant le registre DP, par exemple dans une bibliothèque objet.
-mmpyi
-mno-mpyi
Pour le C3x, utiliser l'instruction 24 bits MPYI pour les multiplications d'entiers au lieu d'un appel de bibliothèque pour garantir des résultats sur 32 bits. Notez que si l'un des opérandes est une constante, alors la multiplication sera effectuée en utilisant des décalages et des additions. Si l'option -mmpyi n'est pas spécifiée pour le C3x, alors les opérations de prise de racine carrée sont effectuées en ligne au lieu de via un appel de bibliothèque.
-mfast-fix
-mno-fast-fix
L'instruction C3x/C4x FIX, pour convertir une valeur flottante en valeur entière, choisit l'entier le plus proche plus petit ou égal à la valeur flottante plutôt que l'entier le plus proche. Donc, si le nombre flottant est négatif, le résultat sera incorrectement tronqué ; un code additionnel est nécessaire pour détecter et corriger ce cas. Cette option peut être utilisée pour désactiver la génération du code additionnel requis pour corriger le résultat.
-mrptb
-mno-rptb
Activer (désactiver) la génération de séquences de blocs de répétitions (repeat block sequences) utilisant l'instruction RPTB pour une surcharge de bouclage nulle. La construction RPTB n'est utilisée que pour les boucles les plus internes qui n'appellent pas de fonction ni ne sautent en dehors des limites de la boucle. Il n'y a aucun avantage à avoir des boucles RPTB imbriquées, à cause de la surcharge requise pour sauver et restaurer les registres RC, RS et RE. C'est activé par défaut avec -O2.
-mrpts=nombre
-mno-rpts
Activer (désactiver) l'utilisation de l'instruction de répétition employant une seule instruction RPTS. Si un bloc de répétition contient une seule instruction, et que l'on peut garantir que le nombre de boucles vaut moins de nombre, GCC émettra une instruction RPTS au lieu d'une instruction RPTB. Si aucune valeur n'est spécifiée, alors un RPTS sera émis même si le nombre de boucles ne peut être déterminé au moment de la compilation. Notez que l'instruction répétée suivant RPTS ne doit pas être rechargée à partir de la mémoire à chaque itération, libérant ainsi les bus CPU pour les opérandes. Néanmoins, puisque les interruptions sont bloquées par cette instruction, elle est désactivée par défaut.
-mloop-unsigned
-mno-loop-unsigned
Le nombre maximum d'itérations lors de l'utilisation de RPTS et RPTB (et DB sur le C40) est 2^{31 + 1} puisque ces instructions testent si le nombre d'itérations est négatif pour terminer la boucle. Si le nombre d'itérations est non signé, il y a une possibilité que le nombre maximum d'itérations de 2^{31 + 1} puisse être dépassé. Cet interrupteur autorise un nombre d'itérations non signé.
-mti
Essayer d'émettre une syntaxe assembleur que comprend l'assembleur TI (asm30). Cela renforce également la compatibilité avec l'API utilisée par le compilateur TI C3x C. Par exemple, les long doubles sont passés dans des structures plutôt que dans des registres flottants.
-mregparm
-mmemparm
Générer du code qui utilise les registres (la pile) pour passer des arguments aux fonctions. Par défaut, les arguments sont passés dans des registres quand c'est possible plutôt que de les placer sur la pile.
-mparallel-insns
-mno-parallel-insns
Permettre la génération d'instructions parallèles. C'est activé par défaut avec -O2.
-mparallel-mpy
-mno-parallel-mpy
Permettre la génération des instructions parallèles MPY||ADD et MPY||SUB, à condition que -mparallel-insns soit également spécifié. Ces instructions souffrent de contraintes serrées sur les registres qui peuvent affecter la génération de code pour les grosses fonctions.

Options V850

Ces options -m sont définies pour les implémentations V850 :

-mlong-calls
-mno-long-calls
Traiter tous les appels comme étant lointains (proches). Si les appels sont supposés être lointains, le compilateur chargera toujours l'adresse de la fonction dans un registre, et l'appellera indirectement via le pointeur.
-mno-ep
-mep
Ne pas optimiser (optimiser) les blocs de base qui utilisent le même pointeur d'index 4 fois ou plus pour copier le pointeur dans le registre « ep », et utiliser les instructions plus courtes « sld » et « sst ». L'option -mep est activée par défaut si vous optimisez.
-mno-prolog-function
-mprolog-function
Utiliser (ne pas utiliser) de fonctions externes pour sauver et restaurer des registres au prologue et à l'épilogue d'une fonction. Les fonctions externes sont plus lentes, mais utilisent moins d'espace de code si plus d'une fonction sauve le même nombre de registres. L'option -mprolog-function est activée par défaut si vous optimisez.
-mspace
Essayer de rendre le code le plus compact possible. Actuellement, cela active simplement les options -mep et -mprolog-function.
-mtda=n
Placer les variables statiques ou globales dont la taille est d'au plus n octets dans la minuscule zone de données vers laquelle pointe le registre « ep ». La minuscule zone de données peut contenir jusqu'à 256 octets au total (128 octets pour les références d'octets).
-msda=n
Placer les variables statiques ou globales dont la taille est d'au plus n octets dans la petite zone de données vers laquelle pointe le registre « gp ». La petite zone de données peut contenir jusqu'à 64 Ko.
-mzda=n
Placer les variables statiques ou globales dont la taille est d'au plus n octets dans les 32 premiers Ko de la mémoire.
-mv850
Spécifier que le processeur cible est le V850.
-mbig-switch
Générer du code convenant aux grandes tables de branchements. N'utilisez cette option que si l'assembleur/éditeur de liens se plaint de branchements hors d'atteinte à l'intérieur d'une table de branchements.

Options ARC

Ces options sont définies pour les implémentations ARC :

-EL
Compiler du code pour le mode petit-boutiste. C'est le comportement par défaut.
-EB
Compiler du code pour le mode gros-boutiste.
-mmangle-cpu
Ajouter le nom du cpu au début de tous les noms de symboles publics. Dans les systèmes multi-processeurs, il y a de nombreuses variantes ARC avec différentes caractéristiques de jeux d'instructions et de registres. Ce drapeau empêche que du code compilé pour un cpu puisse être lié avec du code compilé pour un autre. Aucun mécanisme n'existe pour le traitement de variantes comme les « presque identique ». C'est une option tout ou rien.
-mcpu=cpu
Compiler du code pour la variante de processeur ARC cpu. Les variantes qui sont supportées dépendent de la configuration. Toutes les variantes supportent -mcpu=base, c'est le comportement par défaut.
-mtext=section-texte
-mdata=section-données
-mrodata=section-données-lecture-seule
Placer les fonctions, les données et les données accessibles en lecture uniquement dans les section-texte, section-données et section-données-lecture-seule respectivement par défaut. Cela peut être surchargé avec l'attribut « section ».

Options NS32K

Voici les options -m définies pour la série 32000. Les valeurs par défaut pour ces options dépendent du style de 32000 qui a été sélectionné quand le compilateur a été configuré ; celles pour la plupart des choix courants sont fournies plus bas.

-m32032
-m32032
Générer une sortie pour un 32032. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32032 ou de 32016.
-m32332
-m32332
Générer une sortie pour un 32332. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32332.
-m32532
-m32532
Générer une sortie pour un 32532. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32532.
-m32081
Générer une sortie contenant des instructions 32081 pour flottants. C'est le comportement par défaut sur tous les systèmes.
-m32381
Générer une sortie contenant des instructions 32381 pour flottants. Cela implique également -m32081. Le 32381 n'est compatible qu'avec les processeurs 32332 et 32532. C'est le comportement par défaut pour la configuration pc532-netbsd.
-mmulti-add
Essayer de générer des instructions flottantes multiplier-additionner « polyF » et « dotF ». Cette option n'est disponible que si l'option -m32381 est utilisée. Utiliser ces instructions requiert des modifications à l'allocation des registres qui ont généralement un impact négatif sur les performances. Cette option ne devrait être activée que lors de la compilation de code particulièrement enclin à faire un usage intensif des instructions multiplier-additionner.
-mnomulti-add
Ne pas essayer de générer les instructions flottantes multiplier-additionner « polyF » et « dotF ». C'est le comportement par défaut sur toutes les plate-formes.
-msoft-float
Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises peuvent ne pas être disponibles.
-mnobitfield
Ne pas utiliser les instructions champ-bit. Sur certaines machines, il est plus rapide d'utiliser des opérations de décalage et de masquage. C'est le comportement par défaut pour le pc532.
-mbitfield
Utiliser les instructions champ-bit. C'est le comportement par défaut pour toutes les plate-formes sauf le pc532.
-mrtd
Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant en dépilant leurs arguments en sortie avec l'instruction « ret ».

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

Vous devez également fournir des prototypes de fonction pour toutes les fonctions prenant un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En plus, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

Cette option tire son nom de l'instruction 680x0 « rtd ».

-mregparam
Utiliser une convention d'appel de fonction différente, dans laquelle les deux premiers arguments sont passés dans des registres.

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

-mnoregparam
Ne pas passer d'arguments dans les registres. C'est le comportement par défaut pour toutes les cibles.
-msb
On peut utiliser sb comme un registre d'index qui vaut toujours zéro. C'est le comportement par défaut pour la cible pc532-netbsd.
-mnosb
Le registre n'est pas disponible pour utilisation ou n'a pas été initialisé à zéro par le système d'exécution. C'est le comportement par défaut pour toutes les cibles sauf le pc532-netbsd. C'est également impliqué à chaque fois que -mhimem ou -fpic est utilisé.
-mhimem
Beaucoup de modes d'adressage de la série ns32000 utilisent des déplacements pouvant aller jusqu'à 512 Mo. Si une adresse est située au-delà de 512 Mo, alors les déplacements à partir de zéro ne peuvent être utilisés. Cette option provoque la génération de code qui peut être chargé au-delà de 512 Mo. Cela peut être utile pour les systèmes d'exploitation, ou pour du code de la ROM.
-mnohimem
Supposer que du code sera chargé dans les 512 premiers Mo d'espace d'adressage virtuel. C'est le comportement par défaut pour toutes les plate-formes.

Options AVR

Ces options sont définies pour les implémentations AVR :

-mmcu=mcu
Spécifier le jeu d'instructions AVR ATMEL ou le type MCU.

Le jeu d'instructions avr1 est destiné au coeur AVR minimal, non supporté par le compilateur C, uniquement pour les programmes assembleur (types MCU : at90s1200, attiny10, attiny11, attiny12, attiny15, attiny28).

Le jeu d'instructions avr1 est destiné au coeur AVR classique avec jusqu'à 8 K d'espace mémoire pour le programme (types MCU: at90s2313, at90s2323, attiny22, at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515, at90c8534, at90s8535).

Le jeu d'instructions avr1 est destiné au coeur AVR classique avec jusqu'à 128 Ko d'espace mémoire pour le programme (types MCU : atmega103, atmega603, at43usb320, at76c711).

Le jeu d'instructions avr1 est destiné au coeur AVR amélioré avec jusqu'à 8 Ko d'espace mémoire pour le programme (types MCU: atmega8, atmega83, atmega85).

Le jeu d'instructions avr1 est destiné au coeur AVR amélioré avec jusqu'à 128 Ko d'espace mémoire pour le programme (types MCU : atmega16, atmega161, atmega163, atmega32, atmega323, atmega64, atmega128, at43usb355, at94k).

-msize
Émettre la taille des instructions dans le fichier assembleur.
-minit-stack=N
Spécifier l'adresse initiale de la pile, qui peut être un symbole ou une valeur numérique (__stack par défaut).
-mno-interrupts
Le code généré n'est pas compatible avec les interruptions matérielles. La taille du code sera plus petite.
-mcall-prologues
Les prologues/épilogues des fonctions sont développés en appels aux sous-routines appropriées. La taille du code sera plus petite.
-mno-tablejump
Ne pas générer d'instructions de saut de table qui accroissent parfois la taille du code.
-mtiny-stack
Ne modifier que les 8 bits de poids faible du pointeur de pile.

Options MCore

Voici les options -m définies pour les processeurs Motorola M*Core :

-mhardlit
-mhardlit
-mno-hardlit
Mettre en ligne les constantes dans le flux du programme si cela peut être fait en deux instructions ou moins.
-mdiv
-mdiv
-mno-div
Utiliser l'instruction de division divide. (Activé par défaut).
-mrelax-immediate
-mrelax-immediate
-mno-relax-immediate
Autoriser des valeurs immédiates de taille quelconque dans les opérations sur les bits.
-mwide-bitfields
-mwide-bitfields
-mno-wide-bitfields
Toujours traiter les champs-bit comme s'ils avaient la taille d'un int.
-m4byte-functions
-m4byte-functions
-mno-4byte-functions
Forcer toutes les fonctions à être alignées à des limites de quatre octets.
-mcallgraph-data
-mcallgraph-data
-mno-callgraph-data
Émettre de l'information sur le graphe des appels.
-mslow-bytes
-mslow-bytes
-mno-slow-bytes
Préférer l'accès mot lors de la lecture de quantités de taille d'un octet.
-mlittle-endian
-mlittle-endian
-mbig-endian
Générer du code pour une cible petit-boutiste.
-m210
-m210
-m340
Générer du code pour le processeur 210.

Options IA-64

Voici les options -m définies pour l'architecture Intel IA-64 :

-mbig-endian
Générer du code pour une cible gros-boutiste. C'est le comportement par défaut pour HPUX.
-mlittle-endian
Générer du code pour une cible petit-boutiste. C'est le comportement par défaut pour AIX5 et Linux.
-mgnu-as
-mno-gnu-as
Générer (ou pas) du code pour l'assembleur GNU. C'est le comportement par défaut.
-mgnu-ld
-mno-gnu-ld
Générer (ou pas) du code pour l'éditeur de liens GNU. C'est le comportement par défaut.
-mno-pic
Générer du code qui n'utilise pas de registre de pointeur global. Le résultat n'est pas un code indépendant de la position, et viole l'ABI IA-64.
-mvolatile-asm-stop
-mno-volatile-asm-stop
Générer (ou pas) un bit d'arrêt immédiatement avant et après des instructions assembleur volatiles.
-mb-step
Générer du code qui contourne l'erreur de pas de l'Itanium B.
-mregister-names
-mno-register-names
Générer (ou pas) les noms de registres in, loc et out pour les registres empilés. Cela peut rendre plus lisible la sortie de l'assembleur.
-mno-sdata
-msdata
Désactiver (ou activer) les optimisations qui utilisent la petite section de données. Cela peut être utile pour contourner des bogues de l'optimiseur.
-mconstant-gp
Générer du code qui utilise une seule valeur de pointeur global constant. C'est utile quand on compile du code du noyau.
-mauto-pic
Générer du code qui est auto-relogeable. Ceci implique -mconstant-gp. C'est utile quand on compile du firmware.
-minline-divide-min-latency
Générer du code pour les divisions en ligne en utilisant l'algorithme de latence minimale.
-minline-divide-max-throughput
Générer du code pour les divisions en ligne en utilisant l'algorithme de débit maximum.
-mno-dwarf2-asm
-mdwarf2-asm
Générer (ou pas) du code assembleur code pour l'information de débogage DWARF2 sur les numéros de ligne. Cela peut être utile quand on n'utilise pas l'assembleur GNU.
-mfixed-range=intervalle-registres
Générer du code traitant l'intervalle de registres fournis comme des registres fixes. Un registre fixe est un registre que l'allocateur de registres ne peut utiliser. C'est utile quand on compile du code du noyau. Un intervalle de registres est spécifié par deux registres séparés par un tiret. Des intervalles de registres multiples peuvent être spécifiés en les séparant par des virgules.

Options D30V

Ces options -m sont définies pour les implémentations D30V :

-mextmem
Lier les sections .text, .data, .bss, .strings, .rodata, .rodata1 et .data1 en mémoire externe, qui débute à l'emplacement « 0x80000000 ».
-mextmemory
Identique à l'interrupteur -mextmem.
-monchip
Lier la section .text dans la mémoire texte sur la puce, qui débute à l'emplacement « 0x0 ». Lier également les sections .data, .bss, .strings, .rodata, .rodata1 et .data1 dans la mémoire de données sur la puce, qui débute à l'emplacement « 0x20000000 ».
-mno-asm-optimize
-masm-optimize
Désactiver (activer) le passage de -O à l'assembleur lors de l'optimisation. L'assembleur utilise l'option -O pour paralléliser des instructions courtes adjacentes quand c'est possible.
-mbranch-cost=n
Accroître les coûts internes des branchements à n. Des coûts plus élevés signifient que le compilateur émettra plus d'instructions pour éviter de devoir faire un branchement. La valeur par défaut est 2.
-mcond-exec=n
Spécifier le nombre maximum d'instructions exécutées conditionnellement qui remplacent un branchement. La valeur par défaut est 4.

Options S/390 et zSeries

Voici les options -m définies pour les architectures S/390 et zSeries :

-mhard-float
-msoft-float
Utiliser (ne pas utiliser) les instructions et registres flottants pour les opérations flottantes. Quand -msoft-float est spécifié, les fonctions de libgcc.a seront utilisées pour effectuer des opérations flottantes. Quand -mhard-float est spécifié, le compilateur génère des instructions flottantes IEEE. C'est le comportement par défaut.
-mbackchain
-mno-backchain
Générer (ne pas générer) du code qui conserve un chaînage arrière explicite à l'intérieur du cadre de pile qui pointe vers le cadre de l'appelant. Ce n'est actuellement nécessaire que pour permettre le débogage. Le comportement par défaut est de générer le chaînage arrière.
-msmall-exec
-mno-small-exec
Générer (ne pas générer) du code qui utilise l'instruction « bras » pour effectuer des appels de sous-routines. Cela ne fonctionne fiablement que si la taille totale de l'exécutable ne dépasse pas 64 Ko. Le comportement par défaut est d'utiliser l'instruction « basr » à la place, qui ne souffre pas de cette limitation.
-m64
-m31
Quand -m31 est spécifié, générer du code conforme à Linux pour l'ABI S/390. Quand -m64 est spécifié, générer du code conforme à Linux pour l'ABI zSeries. Cela permet en particulier à GCC de générer des instructions 64 bits. Pour les cibles s390, l'option par défaut est -m31, alors qu'elle est -m64 pour les cibles s390x.
-mmvcle
-mno-mvcle
Générer (ne pas générer) du code qui utilise l'instruction « mvcle » pour effectuer des déplacements de blocs. Quand -mno-mvcle est spécifié, utiliser une boucle « mvc » à la place. C'est le comportement par défaut.
-mdebug
-mno-debug
Afficher (ne pas afficher) des informations de débogage additionnelles lors de la compilation. Le comportement par défaut est d'afficher aucune information de débogage.

Options CRIS

Ces options sont définies spécifiquement pour les portages CRIS :

-march=type-architecture
-mcpu=type-architecture
Générer du code pour l'architecture spécifiée. Les choix possibles pour type-architecture sont v3, v8 et v10 pour les ETRAX 4, ETRAX 100 et ETRAX 100 LX respectivement. Le type d'architecture par défaut est v0 sauf pour cris-axis-linux-gnu, où il est v10.
-mtune=type-architecture
Optimaliser pour type-architecture tout ce qui s'applique au code généré, sauf en ce qui concerne l'ABI et le jeu d'instructions disponibles. Les choix pour type-architecture sont les mêmes que ceux pour -march=type-architecture.
-mmax-stack-frame=n
Avertir quand le cadre de pile d'une fonction dépasse n octets.
-melinux-stacksize=n
Uniquement disponible pour la cible cris-axis-aout. S'arrange pour placer des indications dans le programme afin de signaler au chargeur du noyau que la pile du programme devrait être fixée à n octets.
-metrax4
-metrax100
Les options -metrax4 et -metrax100 sont les synonymes respectifs de -march=v3 et -march=v8.
-mpdebug
Autoriser la présence d'informations de déboggage verbeuses spécifiques au CRIS dans le code d'assemblage. Cette option a également pour effet de faire désactiver l'indicateur de code formaté #NO_APP par l'assembleur au début du fichier assembleur.
-mcc-init
Ne pas utiliser les résultats du code de condition provenant de l'instruction précédente ; toujours émettre des instructions « compare and test » (comparer et tester) avant l'utilisation de codes de condition.
-mno-side-effects
Ne pas émettre d'instruction ayant des effets de bord dans des modes d'adressage autres que la post-incrémentation.
-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
Ces options (options no) s'arrangent (défont les arrangements) pour que le cadre de pile, les données individuelles et les constantes soient alignés sur la taille d'accès maximale à des données individuelles pour le modèle de CPU choisi. Le comportement par défaut est d'utiliser un alignement 32 bits. Les détails de l'ABI comme la disposition de la structure ne sont pas affectés par ces options.
-m32-bit
-m16-bit
-m8-bit
Similaire aux options d'alignement de pile, données et constantes ci-dessus, ces options s'arrangent pour que le cadre de pile, les données accessibles en écriture et les constantes soient alignées sur 32, 16 ou 8 bits respectivement. Le comportement par défaut est l'alignement sur 32 bits.
-mno-prologue-epilogue
-mprologue-epilogue
Avec -mno-prologue-epilogue, les prologue et épilogue normaux d'une fonction qui établissent le cadre de pile sont omis et aucune instruction return ou séquence de retour n'est générée dans le code. N'utilisez cette option que conjointement avec une inspection visuelle du code compilé : aucun avertissement ou erreur n'est généré(e) quand les registres sauvés lors de l'appel doivent être sauvés, ou quand l'espace de stockage destiné aux variables locales doit être alloué.
-mno-gotplt
-mgotplt
Avec -fpic et -fPIC, ne pas générer (générer) des séquences d'instructions qui chargent des adresses depuis la partie PLT de la GOT plutôt que (ce qui est traditionnel sur d'autres architectures) des appels au PLT. Le comportement par défaut est -mgotplt.
-maout
Option no-op héritée reconnue uniquement pour la cible cris-axis-aout.
-melf
Option no-op héritée reconnue uniquement pour les cibles cris-axis-elf et cris-axis-linux-gnu.
-melinux
Uniquement reconnu pour la cible cris-axis-aout, quand il sélectionne un multilib de type GNU/linux, les fichiers d'inclusions et le jeu d'instructions pour -march=v8.
-mlinux
Option no-op héritée reconnue uniquement pour la cible cris-axis-linux-gnu.
-sim
Cette option, reconnue pour cris-axis-aout et cris-axis-elf s'arrange pour effectuer une liaison avec les fonctions d'entrée-sortie d'une bibliothèque de simulation. Le code, les données initialisées et les données initialisées à zéro sont alloués consécutivement.
-sim2
Comme -sim, mais passer des options de l'éditeur de liens pour placer les données initialisées en 0x40000000 et les données initialisées à zéro en 0x80000000.

Options MMIX

Ces options sont définies pour le MMIX :

-mlibfuncs
-mno-libfuncs
Spécifier que des fonctions intrinsèques de bibliothèque sont en cours de compilation, et passer toutes les valeurs dans des registres, quelle qu'en soit la taille.
-mepsilon
-mno-epsilon
Générer des instructions de comparaison flottantes qui comparent en employant le registre epsilon « rE ».
-mabi=mmixware
-mabi=gnu
Générer du code qui passe les paramètres de fonction et les valeurs de retour qui (à l'intérieur de la fonction appelée) sont vus comme les registres « $0 » et supérieurs, par opposition à l'ABI GNU qui utilise les registres globaux « $231 » et supérieurs.
-mzero-extend
-mno-zero-extend
Lors de la lecture en mémoire de données de taille inférieure à 64 bits, utiliser (ne pas utiliser) par défaut les instructions de chargement avec prolongement par des zéros, au lieu de celles prolongeant le signe.
-mknuthdiv
-mno-knuthdiv
Faire en sorte que le résultat d'une division produisant un reste ait le même signe que le diviseur. Avec l'option par défaut, -mno-knuthdiv, le signe du reste suit le signe du dividende. Les deux méthodes sont valides d'un point de vue arithmétique, la dernière étant presque exclusivement utilisée.
-mtoplevel-symbols
-mno-toplevel-symbols
Préfixer (ne pas préfixer) un : à tous les symboles globaux, afin que le code d'assemblage puisse être utilisé avec la directive assembleur « PREFIX ».
-melf
Générer un exécutable dans le format ELF, plutôt que dans le format par défaut mmo utilisé par le simulateur mmix.
-mbranch-predict
-mno-branch-predict
Utiliser (ne pas utiliser) les instructions de branchements probables, quand la prédiction statique de branchements indique un branchement probable.
-mbase-addresses
-mno-base-addresses
Générer (ne pas générer) du code qui utilise les adresses de base. L'utilisation d'une adresse de base génère automatiquement une requête (traitée par l'assembleur et l'éditeur de liens) pour qu'une constante soit placée dans un registre global. Le registre est utilisé pour une ou plusieurs requêtes d'adresse de base comprises dans l'intervalle allant de 0 à 255 à partir de la valeur conservée dans le registre. Cela aboutit généralement à un code plus court et rapide, mais le nombre d'éléments de données différents qui peuvent être adressés est limité. Cela signifie qu'un programme qui utilise beaucoup de données statiques peut requérir -mno-base-addresses.

Options PDP-11

Ces options sont définies pour le PDP-11 :

-mfpu
Utiliser les flottants matériels FPP. Utilisé par défaut. (Les flottants matériels FIS sur le PDP-11/40 ne sont pas supportés.)
-msoft-float
Ne pas utiliser les flottants matériels.
-mac0
Retourner les résultats flottants dans ac0 (fr0 dans la syntaxe d'assembleur Unix).
-mno-ac0
Retourner les résultats flottants en mémoire. Utilisé par défaut.
-m40
Générer du code pour un PDP-11/40.
-m45
Générer du code pour un PDP-11/45. Utilisé par défaut.
-m10
Générer du code pour un PDP-11/10.
-mbcopy-builtin
Utiliser des motifs « movstrhi » en ligne pour la copie de mémoire. Utilisé par défaut.
-mbcopy
Ne pas utiliser de motif « movstrhi » en ligne pour la copie de mémoire.
-mint16
-mno-int32
Utiliser des « int » 16 bits. Utilisé par défaut.
-mint32
-mno-int16
Utiliser des « int » 32 bits.
-mfloat64
-mno-float32
Utiliser des « float » 64 bits. Utilisé par défaut.
-mfloat32
-mno-float64
Utiliser des « float » 32 bits.
-mabshi
Utiliser le motif « abshi2 ». Utilisé par défaut.
-mno-abshi
Ne pas utiliser le motif « abshi2 ».
-mbranch-expensive
Prétendre que les branchements sont coûteux. Cela n'est destiné qu'à des expérimentations avec la génération de code.
-mbranch-cheap
Ne pas prétendre que les branchements sont coûteux. Utilisé par défaut.
-msplit
Générer du code pour un système dont les caches d'instructions et de données sont distincts (with split I&D).
-mno-split
Générer du code pour un système dont les caches d'instructions et de données sont « communs » (without split I&D). Utilisé par défaut.
-munix-asm
Utiliser la syntaxe assembleur Unix. Utilisé par défaut pour une configuration pdp11-*-bsd.
-mdec-asm
Utiliser la syntaxe assembleur DEC. Utilisé par défaut quand gcc est configuré pour toute cible PDP-11 différente de pdp11-*-bsd.

Options Xstormy16

Ces options sont définies pour les Xstormy16 :

-msim
Choisir le script d'éditeur de liens et les fichiers de démarrage convenant au simulateur.

Options Xtensa

L'architecture Xtensa est conçue pour supporter beaucoup de configurations différentes. Les options par défaut du compilateur peuvent être spécifiées pour correspondre à une configuration Xtensa particulière en copiant un fichier de configuration dans les sources de GCC lors de sa construction. Les options présentées ci-dessous peuvent être utilisées pour surcharger les options par défaut.

-mbig-endian
-mlittle-endian
Spécifier une disposition d'ordre d'octets gros-boutiste ou petit-boutiste pour le processeur Xtensa cible.
-mdensity
-mno-density
Activer ou désactiver l'utilisation des instructions optionnelles de densité de code Xtensa.
-mmac16
-mno-mac16
Activer ou désactiver l'utilisation de l'option MAC16 Xtensa. Quand elle est activée, GCC générera des instructions MAC16 à partir de code C standard, avec la limitation qu'il n'utilisera ni le fichier registre MR ni des instructions qui travaillent sur les registres MR. Quand cette option est désactivée, GCC traduira les opérations 16 bits multiply/accumulate en une combinaison d'instructions de base et d'appels de bibliothèque, en fonction de l'utilisation (ou pas) des autres options de multiplicateur.
-mmul16
-mno-mul16
Activer ou désactiver l'utilisation de l'option de multiplicateur entier 16 bits. Quand elle est activée, le compilateur générera des instructions multiply 16 bits pour les multiplications d'au plus 16 bits dans du code C standard. Quand cette option est désactivée, le compilateur utilisera soit le multiply 32 bits, soit des instructions MAC16 si elles sont disponibles ou générera des appels de bibliothèque pour effectuer les opérations de multiplication en utilisant des décalages et des additions.
-mmul32
-mno-mul32
Activer ou désactiver l'utilisation de l'option de multiplicateur entier 32 bits. Quand elle est activée, le compilateur générera des instructions multiply 32 bits pour les multiplications d'au plus 32 bits dans du code C standard. Quand cette option est désactivée, le compilateur générera des appels de bibliothèque pour effectuer les opérations de multiplication en utilisant soit des décalages et des additions, soit des instructions multiply 16 bits si elles sont disponibles.
-mnsa
-mno-nsa
Activer ou désactiver l'utilisation des instructions optionnelles « normalization shift amount » (NSA) pour implémenter la fonction intégrée « ffs ».
-mminmax
-mno-minmax
Activer ou désactiver l'utilisation des instructions optionnelles de valeur minimale et maximale.
-msext
-mno-sext
Activer ou désactiver l'utilisation de l'instruction optionnelle d'extension de signe « SEXT ».
-mbooleans
-mno-booleans
Activer ou désactiver le support du fichier de registres booléens utilisé par les coprocesseurs Xtensa. Ce n'est typiquement pas utile seul mais peut être requis par d'autres options qui font usage des registres booléens (p.ex. l'option virgule flottante).
-mhard-float
-msoft-float
Activer ou désactiver l'utilisation de l'option virgule flottante. Quand elle est activée, GCC génère des instructions flottantes pour les opérations 32 bits sur les « float ». Quand cette option est désactivée, GCC génère des appels de bibliothèque pour émuler les opérations flottantes 32 bits en utilisant des instructions entières. Que cette option soit utilisée ou non, les opérations 64 bits sur les « double » sont toujours émulées par des appels de bibliothèque.
-mfused-madd
-mno-fused-madd
Activer ou désactiver l'utilisation des instructions fusionnées multiply/add et multiply/subtract dans l'option virgule flottante. Cela n'a aucun effet si l'option virgule flottante n'est pas également activée. Interdire les instructions fusionnées multiply/add et multiply/subtract force le compilateur à utiliser des instructions séparées pour les opérations multiply add/subtract. Cela peut être désirable dans certains cas où des résultats strictement conformes à IEEE 754 sont requis : les instructions fusionnées multiply add/subtract n'arrondissent pas le résultat intermédiaire, produisant de ce fait des résultats comportant plus de bits de précision que spécifié par le standard IEEE. Interdire les instructions fusionnées multiply add/subtract assure également que la sortie de programme ne sera pas dépendante de la capacité du compilateur à combiner des opérations multiply et add/subtract.
-mserialize-volatile
-mno-serialize-volatile
Quand cette option est activée, GCC insère des instructions « MEMW » avant des références mémoire « volatile » pour garantir la cohérence séquentielle. L'option par défaut est -mserialize-volatile. Utilisez -mno-serialize-volatile pour omettre les instructions « MEMW ».
-mtext-section-literals
-mno-text-section-literals
Contrôler le traitement des réserves de littéraux (litteral pools). Le comportement par défaut est -mno-text-section-literals, qui place les littéraux dans une section séparée du fichier de sortie. Cela permet de placer la réserve de littéraux dans une RAM/ROM de données, et à l'éditeur de liens de combiner des réserves de littéraux de fichiers objets séparés afin de supprimer les littéraux redondants et d'améliorer la taille du code. Avec -mtext-section-literals, les littéraux sont dispersés dans la section de texte afin de les garder aussi près que possible de leurs références. Cela peut être nécessaire pour de gros fichiers assembleur.
-mtarget-align
-mno-target-align
Quand cette option est activée, GCC indique à l'assembleur d'aligner automatiquement les instructions afin de réduire les pénalités de branchement aux dépens d'une certaine densité du code. L'assembleur essaie d'étendre la taille des instructions « denses » afin d'aligner les cibles de branchements et les instructions subséquentes aux appels de sous-routines. S'il n'y a pas assez d'instructions denses sûres précédant une cible pour permettre de l'aligner, aucune extension n'aura lieu. La valeur par défaut est -mtarget-align. Ces options n'affectent pas le traitement des instructions auto-alignées comme « LOOP », qui seront toujours alignées par l'assembleur, soit en étendant des instructions denses, soit en insérant des instructions no-op.

(NdT : une instruction est dite dense si son encodage peut être réalisé de différentes manières, occupant plus ou moins de place. Ces instructions peuvent être utilisées pour limiter l'utilisation des instructions no-op (No Operation, qui ne font rien) lors des alignements de cibles)

-mlongcalls
-mno-longcalls
Quand cette option est activée, GCC indique à l'assembleur de traduire les appels directs en appels indirects à moins qu'il ne puisse déterminer que la cible d'un appel direct est dans l'intervalle autorisé par l'instruction call. Cette traduction se produit typiquement pour des appels à des fonctions d'autres fichiers source. Spécifiquement, l'assembleur traduit une instruction « CALL » directe en un « L32R » suivi d'une instruction « CALLX ». L'option par défaut est -mno-longcalls. Elle devrait être utilisée dans des programmes où la cible de l'appel peut être potentiellement hors de portée. Cette option est implémentée dans l'assembleur, pas le compilateur, et le code assembleur généré par GCC montrera ainsi toujours des instructions d'appel direct -- jetez un oeil sur le code objet désassemblé pour visualiser les instructions réelles. Notez que l'assembleur utilisera un appel indirect pour chaque appel de fonction située dans un autre fichier, et pas uniquement pour ceux qui seront réellement hors de portée.

Options de conventions de génération de code

Ces options indépendantes de la machine contrôlent les conventions d'interface utilisées lors de la génération de code.

La plupart d'entre elles ont à la fois les formes positive et négative ; la forme négative de -ffoo serait -fno-foo. Dans la table ci-dessous, seule une des formes est listée -- celle qui n'est pas utilisée par défaut. Vous pouvez vous imaginer l'autre forme en retirant no- ou en l'ajoutant.

-fexceptions
Permettre le traitement des exceptions. Génère du code supplémentaire nécessaire pour propager les exceptions. Pour certaines cibles, ceci implique que GCC générera des informations de déroulement de cadre pour toutes les fonctions, ce qui peut produire un surcroît significatif de la taille des données, bien que cela n'affecte pas l'exécution. Si vous ne spécifiez pas cette option, GCC l'activera par défaut pour les langages comme C++ qui requièrent normalement le traitement des exceptions, et le désactivera pour des langages comme C qui ne le requièrent normalement pas. Néanmoins, vous pourriez devoir activer cette option lors de la compilation d'un code C qui doit interopérer proprement avec des gestionnaires d'exceptions écrits en C++. Vous pourriez également être dans l'obligation de désactiver cette option si vous compilez des anciens programmes C++ qui n'utilisent pas le traitement des exceptions.
-fnon-call-exceptions
Générer du code qui permet aux instructions des routines d'interruptions de lancer des exceptions. Notez que cela requiert un support à l'exécution spécifique à la plate-forme qui n'existe pas partout. De plus, cela permet uniquement aux instructions d' interruption de lancer des exceptions, c.-à-d. des références mémoires ou des instructions flottantes. Cela ne permet pas de lancer des exceptions à partir de gestionnaires de signaux arbitraires comme « SIGALRM ».
-funwind-tables
Similaire à -fexceptions, sauf qu'il ne générera que les données statiques nécessaires, mais n'affectera le code généré en aucune autre façon. Vous ne devriez normalement pas activer cette option ; au lieu de cela, un processeur de langage qui a besoin de ce traitement l'activera pour vous.
-fasynchronous-unwind-tables
Générer une table de déroulement dans le format dwarf2, s'il est supporté par la machine cible. La table est correcte à chaque limite d'instruction, et peut donc être utilisée pour le déroulement de pile depuis des événements asynchrones (comme un débogueur ou un ramasse-miettes).
-fpcc-struct-return
Retourner les valeurs « struct » et « union » en mémoire comme c'est le cas pour les valeurs plus longues, plutôt que dans des registres. Cette convention est moins efficace, mais elle a l'avantage de permettre l'interappelabilité entre des fichiers compilés par GCC et des fichiers compilés avec d'autres compilateurs.

La convention précise pour le renvoi de structures en mémoire dépend des macros de configuration de la cible.

Les structures et unions courtes sont celles dont la taille et l'alignement correspondent à ceux d'un type entier.

-freg-struct-return
Retourner des valeurs « struct » et « union » dans des registres quand c'est possible. C'est plus efficace que -fpcc-struct-return pour des petites structures.

Si vous ne spécifiez ni -fpcc-struct-return ni -freg-struct-return, GCC utilisera par défaut la convention qui est standard pour la cible. S'il n'y a pas de convention standard, GCC utilisera par défaut -fpcc-struct-return, sauf pour les cibles où GCC est le compilateur principal. Dans ces cas, nous pouvons choisir le standard, et nous avons choisi l'alternative plus efficace de retour dans un registre.

-fshort-enums
N'allouer à un type « enum » que le nombre d'octets dont il a besoin pour l'intervalle déclaré de valeurs possibles. Spécifiquement, le type « enum » sera équivalent au plus petit type entier suffisamment grand pour supporter les valeurs de ce type.
-fshort-double
Utiliser la même taille pour « double » que pour « float ».
-fshared-data
Requiert que les données et les variables non-« const » de cette compilation soient partagées plutôt que d'être des données privées. La distinction n'a de sens que dans certains systèmes d'exploitation, où les données partagées sont partagées entre des processus exécutant le même programme, alors que les données privées existent en une copie par processus.
-fno-common
En C, allouer même les variables globales non initialisées dans la section de données du fichier objet, plutôt que de les générer comme des blocs communs. Ceci a pour effet que si la même variable est déclarée (sans « extern ») dans deux compilations différentes, vous obtiendrez une erreur quand vous essayerez de les lier. Le seul moment où ceci pourrait être utile est quand vous voulez vérifier que le programme peut tourner sur d'autres systèmes qui travaillent toujours de cette façon.
-fno-ident
Ignorer la directive #ident.
-fno-gnu-linker
Ne pas produire les initialisations globales (tels que les constructeurs et destructeurs C++) dans la forme utilisée par l'éditeur de liens GNU (sur les systèmes où l'éditeur de liens GNU est le standard). Utilisez cette option quand vous voulez utiliser un éditeur de liens non GNU, qui requiert également le programme collect2 pour être sûr que l'éditeur de liens du système inclue des constructeurs et des destructeurs. (collect2 est inclus dans la distribution GCC.) Pour les systèmes qui doivent utiliser collect2, le pilote du compilateur gcc est configuré pour faire cela automatiquement.
-finhibit-size-directive
Ne pas produire de directive assembleur « .size », ou quoi que ce soit d'autre qui causerait des ennuis si la fonction était coupée en son milieu, et les deux moitiés placées dans des emplacements fortement séparés en mémoire. Cette option est utilisée pour compiler crtstuff.c ; vous ne devriez pas l'utiliser pour quoi que ce soit d'autre.
-fverbose-asm
Ajouter des commentaires supplémentaires au code assembleur généré pour le rendre plus lisible. Cette option n'est généralement utile qu'à ceux qui ont réellement besoin de lire le code assembleur généré (peut-être lors du débogage du compilateur lui-même).

-fno-verbose-asm, le comportement par défaut, provoque l'omission de l'information supplémentaire, et est utile lors de la comparaison de deux fichiers assembleur.

-fvolatile
Considérer que toutes les références mémoires via des pointeurs sont volatiles.
-fvolatile-global
Considérer que toutes les références mémoires à des éléments de données externes et globaux sont volatiles. GCC ne considère pas que les éléments de données statiques sont volatils avec cet interrupteur.
-fvolatile-static
Considérer que toutes les références mémoires à des données statiques sont volatiles.
-fpic
Générer du code indépendant de la position (position-independent code, PIC), convenant à l'utilisation dans une bibliothèque partagée, si c'est supporté par la machine cible. Un tel code accède à toutes les adresses constantes via une table de décalages globale (GOT). Le chargeur dynamique résout les entrées GOT quand le programme démarre (le chargeur dynamique ne fait pas partie de GCC ; il fait partie du système d'exploitation). Si la taille de la GOT pour l'exécutable lié dépasse une taille maximum spécifique à la machine, vous obtiendrez un message d'erreur de l'éditeur de liens indiquant que -fpic ne fonctionne pas, recompilez avec -fPIC à la place. (Ces maxima sont 16 Ko sur le m88k, 8 Ko sur la Sparc, et 32 Ko sur les m68k et RS/6000. Le 386 ne possède pas de telle limite.)

Le code indépendant de la position requiert un support spécial, et ne fonctionne donc que sur certaines machines. Pour le 386, GCC supporte le PIC pour System V mais pas pour le Sun 386i. Le code généré pour le RS/6000 d'IBM est toujours indépendant de la position.

-fPIC
Si supporté par la machine cible, émettre du code indépendant de la position, convenant à la liaison dynamique et évitant la limite sur la taille de la table de décalages globale. Cette option apporte une différence sur les m68k, m88k et la Sparc.

Le code indépendant de la position requiert un support spécial, et ne fonctionne donc que sur certaines machines.

-ffixed-registre
Traiter le registre nommé registre comme étant un registre fixe ; le code généré ne devrait jamais le référencer (sauf peut-être en tant que pointeur de pile, pointeur de cadre ou dans un autre rôle fixé).

registre doit être le nom d'un registre. Les noms de registres acceptés sont spécifiques à la machine et sont définis dans la macro « REGISTER_NAMES » dans le fichier de macros de description de la machine.

Ce drapeau n'a pas de forme négative, car il spécifie un triple choix.

-fcall-used-registre
Traiter le registre nommé registre comme un registre allouable qui est écrasé lors d'un appel de fonction. Il peut être alloué pour des variables temporaires ou des variables qui ne survivent pas à un appel. Les fonctions compilées de cette façon ne sauveront ni ne restaureront le registre registre.

C'est une erreur d'utiliser ce drapeau avec le pointeur de cadre ou le pointeur de pile. L'utilisation de ce drapeau pour un registre qui a un rôle fixé déterminant dans le modèle d'exécution de la machine, tel que le pointeur de pile ou le pointeur de cadre, produira des résultats désastreux.

Ce drapeau n'a pas de forme négative car il spécifie un choix triple.

-fcall-saved-registre
Traiter le registre nommé registre comme un registre allouable sauvé par des fonctions. Il peut être alloué même pour des variables temporaires ou des variables qui survivent à un appel. Les fonctions compilées de cette façon sauveront et restaureront le registre registre si elles l'utilisent.

C'est une erreur d'utiliser ce drapeau avec le pointeur de cadre ou le pointeur de pile. L'utilisation de ce drapeau pour d'autres registres qui ont un rôle fixé déterminant dans le modèle d'exécution de la machine, tel que le pointeur de pile ou le pointeur de cadre, produira des résultats désastreux.

Un autre type de désastre résultera de l'utilisation de ce drapeau pour un registre dans lequel des valeurs de retour de fonctions peuvent être retournées.

Ce drapeau n'a pas de forme négative car il spécifie un choix triple.

-fpack-struct
Empaqueter tous les membres de structure ensemble sans laisser de trous. D'habitude, vous ne devriez pas utiliser cette option, car elle rend le code sous-optimal, et les décalages des membres de structure ne seront pas conformes aux bibliothèques système.
-finstrument-functions
Générer des appels d'instrumentation à l'entrée et à la sortie des fonctions. Juste après l'entrée dans la fonction et juste avant la sortie de la fonction, les fonctions de profilage suivantes seront appelées avec l'adresse de la fonction courante et le lieu de son appel. (Sur certaines plate-formes, « __builtin_return_address » ne fonctionne pas au-delà de la fonction courante, de sorte que l'information de lieu d'appel peut dans ce cas ne pas être disponible pour les fonctions de profilage.)
         void __cyg_profile_func_enter (void *this_fn,
                                        void *call_site);
         void __cyg_profile_func_exit  (void *this_fn,
                                        void *call_site);
 
 

Le premier argument est l'adresse du début de la fonction courante, qui peut être recherchée avec précision dans la table des symboles.

Cette instrumentation est également effectuée pour les fonctions développées en ligne dans d'autres fonctions. Les appels de profilage indiqueront où, conceptuellement, on entre dans la fonction en ligne et où on en sort. Cela signifie que des versions adressables de telles fonctions doivent être disponibles. Si toutes vos utilisations d'une fonction sont développées en ligne, cela peut résulter en un accroissement additionnel de la taille du code. Si vous utilisez extern inline dans votre code C, une version adressable de telles fonctions doit être fournie. (C'est d'ailleurs normalement le cas, mais si vous êtes chanceux et que l'optimiseur développe toujours les fonctions en ligne, vous pourriez vous en sortir sans avoir fourni de copies statiques.)

Une fonction peut posséder l'attribut « no_instrument_function », auquel cas cette instrumentation n'est pas effectuée. Ceci peut être utilisé, par exemple, pour les fonctions de profilage listées ci-dessus, les routines d'interruption de haute priorité, et toutes les fonctions à partir desquelles les fonctions de profilage ne peuvent être appelées de façon sûre (peut-être les gestionnaires de signaux, si les routines de profilage génèrent une sortie ou allouent de la mémoire).

-fstack-check
Générer du code pour vérifier que vous ne dépassez pas la limite de la pile. Vous devriez spécifier cette option si vous vous situez dans un environnement comportant de multiples threads, mais vous n'avez que rarement besoin de la spécifier dans un environnement à un seul thread (ne supportant pas les threads) car le débordement de pile est automatiquement détecté sur pratiquement tous les systèmes s'il n'y a qu'une seule pile.

Notez que cet interrupteur ne provoque pas réellement l'exécution du contrôle ; le système d'exploitation doit le faire. Cet interrupteur provoque la génération de code pour s'assurer que le système d'exploitation voie l'extension de la pile.

-fstack-limit-register=registre
-fstack-limit-symbol=sym
-fno-stack-limit
Générer du code pour s'assurer que la pile ne grandira pas au-delà d'une certaine valeur, à savoir soit la valeur d'un registre, soit l'adresse d'un symbole. Si la pile grandit au-delà de cette valeur, un signal est émis. Pour la plupart des cibles, le signal est émis avant que la pile ne dépasse la limite, de sorte qu'il est possible de capturer le signal sans prendre de précautions particulières.

Par exemple, si la pile débute à l'adresse absolue 0x80000000 et grandit vers le bas, vous pouvez alors utiliser les drapeaux -fstack-limit-symbol=__stack_limit et -Wl,--defsym,__stack_limit=0x7ffe0000 pour imposer une limite de pile de 128 Ko. Notez que cela ne fonctionne qu'avec l'éditeur de liens GNU.

-fargument-alias
-fargument-noalias
-fargument-noalias-global
Spécifier les relations possibles entre paramètres, et entre des paramètres et des données globales.

-fargument-alias spécifie que les arguments (paramètres) peuvent se masquer l'un l'autre et peuvent masquer des valeurs globales. -fargument-noalias spécifie que les arguments ne se masquent pas l'un l'autre, mais peuvent masquer des valeurs globales. -fargument-noalias-global spécifie que les arguments ne se masquent pas l'un l'autre et ne masquent pas des valeurs globales.

Chaque langage utilisera automatiquement l'option qui est requise par le standard du langage. Vous ne devriez pas utiliser ces options vous-même.

-fleading-underscore
Cette option et son homologue, -fno-leading-underscore, modifie fortement la façon dont les symboles C sont représentés dans le fichier objet. Une de ses utilisations est d'aider la liaison avec du code assembleur ancien.

Soyez averti que vous êtes censé savoir ce que vous faites quand vous invoquez cette option, et que toutes les cibles ne la supportent pas.

-ftls-model=modèle
Changer de modèle de stockage local à un thread. L'argument modèle devrait être « global-dynamic », « local-dynamic », « initial-exec » ou « local-exec ».

Le modèle par défaut en l'absence de -fpic est « initial-exec » ; avec -fpic, il s'agit de « global-dynamic ».

ENVIRONNEMENT

Cette section décrit diverses variables d'environnement qui affectent la façon dont GCC se comporte. Certaines d'entre elles fonctionnent en spécifiant des répertoires ou des préfixes à utiliser lors de la recherche de différents types de fichiers. Certaines sont utilisées pour spécifier d'autres aspects de l'environnement de compilation.

Notez que vous pouvez également spécifier des endroits où chercher en utilisant des options comme -B, -I et -L. Elles sont prioritaires par rapport aux emplacements spécifiés en utilisant des variables d'environnement, qui sont à leur tour prioritaires sur ceux spécifiés dans la configuration de GCC.

LANG
LC_CTYPE
LC_MESSAGES
LC_ALL
Ces variables d'environnement contrôlent la façon dont GCC utilise l'information de localisation qui lui permet de travailler avec différentes conventions nationales. GCC inspecte les catégories de localisation LC_CTYPE et LC_MESSAGES s'il a été configuré pour le faire. Ces catégories de localisation peuvent être fixées à n'importe quelle valeur supportée par votre installation. Une valeur typique est en_UK pour l'anglais dans le Royaume-Uni.

La variable d'environnement LC_CTYPE spécifie la classification des caractères. GCC l'utilise pour déterminer les limites des caractères dans une chaîne de caractères ; c'est nécessaire pour certains encodages multi-octets qui contiennent des guillemets et des caractères d'échappement qui seraient autrement interprétés comme une fin de chaîne ou un échappement.

La variable d'environnement LC_MESSAGES spécifie la langue à utiliser dans les messages de diagnostic.

Si la variable d'environnement LC_ALL est définie, elle surcharge la valeur de LC_CTYPE et LC_MESSAGES ; sinon, LC_CTYPE et LC_MESSAGES ont comme valeur par défaut la valeur de la variable d'environnement LANG. Si aucune de ces variables n'est définie, GCC utilise par défaut le comportement C traditionnel en anglais.

TMPDIR
Si TMPDIR est défini, il spécifie le répertoire à utiliser pour les fichiers temporaires. GCC utilise des fichiers temporaires pour sauver la sortie d'une étape de la compilation qui est utilisée comme entrée pour l'étape suivante : par exemple la sortie du préprocesseur, qui est l'entrée du compilateur proprement dit.
GCC_EXEC_PREFIX
Si GCC_EXEC_PREFIX est défini, il spécifie un préfixe à utiliser dans les noms des sous-programmes exécutés par le compilateur. Aucun slash (/) n'est ajouté quand ce préfixe est combiné avec le nom d'un sous-programme, mais vous pouvez spécifier un préfixe qui se termine par un slash si vous le désirez.

Si GCC_EXEC_PREFIX n'est pas défini, GCC essaiera d'imaginer un préfixe approprié à utiliser sur base du nom de chemin par lequel il a été invoqué.

Si GCC ne peut trouver le sous-programme en utilisant le préfixe spécifié, il essaie de regarder dans les endroits habituels du sous-programme.

La valeur par défaut pour GCC_EXEC_PREFIX est préfixe/lib/gcc-lib/préfixe est la valeur de « prefix » spécifiée quand vous avez lancé le script configure.

D'autres préfixes précisés avec -B sont prioritaires par rapport à ce préfixe.

Ce préfixe est également utilisé pour trouver des fichiers comme crt0.o qui sont utilisés lors de l'édition des liens.

De plus, le préfixe est utilisé d'une façon inhabituelle pour trouver les répertoires où rechercher les fichiers d'en-tête. Pour chacun des répertoires standard dont le nom commence normalement par /usr/local/lib/gcc-lib (plus précisément par la valeur de GCC_INCLUDE_DIR), GCC essaie de remplacer ce début par le préfixe spécifié pour produire un nom de répertoire alternatif. Donc, avec -Bfoo/, GCC cherchera foo/bar là où il chercherait normalement /usr/local/lib/bar. Ces répertoires alternatifs sont recherchés en premier lieu ; les répertoires standard viennent par après.

COMPILER_PATH
La valeur de COMPILER_PATH est une liste de répertoires séparés par des signes « deux-points », comme pour PATH. GCC parcourt les répertoires ainsi spécifiés quand il recherche des sous-programmes, s'il ne peut trouver les sous-programmes en utilisant GCC_EXEC_PREFIX.
LIBRARY_PATH
La valeur de LIBRARY_PATH est une liste de répertoires séparés par des signes « deux-points », comme pour PATH. Quand il est configuré comme un compilateur natif, GCC parcourt les répertoires ainsi spécifiés quand il recherche des fichiers spéciaux de l'éditeur de liens, s'il ne peut trouver les sous-programmes en utilisant GCC_EXEC_PREFIX. L'édition des liens employant GCC utilise également ces répertoires lors de la recherche de bibliothèques ordinaires pour l'option -l (mais les répertoires spécifiés avec -L viennent en premier).
LANG
Cette variable est utilisée pour passer des informations de localisation au compilateur. Une des utilisations de ces informations est la détermination du jeu de caractères à utiliser quand les littéraux caractères, les littéraux chaînes de caractères et les commentaires sont reconnus en C et en C++. Quand le compilateur est configuré pour permettre les caractères multi-octets, les valeurs suivantes pour LANG sont reconnues :
C-JIS
Reconnaître les caractères JIS.
C-SJIS
Reconnaître les caractères SJIS.
C-EUCJP
Reconnaître les caractères EUCJP.

Si LANG n'est pas défini, ou s'il a une autre valeur, alors le compilateur utilisera mblen et mbtowc comme défini par la localisation par défaut pour reconnaître et traduire les caractères multi-octets.

Certaines variables d'environnement additionnelles affectent le comportement du préprocesseur.

CPATH
C_INCLUDE_PATH
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
La valeur de chaque variable est une liste de répertoires séparés par un caractère spécial, un peu comme PATH, dans lesquels on cherche les fichiers d'en-tête. Le caractère spécial, « PATH_SEPARATOR », dépend de la cible et est déterminé au moment de la construction de GCC. Pour les cibles basées sur Windows, c'est un point-virgule, et pour pratiquement toutes les autres cibles, c'est un signe deux-points.

CPATH spécifie une liste de répertoires à parcourir comme s'ils avaient été spécifiés par -I, mais après tous les chemins fournis par des options -I sur la ligne de commandes. La variable d'environnement est utilisée quel que soit le langage en cours de prétraitement.

Les variables d'environnement restantes ne s'appliquent que lors du prétraitement du langage particulier indiqué. Chacune d'entre elles spécifie une liste de répertoires à parcourir comme s'ils avaient été spécifiés par -isystem, mais après tous les chemins fournis par des options -isystem sur la ligne de commandes.

DEPENDENCIES_OUTPUT
Si cette variable est définie, sa valeur spécifie la façon de produire des dépendances pour Make basées sur les fichiers d'en-tête non-système traités par le compilateur. Les fichiers d'en-tête système sont ignorés dans la sortie des dépendances.

La valeur de DEPENDENCIES_OUTPUT peut être simplement un nom de fichier, auquel cas les règles Make sont écrites dans ce fichier, en devinant le nom de la cible à partir du nom de fichier source, ou bien la valeur peut avoir la forme fichier cible, auquel cas les règles sont écrites dans le fichier en utilisant cible en tant que nom de cible.

En d'autres termes, cette variable d'environnement est équivalente à la combinaison des options -MM et -MF, complétée par un interrupteur -MT éventuel.

SUNPRO_DEPENDENCIES
Cette variable est identique à la variable d'environnement DEPENDENCIES_OUTPUT, mis à part que les fichiers d'en-tête système ne sont pas ignorés, et implique donc -M plutôt que -MM. Néanmoins, les dépendances du fichier d'entrée principal sont omises.

BOGUES

Pour obtenir des instructions sur la façon de rapporter des bogues, voyez <http://gcc.gnu.org/bugs.html>. L'utilisation du script gccbug pour rapporter des bogues est recommandée.

NOTES DE BAS DE PAGE

1.
Sur certains systèmes, gcc -shared doit construire un code souche (stub) supplémentaire pour que les constructeurs fonctionnent. Sur les systèmes à plusieurs bibliothèques, gcc -shared doit sélectionner les bibliothèques de support correctes avec lesquelles se lier. Ne pas fournir les drapeaux corrects peut mener à des défectuosités subtiles. Les fournir alors qu'ils ne sont pas nécessaires n'est pas dangereux.

VOIR AUSSI

gpl(7), gfdl(7), fsf-funding(7), cpp(1), gcov(1), g77(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1) et les entrées Info pour gcc, cpp, g77, as, ld, binutils et gdb.

AUTEUR

Voyez l'entrée Info pour gcc, ou <http://gcc.gnu.org/onlinedocs/gcc/Contributors.html>, pour connaître les contributeurs à GCC. Copyright (c) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

L'autorisation est donnée de copier, de distribuer et/ou de modifier ce document sous les termes de la GNU Free Documentation License version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation ; les sections invariantes étant « GNU General Public License » et « Funding Free Software », le texte de couverture étant (a) (voir ci-dessous), et le texte de quatrième de couverture étant (b) (voir ci-dessous). Une copie de la licence est incluse dans la page de manuel gfdl(7).

(a) Le texte de couverture de la FSF est :

      Un Manuel GNU
 
 

(b) Le texte de quatrième de couverture de la FSF est :

      Vous êtes libre de copier et de modifier ce manuel GNU,
      tout comme les logiciels GNU. Les copies publiées par la Free
      Software Foundation collectent des fonds pour le
      développement de GNU.
 
 

TRADUCTION

Frédéric Delanoy <delanoy_f at yahoo.com>, 2002.
Le bien nous le faisons, le mal c'est la fortune,
On a toujours raison, le destin toujours tort.
-+- Jean de La Fontaine (1621-1695),
L'Ingratitude et l'Injustice des hommes
envers la Fortune (Fables VII.13) -+-