| gcc | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
| NOM | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| SYNOPSIS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Résumé des options | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
-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 contrôlant le type de sortie | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Pour tout fichier d'entrée, le suffixe du nom de fichier détermine le type de compilation qui est effectuée :
Vous pouvez spécifier explicitement le langage d'entrée avec l'option -x :
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
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.
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.
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.
Les fichiers d'entrée ne requérant pas de compilation sont ignorés.
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.
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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é.
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.
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.
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.
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))
Nous ne garantissons pas le maintien de cette option dans le futur, et nous pourrions modifier sa sémantique.
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.
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à.
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.
Néanmoins, lorsque -traditional est utilisé, les champs-bits sont tous considérés comme étant non signés.
É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.
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).
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++ :
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).
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.
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 * ».
Cette option est dépréciée.
Cette option est dépréciée.
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.
Cette optimisation requiert GNU as et GNU ld. Tous les systèmes ne supportent pas cette option. -Wl,--gc-sections est ignoré sans -static.
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++:
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 :
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.
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.
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.
et des violations de directives de style suivantes provenant du livre More Effective C++ de Scott Meyers :
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.
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.
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
gcc -g -fgnu-runtime -O -c une_classe.mDans 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 :
| Options pour contrôler le formatage des messages de diagnostic | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options pour requérir ou supprimer des avertissements | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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}.
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.)
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.
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.
int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };
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 ();
}
}
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>.
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.
Pour supprimer cet avertissement, utilisez l'attribut unused.
Pour supprimer cet avertissement, utilisez l'attribut unused.
Pour supprimer cet avertissement, utilisez l'attribut unused.
Pour supprimer cet avertissement, transtypez l'expression vers void.
Pour obtenir un avertissement sur un paramètre de fonction inutilisé, vous devez spécifier soit -W -Wunused, soit -Wunused-parameter.
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 ».
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.
foo (a)
{
if (a > 0)
return a;
}
struct s { int f, g; };
struct t { struct s h; int i; };
struct t x = { 1, 2, 3 };
struct s { int f, g, h; };
struct s x = { 3, 4 };
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.
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 ».
struct foo {
int x;
char a, b, c, d;
} __attribute__((packed));
struct bar {
char z;
struct foo f;
};
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.
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.
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.
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.
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 :
Les données de couverture seront mieux associés avec les fichiers source si -ftest-coverage est utilisé sans optimisation.
Les déchargements d'arbre suivants sont possibles :
# 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.
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`
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.
| Options contrôlant l'optimisation | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Notez que -fregmove et -foptimize-register-move constituent la même optimisation.
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.
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.
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.
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.
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.
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 ».
-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.
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.
Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.
Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.
Dans chaque cas, la valeur est un entier. Les choix permis pour nom sont donnés dans la table suivante :
| Options contrôlant le préprocesseur | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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.
À 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.
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.
Quand il est utilisé avec les options du pilote -MD ou -MMD, -MF surcharge le fichier de sortie des dépendances par défaut.
Cette fonctionnalité est utilisée dans la mise à jour automatique de makefiles.
Voici une sortie typique :
test.o: test.c test.h
test.h:
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
$$(objpfx)foo.o: foo.cLa cible par défaut est automatiquement protégée, comme si elle avait été fournie avec -MQ.
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.
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.
Le standard peut être :
L'option -ansi est équivalente à -std=c89.
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" ».
Si plusieurs options -include sont fournies, les fichiers sont inclus dans leur ordre d'apparition sur la ligne de commandes.
Tous les fichiers spécifiés par -imacros sont traités avant tous les fichiers spécifiés par -include.
L'utilisation de ces options est découragée.
-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.
touch foo.h; cpp -dM foo.haffichera toutes les macros prédéfinies.
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 #.
Les neufs trigraphes et leur valeur de remplacement sont :
Trigraphe : ??( ??) ??< ??> ??= ??/ ??' ??! ??-
Remplacement : [ ] { } # \ ^ | ~
| Passer des options à l'assembleur | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options pour l'édition des liens | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.)
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.
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.
| Options de recherche dans les répertoires | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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.
| Spécifier la machine cible et la version du compilateur | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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.
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.
Utilisez cette option pour les microcontrôleurs possédant un coeur 5200, ce qui inclut les MCF5202, MCF5203, MCF5204 et les MCF5202.
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.
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.
| Options M68hc1x | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
-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.
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.
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.
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.
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.
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.
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
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.
Ces interrupteurs -m sont supportés en plus de ceux ci-dessus pour les processeurs SPARC V9 dans les environnements 64 bits.
| Options Convex | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Notez que quand cette option est utilisée, les noms de registres dans les drapeaux -f doivent utiliser les noms normaux en mode utilisateur.
-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.
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.
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.
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.
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) ».
Cette option empêche le débogage symbolique.
Cette option interdit tout débogage symbolique.
| Options M32R/D | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
L'adressabilité d'un objet particulier peut être fournie via l'attribut « modèle ».
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.
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 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.
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.
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.
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.
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=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 :
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é.
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.
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).
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.
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.
C'est le choix par défaut pour le compilateur i386.
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.
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é.
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.
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.
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.
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.)
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.
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.
Ces interrupteurs -m sont supportés en plus de ceux ci-dessus sur les processeurs AMD x86-64 dans les environnements 64 bits.
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.
Cette option ne fonctionnera pas en présence de bibliothèques partagées ou de fonctions imbriquées.
-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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Notez que les implémentations Alpha sans opérations flottantes sont requises pour avoir des registres flottants.
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.
D'autres compilateurs Alpha fournissent les options équivalentes appelées -scope_safe et -resumption_safe.
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.
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.
Les valeurs supportées pour type-cpu sont
Les options valides pour temps sont
| Options Clipper | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options H8/300 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options pour System V | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options TMS320C3x/C4x | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options V850 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 ».
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.
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).
| Options MCore | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options D30V | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options S/390 et zSeries | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options Xstormy16 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Options Xtensa | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
(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)
| Options de conventions de génération de code | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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.
-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.
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.
Le code indépendant de la position requiert un support spécial, et ne fonctionne donc que sur certaines machines.
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.
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.
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.
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).
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.
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 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.
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.
Le modèle par défaut en l'absence de -fpic est « initial-exec » ; avec -fpic, il s'agit de « global-dynamic ».
| ENVIRONNEMENT | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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.
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.
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/ où 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.
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 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.
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 fichiercible, 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.
| BOGUES | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| NOTES DE BAS DE PAGE | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| VOIR AUSSI | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| AUTEUR | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| COPYRIGHT | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
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 | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
| Sommaire | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
| Table des mots clés | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
| -### | Options contrôlant le type de sortie |
| -$ | Options contrôlant le préprocesseur |
| --help | Options contrôlant le préprocesseur |
| --param nom=valeur | Options contrôlant l'optimisation |
| --target-help | Options contrôlant le préprocesseur |
| --version | Options contrôlant le préprocesseur |
| -A -prédicat=réponse | Options contrôlant le préprocesseur |
| -A prédicat=réponse | Options contrôlant le préprocesseur |
| -A- | Options contrôlant le préprocesseur |
| -ansi | Options contrôlant le préprocesseur |
| -aux-info nom-fichier | Options contrôlant le dialecte C |
| -b machine | Spécifier la machine cible et la version du compilateur |
| -Bpréfixe | Options de recherche dans les répertoires |
| -c | Options pour l'édition des liens |
| -D nom | Options contrôlant le préprocesseur |
| -D nom=définition | Options contrôlant le préprocesseur |
| -dCARS | Options contrôlant le préprocesseur |
| -dlettres | Options pour requérir ou supprimer des avertissements |
| -dumpmachine | Options pour requérir ou supprimer des avertissements |
| -dumpspecs | Options pour requérir ou supprimer des avertissements |
| -dumpversion | Options pour requérir ou supprimer des avertissements |
| -E | Options pour l'édition des liens |
| -EB | Options V850 |
| -EL | Options V850 |
| -falign-functions | Options contrôlant l'optimisation |
| -falign-functions=n | Options contrôlant l'optimisation |
| -falign-jumps | Options contrôlant l'optimisation |
| -falign-jumps=n | Options contrôlant l'optimisation |
| -falign-labels | Options contrôlant l'optimisation |
| -falign-labels=n | Options contrôlant l'optimisation |
| -falign-loops | Options contrôlant l'optimisation |
| -falign-loops=n | Options contrôlant l'optimisation |
| -fallow-single-precision | Options contrôlant le dialecte C |
| -falt-external-templates | Options contrôlant le dialecte C |
| -fargument-alias | Options de conventions de génération de code |
| -fargument-noalias | Options de conventions de génération de code |
| -fargument-noalias-global | Options de conventions de génération de code |
| -fasynchronous-unwind-tables | Options de conventions de génération de code |
| -fbranch-probabilities | Options contrôlant l'optimisation |
| -fcall-saved-registre | Options de conventions de génération de code |
| -fcall-used-registre | Options de conventions de génération de code |
| -fcaller-saves | Options contrôlant l'optimisation |
| -fcheck-new | Options contrôlant le dialecte C |
| -fcond-mismatch | Options contrôlant le dialecte C |
| -fconserve-space | Options contrôlant le dialecte C |
| -fconstant-string-class=nom-classe | Options contrôlant le dialecte Objective-C |
| -fcse-follow-jumps | Options contrôlant l'optimisation |
| -fcse-skip-blocks | Options contrôlant l'optimisation |
| -fdata-sections | Options contrôlant l'optimisation |
| -fdelayed-branch | Options contrôlant l'optimisation |
| -fdelete-null-pointer-checks | Options contrôlant l'optimisation |
| -fdiagnostics-show-location=every-line | Options pour contrôler le formatage des messages de diagnostic |
| -fdiagnostics-show-location=once | Options pour contrôler le formatage des messages de diagnostic |
| -fdollars-in-identifiers | Options contrôlant le dialecte C |
| -fdump-class-hierarchy (C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -fdump-class-hierarchy-options (C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -fdump-translation-unit (C et C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -fdump-translation-unit-options (C et C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -fdump-tree-interrupteur (C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -fdump-tree-interrupteur-options(C++ uniquement)" 4 | Options pour requérir ou supprimer des avertissements |
| -fdump-unnumbered | Options pour requérir ou supprimer des avertissements |
| -fexceptions | Options de conventions de génération de code |
| -fexpensive-optimizations | Options contrôlant l'optimisation |
| -fexternal-templates | Options contrôlant le dialecte C |
| -ffast-math | Options contrôlant l'optimisation |
| -ffixed-registre | Options de conventions de génération de code |
| -ffloat-store | Options contrôlant l'optimisation |
| -ffor-scope | Options contrôlant le dialecte C |
| -fforce-addr | Options contrôlant l'optimisation |
| -fforce-mem | Options contrôlant l'optimisation |
| -ffreestanding | Options contrôlant le dialecte C |
| -ffunction-sections | Options contrôlant l'optimisation |
| -fgcse | Options contrôlant l'optimisation |
| -fgcse-lm | Options contrôlant l'optimisation |
| -fgcse-sm | Options contrôlant l'optimisation |
| -fgnu-runtime | Options contrôlant le dialecte Objective-C |
| -fhosted | Options contrôlant le dialecte C |
| -finhibit-size-directive | Options de conventions de génération de code |
| -finline-functions | Options contrôlant l'optimisation |
| -finline-limit=n | Options contrôlant l'optimisation |
| -finstrument-functions | Options de conventions de génération de code |
| -fkeep-inline-functions | Options contrôlant l'optimisation |
| -fkeep-static-consts | Options contrôlant l'optimisation |
| -fleading-underscore | Options de conventions de génération de code |
| -fmem-report | Options pour requérir ou supprimer des avertissements |
| -fmerge-all-constants | Options contrôlant l'optimisation |
| -fmerge-constants | Options contrôlant l'optimisation |
| -fmessage-length=n | Options pour contrôler le formatage des messages de diagnostic |
| -fmove-all-movables | Options contrôlant l'optimisation |
| -fms-extensions | Options contrôlant le dialecte C |
| -fnext-runtime | Options contrôlant le dialecte Objective-C |
| -fno-access-control | Options contrôlant le dialecte C |
| -fno-asm | Options contrôlant le dialecte C |
| -fno-builtin | Options contrôlant le dialecte C |
| -fno-builtin-fonction (C et Objective-C uniquement) | Options contrôlant le dialecte C |
| -fno-common | Options de conventions de génération de code |
| -fno-const-strings | Options contrôlant le dialecte C |
| -fno-cprop-registers | Options contrôlant l'optimisation |
| -fno-default-inline | Options contrôlant l'optimisation |
| -fno-defer-pop | Options contrôlant l'optimisation |
| -fno-elide-constructors | Options contrôlant le dialecte C |
| -fno-enforce-eh-specs | Options contrôlant le dialecte C |
| -fno-for-scope | Options contrôlant le dialecte C |
| -fno-function-cse | Options contrôlant l'optimisation |
| -fno-gnu-keywords | Options contrôlant le dialecte C |
| -fno-gnu-linker | Options de conventions de génération de code |
| -fno-guess-branch-probability | Options contrôlant l'optimisation |
| -fno-ident | Options de conventions de génération de code |
| -fno-implement-inlines | Options contrôlant le dialecte C |
| -fno-implicit-inline-templates | Options contrôlant le dialecte C |
| -fno-implicit-templates | Options contrôlant le dialecte C |
| -fno-inline | Options contrôlant l'optimisation |
| -fno-math-errno | Options contrôlant l'optimisation |
| -fno-nonansi-builtins | Options contrôlant le dialecte C |
| -fno-operator-names | Options contrôlant le dialecte C |
| -fno-optional-diags | Options contrôlant le dialecte C |
| -fno-peephole | Options contrôlant l'optimisation |
| -fno-peephole2 | Options contrôlant l'optimisation |
| -fno-rtti | Options contrôlant le dialecte C |
| -fno-show-column | Options contrôlant le préprocesseur |
| -fno-signed-bitfields | Options contrôlant le dialecte C |
| -fno-stack-limit | Options de conventions de génération de code |
| -fno-trapping-math | Options contrôlant l'optimisation |
| -fno-unsigned-bitfields | Options contrôlant le dialecte C |
| -fno-weak | Options contrôlant le dialecte C |
| -fnon-call-exceptions | Options de conventions de génération de code |
| -fomit-frame-pointer | Options contrôlant l'optimisation |
| -foptimize-register-move | Options contrôlant l'optimisation |
| -foptimize-sibling-calls | Options contrôlant l'optimisation |
| -fpack-struct | Options de conventions de génération de code |
| -fpcc-struct-return | Options de conventions de génération de code |
| -fpermissive | Options contrôlant le dialecte C |
| -fpic | Options de conventions de génération de code |
| -fprefetch-loop-arrays | Options contrôlant l'optimisation |
| -fpreprocessed | Options contrôlant le préprocesseur |
| -fpretend-float | Options pour requérir ou supprimer des avertissements |
| -fprofile-arcs | Options pour requérir ou supprimer des avertissements |
| -freduce-all-givs | Options contrôlant l'optimisation |
| -freg-struct-return | Options de conventions de génération de code |
| -fregmove | Options contrôlant l'optimisation |
| -frename-registers | Options contrôlant l'optimisation |
| -frepo | Options contrôlant le dialecte C |
| -frerun-cse-after-loop | Options contrôlant l'optimisation |
| -frerun-loop-opt | Options contrôlant l'optimisation |
| -fschedule-insns | Options contrôlant l'optimisation |
| -fschedule-insns2 | Options contrôlant l'optimisation |
| -fshared-data | Options de conventions de génération de code |
| -fshort-double | Options de conventions de génération de code |
| -fshort-enums | Options de conventions de génération de code |
| -fshort-wchar | Options contrôlant le dialecte C |
| -fsigned-bitfields | Options contrôlant le dialecte C |
| -fsigned-char | Options contrôlant le dialecte C |
| -fsingle-precision-constant | Options contrôlant l'optimisation |
| -fssa | Options contrôlant l'optimisation |
| -fssa-ccp | Options contrôlant l'optimisation |
| -fssa-dce | Options contrôlant l'optimisation |
| -fstack-check | Options de conventions de génération de code |
| -fstack-limit-register=registre | Options de conventions de génération de code |
| -fstack-limit-symbol=sym | Options de conventions de génération de code |
| -fstats | Options contrôlant le dialecte C |
| -fstrength-reduce | Options contrôlant l'optimisation |
| -fstrict-aliasing | Options contrôlant l'optimisation |
| -fsyntax-only | Options pour requérir ou supprimer des avertissements |
| -ftabstop=largeur | Options contrôlant le préprocesseur |
| -ftemplate-depth-n | Options contrôlant le dialecte C |
| -ftest-coverage | Options pour requérir ou supprimer des avertissements |
| -fthread-jumps | Options contrôlant l'optimisation |
| -ftime-report | Options pour requérir ou supprimer des avertissements |
| -ftls-model=modèle | Options de conventions de génération de code |
| -ftrapv | Options contrôlant l'optimisation |
| -funroll-all-loops | Options contrôlant l'optimisation |
| -funroll-loops | Options contrôlant l'optimisation |
| -funsafe-math-optimizations | Options contrôlant l'optimisation |
| -funsigned-bitfields | Options contrôlant le dialecte C |
| -funsigned-char | Options contrôlant le dialecte C |
| -funwind-tables | Options de conventions de génération de code |
| -fuse-cxa-atexit | Options contrôlant le dialecte C |
| -fverbose-asm | Options de conventions de génération de code |
| -fvolatile | Options de conventions de génération de code |
| -fvolatile-global | Options de conventions de génération de code |
| -fvolatile-static | Options de conventions de génération de code |
| -fvtable-gc | Options contrôlant le dialecte C |
| -fwritable-strings | Options contrôlant le dialecte C |
| -G | Options pour System V |
| -G nombre | Options M88K |
| -gcc | Options contrôlant le préprocesseur |
| -gcoff | Options pour requérir ou supprimer des avertissements |
| -gcoffniveau | Options pour requérir ou supprimer des avertissements |
| -gdwarf | Options pour requérir ou supprimer des avertissements |
| -gdwarf+ | Options pour requérir ou supprimer des avertissements |
| -gdwarf-2 | Options pour requérir ou supprimer des avertissements |
| -gen-decls | Options contrôlant le dialecte Objective-C |
| -ggdb | Options pour requérir ou supprimer des avertissements |
| -ggdbniveau | Options pour requérir ou supprimer des avertissements |
| -gniveau | Options pour requérir ou supprimer des avertissements |
| -gstabs | Options pour requérir ou supprimer des avertissements |
| -gstabs+ | Options pour requérir ou supprimer des avertissements |
| -gstabsniveau | Options pour requérir ou supprimer des avertissements |
| -gvms | Options pour requérir ou supprimer des avertissements |
| -gvmsniveau | Options pour requérir ou supprimer des avertissements |
| -gxcoff | Options pour requérir ou supprimer des avertissements |
| -gxcoff+ | Options pour requérir ou supprimer des avertissements |
| -gxcoffniveau | Options pour requérir ou supprimer des avertissements |
| -H | Options contrôlant le préprocesseur |
| -I rép | Options contrôlant le préprocesseur |
| -I- | Options de recherche dans les répertoires |
| -idirafter répertoire | Options contrôlant le préprocesseur |
| -imacros fichier | Options contrôlant le préprocesseur |
| -include fichier | Options contrôlant le préprocesseur |
| -iprefix préfixe | Options contrôlant le préprocesseur |
| -Irép | Options de recherche dans les répertoires |
| -isystem répertoire | Options contrôlant le préprocesseur |
| -iwithprefix répertoire | Options contrôlant le préprocesseur |
| -iwithprefixbefore répertoire | Options contrôlant le préprocesseur |
| -l bibliothèque | Options pour l'édition des liens |
| -lbibliothèque | Options pour l'édition des liens |
| -lobjc | Options pour l'édition des liens |
| -Lrép | Options de recherche dans les répertoires |
| -M | Options contrôlant le préprocesseur |
| -m1 | Options H8/300 |
| -m10 | Options S/390 et zSeries |
| -m128bit-long-double | Options M88K |
| -m16-bit | Options S/390 et zSeries |
| -m2 | Options H8/300 |
| -m210 | Options MCore |
| -m29000 | Options Convex |
| -m29050 | Options Convex |
| -m3 | Options H8/300 |
| -m31 | Options S/390 et zSeries |
| -m32 | Options M88K |
| -m32-bit | Options S/390 et zSeries |
| -m32032 | Options V850 |
| -m32081 | Options V850 |
| -m32332 | Options V850 |
| -m32381 | Options V850 |
| -m32532 | Options V850 |
| -m32r | Options M32R/D |
| -m32rx | Options M32R/D |
| -m340 | Options MCore |
| -m386 | Options M88K |
| -m3dnow | Options M88K |
| -m3e | Options H8/300 |
| -m4 | Options H8/300 |
| -m4-nofpu | Options H8/300 |
| -m4-single | Options H8/300 |
| -m4-single-only | Options H8/300 |
| -m40 | Options S/390 et zSeries |
| -m45 | Options S/390 et zSeries |
| -m4650 | Options M88K |
| -m486 | Options M88K |
| -m4byte-functions | Options MCore |
| -m5200 | Options M680x0 |
| -m64 | Options S/390 et zSeries |
| -m68000 | Options M680x0 |
| -m68020 | Options M680x0 |
| -m68020-40 | Options M680x0 |
| -m68020-60 | Options M680x0 |
| -m68030 | Options M680x0 |
| -m68040 | Options M680x0 |
| -m68060 | Options M680x0 |
| -m6811 | Options M68hc1x |
| -m6812 | Options M68hc1x |
| -m68881 | Options M680x0 |
| -m68hc11 | Options M68hc1x |
| -m68hc12 | Options M68hc1x |
| -m8-bit | Options S/390 et zSeries |
| -m88000 | Options M88K |
| -m88100 | Options M88K |
| -m88110 | Options M88K |
| -m96bit-long-double | Options M88K |
| -mabi=32 | Options M88K |
| -mabi=64 | Options M88K |
| -mabi=altivec | Options M88K |
| -mabi=eabi | Options M88K |
| -mabi=gnu | Options S/390 et zSeries |
| -mabi=mmixware | Options S/390 et zSeries |
| -mabi=n32 | Options M88K |
| -mabi=no-altivec | Options M88K |
| -mabi=o64 | Options M88K |
| -mabicalls | Options M88K |
| -mabort-on-noreturn | Options Convex |
| -mabshi | Options S/390 et zSeries |
| -mac0 | Options S/390 et zSeries |
| -maccumulate-outgoing-args | Options M88K |
| -mads | Options M88K |
| -maix-struct-return | Options M88K |
| -maix32 | Options M88K |
| -maix64 | Options M88K |
| -malign-300 | Options H8/300 |
| -malign-double | Options M88K |
| -malign-int | Options M680x0 |
| -malignment-traps | Options Convex |
| -malpha-as | Options Intel 960 |
| -maltivec | Options M88K |
| -mam33 | Options Convex |
| -maout | Options S/390 et zSeries |
| -mapcs | Options Convex |
| -mapcs-26 | Options Convex |
| -mapcs-32 | Options Convex |
| -mapcs-frame | Options Convex |
| -mapp-regs | Options M68hc1x |
| -march=nom | Options Convex |
| -march=type-architecture | Options S/390 et zSeries |
| -march=type-cpu | Options M88K |
| -margcount | Options Convex |
| -masm-compat | Options Intel 960 |
| -masm-optimize | Options D30V |
| -masm=dialecte | Options M88K |
| -mauto-incdec | Options M68hc1x |
| -mauto-pic | Options MCore |
| -mb | Options H8/300 |
| -mb-step | Options MCore |
| -mbackchain | Options S/390 et zSeries |
| -mbase-addresses | Options S/390 et zSeries |
| -mbcopy | Options S/390 et zSeries |
| -mbcopy-builtin | Options S/390 et zSeries |
| -mbig | Options TMS320C3x/C4x |
| -mbig-endian | Options Xtensa |
| -mbig-memory | Options TMS320C3x/C4x |
| -mbig-pic | Options M88K |
| -mbig-switch | Options V850 |
| -mbigtable | Options H8/300 |
| -mbit-align | Options M88K |
| -mbitfield | Options V850 |
| -mbk | Options TMS320C3x/C4x |
| -mbooleans | Options Xtensa |
| -mbranch-cheap | Options S/390 et zSeries |
| -mbranch-cost=n | Options D30V |
| -mbranch-expensive | Options S/390 et zSeries |
| -mbranch-predict | Options S/390 et zSeries |
| -mbroken-saverestore | Options M68hc1x |
| -mbsd | Options Convex |
| -mbuild-constants | Options Intel 960 |
| -mbw | Options Convex |
| -mbwx | Options Intel 960 |
| -mc1 | Options Convex |
| -mc2 | Options Convex |
| -mc300 | Options Clipper |
| -mc32 | Options Convex |
| -mc34 | Options Convex |
| -mc38 | Options Convex |
| -mc400 | Options Clipper |
| -mc68000 | Options M680x0 |
| -mc68020 | Options M680x0 |
| -mcall-aix | Options M88K |
| -mcall-gnu | Options M88K |
| -mcall-lib-mul | Options M88K |
| -mcall-linux | Options M88K |
| -mcall-netbsd | Options M88K |
| -mcall-prologues | Options V850 |
| -mcall-solaris | Options M88K |
| -mcall-sysv | Options M88K |
| -mcall-sysv-eabi | Options M88K |
| -mcall-sysv-noeabi | Options M88K |
| -mcallee-super-interworking | Options Convex |
| -mcaller-super-interworking | Options Convex |
| -mcallgraph-data | Options MCore |
| -mcc-init | Options S/390 et zSeries |
| -mcheck-zero-division | Options M88K |
| -mcix | Options Intel 960 |
| -mcmodel=embmedany | Options M68hc1x |
| -mcmodel=kernel | Options M88K |
| -mcmodel=large | Options M88K |
| -mcmodel=medany | Options M68hc1x |
| -mcmodel=medium | Options M88K |
| -mcmodel=medlow | Options M68hc1x |
| -mcmodel=medmid | Options M68hc1x |
| -mcmodel=small | Options M88K |
| -mcode-align | Options Intel 960 |
| -mcode-model=large | Options M32R/D |
| -mcode-model=medium | Options M32R/D |
| -mcode-model=small | Options M32R/D |
| -mcomplex-addr | Options Intel 960 |
| -mcond-exec=n | Options D30V |
| -mconst-align | Options S/390 et zSeries |
| -mconstant-gp | Options MCore |
| -mcpu32 | Options M680x0 |
| -mcpu=cpu | Options V850 |
| -mcpu=nom | Options Convex |
| -mcpu=type-architecture | Options S/390 et zSeries |
| -mcpu=type-cpu | Options TMS320C3x/C4x |
| -mcypress | Options M68hc1x |
| -MD | Options contrôlant le préprocesseur |
| -mdalign | Options H8/300 |
| -mdata-align | Options S/390 et zSeries |
| -mdata=section-données | Options V850 |
| -mdb | Options TMS320C3x/C4x |
| -mdebug | Options S/390 et zSeries |
| -mdec-asm | Options S/390 et zSeries |
| -mdensity | Options Xtensa |
| -mdisable-fpregs | Options M88K |
| -mdisable-indexing | Options M88K |
| -mdiv | Options MCore |
| -mdouble-float | Options M88K |
| -mdp-isr-reload | Options TMS320C3x/C4x |
| -mdw | Options Convex |
| -mdwarf2-asm | Options MCore |
| -meabi | Options M88K |
| -melf | Options S/390 et zSeries |
| -melinux | Options S/390 et zSeries |
| -melinux-stacksize=n | Options S/390 et zSeries |
| -memb | Options M88K |
| -membedded-data | Options M88K |
| -membedded-pic | Options M88K |
| -mentry | Options M88K |
| -mep | Options V850 |
| -mepsilon | Options S/390 et zSeries |
| -metrax100 | Options S/390 et zSeries |
| -metrax4 | Options S/390 et zSeries |
| -mexplicit-relocs | Options Intel 960 |
| -mextmem | Options D30V |
| -mextmemory | Options D30V |
| -MF fichier | Options contrôlant le préprocesseur |
| -mfast-fix | Options TMS320C3x/C4x |
| -mfast-indirect-calls | Options M88K |
| -mfaster-structs | Options M68hc1x |
| -mfix | Options Intel 960 |
| -mfix7000 | Options M88K |
| -mfixed-range=intervalle-registres | Options MCore |
| -mflat | Options M68hc1x |
| -mfloat-ieee | Options Intel 960 |
| -mfloat-vax | Options Intel 960 |
| -mfloat32 | Options S/390 et zSeries |
| -mfloat64 | Options S/390 et zSeries |
| -mflush-func=fonc | Options M88K |
| -mfmovd | Options H8/300 |
| -mfp-arg-in-fpregs | Options M88K |
| -mfp-arg-in-gregs | Options M88K |
| -mfp-reg | Options Intel 960 |
| -mfp-rounding-mode=mode-arrondi | Options Intel 960 |
| -mfp-trap-mode=mode-interruption | Options Intel 960 |
| -mfp32 | Options M88K |
| -mfp64 | Options M88K |
| -mfp=nombre | Options Convex |
| -mfpa | Options M680x0 |
| -mfpe=nombre | Options Convex |
| -mfpmath=unité | Options M88K |
| -mfpu | Options S/390 et zSeries |
| -mfull-fp-blocks | Options M88K |
| -mfull-toc | Options M88K |
| -mfused-madd | Options Xtensa |
| -mg | Options M68hc1x |
| -mgas | Options Intel 960 |
| -mgnu | Options M68hc1x |
| -mgnu-as | Options MCore |
| -mgnu-ld | Options MCore |
| -mgotplt | Options S/390 et zSeries |
| -mgp32 | Options M88K |
| -mgp64 | Options M88K |
| -mgpopt | Options M88K |
| -mh | Options H8/300 |
| -mhalf-pic | Options M88K |
| -mhandle-large-shift | Options M88K |
| -mhard-float | Options Xtensa |
| -mhard-quad-float | Options M68hc1x |
| -mhardlit | Options MCore |
| -mhc-struct-return | Options M88K |
| -mhimem | Options V850 |
| -mhitachi | Options H8/300 |
| -mic-compat | Options Intel 960 |
| -mic2.0-compat | Options Intel 960 |
| -mic3.0-compat | Options Intel 960 |
| -midentify-revision | Options M88K |
| -mieee | Options H8/300 |
| -mieee-conformant | Options Intel 960 |
| -mieee-fp | Options M88K |
| -mieee-with-inexact | Options Intel 960 |
| -mimpure-text | Options Convex |
| -min-line-mul | Options M88K |
| -minit-stack=N | Options V850 |
| -minline-all-stringops | Options M88K |
| -minline-divide-max-throughput | Options MCore |
| -minline-divide-min-latency | Options MCore |
| -mint16 | Options S/390 et zSeries |
| -mint32 | Options S/390 et zSeries |
| -mint64 | Options M88K |
| -mintel-asm | Options Intel 960 |
| -mips1 | Options M88K |
| -mips16 | Options M88K |
| -mips2 | Options M88K |
| -mips3 | Options M88K |
| -mips4 | Options M88K |
| -misize | Options H8/300 |
| -mjump-in-delay | Options M88K |
| -mkernel-registers | Options Convex |
| -mknuthdiv | Options S/390 et zSeries |
| -ml | Options H8/300 |
| -mlarge | Options Convex |
| -mlarge-data | Options Intel 960 |
| -mleaf-procedures | Options Intel 960 |
| -mlibfuncs | Options S/390 et zSeries |
| -mlinker-opt | Options M88K |
| -mlinux | Options S/390 et zSeries |
| -mlittle | Options M88K |
| -mlittle-endian | Options Xtensa |
| -mlive-g0 | Options M68hc1x |
| -mlong-calls | Options V850 |
| -mlong-double-64 | Options Intel 960 |
| -mlong-load-store | Options M88K |
| -mlong32 | Options M88K |
| -mlong64 | Options M88K |
| -mlongcalls | Options Xtensa |
| -mloop-unsigned | Options TMS320C3x/C4x |
| -MM | Options contrôlant le préprocesseur |
| -mmac16 | Options Xtensa |
| -mmad | Options M88K |
| -mmangle-cpu | Options V850 |
| -mmax | Options Intel 960 |
| -mmax-stack-frame=n | Options S/390 et zSeries |
| -mmcu=mcu | Options V850 |
| -MMD | Options contrôlant le préprocesseur |
| -mmemcpy | Options M88K |
| -mmemory-latency=temps | Options Intel 960 |
| -mmemparm | Options TMS320C3x/C4x |
| -mminimal-toc | Options M88K |
| -mminimum-fp-blocks | Options M88K |
| -mminmax | Options Xtensa |
| -mmips-as | Options M88K |
| -mmips-tfile | Options M88K |
| -mmmx | Options M88K |
| -mmpyi | Options TMS320C3x/C4x |
| -mmul16 | Options Xtensa |
| -mmul32 | Options Xtensa |
| -mmult-bug | Options Convex |
| -mmulti-add | Options V850 |
| -mmultiple | Options M88K |
| -mmvcle | Options S/390 et zSeries |
| -mmvme | Options M88K |
| -mnbw | Options Convex |
| -mndw | Options Convex |
| -mnew-mnemonics | Options M88K |
| -mno-3dnow | Options M88K |
| -mno-4byte-functions | Options MCore |
| -mno-abicalls | Options M88K |
| -mno-abshi | Options S/390 et zSeries |
| -mno-ac0 | Options S/390 et zSeries |
| -mno-align-double | Options M88K |
| -mno-align-int | Options M680x0 |
| -mno-align-stringops | Options M88K |
| -mno-alignment-traps | Options Convex |
| -mno-altivec | Options M88K |
| -mno-am33 | Options Convex |
| -mno-app-regs | Options M68hc1x |
| -mno-asm-optimize | Options D30V |
| -mno-backchain | Options S/390 et zSeries |
| -mno-base-addresses | Options S/390 et zSeries |
| -mno-bit-align | Options M88K |
| -mno-bk | Options TMS320C3x/C4x |
| -mno-booleans | Options Xtensa |
| -mno-branch-predict | Options S/390 et zSeries |
| -mno-bwx | Options Intel 960 |
| -mno-callgraph-data | Options MCore |
| -mno-check-zero-division | Options M88K |
| -mno-cix | Options Intel 960 |
| -mno-code-align | Options Intel 960 |
| -mno-complex-addr | Options Intel 960 |
| -mno-const-align | Options S/390 et zSeries |
| -mno-crt0 | Options Convex |
| -mno-data-align | Options S/390 et zSeries |
| -mno-db | Options TMS320C3x/C4x |
| -mno-debug | Options S/390 et zSeries |
| -mno-density | Options Xtensa |
| -mno-div | Options MCore |
| -mno-dwarf2-asm | Options MCore |
| -mno-eabi | Options M88K |
| -mno-embedded-data | Options M88K |
| -mno-embedded-pic | Options M88K |
| -mno-ep | Options V850 |
| -mno-epsilon | Options S/390 et zSeries |
| -mno-explicit-relocs | Options Intel 960 |
| -mno-fancy-math-387 | Options M88K |
| -mno-fast-fix | Options TMS320C3x/C4x |
| -mno-faster-structs | Options M68hc1x |
| -mno-fix | Options Intel 960 |
| -mno-flat | Options M68hc1x |
| -mno-float32 | Options S/390 et zSeries |
| -mno-float64 | Options S/390 et zSeries |
| -mno-flush-func | Options M88K |
| -mno-fp-in-toc | Options M88K |
| -mno-fp-regs | Options Intel 960 |
| -mno-fp-ret-in-387 | Options M88K |
| -mno-fpu | Options M68hc1x |
| -mno-fused-madd | Options Xtensa |
| -mno-gnu-as | Options MCore |
| -mno-gnu-ld | Options MCore |
| -mno-gotplt | Options S/390 et zSeries |
| -mno-gpopt | Options M88K |
| -mno-half-pic | Options M88K |
| -mno-hardlit | Options MCore |
| -mno-ieee-fp | Options M88K |
| -mno-impure-text | Options Convex |
| -mno-int16 | Options S/390 et zSeries |
| -mno-int32 | Options S/390 et zSeries |
| -mno-interrupts | Options V850 |
| -mno-knuthdiv | Options S/390 et zSeries |
| -mno-leaf-procedures | Options Intel 960 |
| -mno-libfuncs | Options S/390 et zSeries |
| -mno-long-calls | Options V850 |
| -mno-longcalls | Options Xtensa |
| -mno-loop-unsigned | Options TMS320C3x/C4x |
| -mno-mac16 | Options Xtensa |
| -mno-mad | Options M88K |
| -mno-max | Options Intel 960 |
| -mno-memcpy | Options M88K |
| -mno-minmax | Options Xtensa |
| -mno-mips-tfile | Options M88K |
| -mno-mips16 | Options M88K |
| -mno-mmx | Options M88K |
| -mno-mpyi | Options TMS320C3x/C4x |
| -mno-mul16 | Options Xtensa |
| -mno-mul32 | Options Xtensa |
| -mno-mult-bug | Options Convex |
| -mno-multiple | Options M88K |
| -mno-multm | Options Convex |
| -mno-mvcle | Options S/390 et zSeries |
| -mno-nsa | Options Xtensa |
| -mno-ocs-debug-info | Options M88K |
| -mno-ocs-frame-position | Options M88K |
| -mno-optimize-arg-area | Options M88K |
| -mno-parallel-insns | Options TMS320C3x/C4x |
| -mno-parallel-mpy | Options TMS320C3x/C4x |
| -mno-pic | Options MCore |
| -mno-power | Options M88K |
| -mno-power2 | Options M88K |
| -mno-powerpc | Options M88K |
| -mno-powerpc-gfxopt | Options M88K |
| -mno-powerpc-gpopt | Options M88K |
| -mno-powerpc64 | Options M88K |
| -mno-prolog-function | Options V850 |
| -mno-prologue-epilogue | Options S/390 et zSeries |
| -mno-prototype | Options M88K |
| -mno-push-args | Options M88K |
| -mno-red-zone | Options M88K |
| -mno-register-names | Options MCore |
| -mno-regnames | Options M88K |
| -mno-relax-immediate | Options MCore |
| -mno-relocatable | Options M88K |
| -mno-relocatable-lib | Options M88K |
| -mno-reuse-arg-regs | Options Convex |
| -mno-rnames | Options M88K |
| -mno-rptb | Options TMS320C3x/C4x |
| -mno-rpts | Options TMS320C3x/C4x |
| -mno-sched-prolog | Options Convex |
| -mno-sdata | Options MCore |
| -mno-serialize-volatile | Options Xtensa |
| -mno-sext | Options Xtensa |
| -mno-short-load-bytes | Options Convex |
| -mno-short-load-words | Options Convex |
| -mno-side-effects | Options S/390 et zSeries |
| -mno-slow-bytes | Options MCore |
| -mno-small-exec | Options S/390 et zSeries |
| -mno-soft-float | Options Intel 960 |
| -mno-space-regs | Options M88K |
| -mno-split | Options S/390 et zSeries |
| -mno-split-addresses | Options M88K |
| -mno-sse | Options M88K |
| -mno-sse2 | Options M88K |
| -mno-stack-align | Options S/390 et zSeries |
| -mno-stack-bias | Options M68hc1x |
| -mno-stack-check | Options Convex |
| -mno-stats | Options M88K |
| -mno-storem-bug | Options Convex |
| -mno-strict-align | Options Intel 960 |
| -mno-string | Options M88K |
| -mno-sum-in-toc | Options M88K |
| -mno-svr3-shlib | Options M88K |
| -mno-symrename | Options Convex |
| -mno-tablejump | Options V850 |
| -mno-tail-call | Options Intel 960 |
| -mno-target-align | Options Xtensa |
| -mno-text-section-literals | Options Xtensa |
| -mno-toc | Options M88K |
| -mno-toplevel-symbols | Options S/390 et zSeries |
| -mno-unaligned-doubles | Options M68hc1x |
| -mno-underscores | Options M88K |
| -mno-uninit-const-in-rodata | Options M88K |
| -mno-update | Options M88K |
| -mno-volatile-asm-stop | Options MCore |
| -mno-wide-bitfields | Options MCore |
| -mno-xl-call | Options M88K |
| -mno-zero-extend | Options S/390 et zSeries |
| -mnoargcount | Options Convex |
| -mnobitfield | Options V850 |
| -mnohc-struct-return | Options M88K |
| -mnohimem | Options V850 |
| -mnomacsave | Options H8/300 |
| -mnomulti-add | Options V850 |
| -mnop-fun-dllimport | Options Convex |
| -mnoregparam | Options V850 |
| -mnormal | Options Convex |
| -mnosb | Options V850 |
| -mnsa | Options Xtensa |
| -mnumerics | Options Intel 960 |
| -mocs-debug-info | Options M88K |
| -mocs-frame-position | Options M88K |
| -mold-align | Options Intel 960 |
| -mold-mnemonics | Options M88K |
| -momit-leaf-frame-pointer | Options M88K |
| -monchip | Options D30V |
| -moptimize-arg-area | Options M88K |
| -MP | Options contrôlant le préprocesseur |
| -mpa-risc-1-0 | Options M88K |
| -mpa-risc-1-1 | Options M88K |
| -mpa-risc-2-0 | Options M88K |
| -mpadstruct | Options H8/300 |
| -mparallel-insns | Options TMS320C3x/C4x |
| -mparallel-mpy | Options TMS320C3x/C4x |
| -mparanoid | Options TMS320C3x/C4x |
| -mpcrel | Options M680x0 |
| -mpdebug | Options S/390 et zSeries |
| -mpe | Options M88K |
| -mpentium | Options M88K |
| -mpentiumpro | Options M88K |
| -mpic-register=reg | Options Convex |
| -mpoke-function-name | Options Convex |
| -mportable-runtime | Options M88K |
| -mpower | Options M88K |
| -mpower2 | Options M88K |
| -mpowerpc | Options M88K |
| -mpowerpc-gfxopt | Options M88K |
| -mpowerpc-gpopt | Options M88K |
| -mpowerpc64 | Options M88K |
| -mprefergot | Options H8/300 |
| -mpreferred-stack-boundary=nombre | Options M88K |
| -mprolog-function | Options V850 |
| -mprologue-epilogue | Options S/390 et zSeries |
| -mprototype | Options M88K |
| -mpush-args | Options M88K |
| -MQ cible | Options contrôlant le préprocesseur |
| -mregister-names | Options MCore |
| -mregnames | Options M88K |
| -mregparam | Options V850 |
| -mregparm | Options TMS320C3x/C4x |
| -mregparm=nombre | Options M88K |
| -mrelax | Options H8/300 |
| -mrelax-immediate | Options MCore |
| -mrelocatable | Options M88K |
| -mrelocatable-lib | Options M88K |
| -mreuse-arg-regs | Options Convex |
| -mrnames | Options M88K |
| -mrodata=section-données-lecture-seule | Options V850 |
| -mrptb | Options TMS320C3x/C4x |
| -mrpts=nombre | Options TMS320C3x/C4x |
| -mrtd | Options V850 |
| -ms | Options H8/300 |
| -ms2600 | Options H8/300 |
| -msb | Options V850 |
| -mschedule=type-cpu | Options M88K |
| -msda=n | Options V850 |
| -msdata | Options MCore |
| -msdata-data | Options M88K |
| -msdata=default | Options M88K |
| -msdata=eabi | Options M88K |
| -msdata=none | Options M88K |
| -msdata=sdata | Options M32R/D |
| -msdata=sysv | Options M88K |
| -msdata=use | Options M32R/D |
| -mserialize-volatile | Options Xtensa |
| -msext | Options Xtensa |
| -mshort | Options M68hc1x |
| -mshort-data-nombre | Options M88K |
| -mshort-load-bytes | Options Convex |
| -mshort-load-words | Options Convex |
| -msim | Options Xstormy16 |
| -msingle-float | Options M88K |
| -msingle-pic-base | Options Convex |
| -msize | Options V850 |
| -mslow-bytes | Options MCore |
| -msmall | Options TMS320C3x/C4x |
| -msmall-data | Options Intel 960 |
| -msmall-exec | Options S/390 et zSeries |
| -msmall-memory | Options TMS320C3x/C4x |
| -msoft-float | Options Xtensa |
| -msoft-quad-float | Options M68hc1x |
| -msoft-reg-count=nombre | Options M68hc1x |
| -mspace | Options V850 |
| -msparclite | Options M68hc1x |
| -msplit | Options S/390 et zSeries |
| -msplit-addresses | Options M88K |
| -msse | Options M88K |
| -msse2 | Options M88K |
| -mstack-align | Options S/390 et zSeries |
| -mstack-bias | Options M68hc1x |
| -mstack-check | Options Convex |
| -mstats | Options M88K |
| -mstorem-bug | Options Convex |
| -mstrict-align | Options Intel 960 |
| -mstring | Options M88K |
| -mstructure-size-boundary=n | Options Convex |
| -msupersparc | Options M68hc1x |
| -msvr3 | Options M88K |
| -msvr3-shlib | Options M88K |
| -msvr4 | Options M88K |
| -msvr4-struct-return | Options M88K |
| -MT cible | Options contrôlant le préprocesseur |
| -mtail-call | Options Intel 960 |
| -mtarget-align | Options Xtensa |
| -mtda=n | Options V850 |
| -mtext-section-literals | Options Xtensa |
| -mtext=section-texte | Options V850 |
| -mthreads | Options M88K |
| -mthumb | Options Convex |
| -mthumb-interwork | Options Convex |
| -mti | Options TMS320C3x/C4x |
| -mtiny-stack | Options V850 |
| -mtoc | Options M88K |
| -mtoplevel-symbols | Options S/390 et zSeries |
| -mtpcs-frame | Options Convex |
| -mtpcs-leaf-frame | Options Convex |
| -mtrap-large-shift | Options M88K |
| -mtrap-precision=précision-interruption | Options Intel 960 |
| -mtune=nom | Options Convex |
| -mtune=type-architecture | Options S/390 et zSeries |
| -mtune=type-cpu | Options Intel 960 |
| -mtype-cpu | Options Intel 960 |
| -munaligned-doubles | Options M68hc1x |
| -muninit-const-in-rodata | Options M88K |
| -munix | Options M68hc1x |
| -munix-asm | Options S/390 et zSeries |
| -mupdate | Options M88K |
| -muse-div-instruction | Options M88K |
| -muser-registers | Options Convex |
| -musermode | Options H8/300 |
| -mv8 | Options M68hc1x |
| -mv850 | Options V850 |
| -mversion-03.00 | Options M88K |
| -mvms-return-codes | Options Intel 960 |
| -mvolatile-asm-stop | Options MCore |
| -mvolatile-cache | Options Convex |
| -mvolatile-nocache | Options Convex |
| -mvxworks | Options M88K |
| -mwarn-passed-structs | Options M88K |
| -mwide-bitfields | Options MCore |
| -mwords-little-endian | Options Convex |
| -mxl-call | Options M88K |
| -mxopen | Options Convex |
| -myellowknife | Options M88K |
| -mzda=n | Options V850 |
| -mzero-extend | Options S/390 et zSeries |
| -no-crt0 | Options M88K |
| -no-integrated-cpp | Options contrôlant le dialecte C |
| -nocpp | Options M88K |
| -nodefaultlibs | Options pour l'édition des liens |
| -nostartfiles | Options pour l'édition des liens |
| -nostdinc++ | Options contrôlant le préprocesseur |
| -nostdlib | Options pour l'édition des liens |
| -O | Options contrôlant l'optimisation |
| -o fichier | Options contrôlant le préprocesseur |
| -O0 | Options contrôlant l'optimisation |
| -O1 | Options contrôlant l'optimisation |
| -O2 | Options contrôlant l'optimisation |
| -O3 | Options contrôlant l'optimisation |
| -Os | Options contrôlant l'optimisation |
| -p | Options pour requérir ou supprimer des avertissements |
| -pass-exit-codes | Options contrôlant le type de sortie |
| -pedantic | Options contrôlant le préprocesseur |
| -pedantic-errors | Options contrôlant le préprocesseur |
| -pg | Options pour requérir ou supprimer des avertissements |
| -pipe | Options contrôlant le type de sortie |
| -print-file-name=bibliothèque | Options pour requérir ou supprimer des avertissements |
| -print-libgcc-file-name | Options pour requérir ou supprimer des avertissements |
| -print-multi-directory | Options pour requérir ou supprimer des avertissements |
| -print-multi-lib | Options pour requérir ou supprimer des avertissements |
| -print-prog-name=programme | Options pour requérir ou supprimer des avertissements |
| -print-search-dirs | Options pour requérir ou supprimer des avertissements |
| -pthread | Options M88K |
| -Q | Options pour requérir ou supprimer des avertissements |
| -Qn | Options pour System V |
| -Qy | Options pour System V |
| -remap | Options contrôlant le préprocesseur |
| -S | Options pour l'édition des liens |
| -save-temps | Options pour requérir ou supprimer des avertissements |
| -shared | Options pour l'édition des liens |
| -shared-libgcc | Options pour l'édition des liens |
| -sim | Options S/390 et zSeries |
| -sim2 | Options S/390 et zSeries |
| -specs=fichier | Options de recherche dans les répertoires |
| -static | Options pour l'édition des liens |
| -static-libgcc | Options pour l'édition des liens |
| -std= | Options contrôlant le dialecte C |
| -std=standard | Options contrôlant le préprocesseur |
| -symbolic | Options pour l'édition des liens |
| -time | Options pour requérir ou supprimer des avertissements |
| -traditional | Options contrôlant le préprocesseur |
| -traditional-cpp | Options contrôlant le dialecte C |
| -trigraphs | Options contrôlant le préprocesseur |
| -U nom | Options contrôlant le préprocesseur |
| -u symbole | Options pour l'édition des liens |
| -undef | Options contrôlant le préprocesseur |
| -v | Options contrôlant le préprocesseur |
| -V version | Spécifier la machine cible et la version du compilateur |
| -version | Options contrôlant le préprocesseur |
| -W | Options pour requérir ou supprimer des avertissements |
| -Wa,option | Passer des options à l'assembleur |
| -Wabi (C++ uniquement) | Options contrôlant le dialecte C |
| -Waggregate-return | Options pour requérir ou supprimer des avertissements |
| -Wall | Options contrôlant le préprocesseur |
| -Wbad-function-cast (C uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wcast-align | Options pour requérir ou supprimer des avertissements |
| -Wcast-qual | Options pour requérir ou supprimer des avertissements |
| -Wchar-subscripts | Options pour requérir ou supprimer des avertissements |
| -Wcomment | Options contrôlant le préprocesseur |
| -Wcomments | Options contrôlant le préprocesseur |
| -Wconversion | Options pour requérir ou supprimer des avertissements |
| -Wctor-dtor-privacy (C++ uniquement) | Options contrôlant le dialecte C |
| -Wdisabled-optimization | Options pour requérir ou supprimer des avertissements |
| -Wdiv-by-zero | Options pour requérir ou supprimer des avertissements |
| -Weffc++ (C++ uniquement) | Options contrôlant le dialecte C |
| -Werror | Options contrôlant le préprocesseur |
| -Werror-implicit-function-declaration | Options pour requérir ou supprimer des avertissements |
| -Wfloat-equal | Options pour requérir ou supprimer des avertissements |
| -Wformat | Options pour requérir ou supprimer des avertissements |
| -Wformat-nonliteral | Options pour requérir ou supprimer des avertissements |
| -Wformat-security | Options pour requérir ou supprimer des avertissements |
| -Wformat=2 | Options pour requérir ou supprimer des avertissements |
| -Wimplicit | Options pour requérir ou supprimer des avertissements |
| -Wimplicit-function-declaration | Options pour requérir ou supprimer des avertissements |
| -Wimplicit-int | Options pour requérir ou supprimer des avertissements |
| -Wimport | Options contrôlant le préprocesseur |
| -Winline | Options pour requérir ou supprimer des avertissements |
| -Wl,option | Options pour l'édition des liens |
| -Wlarger-than-longueur | Options pour requérir ou supprimer des avertissements |
| -Wlong-long | Options pour requérir ou supprimer des avertissements |
| -Wmain | Options pour requérir ou supprimer des avertissements |
| -Wmissing-braces | Options pour requérir ou supprimer des avertissements |
| -Wmissing-declarations | Options pour requérir ou supprimer des avertissements |
| -Wmissing-format-attribute | Options pour requérir ou supprimer des avertissements |
| -Wmissing-noreturn | Options pour requérir ou supprimer des avertissements |
| -Wmissing-prototypes (C uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wmultichar | Options pour requérir ou supprimer des avertissements |
| -Wnested-externs (C uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wno-deprecated (C++ uniquement) | Options contrôlant le dialecte C |
| -Wno-deprecated-declarations | Options pour requérir ou supprimer des avertissements |
| -Wno-format-extra-args | Options pour requérir ou supprimer des avertissements |
| -Wno-format-y2k | Options pour requérir ou supprimer des avertissements |
| -Wno-import | Options pour requérir ou supprimer des avertissements |
| -Wno-non-template-friend (C++ uniquement) | Options contrôlant le dialecte C |
| -Wno-pmf-conversions (C++ uniquement) | Options contrôlant le dialecte C |
| -Wno-protocol | Options contrôlant le dialecte Objective-C |
| -Wnon-virtual-dtor (C++ uniquement) | Options contrôlant le dialecte C |
| -Wold-style-cast (C++ uniquement) | Options contrôlant le dialecte C |
| -Woverloaded-virtual (C++ uniquement) | Options contrôlant le dialecte C |
| -Wpacked | Options pour requérir ou supprimer des avertissements |
| -Wpadded | Options pour requérir ou supprimer des avertissements |
| -Wparentheses | Options pour requérir ou supprimer des avertissements |
| -Wpointer-arith | Options pour requérir ou supprimer des avertissements |
| -Wredundant-decls | Options pour requérir ou supprimer des avertissements |
| -Wreorder (C++ uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wreturn-type | Options pour requérir ou supprimer des avertissements |
| -Wselector | Options contrôlant le dialecte Objective-C |
| -Wsequence-point | Options pour requérir ou supprimer des avertissements |
| -Wshadow | Options pour requérir ou supprimer des avertissements |
| -Wsign-compare | Options pour requérir ou supprimer des avertissements |
| -Wsign-promo (C++ uniquement) | Options contrôlant le dialecte C |
| -Wstrict-prototypes (C uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wswitch | Options pour requérir ou supprimer des avertissements |
| -Wsynth (C++ uniquement) | Options contrôlant le dialecte C |
| -Wsystem-headers | Options contrôlant le préprocesseur |
| -Wtraditional | Options contrôlant le préprocesseur |
| -Wtraditional (C uniquement) | Options pour requérir ou supprimer des avertissements |
| -Wtrigraphs | Options contrôlant le préprocesseur |
| -Wundef | Options contrôlant le préprocesseur |
| -Wuninitialized | Options pour requérir ou supprimer des avertissements |
| -Wunknown-pragmas | Options pour requérir ou supprimer des avertissements |
| -Wunreachable-code | Options pour requérir ou supprimer des avertissements |
| -Wunused | Options pour requérir ou supprimer des avertissements |
| -Wunused-function | Options pour requérir ou supprimer des avertissements |
| -Wunused-label | Options pour requérir ou supprimer des avertissements |
| -Wunused-parameter | Options pour requérir ou supprimer des avertissements |
| -Wunused-value | Options pour requérir ou supprimer des avertissements |
| -Wunused-variable | Options pour requérir ou supprimer des avertissements |
| -Wwrite-strings | Options pour requérir ou supprimer des avertissements |
| -x assembler-with-cpp | Options contrôlant le préprocesseur |
| -x c | Options contrôlant le préprocesseur |
| -x c++ | Options contrôlant le préprocesseur |
| -x langage | Options contrôlant le type de sortie |
| -x none | Options contrôlant le type de sortie |
| -x objective-c | Options contrôlant le préprocesseur |
| -Xlinker option | Options pour l'édition des liens |
| -Ym,répertoire | Options pour System V |
| -YP,répertoires | Options pour System V |
| C_INCLUDE_PATH | ENVIRONNEMENT |