Manuel du compilateur GCC sous Linux

Imprimer la page  gcc     Pour fermer la fenêtre  Cliquez ici

 

         

NOM
       gcc - Compilateurs C et C++ du projet GNU (egcs-1.1.2).

SYNOPSIS
       gcc [ option | fichier ]...
       g++ [ option | fichier ]...

AVERTISSEMENT
       L'information contenue dans cette page de manuel constitue
       un extrait de la documentation complète du compilateur GNU
       C, et est limitée à la signification des options.

       Cette  page  de  manuel n'est pas tenue à jour à moins que
       des volontaires ne veuillent la maintenir.  Si vous  trou­
       vez  une  contradiction entre la page de manuel et le pro­
       gramme, reportez-vous au fichier  Info  qui  constitue  la
       documentation de référence.

       Si nous trouvons que les infos de cette page de manuel qui
       ne sont plus à jour causent une confusion significative ou
       des  plaintes,  nous  arrêterons  de distribuer la page de
       manuel.  L'autre possibilité, mettre à  jour  la  page  de
       manuel  quand  nous  mettons  à  jour le fichier Info, est
       impossible car le reste du travail de maintenance  de  GNU
       CC  ne  nous en laisse pas le temps.  Le projet GNU trouve
       les pages de  manuel  obsolètes  et  ne  devrait  pas  les
       laisser leur faire perdre du temps.

       Pour  une  documentation complète et récente, référez-vous
       au fichier info `gcc' ou au manuel Using and  Porting  GNU
       CC (pour la version 2.0).  Les deux sont construits à par­
       tir du fichier source Texinfo gcc.texinfo.

DESCRIPTION
       Les compilateurs C et C++ sont intégrés.  Les deux  trait­
       ent  les  fichiers  en  entrée  en suivant de une à quatre
       étapes  :  prétraitement,  compilation,   assemblage,   et
       édition  des  liens.   Les  suffixes  des noms de fichiers
       sources identifient le langage source, mais quel que  soit
       le nom utilisé, le compilateur suppose par défaut que :

       gcc    suppose  que les fichiers prétraités (.i) sont en C
              et que l'édition des liens se fait comme en C.

       g++    suppose que les fichiers prétraités  (.i)  sont  en
              C++  et  que  l'édition  des liens se fait comme en
              C++.

       Les suffixes des noms de  fichiers  sources  indiquent  le
       langage utilisé et le type de traitement à effectuer :
       .c    source C; prétraiter, compiler, assembler
       .C    source C++; prétraiter, compiler, assembler
       .cc   source C++; prétraiter, compiler, assembler
       .cxx  source C++; prétraiter, compiler, assembler
       .m    source Objective-C; prétraiter, compiler, assembler
       .i    C prétraité; compiler, assembler
       .ii   C++ prétraité; compiler, assembler
       .s    source assembleur; assembler
       .S    source assembleur; prétraiter, assembler
       .h    fichier prétraité; rarement utilisé en ligne de commandes
       Les   fichiers   avec  d'autres  suffixes  sont  passés  à
       l'éditeur de liens.  Les cas habituels incluent :
       .o    Fichier objet
       .a    Fichier archive
       L'édition des liens est toujours la dernière étape à moins
       d'utiliser  les  options -c, -S, ou -E pour l'éviter (ou à
       moins que des erreurs de  compilations  n'interrompent  le
       traitement  en  entier).   Lors  de  l'étape d'édition des
       liens, tous les fichiers  .o  correspondant  aux  fichiers
       sources,  les  librairies  -l  ,  les noms de fichiers not
       reconnus (y compris les fichiers objets .o et les fichiers
       archives  .a  )  sont  passés  à  l'éditeur  de liens dans
       l'ordre de la ligne de commandes.

OPTIONS
       Les  options  doivent  être  séparées  :  `-dr'  est  très
       différent de `-d -r '.

       La  plupart  des  options  `-f'  et  `-W'  ont deux formes
       opposées : -fname and -fno-name (ou -Wname and -Wno-name).
       Seules  les  formes  qui  ne sont pas utilisées par défaut
       seront montrées ici.

       Voici un résumé de toutes les options, groupées par  type.
       Les explications suivent dans les prochaines sections.

       Options Globales
              -c -S -E -o fichier-pipe -v -x langage

       Options de Langage
              -ansi -fall-virtual -fcond-mismatch
              -fdollars-in-identifiers -fenum-int-equiv
              -fexternal-templates -fno-asm -fno-builtin -fhosted
              -fno-hosted -ffreestanding -fno-freestanding
              -fno-strict-prototype -fsigned-bitfields
              -fsigned-char -fthis-is-variable
              -funsigned-bitfields -funsigned-char
              -fwritable-strings -traditional -traditional-cpp
              -trigraphs

       Options d'Avertissement
              -fsyntax-only -pedantic -pedantic-errors -w -W
              -Wall -Waggregate-return -Wcast-align -Wcast-qual
              -Wchar-subscript -Wcomment -Wconversion
              -Wenum-clash -Werror -Wformat -Wid-clash-longueur
              -Wimplicit -Wimplicit-int
              -Wimplicit-function-declaration -Winline
              -Wlong-long -Wmain -Wmissing-prototypes
              -Wmissing-declarations -Wnested-externs -Wno-import
              -Wparentheses -Wpointer-arith -Wredundant-decls
              -Wreturn-type -Wshadow -Wstrict-prototypes -Wswitch
              -Wtemplate-debugging -Wtraditional -Wtrigraphs
              -Wuninitialized -Wunused -Wwrite-strings

       Options de Déboggage
              -a -dlettres -fpretend-float -g -gniveau -gcoff
              -gxcoff -gxcoff+ -gdwarf -gdwarf+ -gstabs -gstabs+
              -ggdb -p -pg -save-temps -print-file-name=librairie
              -print-libgcc-file-name -print-prog-name=programme

       Options d'Optimisation
              -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
              -fdelayed-branch -felide-constructors
              -fexpensive-optimizations -ffast-math -ffloat-store
              -fforce-addr -fforce-mem -finline-functions
              -fkeep-inline-functions -fmemoize-lookups
              -fno-default-inline -fno-defer-pop
              -fno-function-cse -fno-inline -fno-peephole
              -fomit-frame-pointer -frerun-cse-after-loop
              -fschedule-insns -fschedule-insns2
              -fstrength-reduce -fthread-jumps -funroll-all-loops
              -funroll-loops -O -O2 -O3

       Options du Préprocesseur
              -Aassertion -C -dD -dM -dN -Dmacro[=defn] -E -H
              -idirafter répertoire -include fichier -imacros
              fichier -iprefix fichier -iwithprefix répertoire -M
              -MD -MM -MMD -nostdinc -P -Umacro -undef

       Options de l'Assembleur
              -Wa,option

       Options de l'Editeur de liens
              -llibrairie -nostartfiles -nostdlib -static -shared
              -symbolic -Xlinker option -Wl,option -u symbole

       Options de Répertoires
              -Bpréfixe -Irépertoire -I- -Lrépertoire

       Options de Cible
              -b  machine -V version

       Options Dépendantes de la Configuration
              Options M680x0
              -m68000 -m68020 -m68020-40 -m68030 -m68040 -m68881
              -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield
              -mrtd -mshort -msoft-float Options VAX
              -mg -mgnu -munix Options SPARC
              -mepilogue -mfpu -mhard-float -mno-fpu
              -mno-epilogue -msoft-float -msparclite -mv8
              -msupersparc -mcypress Options Convex
              -margcount -mc1 -mc2 -mnoargcount Options AMD29K
              -m29000 -m29050 -mbw -mdw -mkernel-registers
              -mlarge -mnbw -mnodw -msmall -mstack-check
              -muser-registers 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
              RS6000
              -mfp-in-toc -mno-fop-in-toc 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
              -mcpu=type de processeur -mips2 -mips3 -mint64
              -mlong64 -mmips-as -mgas -mrnames -mno-rnames
              -mgpopt -mno-gpopt -mstats -mno-stats -mmemcpy
              -mno-memcpy -mno-mips-tfile -mmips-tfile
              -msoft-float -mhard-float -mabicalls -mno-abicalls
              -mhalf-pic -mno-half-pic -G nombre -nocpp Options
              i386
              -m486 -mno-486 -msoft-float -mno-fp-ret-in-387
              Options HPPA
              -mpa-risc-1-0 -mpa-risc-1-1 -mkernel -mshared-libs
              -mno-shared-libs -mlong-calls -mdisable-fpregs
              -mdisable-indexing -mtrailing-colon Options i960
              -mtype_de_processeur -mnumerics -msoft-float
              -mleaf-procedures -mno-leaf-procedures -mtail-call
              -mno-tail-call -mcomplex-addr -mno-complex-addr
              -mcode-align -mno-code-align -mic-compat
              -mic2.0-compat -mic3.0-compat -masm-compat
              -mintel-asm -mstrict-align -mno-strict-align
              -mold-align -mno-old-align Options DEC Alpha
              -mfp-regs -mno-fp-regs -mno-soft-float -msoft-float
              Options System V
              -G -Qy -Qn -YP,chemins -Ym,répertoire

       Options de Géneration de Code
              -fcall-saved-registre -fcall-used-registre
              -ffixed-registre -finhibit-size-directive
              -fnonnull-objects -fno-common -fno-ident
              -fno-gnu-linker -fpcc-struct-return -fpic -fPIC
              -freg-struct-return -fshared-data -fshort-enums
              -fshort-double -fvolatile -fvolatile-global
              -fverbose-asm

OPTIONS GLOBALES
       -x langage
              Spécifie  explicitement  le  langage  des  fichiers
              d'entrée  suivants  (plutôt  que de choisir un com­
              portement par défaut basé sur le suffixe du nom  du
              fichier)  .   Cette  option  s'applique  à tous les
              fichiers d'entrées suivants  jusqu'à  la  prochaine
              option  `-x'.   Les  valeurs possibles pour langage
              sont   `c',   `objective-c',   `c-header',   `c++',
              `cpp-output', `assembler', et `assembler-with-cpp'.

       -x none
              Annule toute spécification d'un langage,  de  sorte
              que  tous les fichiers ultérieurs soient traités en
              rapport avec leur suffixe de nom de fichier  (comme
              si `-x' n'avait jamais été utilisé).

       Si vous ne voulez que quelques unes des étapes (prétraite­
       ment, compilation, assemblage, édition  des  liens),  vous
       pouvez utiliser `-x' (ou des suffixes de noms de fichiers)
       pour dire à gcc où commencer, et  une  des  options  `-c',
       `-S',  ou  `-E' pour dire quand gcc doit s'arrêter.  Notez
       que certaines combinaisons (par  exemple,  `-x  cpp-output
       -E') diesnt à gcc de ne rien faire du tout.

       -c     Compiler ou assembler les fichiers sources, mais ne
              pas éditer les liens.  La sortie du compilateur est
              un  fichier  objet  correspondant  à chaque fichier
              source.  Par défaut, GCC crée le nom du fichier ob­
              jet  à partir d'un fichier source en remplaçant les
              suffixes  `.c',  `.i',  `.s',   etc.,   par   `.o'.
              Utilisez  -o  pour  sélectionner un autre nom.  GCC
              ignore tous  les  fichiers  d'entrée  non  reconnus
              (ceux qui ne requièrent pas de compilation ou d'as­
              semblage) avec l'option -c.

       -S     S'arrêter après l'étape de la  compilation  propre­
              ment  dite;  ne  pas  assembler.   La sortie est un
              fichier de  code  assembleur  pour  chaque  fichier
              d'entrée  non assembleur spécifié.  Par défaut, GCC
              crée le nom  du  fichier  assembleur  à  partir  du
              fichier source en remplaçant le suffixe `.c', `.i',
              etc., par `.s'.  Utilisez -o pour  sélectionner  un
              autre nom.  GCC ignore tout fichier d'entrée ne re­
              quérant pas de compilation.

       -E     S'arrêter après l'étape du  prétraitement;  ne  pas
              lancer  le  compilateur  proprement dit.  La sortie
              est un code source prétraité, qui est  envoyé  vers
              la  sortie standard.  GCC ignore les fichiers d'en­
              trée ne requérant pas de prétraitement.

       -o fichier
              Placer la sortie dans  le  fichier  fichier.   Cela
              s'applique  quel que soit le type de sortie produit
              par GCC, que ce  soit  un  fichier  exécutable,  un
              fichier  objet,  un fichier assembleur ou du code C
              prétraité.  Puisqu'un seul fichier de  sortie  peut
              être  spécifié,  cela n'a aucun sens d'utiliser`-o'
              quand on compile  plus  d'un  fichier  d'entrée,  à
              moins  que  l'on  ne  veuille  produire  un fichier
              exécutable en sortie.  Si  vous  ne  spécifiez  pas
              `-o', le comportement par défaut est de produire un
              fichier exécutable nommé `a.out', le fichier  objet
              pour  `source.suffixe' dans `source.o', son fichier
              assembleur dans `source.s', et tout le code  source
              C sur la sortie standard.

       -v     Imprimer (sur la sortie d'erreur standard) les com­
              mandes exécutées pour lancer les étapes de la  com­
              pilation.   Imprimer également le numéro de version
              du programme  pilote  du  compilateur,  du  prépro­
              cesseur et du compilateur proprements dits.

       -pipe  Utiliser  des  tubes plutot que des fichiers tempo­
              raires pour la communication entre les  différentes
              phases  de  la compilation.  Ceci ne marche pas sur
              certains systèmes où l'assembleur ne  peut  lire  à
              partir  d'un  tube; mais l'assembleur GNU n'a aucun
              problème.

OPTIONS DE LANGAGE
       Les options suivantes contrôlent le dialecte de C  accepté
       par le compilateur :

       -ansi  Supporte  tous  les programmes C au format standard
              ANSI.  Ceci désactive certaines caractéristiques du
              C  GNU  qui  sont incompatibles avec le C ANSI, tel
              que les mots-clés asm, inline et ,  et  les  macros
              prédéfinies  telles que unix et vax qui identifient
              le type de système que vous  utilisez.   Il  active
              également  la  caractéristique rarement utilisée et
              non souhaitable des trigraphes ANSI,  et  désactive
              la  possibilité d'utiliser `$' dans les identifica­
              teurs.    Les   mots-clés   alternatifs    __asm__,
              __extension__,  __inline__ et __typeof__ continuent
              à fonctionner malgré `-ansi'.  Vous ne voudriez na­
              turellemnt  pas  les utiliser dans des programmes C
              ANSI, mais il est utile  de  les  placer  dans  des
              fichiers  d'entête  qui pourraient être inclus dans
              des compilations faites avec `-ansi'.   Des  macros
              prédéfinies  comme  __unix__  et __vax__ sont aussi
              disponibles,  avec  ou  sans   `-ansi'.    L'option
              `-ansi'  ne  pousse  pas  les programmes non ANSI à
              être   rejetés    arbitrairement.     Pour    cela,
              `-pedantic'  est  requis  en  plus  de `-ansi'.  Le
              préprocesseur prédéfinit une macro  __STRICT_ANSI__
              quand vous utilisez l'option `-ansi'.
                Certains   fichiers  d'entête  peuvent  remarquer
              cette macro et  s'abstenir  de  déclarer  certaines
              fonctions  ou  de  définir  certaines macros que le
              standard ANSI n'utilise pas, ceci dans le but de ne
              pas  interférer  avec un programme pouvant utiliser
              ces noms pour d'autres choses.

       -fno-asm
              Ne pas reconnaître asm, inline etc typeof comme des
              mots-clés.   Ces  noms  peuvent alors être utilisés
              comme  identificateurs.    Vous   pouvez   utiliser
              __asm__,  __inline__  et  __typeof__  à  la  place.
              `-ansi' implique `-fno-asm'.

       -fno-builtin
              Ne pas reconnaître les fonctions intégrées  qui  ne
              commencent  pas par deux caractères de soulignement
              (__).  Actuellement, les fonctions affectées inclu­
              ent  _exit,  abort,  abs,  alloca, cos, exit, fabs,
              labs, memcmp, memcpy, sin, sqrt, strcmp, strcpy, et
              strlen.   L'option  `-ansi' empêche alloca et _exit
              d'être des fonctions intégrées.

       -fhosted
              Compiler pour un environnement hôte; ceci  implique
              l'option  `-fbuiltin'  et implique que des déclara­
              tions suspicieuses  de  main  feront  l'objet  d'un
              avertissement.

       -ffreestanding
              Compiler  pour  un  environnement non attaché; ceci
              implique l'option `-fno-builtin' , et implique  que
              main n'a pas d'exigences particulières.

       -fno-strict-prototype
              Traiter  une déclaration de fonction sans arguments
              telle que `int foo ();', que C traiterait comme  ne
              disant  rien du nombre d'arguments ou de leur types
              (C++ uniquement).  Normalement, une telle  déclara­
              tion  en  C++ signifie que la fonction foo ne prend
              aucun argument.

       -trigraphs
              Supporter les trigraphes C ANSI.  L'option  `-ansi'
              implique `-trigraphs'.

       -traditional
              Essaie  de  supporter certains aspects des compila­
              teurs C traditionnels.  Pour les détails, voyez  le
              manuel  GNU  C;  la  liste dupliquée ici a été sup­
              primée afin de  ne  pas  recevoir  de  réclamations
              quand elle n'est pas à jour.  Mais notons une chose
              sur  les  programmes  C++   uniquement   (pas   C).
              `-traditional'  a  un effet supplémentaire en C++ :
              l'affectation vers this est  permise.   Ceci  a  le
              même effet que `-fthis-is-variable'.
       -traditional-cpp
              Essaie  de  supporter  certains aspects des prépro­
              cesseurs C traditionnels.  Ceci inclut  les  points
              qui  mentionnent  spécifiquement  le préprocesseur,
              mais aucun des autres effets de `-traditional'.

       -fdollars-in-identifiers
              Permet l'utilisation de `$'  dans  les  identifica­
              teurs   (C++  uniquement).  Vous  pouvez  également
              utiliser `-fno-dollars-in-identifiers' pour  inter­
              dire explicitement l'usage de `$'.  (Le C++ GNU au­
              torise `$' par défaut sur certains systèmes  cibles
              mais pas les autres.)

       -fenum-int-equiv
              Permet  la  conversion  implicite  de  int  en type
              énuméré (C++  uniquement).   Normalement,  C++  GNU
              permet  la  conversion  d'  enum vers int, mais pas
              l'inverse.

       -fexternal-templates
              Produire moins de code  pour  les  déclarations  de
              templates,  en  générant seulement une unique copie
              de chaque fonction template  où  elle  est  définie
              (C++  uniquement).  Pour utiliser cette option avec
              succès, vous devez également  marquer  les  fichier
              utilisant   des   templates   avec   soit  `#pragma
              implementation'  (la  définition),  soit   `#pragma
              interface' (déclarations).

              Quand     votre     code     est    compilé    avec
              `-fexternal-templates', toutes  les  instanciations
              de  templates  sont  externes.  Vous devez vous ar­
              ranger pour que les instanciations nécessaires  ap­
              paraîssent  dans  le fichier d'implémentation; vous
              pouvez faire cela avec  un  typedef  qui  référence
              chaque  instanciation  nécessaire.  Réciproquement,
              quand  vous  compilez  en  utilisant  l'option  par
              défaut  `-fno-external-templates',  toutes  les in­
              stanciations de templates  sont  explicitement  in­
              ternes.

       -fall-virtual
              Traite  tous les fonctions membres possible en tant
              que fonctions virtuelles implicitement.  Toutes les
              fonctions  membres (excepté les fonctions construc­
              teurs et les opérateurs de membres new ou delete  )
              sont  traitées comme des fonctions virtuelles de la
              classe où elles apparaîssent.  Ceci ne signifie pas
              que  tous les appels à ces fonctions membres seront
              faits par l'intermédiaire de la table  interne  des
              fonctions   virtuelles.    Sous  certaines  circon­
              stances, le compilateur peut déterminer qu'un appel
              à  une fonction virtuelle donnée peut être fait di­
              rectement; dans ce cas, les appels sont directs.

       -fcond-mismatch
              Autorise les expressions  conditionnelles  avec  de
              mauvais  types dans les deuxième et troisième argu­
              ments.  La valeur d'une telle expression  est  vide
              (void).

       -fthis-is-variable
              Permet  l'affectation  de  this  (C++  uniquement).
              L'incorporation d'une  gestion  de  l'espace  libre
              définie par l'utilisateur en C++ a fait de l'affec­
              tation   vers   `this'   un   anachronisme.     Par
              conséquent,  il  est par défaut invalide d'affecter
              vers this à l'intérieur d'une fonction d'un  membre
              de  classe.   Néanmoins,  pour la compatibilité de­
              scendante,  vous  pouvez  le  rendre  valide   avec
              `-fthis-is-variable'.

       -funsigned-char
              Permet  au  type  char d'être non signé (unsigned),
              comme unsigned char.  Chaque type de machine  à  un
              comportement  par  défaut  sur  ce que char devrait
              être.  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,  ceci dépendant des machines pour lequelles
              le programme a été écrit.  Cette option, et son in­
              verse,  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 comporte­
              ment est toujours celui d'un de ces deux là.

       -fsigned-char
              Permet  au  type  char  d'être  signé, comme signed
              char.     Notez    que    c'est    équivalent     à
              `-fno-unsigned-char',  qui  est  la  forme négative
              de`-funsigned-char'.  De  même,  `-fno-signed-char'
              est équivalent à `-funsigned-char'.

       -fsigned-bitfields

       -funsigned-bitfields

       -fno-signed-bitfields

       -fno-unsigned-bitfields
              Ces  options  contrôlent si un champ-bit (bitfield)
              est signé ou non signé, quand il est  déclaré  sans
              qualificateur  `signed'  ou  `unsigned'  explicite.
              Par défaut, un tel champ-bit d'un  bit  est  signé,
              parce  que  c'est  logique  :  les types entiers de
              bases tels que int sont des  types  signés.   Néan­
              moins,  quand  vous  spécifiez  `-traditional', les
              champs-bit sont tous non signés de toute façon.

       -fwritable-strings
              Conserve les constantes  de  type  chaîne  de  car­
              actères  dans  le  segment de données accessible en
              écriture et ne les rend pas uniques.  C'est dans le
              but  de compatibilité avec d'anciens programmes qui
              supposent qu'ils peuvent écrire dans des constantes
              de  type  chaîne  de  caractères.  `-traditional' a
              aussi cet effet.  Ecrire  dans  des  constantes  de
              type  chaîne  de  caractères  est une très mauvaise
              idée; Les "constantes" devraient être constantes  !
       Ces options contrôlent le préprocesseur C, qui est exécuté
       sur chaque fichier source C avant la compilation réelle.

       Si vous utilisez l'option `-E' , GCC ne fait rien sauf  le
       prétraitement.   Certaines  de  ces  options n'ont un sens
       qu'avec `-E' car elles forcent la sortie du  préprocesseur
       à être inappropriée pour la compilation réelle.

       -include fichier
              Traite fichier en entrée avant de traiter le fichi­
              er d'entrée normal.  En fait, le contenu de fichier
              est compilé en premier.  Toutes les options `-D' et
              `-U' en ligne de commandes sont  toujours  traitées
              avant  `-include fichier', quel que soit leur ordre
              d'écriture.   Toutes  les  options  `-include'  and
              `-imacros' sont traitées dans leur ordre d'écriture

       -imacros fichier
              Traite fichier en entrée, en abandonnant le  sortie
              résultante,  avant  de  traiter le fichier d'entrée
              normal.  Puisque la sortie générée à partir de file
              est abandonnée, le seul effet de `-imacros fichier'
              est de rendre  les  macros  définies  dans  fichier
              disponibles pour être utilisées dans l'entrée prin­
              cipale.  Le préprocesseur évalue  n'importe  quelle
              option  `-D'  et `-U' présente sur la ligne de com­
              mandes avant de traiter  `-imacros  fichier',  quel
              que soit leur ordre d'écriture.  Toutes les options
              `-include' et `-imacros' sont  traitées  dans  leur
              ordre d'écriture.

       -idirafter répertoire
              Ajoute  le  répertoire  répertoire au second chemin
              d'inclusion.  Les répertoires dans le second chemin
              d'inclusion   sont   parcourus   quand  un  fichier
              d'entête n'est trouvé dans aucun des répertoires du
              chemin  principal  d'inclusion  (Celui  auquel `-I'
              s'ajoute).

       -iprefix préfixe
              Spécifie préfixe comme étant le  préfixe  pour  les
              options `-iwithprefix' ultérieures.

       -iwithprefix répertoire
              Ajoute  un répertoire au second chemin d'inclusion.
              Le  nom  du  répertoire  est  créé  en  concaténant
              préfixe  et  répertoire,  où préfixe a été spécifié
              préalablement par `-iprefix'.

       -nostdinc
              Ne pas chercher  les  fichiers  d'entête  dans  les
              répertoires standards du système.  Seuls les réper­
              toires que vous avez  spécifiés  avec  des  options
              `-I' (et le répertoire courant, si c'est approprié)
              sont parcourus.  En utilisant à la fois `-nostdinc'
              et  `-I-',  vous  pouvez  limiter  la  recherche de
              fichiers d'entête aux seuls  répertoires  que  vous
              spécifiez explicitement.

       -nostdinc++
              Ne  pas  rechercher  de  fichiers d'entête dans les
              répertoires  standards  C++,  mais   toujours   les
              chercher  dans  les  autres  répertoires standards.
              (Cette  option  est  utilisée  quand  on  construit
              `libg++'.)

       -undef Ne  pas  prédéfinir  de macros non standard.  (Ceci
              incluant les drapeaux d'architecture).

       -E     Lancer uniquement le préprocesseur  C.   Prétraiter
              tous  les  fichiers sources C spécifiés et produire
              les résultats sur la sortie  standard  ou  dans  le
              fichier de sortie spécifié.

       -C     Dire  au préprocessuer de ne pas se débarrasser des
              commentaires.  Utilisé avec l'option `-E'.

       -P     Dire au préprocessuer de ne pas générer  d'instruc­
              tions `#line'.  Utilisé avec l'option `-E'.

       -M  [ -MG ]
              Dire  au  préprocessuer  de  générer une règle con­
              venant à make décrivant les dépendances  de  chaque
              fichier  objet.   Pour  chaque  fichier  source, le
              préprocesseur génère une règle make dont  la  cible
              est le nom du fichier objet pour ce fichier source,
              et dont les dépendances sont tous les fichiers  in­
              clus par des `#include'.  Cette règle peut être une
              simple ligne ou peut être continuée par `\'-newline
              si  elle  est  trop longue.  La liste de règles est
              imprimée sur la sortie standard  au  lieu  du  pro­
              gramme C prétraité.  `-M' implique `-E'.  `-MG' in­
              forme de traiter  les  fichier  d'entête  manquants
              comme  des  fichiers générés et suppose qu'ils sont
              situés dans  le  même  répertoire  que  le  fichier
              source.  Il doit être spécifié en plus de `-M'.

       -MM  [ -MG ]
              Comme `-M', mais la sortie mentionne uniquement les
              fichiers d'entête de l'utilisateur inclus par `#in­
              clude  fichier"'.  Les fichiers d'entête du système
              inclus par `#include <fichier>' sont omis.

       -MD    Comme `-M', mais les  informations  de  dépendances
              sont  écrites  dans des fichiers dont les noms sont
              construits en remplaçant `.o' par `.d' à la fin des
              noms  de fichiers de sortie.  Ceci, en plus de com­
              piler les fichiers comme spécifié--`-MD' n'interdit
              pas  la  compilation  ordinaire comme `-M' le fait.
              L'utilitaire Mach `md' peut être utilisé  pour  fu­
              sionner  les  fichiers `.d' en un unique fichier de
              dépendances apte à être  utilisé  par  la  commande
              `make'

       -MMD   Comme  `-MD' sauf que cela mentionne uniquement les
              fichiers d'entête de l'utilisateur, et pas ceux  du
              système.

       -H     Imprime  le nom de chaque fichier d'entête utilisé,
              en plus d'autres activités normales.

       -Aquestion(réponse)
              Affirme la réponse réponse pour question,  dans  le
              cas  où elle serait testée par une proposition con­
              ditionnelle  du  préprocesseur   telle   que   `#if
              #question(réponse)'.   `-A-'  désactive  les asser­
              tions standards qui décrivent  normalement  la  ma­
              chine cible.

       -Dmacro
              Définit la macro macro avec la chaîne de caractères
              `1' comme définition.

       -Dmacro=defn
              Definit la macro macro comme  defn.     Toutes  les
              occurences  de  `-D'  sur la ligne de commande sont
              traitées avant n'importe quelle option `-U'.

       -Umacro
              Supprime la définition de la macro macro.  Les  op­
              tions   `-U'   sont  évaluées  après  chaque option
              `-D', mais avant n'importe quelle option `-include'
              ou `-imacros'.
       -dM    Dit  au  préprocesseur  de  produire uniquement une
              liste des définitions de macros qui sont en effet à
              la  fin  du  prétraitement.   Utilisé avec l'option
              `-E'

       -dD    Dit au préprocesseur de passer toutes  les  défini­
              tions  de  macros en sortie, dans le bon ordre dans
              le reste de la sortie.

       -dN    Comme `-dD' sauf que les  arguments  de  macros  et
              leur  contenu  sont  omis.  Seul `#define name' est
              inclus en sortie.

OPTION
       -Wa,option
              Passer l'option option à l'assembleur.   Si  option
              contient des virgules, elle est découpée en de mul­
              tiple options aux emplacements des virgules.
       Ces options entre en jeu  quand  le  compilateur  effectue
       l'édition  des  liens  des  fichiers  objets pour créer un
       fichier de sortie exécutable.  Elles n'ont aucune signifi­
       cation  particulière  si  le  compilateur  ne lance pas la
       phase d'édition des liens.

       object-file-name
              Un nom de fichier qui ne se termine  pas  comme  un
              suffixe  spécial  reconnu  est  supposé  nommer  un
              fichier objet ou une librairie.  (Les fichiers  ob­
              jets  sont  distingués des librairies par l'éditeur
              de liens en fonction du contenu  du  fichier.)   Si
              GCC  effectue  une  phase  d'édition des liens, ces
              fichiers objets sont  utilisés  comme  entrée  pour
              l'éditeur des liens.

       -llibrairie
              Utilise   la  librairie  nommée  librairie  pendant
              l'édition des liens.  L'éditeur de liens  recherche
              la  librairie  dans  une  liste  standard de réper­
              toires, librairie qui est en fait un fichier  s'ap­
              pelant   `liblibrairie.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  standards
              du  système, plus tous ceux que vous avez spécifiés
              par `-L'.  Normalement,  les  fichiers  trouvés  de
              cette   façon   sont   des   fichiers--archives  de
              libaririe dont les membres sont  des  fichiers  ob­
              jets.   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 librairie, le fichier
              objet est lié de la  façon  habituelle.   La  seule
              différence entre utiliser l'option `-l' et spécifi­
              er un nom de fichier est que `-l' entoure librairie
              avec `lib' et `.a' et cherche dans plusieurs réper­
              toires.

       -lobjc Vous avez besoin de ce cas particulier de  l'option
              -l  afin  d'effectuer l'édition des liens d'un pro­
              gramme Objective C.

       -nostartfiles
              Ne pas utiliser les fichiers de démarrage standards
              du  système  en effectuant l'édition de liens.  Les
              librairies standards sont utilisées nomralement.

       -nostdlib
              Ne pas utiliser les fichiers de  démarrage  et  les
              librairies   standards  du  système  en  effectuant
              l'édition de liens.  Seuls les  fichiers  que  vous
              spécifiés seront passés à l'éditeur de liens.

       -static
              Sur les systèmes supportant l'édition des liens dy­
              namique, ceci empêche d'effectuer  une  édition  de
              liens  en  utilisant des librairies partagées.  Sur
              les autres systèmes, cette option n'a aucun  effet.

       -shared
              Produit  un  objet  partagé  qui peut être lié avec
              d'autres objets pour former un exécutable.  Seul un
              petit nombre de systèmes supportent cette option.

       -symbolic
              Lier  les références à des symboles globaux en con­
              struisant un objet partagé.  Avertir des références
              non  résolues (à moins que l'option ne soit annulée
              par l'option de l'éditeur  de  liens  `-Xlinker  -z
              -Xlinker  defs').  Seul un petit nombre de systèmes
              supportent cette option.

       -Xlinker option
              Passer option en tant qu'option pour  l'éditeur  de
              liens.   Vous pouvez utiliser ceci pour fournir des
              options d'édition des liens spécifiques au  système
              que  GNU  CC  ne  sait pas comment reconnaître.  Si
              vous voulez passer une option qui  prend  un  argu­
              ment,  vous devez utiliser `-Xlinker' deux fois, la
              première pour l'option et la seconde  pour  l'argu­
              ment.     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 à quoi  s'attend  l'édi­
              teur de liens.

       -Wl,option
              Passer  option  en tant qu'option pour l'éditeur de
              liens. Si option contient des  virgules,  elle  est
              découpée  en  de multiples options aux emplacements
              des virgules.

       -u symbole
              Prétendre que le symbole symbole  est  non  défini,
              pour  obliger  la  liaison  avec les modules de li­
              brairies pour le  définir.   Vous  pouvez  utiliser
              `-u'  de  multiples  fois  avec différents symboles
              pour forcer le chargement de  modules  additionnels
              de librairies.
       Ces  options  spécifient  les  répertoires où chercher les
       fichiers d'entête, les librairies et les parties du compi­
       lateur :

       -Irépertoire
              Ajoute  le  répertoire  répertoire  à  la liste des
              répertoires où chercher les fichiers d'entête.

       -I-    Tous les répertoires  spécifiés  avec  des  options
              `-I' avant l'option `-I-' sont parcourus uniquement
              pour le cas de  `#include "fichier"'; ils  ne  sont
              pas  parcourus  pour  des `#include <fichier>'.  Si
              des réperoires 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 le  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  souvant  satisfaisant.  `-I-'
              n'empêche pas l'utilisation des  fichiers  d'entête
              standards  du  système.  Donc, `-I-' et `-nostdinc'
              sont indépendants.

       -Lrépertoire
              Ajoute le répertoire  répertoire  à  la  liste  des
              répertoires où aller chercher `-l'.

       -Bpréfixe
              Cette  option  spécifie où trouver les exécutables,
              les librairies et les fichiers de données du compi­
              lateur  lui-même.   Le programme pilote du compila­
              teur lance  un  ou  plusieurs  des  sous-programmes
              `cpp',  `cc1' (ou, pour le C++, `cc1plus'), `as' ou
              `ld'.   Il  essaie  d'utiliser  préfixe  comme   un
              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  standards,  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 pi­
              lote du compilateur recherche le nom non modifié du
              programme  en  utilisant  les  réperoires spécifiés
              dans votre  variable  d'environnement  `PATH'.   Le
              fichier  de  support  à  l'exécution `libgcc.a' est
              aussi recherché en utilisant  le  préfixe  `-B'  si
              nécessaire.   S'il  n'est  pas trouvé ici, les deux
              préfixes standards 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é de  cette
              façon.   La  plupart  du  temps, sur la plupart des
              machines, `libgcc.a' n'est  pas  réellement  néces­
              saire.   Vous  pouvez obtenir un résultat similaire
              àgrâce à la variable d'environnement  GCC_EXEC_PRE­
              FIX;  si  elle  est définie, sa valeur est utilisée
              comme préfixe de la même manière.   Si  à  la  fois
              l'option  `-B'  et la variable GCC_EXEC_PREFIX sont
              présentes, l'option `-B' est  utilisée  en  premier
              lieu,  et  la valeur de la variable d'environnement
              en second lieu.
       Les avertissements sont des  messages  de  diagnostic  qui
       rapportent  des  constructions  qui ne sont pas par nature
       erronées, mais qui sont risquées ou qui  peuvent  suggérer
       qu'il  y ait peut-être une erreur.  Ces options contrôlent
       la quantité et les types d'avertissements produits par GNU
       CC:

       -fsyntax-only
              Vérifie  le  code pour des erreurs de syntaxe, mais
              n'émet aucune sortie.

       -w     Empêche tout message d'avertissement.

       -Wno-import
              Empêche les messages d'avertissement sur l'utilisa­
              tion de #import.

       -pedantic
              Fournit  tous  les  avertissement  demandés  par le
              standard ANSI C strict  ;  rejette  tous  les  pro­
              grammes  qui  utilisent  des extensions interdites.
              Les programmes C valides au  format  standard  ANSI
              devraient compiler sans problème avec ou sans cette
              option (bien qu'un petit  nombre  d'entre  eux  re­
              quierrent  `-ansi').  Néanmoins, sans cette option,
              certaines extensions GNU et des caractéristiques du
              C  traditionnel  seront également supportées.  Avec
              cette option, elles sont rejetées.  Il n'y a aucune
              raison   d'  utiliser  cette  option;  elle  existe
              uniquement    pour    satisfaire    les    pédants.
              `-pedantic'  n'engendre  aucun message d'erreur sur
              l'utilisation de  mots-clés  alternatifs  dont  les
              noms  commencent  et  se  terminent  par `__'.  Les
              avertissements pédants  sont  également  désactivés
              dans  l'expression  qui  suit __extension__.  Néan­
              moins, seuls les fichiers d'entête du  système  de­
              vraient  utiliser  ces sorties de secours; les pro­
              grammes d'application devraient les éviter.

       -pedantic-errors
              Comme `-pedantic', sauf que des erreurs  sont  pro­
              duites plutôt que des avertissements.

       -W     Imprime  des  messages  d'avertissement  supplémen­
              taires pour ces événements :

          ·   Une variable automatique non volatile pourrait être
              modifiée par un appel à longjmp.  Ces avertissement
              sont uniquement possibles  lors  d'une  compilation
              optimisante.   Le  compilateur  voit uniquement les
              appels à setjmp.  Il ne peut pas savoir où  longjmp
              sera  appelé  ;  en fait, un gestionnaire de signal
              pourrait l'appeler n'importe où dans le  code.   En
              conséquence,  vous  pouvez obtenir un avertissement
              même s'il n'y a en fait aucun problème car  longjmp
              ne  peut  en  fait  pas être appelé à l'endroit qui
              poserait problème.

          ·   Une fonction peut  revenir  avec  ou  sans  valeur.
              (Sortir  à  la fin du corps de la fonction est con­
              sidéré comme ne retourner aucune valeur.)  Par  ex­
              emple,  cette  fonction  engendrerait  un tel aver­
              tissement :
              foo (a)
              {
                if (a > 0)
                  return a;
              }
              Des avertissements intempestifs peuvent se produire
              car  GNU  CC  ne  se  rend pas compte que certaines
              fonctions (incluant abort et  longjmp)  ne  revien­
              dront jamais.

          ·   Une  expression-instruction  située  du côté gauche
              d'une expression avec une virgule ne contient aucun
              effet  de  bord.  Pour supprimer cet avertissement,
              transtypez l'expressions inutilisée vers void.  Par
              exemple, une expression telle que  `x[i,j]' causera
              un avertissemnt, mais  `x[(void)i,j]'  ne  le  fera
              pas.

          ·   Une  valeur  non  signée est comparée avec zéro par
              `>' ou `<='.

       -Wimplicit-int
              Avertir chaque fois qu'une déclaration ne  spécifie
              pas de type.

       -Wimplicit-function-declaration
              Avertir  chaque  fois  qu'une fonction est utilisée
              avant d'être déclarée.

       -Wimplicit
              Idem que -Wimplicit-int et -Wimplicit-function-dec­
              laration.

       -Wmain Avertir si la fonction main est déclarée ou définie
              avec un type suspect.  Typiquement, c'est une fonc­
              tion avec une liaison externe, renvoyant un int, et
              prenant zéro ou deux arguments.

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

       -Wunused
              Avertir chaque fois qu'une variable locale est inu­
              tilisée  à  l'écart  de sa déclaration, chaque fois
              qu'une fonction est déclarée  statique  mais  n'est
              jamais  définie,  et chaque fois qu'une instruction
              calcule un  résultat  qui  n'est  pas  utilisé  ex­
              plicitement.

       -Wswitch
              Avertir  chaque fois qu'une instruction switch a un
              index de type énuméré auquel manque un case pour un
              ou plusieurs des codes nommés de cette énumération.
              (La présence d'un label default empêche  cet  aver­
              tissement  de se produire.)  Les labels case en de­
              hors de la portée de l'énumeration provoquent aussi
              des avertissements quand cette option est utilisée.

       -Wcomment
              Avertir quand une séquence de début de  commentaire
              `/*' apparaît dans un commentaire.

       -Wtrigraphs
              Avertir  quand n'importe quel trigraphe est rencon­
              tré (en supposant qu'ils soient activés).

       -Wformat
              Vérifie les appels à printf et  scanf,  etc.,  pour
              s'assurer  que  les arguments fournis ont des types
              appropriés à la chaîne de format spécifiée

       -Wchar-subscripts
              Avertir si un indice de tableau  a  le  type  char.
              Ceci  est  une cause fréquente d'erreur puisque les
              programmeurs oublient souvent que ce type est signé
              sur certaines machines.

       -Wuninitialized
              Une  variable  automatique  est utilisée sans avoir
              été initialisée au préalable.   Ces  avertissements
              sont possibles uniquement en cas de compilation op­
              timisante, car ils requierrent de l'information sur
              le  flux de données qui est calculé uniquement dans
              la compilation optimisante.  SI vous  ne  spécifiez
              pas  `-O',  vous  n'obtiendrez  simplement  pas ces
              avertissements.  Ces avertissements  se  produisent
              uniquement  pour les variable qui sont candidates à
              une allocation dans un registre.  Donc, elles ne se
              produisent pas pour une variable déclarée volatile,
              ou dont l'adresse est utilisée, ou encore  donc  la
              taille  est différente de 1, 2, 4 ou 8 octets.  Ils
              ne se produisent pas non plus pour les  structures,
              les  unions  ou  les  tableaux, même quand ils sont
              dans des registres.  Notez qu'il n'y a pas  d'aver­
              tissement  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é faits optionnels car GNU
              CC 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 er­
              reur.  Voici un exemple de  comment  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 GNU CC  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  d'erreur  car  save_y  est
              utilisé  uniquement  s'il  est  préalablement  ini­
              tialisé.  Certains avertissements intempestifs peu­
              vent être évités si vous déclarez  volatile  toutes
              les  fonctions  que vous utilisez et qui ne retour­
              nent jamais à leur appelant.

       -Wparentheses
              Avertir si des parenthèses sont  omises  dans  cer­
              tains contextes.

       -Wtemplate-debugging
              Quand des templates sont utilisés dans un programme
              C++, avertir  si  le  déboggage  n'est  pas  encore
              pleinement disponible (C++ uniquement).

       -Wall  Toutes  les  options  `-W' ci-dessus combinées.  Ce
              sont toutes les options qui se rattachent à l'usage
              que  nous recommandons d'éviter et que nous croyons
              facile à  éviter,  même  en  conjonction  avec  des
              macros.

       Les  options  `-W...' restantes ne sont pas impliquées par
       `-Wall' car elles avertissent de  constructions  que  nous
       considérons  comme  raisonnables à utiliser, à l'occasion,
       dans des programmes propres.

       -Wtraditional
              Avertir de certaines constructions qui  se  compor­
              tent différemment en C traditionnel et en C ANSI.

          ·   Les  arguments  de macros présents dans des chaînes
              de carctères constantes dans le corps de la  macro.
              Ceux-ci  substitueraient l'argument en C tradition­
              nel, mais font partie intégrante de la constante en
              C ANSI.

          ·   Une  fonction  déclarée externe dans un bloc et en­
              suite utilisée après la fin du bloc.

          ·   Une instruction switch a une opérande de type long.

       -Wshadow
              Avertir  chaque  fois qu'une variable locale masque
              une autre variable locale.

       -Wid-clash-len
              Avertir chaque fois que deux  identificateurs  dis­
              tincts  sont  identiques dans les premiers len car­
              actères.  Ceci peut vous aider à préparer  un  pro­
              gramme qui pourra être compilé dans certains compi­
              lateurs de l'âge de pierre.

       -Wpointer-arith
              Avertir de tout ce qui dépend de la  "taille"  d'un
              type  fonction ou de void.  GNU C donne à ces types
              une taille de 1, pour sa propre convenance dans les
              calculs  avec des pointeurs void * et des pointeurs
              vers des fonctions.

       -Wcast-qual
              Avertir chaque fois qu'un  pointeur  est  transtypé
              afin  de supprimer un qualificateur de type du type
              de la cible.  Par exemple,  avertir  si  un   const
              char * est transtypé vers un char * ordinaire.

       -Wcast-align
              Avertir  chaque  fois  qu'un pointeur est transtypé
              d'une façon telle que l'alignement de la cible  est
              augmenté.   Par  exemple,  avertir si un char * est
              transtypé vers un int * sur des machines où les en­
              tiers peuvent uniquement être accédés à des limites
              de deux ou quatre octets.

       -Wwrite-strings
              Donne aux chaînes de caractères constantes le  type
              const  char[longueur]  de  sorte  que  la  copie de
              l'adresse d'une de celles-ci dans un pointeur const
              char  *  non  constant engendrera un avertissement.
              Ces avertissements vous aiderons à trouver  au  mo­
              ment  de  la compilation du code qui tente d'écrire
              dans  une  chaîne  de  carctères  constante,   mais
              uniquement  si vous avez été très attentif en util­
              isant const dans les  déclarations  et  les  proto­
              types.   Sinon,  cela ne pourrait qu'être nuisible;
              voilà pourquoi nous n'avons  pas  inclu  ces  aver­
              tissements dans `-Wall'.

       -Wconversion
              Avertir  si  un  prototype  cause une conversion de
              types qui est différente de ce  qui  arriverait  au
              même  argument  en  l'absence d'un prototype.  Ceci
              inclue les conversions de point fixe vers  flottant
              et  vice-versa,  et  les  conversions  modifiant la
              largeur ou le signe d'un  argument  de  type  point
              fixe  sauf  quand elles sont identiques à la promo­
              tion par défaut.

       -Waggregate-return
              Avertir si n'importe quelle fonction retournant une
              structure  ou  une  union  est déclarée ou appelée.
              (Dans les langages où on peut retourner un tableau,
              ceci provoque également un avertissement.)

       -Wstrict-prototypes
              Avertir  si  une  fonction  est déclarée ou définie
              sans spécifier le type des arguments.  (Une défini­
              tion  de  fonction  écrite  dans l'ancien style est
              permise sans avertissement si elle est précédée par
              une  déclaration  qui  spécifie  le  type des argu­
              ments.)

       -Wmissing-prototypes
              Avertir si une fonction globale  est  définie  sans
              déclaration de prototype préalable.  Cet avertisse­
              ment est délivré même si  la  définition  elle-même
              fournit  un  prototype.  Le but est de détecter les
              fonctions globales qui ne sont pas  déclarées  dans
              des fichiers d'entête.

       -Wmissing-declarations
              Avertir  si  une  fonction globale est définie sans
              une déclaration préalable.  Faire cela même  si  la
              définition    elle-même   fournit   un   prototype.
              Utilisez cette option pour détecter  les  fonctions
              globales   qui  ne  sont  pas  déclarées  dans  des
              fichiers d'entête.

       -Wredundant-decls
              Avertir si quoi que ce soit est déclaré plus  d'une
              fois  dans la même portée, même dans les cas où une
              déclaration multiple est valide et ne change  rien.

       -Wnested-externs
              Avertir  si une déclaration extern est rencontrée à
              l'intérieur d'une fonction.

       -Wenum-clash
              Avertir d'une  conversion  entre  différents  types
              énumérés (C++ uniquement).

       -Wlong-long
              Avertir si le type long long est utilisé.  C'est le
              comportement par défaut.  Pour inhiber les messages
              d'avertissement,      utilisez      le      drapeau
              `-Wno-long-long'.  Les drapeaux  `-W-long-long'  et
              `-Wno-long-long'  sont  pris  en  compte uniquement
              quand le drapeau `-pedantic' est utilisé.

       -Woverloaded-virtual
              (C++ uniquement.)  Dans  une  classe  dérivée,  les
              définitions  de fonctions virtuelles doivent corre­
              spondre à la signature  des  types  d'une  fonction
              virtuelle   déclarée   dans   la  classe  de  base.
              Utilisez cette option pour requérir des  avertisse­
              ments quand une classe dérivée déclare une fonction
              qui peut être une tentative erronée de définir  une
              fonction  virtuelle,  çàd  avertir quand il y a une
              fonction avec le même nom qu'une fonction virtuelle
              dans  la classe de base, mais avec une signature de
              types qui ne correspond à aucune fonction virtuelle
              de la classe de base.

       -Winline
              Avertir  quand une fonction ne peut pas être placée
              en ligne, et ce si elle a été déclarée comme  étant
              en  ligne,  ou si l'option -finline-functions a été
              donnée.

       -Werror
              Traiter  les  avertissements  comme  des   erreurs;
              avorter  la  compilation après n'importe quel aver­
              tissemnt.
       GNU CC a des options spéciales variées qui sont  utilisées
       pour débogger ou votre programme, ou GCC :

       -g     Produire des informations de déboggage dans le for­
              mat natif du système d'exploitation  (stabs,  COFF,
              XCOFF, ou DWARF).  GDB peut travailler avec ces in­
              formations  de  déboggage.   Sur  la  plupart   des
              systèmes  utilisant  le  format  stabs, `-g' active
              l'utilisation  d'informations  de  déboggage   sup­
              plémentaires  que  seul GDB peut utiliser ; ces in­
              formations supplémentaires améliorent le  déboggage
              avec  GDB  mais vont probablement faire crasher les
              autres déboggeurs, ou leur faire refuser de lire le
              programme.  Si vous voulez contrôler avec certitude
              s'il faut générer de l'information  supplémentaire,
              utilisez    `-gstabs+',    `-gstabs',   `-gxcoff+',
              `-gxcoff',  `-gdwarf+',  or  `-gdwarf'  (voir   ci-
              dessous).   Au  contraire  de la plupart des autres
              compilateurs C, GNU CC 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 là où vous ne  vous  seriez  pas  attendu,
              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ébogger  une sortie optimisée.  Cela
              rend possible l'usage de l'optimiseur pour des pro­
              grammes qui peuvent êtres boggés.

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

       -ggdb  Produire des informations de déboggage dans le for­
              mat natif (s'il est supporté) incluant  les  exten­
              sions GDB si c'est possible.

       -gstabs
              Produire des informations de déboggage dans le for­
              mat stabs (s'il est supporté) sans extensions  GDB.
              C'est  le format utilisé par DBX sur la plupart des
              systèmes BSD.

       -gstabs+
              Produire des informations de déboggage dans le for­
              mat stabs (s'il est supporté), en utilisant les ex­
              tensions GDB comprises uniquement par le  déboggeur
              GNU  (GDB).   L'utilisation  de  ces  extensions va
              probablement faire crasher les  autres  déboggeurs,
              ou leur faire refuser de lire le programme.

       -gcoff Produire des informations de déboggage dans le for­
              mat COFF (s'il  est  supporté).   C'est  le  format
              utilisé  par SDB sur la plupart des systèmes System
              V antérieurs à System V Release 4.

       -gxcoff
              Produire des informations de déboggage dans le for­
              mat  XCOFF  (s'il  est  supporté).  C'est le format
              utilisé par le déboggeur DBX sur les  systèmes  IBM
              RS/6000.

       -gxcoff+
              Produire des informations de déboggage dans le for­
              mat XCOFF (s'il est supporté), en utilisant les ex­
              tensions  GDB comprises uniquement par le déboggeur
              GNU (GDB).   L'utilisation  de  ces  extensions  va
              probablement  faire  crasher les autres déboggeurs,
              ou leur faire refuser de lire le programme.

       -gdwarf
              Produire des informations de déboggage dans le for­
              mat  DWARF  (s'il  est  supporté).  C'est le format
              utilisé par SDB sur la plupart des systèmes  System
              V Release 4.

       -gdwarf+
              Produire des informations de déboggage dans le for­
              mat DWARF (s'il est supporté), en utilisant les ex­
              tensions  GDB comprises uniquement par le déboggeur
              GNU (GDB).   L'utilisation  de  ces  extensions  va
              probablement  faire  crasher les autres déboggeurs,
              ou leur faire refuser de lire le programme.

       -gniveau
       -ggdbniveau
       -gstabsniveau
       -gcoffniveau -gxcoffniveau

       -gdwarfniveau
              Requérir des information de déboggage  et  utiliser
              également  niveau pour spécifier le niveau d'infor­
              mation requis.  Le niveau par  défaut  est  2.   Le
              niveau  1  produit  une information minimale, suff­
              isante pour créer des piles  d'appels  (backtraces)
              dans  des  parties du programme que vous n'avez pas
              l'intention de débogger.  Ceci inclut les  descrip­
              tions des fonctions et des variables externes, mais
              aucune information sur les variables locales ni sur
              les  numéros  de ligne.  Le niveau 3 inclue des in­
              formations supplémentaires, telles les  définitions
              de  macros  présentes  dans  le programme.  Certain
              déboggeurs supportent l'expansion des macros  quand
              vous utilisez `-g3'.

       -p     Générer  du  code  supplémentaire pour afficher des
              informations de profilage  convenant  au  programme
              d'analyse prof.

       -pg    Générer  du  code  supplémentaire pour afficher des
              informations de profilage  convenant  au  programme
              d'analyse gprof.

       -a     Générer  du  code  supplémentaire pour afficher des
              informations de profilage sur les  blocs  de  base,
              qui  enregistrera le nombre de fois que chaque bloc
              de base est exécuté.  Ces données  pourraient  être
              utilisées  par  un  programme  comme  tcov.  Notez,
              cependant, que le format des données n'est pas ce à
              quoi  tcov s'attend.  Par la suite, GNU gprof pour­
              rait être étendu pour traiter ces données.

       -ax    Générer  du  code  supplémentaire  pour  lire   les
              paramètres  de profilage des blocs de base à partir
              du fichier `bb.in' et écrire les résultats du  pro­
              filage  dans le fichier `bb.out'.  `bb.in' contient
              une liste de fonctions.  Chaque  fois  qu'on  entre
              dans une fonction de la liste, le profilage est ac­
              tivé.  Quand la fonction la plus à l'extérieur  est
              quittée, le profilages est désactivé.  Si un nom de
              fonction est préfixé par `-', la fonction  est  ex­
              clue du profilage.  Si un nom de focntion n'est pas
              unique, il  peut  être  désambiguïfié  en  écrivant
              `/chemin/nom_de_fichier.d:nom_de_fonction'.
              `bb.out'  listera   quelques   noms   de   fichiers
              disponibles.   Quatre noms de fonction ont une sig­
              nification  spéciale  :  `__bb_jumps__'  forcera  à
              écrire   les  fréquences  de  saut  dans  `bb.out'.
              `__bb_trace__' forcera la séquence de blocs de base
              à  être pipelinés dans `gzip' et à être écrits dans
              le fichier `bbtrace.gz'.  `__bb_hidecall__' forcera
              les  instructions  d'appel  à  être  exclues  de la
              trace.  `__bb_showret__' forcera  les  instructions
              de retour à être inclues dans la trace.

       -dlettres
              Dit de faire des déchargements (dumps) de déboggage
              durant la compilation aux  moments  spécifiées  par
              lettres.   Ceci est utilisé pour débogger le compi­
              lateur.  Les noms de fichiers pour la  plupart  des
              dumps sont produits en concaténant un mot au nom du
              fichier    source    (p.ex.      `foo.c.rtl'     or
              `foo.c.jump').

       -dM    Décharger toutes les définitions de macros à la fin
              du prétraitement, et ne rien écrire en sortie.

       -dN    Décharger tous les noms  de  macros  à  la  fin  du
              prétraitement.

       -dD    Décharger toutes les définitions de macros à la fin
              du prétraitement, en plus de la sortie normale.

       -dy    Décharger des informations de déboggage  durant  le
              parsage, sur la sortie d'erreur standard.

       -dr    Décharger   après   la   génération  de  RTL,  dans
              `fichier.rtl'.

       -dx    Générer le RTL pour une fonction au lieu de la com­
              piler.  Habituellement utilisé avec `r'.

       -dj    Décharger  après  la première optimisation de saut,
              dans `fichier.jump'.

       -ds    Décharger après le CSE (incluant l'optimisation  de
              saut    qui   suivent   parfois   le   CSE),   dans
              `fichier.cse'.

       -dL    Décharger après l'optimisation  des  boucles,  dans
              `fichier.loop'.

       -dt    Décharger  après  la seconde passe du CSE (incluant
              l'optimisation de saut  suivant  parfois  le  CSE),
              dans `fichier.cse2'.

       -df    Décharger    après    l'analyse   de   flux,   dans
              `fichier.flow'.

       -dc    Décharger après la combinaison d'instructions, dans
              `fichier.combine'.

       -dS    Décharger  après la première passe d'ordonnancement
              des instructions, dans `fichier.sched'.

       -dl    Décharger après  l'allocation  du  registre  local,
              dans `fichier.lreg'.

       -dg    Décharger  après  l'allocation  du registre global,
              dans `fichier.greg'.

       -dR    Décharger après la seconde  passe  d'ordonnancement
              des instructions, dans `fichier.sched2'.

       -dJ    Décharger  après  la dernière optimisation de saut,
              dans `fichier.jump2'.

       -dd    Décharger après la planification du branchement re­
              tardé, dans `fichier.dbr'.

       -dk    Décharger après la conversion des registres vers la
              pile, dans `file.stack'.

       -da    Produire tous les déchargements listés ci-dessus.

       -dm    Imprimer  des  statistiques  sur  l'usage   de   la
              mémoire,  à  la  fin  de l'exécution, sur la sortie
              d'erreur standard.

       -dp    Annoter la sortie de l'assembleur avec  un  commen­
              taire  indiquant  quel  motif et quelle alternative
              ont été utilisées.

       -fpretend-float
              Quand on exécute un compilateur  multi-plateformes,
              prétendre que la machine cible utilise le même for­
              mat  de  flottants  que  la  machine  hôte.    Ceci
              provoque une sortie incorrecte des constantes flot­
              tantes réelles, mais la séquence réelle  d'instruc­
              tions  va  probablement  être la même que celle que
              GNU CC  donnerait  s'il  tournait  sur  la  machine
              cible.

       -save-temps
              Stocker  les  fichiers intermédiaires "temporaires"
              de façon permanente ; les placer dans le répertoire
              courant  et  les nommer sur base du fichier source.
              Donc, compiler `foo.c' avec `-c  -save-temps'  pro­
              duirait  les  fichiers  `foo.cpp' et `foo.s', aussi
              bien que `foo.o'.

       -print-file-name=librairie
              Imprimer le nom de fichier absolu complet du fichi­
              er  de librairie librairie  qui serait utilisé lors
              de l'édition des liens et ne  rien  faire  d'autre.
              Avec cette option, GNU CC ne compile ou ne lie rien
              du tout; il imprime juste le nom du fichier.

       -print-libgcc-file-name
              Idem que `-print-file-name=libgcc.a'.

       -print-prog-name=programme
              Comme `-print-file-name', mais  recherche  un  pro­
              gramme tel que `cpp'.
       Ces options contrôlent différents types d'optimisations

       -O

       -O1    Optimiser.  La compilation optimisante prend un peu
              plus de temps, et beaucoup plus de mémoire pour une
              grande  fonction.  Sans `-O', le but du compilateur
              est de réduire le coût de la compilation et de per­
              mettre  au  déboggage de produire les résultats es­
              comptés.  Les instructions sont indépendantes :  si
              vous stoppez le programme avec un point d'arrêt en­
              tre des instructions,  vous  pouvez  attribuer  une
              nouvelle valeur à n'importe quelle variable ou mod­
              ifier l'indicateur d'instruction courante  (program
              counter)  pour  le  faire  pointer  vers  n'importe
              quelle  autre  instruction  dans  la  fonction   et
              obtenir  exactement  les  mêmes  résultats que ce à
              quoi vous vous  attendiez  du  code  source.   Sans
              `-O',  seules les variables déclarées register sont
              allouées  dans  des  registres.   Le  code  compilé
              résultant est un petit peu moins bon que celui pro­
              duit par PCC sans `-O'.  Avec `-O', le  compilateur
              essaie  de  réduire  la  taille du code et le temps
              d'exécution.  Quand vous spécifiez `-O',  les  deux
              options  `-fthread-jumps' et `-fdefer-pop' sont ac­
              tivées.  Sur les machines  ayant  des  tranches  de
              temps     retardées    (delay    slot),    l'option
              `-fdelayed-branch' est désactivée.   Pour  ces  ma­
              chines  là  qui  supportent  le déboggage même sans
              pointeur  de  cadre   (frame   pointer),   l'option
              `-fomit-frame-pointer'  est activée.  Sur certaines
              machines, d'autres drapeaux peuvent également  être
              activés.

       -O2    Optimiser  encore plus.  Presque toutes les optimi­
              sations supportées qui n'impliquent pas un  compro­
              mis espace/vitesse sont effectuées.  Le déroulement
              des boucles et la mise en  ligne  de  fonctions  ne
              sont  pas  effectuées, par exemple.  Comparée à -O,
              cette option augmente à la fois le temps de  compi­
              lation et la performance du code généré.

       -O3    Optimiser  toujours  plus.  Ceci active tout ce que
              fait -O2 , ce à quoi s'ajoute -finline-functions.

       -O0    Ne pas optimiser.  Si vous  utilisez  de  multiples
              options  -O , avec ou sans numéros de niveau, seule
              la dernière option de ce type sera tenue en compte.

       Les  options  de  la forme `-fdrapeau' spécifient des dra­
       peaux 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'.  La  liste  suivante
       montre  seulement  une  forme  ;  celle  qui n'est pas par
       défaut.  Vous pouvez imaginer l'autre forme en  supprimant
       `no-' ou en l'ajoutant.

       -ffloat-store
              Ne  pas  stocker  les variables flottantes dans des
              registres.  Ceci 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.  Pour
              la plupart des programmes, l'excès de précision  ne
              fait  que  du  bien,  mais  un petit nombre de pro­
              grammes de basent  sur  la  définition  précise  du
              flottant  IEEE.   Utilisez  `-ffloat-store' pour de
              tels programmes.

       -fmemoize-lookups

       -fsave-memoized
              Utiliser des heuristiques pour compiler plus  rapi­
              dement  (C++ uniquement).  Ces heuristiques ne sont
              pas activées par défaut, car elles  sont  seulement
              efficaces  pour  certains  fichiers  d'entrée.  Les
              autres fichiers d'entrée compilent plus  lentement.
              La première fois que le compilateur doit construire
              un appel à une fonction membre  (ou  référencer  un
              membre  de  données),  il doit (1) déterminer si la
              classe implémente les fonctions  membres  ayant  ce
              nom; (2) décider quelle fonction membre appeler (ce
              qui implique de s'imaginer quelles sortes  de  con­
              versions de type doivent être faites); et (3) véri­
              fier la visibilité de la fonction membre par  l'ap­
              pelant.  Tout ceci s'ajoute pour ralentir la compi­
              lation.  Normalement, la seconde fois  qu'un  appel
              est  fait vers cette fonction membre (ou qu'un mem­
              bre de données est référencé), il doit  refaire  ce
              même  (long)  processus.  Cela signifie que du code
              comme celui-ci   cout << "This " << p << " has " <<
              n  <<  " legs.\n"; fait six passes à travers de ces
              trois pas.  En  utilisant  un  cache  logiciel,  un
              "hit"   réduit  significativement  ce  coût.   Mal­
              heureusemnt, utiliser le cache introduit une  autre
              couche  de mécanismes qui doivent être implémentés,
              et donc qui amènent leur propre surcoût à  l'exécu­
              tion.   `-fmemoize-lookups'  active  le cache logi­
              ciel.  Puisque les privilèges d'accès  (visibilité)
              aux   membres  et  aux  fonctions  membres  peuvent
              différer d'un contexte d'une fonction à une  autre,
              g++  peut  avoir besoin de vider le cache.  Avec le
              drapeau  `-fmemoize-lookups',  le  cache  est  vidé
              après   chaque   fonction   compilée.   Le  drapeau
              `-fsave-memoized' active le  même  cache  logiciel,
              mais quand le compilateur détermine que le contexte
              de la dernière fonction compilée  donne  les  mêmes
              privilèges  d'accès  à la prochaine fonction à com­
              piler, il préserve le  cache.   Ceci  est  le  plus
              utile  quand  on définit des fonctions membres pour
              la même classe : si on exepte les fonctions membres
              qui  sont  des  compagnons d'autres classes, chaque
              fonction membre a exactement les  mêmes  privilèges
              que  tout  autre, et le cache n'a pas besoin d'être
              vidé.

       -fno-default-inline
              Ne pas rendre les fonctions membres  en  ligne  par
              défaut  simplement  parce  qu'elles sont définies à
              l'intérieur de la portée de la classe (C++  unique­
              ment).

       -fno-defer-pop
              Toujours  dépiler  les arguments de chaque appel de
              fonction dès que la fonction se termine.  Pour  les
              machines qui doivent dépiler les arguments après un
              appel de fonction, le compilateur  laisse  normale­
              ment  les  arguments  s'accumuler  sur la pile pour
              plusieurs appels de fonctions, et les  dépile  tous
              en une fois.

       -fforce-mem
              Force les opérandes mémoire à être copiées dans des
              registres   avant   d'effectuer   des    opérations
              arithmétiques  sur  eux.   Ceci  peut  produire  un
              meilleur code en faisant de toutes  les  références
              mémoire  des  sous-expressions potentiellement com­
              munes.  Quand elles ne sont  pas  des  sous-expres­
              sions  communes,  la combinaison d'instructions de­
              vrait éliminer le chargement séparé dans  des  reg­
              istres.

       -fforce-addr
              Force  les  constantes  d'adresse  mémoire  à  être
              copiées dans des registres  avant  d'effectuer  des
              opérations  arithmétiques  sur eux.  Ceci peut pro­
              duire du meilleur code exactement comme pourrait le
              faire `-fforce-mem'.

       -fomit-frame-pointer
              Ne pas garder le pointeur de cadre dans un registre
              pour les fonctions qui n'en ont pas  besoin.   Ceci
              évite  les  instructions pour sauver, mettre à jour
              et restaurer les pointeurs de cadre ;  cela  permet
              aussi   de   rendre   un   registre  supplémentaire
              disponible dans de nombreuses fonctions.  Cela rend
              également  le  déboggage  impossible sur la plupart
              des machines.  Sur certaines machines,  telles  que
              le Vax, ce drapeau 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.

       -finline-functions
              Intégrer toutes les fonctions  simples  dans  leurs
              appelants.   Le  compilateur détermine heuristique­
              ment quelles fonctions  sont  suffisamment  simples
              pour  valoir  la  peine  d'être  intégrées de cette
              façon.  Si tous les appels à  une  fonction  donnée
              sont intégrés, et si la fonction est déclarée stat­
              ic, alors GCC n'effectue pas  de  sortie  de  cette
              fonction en assembleur et ce de son plein droit.

       -fcaller-saves
              Permet  à des valeurs d'être allouées dans des reg­
              istres qui seront écrasés lors  d'appels  de  fonc­
              tion,  en émettant des instructions supplémentaires
              pour sauver er restaurer les  registres  autour  de
              tels  appels.   Une  telle allocation est effectuée
              uniquement quand elle semble produire  du  meilleur
              code que celui qui serait produit autrement.  Cette
              option est activée par  défaut  sur  certaines  ma­
              chines,  celles  qui  n'ont  d'habitude pas de reg­
              istres préservés lors de l'appel à  utiliser  à  la
              place.

       -fkeep-inline-functions
              Même  si tous les appels à une fonction donnée sont
              intégrés, et que la fonction est  déclarée  static,
              produire  néanmoins  une  version  séparée de cette
              fonction appelable durant l'exécution.

       -fno-function-cse
              Ne pas mettre d'adresse de fonctions dans des  reg­
              istres;  faire  contenir  explicitement dans chaque
              instruction qui  appelle  une  fonction  constante,
              l'adresse  de la fonction.  Cette option résulte en
              un code moins efficace, mais  certaines  bidouilles
              étranges  qui  altèrent  la  sortie de l'assembleur
              peuvent être  confus  si  cette  option  n'est  pas
              utilisée.

       -fno-peephole
              Désactive  toute optimisation peephole spécifique à
              la machine.

       -ffast-math
              Cette option  permet  à  GCC  de  violer  certaines
              règles/spécifications  de  l'ANSI ou de l'IEEE dans
              l'intérêt  de  l'optimisation  du  code   pour   la
              vitesse.   Par exemple, il permet au compilateur de
              supposer que les arguments de la fonction sqrt sont
              des  nombres non négatifs.  Cette option ne devrait
              jamais être activée par une option `-O' car il peut
              en  résulter  une  sortie  incorrecte pour les pro­
              grammes qui dépendent d'une  implémentation  exacte
              des  règles/spécifications  de  l'ANSI ou de l'IEEE
              pour les fonctions mathématiques.

       Les  options  suivantes   contrôlent   des   optimisations
       spécifiques.   L'option  `-O2' active toutes les optimisa­
       tions sauf `-funroll-loops' et `-funroll-all-loops'.

       L'option    `-O'    active    d'habitude    les    options
       `-fthread-jumps'  et `-fdelayed-branch', mais des machines
       spécifiques peuvent modifier les optimisations par défaut.

       Vous  pouvez utiliser les drapeaux suivants dans les rares
       cas où l'on désire "un règlage fin"  des  optimisations  à
       effectuer.

       -fstrength-reduce
              Effectuer  les  optimisations de réduction de force
              des boucles et d'élimination des variables d'itéra­
              tion.

       -fthread-jumps
              Effectuer  des  optimisations où l'on vérifie si un
              saut se branche vers un emplacement  où  une  autre
              comparaison  englobée  par la première est trouvée.
              Si  c'est  le  cas,  le  premier  branchement   est
              redirigé   soit   vers  la  destination  du  second
              branchement, soit sur le point le  suivant  immédi­
              atement,  dépendant  du  fait que la condition soit
              vraie ou fausse.

       -funroll-loops
              Effectuer   l'optimisation   de   déroulement   des
              boucles.  Ceci est fait uniquement pour les boucles
              dont le nombre d'itérations peut être déterminé  au
              moment de la compilation ou de l'exécution.

       -funroll-all-loops
              Effectuer   l'optimisation   de   déroulement   des
              boucles.  Ceci est fait pour  toutes  les  boucles.
              Cela ralentit habituellement les programmes.

       -fcse-follow-jumps
              Dans  l'élimination  de  sous-expressions communes,
              passe à travers les instructions de saut lorque  la
              cible du saut n'est atteint par aucun autre chemin.
              Par exemple, quand CSE rencontre une instruction if
              avec  une clause else , CSE va suivre le saut quand
              la condition testée est fausse.

       -fcse-skip-blocks
              Ceci est  similaire  à  `-fcse-follow-jumps',  mais
              oblige   CSE   à  suivre  les  sauts  conditionnels
              au-dessus des blocs.  Quand CSE rencontre une  sim­
              ple    instruction    if    sans    clause    else,
              `-fcse-skip-blocks' oblige CSE à suivre le saut au­
              tour du corps du  if.

       -frerun-cse-after-loop
              Relancer  l'élimination  des  sous-expressions com­
              munes après que les optimisations de boucles  aient
              été effectuées.

       -felide-constructors
              Elider  les constructeurs quand cela semble plausi­
              ble (C++ uniquement).  Avec  ce  drapeau,  GNU  C++
              initialise  y directement à partir de l'appel à foo
              sans passer par une  variable  temporaire  dans  le
              code  suivant  : A foo (); A y = foo (); Sans cette
              option, GNU C++ initialise d'abord y en appelant le
              constructeur  approprié  pour le type A; et affecte
              ensuite le résultat de foo dans une variable tempo­
              raire;  et  remplace  finalement la valeur initiale
              de`y' par la variable temporaire.  Le  comportement
              par défaut (`-fno-elide-constructors') est spécifié
              par le premier jet du standard C++  ANSI.   Si  vos
              constructeurs de programmes ont des effets de bord,
              utiliser `-felide-constructors'  peut  faire  fonc­
              tionner  votre  programme différemment, puique cer­
              tains appels de constructeurs pourraient être omis.

       -fexpensive-optimizations
              Effectue un certain nombre d'optimisations mineures
              qui sont relativement coûteuses.

       -fdelayed-branch
              Si supporté par la machine cible, tente de réordon­
              ner les instructions pour exploiter des slots d'in­
              struction disponibles  après  des  instructions  de
              branchement différé.

       -fschedule-insns
              Si supporté par la machine cible, tente de réordon­
              ner les instructions pour éliminer  les  pertes  de
              vitesse  à  l'exécution dues à des données requises
              indisponibles.  Cela aide les  machines  ayant  des
              flottants  ou  des  instructions  de  chargement en
              mémoire lents, en autorisant d'autres  instructions
              à  être  exécutées  jusqu'à  ce  que le résultat du
              chargement ou de l'instruction flottante soit  req­
              uis.

       -fschedule-insns2
              Similaire  à  `-fschedule-insns', mais requiert une
              passe supplémentaire d'ordonnancement des  instruc­
              tions  après  que l'allocation registre ait été ef­
              fectuée.  Ceci est spécialement utile sur  des  ma­
              chine  avec un nombre de registres relativement pe­
              tit et où les instructions de chargement en mémoire
              prennent plus d'un cycle.

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

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

       -b machine
              L'argument machine spécifie la machine  cible  pour
              la  compilation.   Ceci  est utile si vous avez in­
              stallé GNU CC en tant que compilateur  multi-plate­
              formes.   La  valeur à utiliser pour machine est la
              même que celle spécifiée au moment de la configura­
              tion  de  GNU  CC comme un compilateur multi-plate­
              formes.   Par  exemple,  si  un  compilateur   mul­
              ti-plateformes  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  multi-plate­
              formes.   Quand  vous  ne  spécifiez pas `-b', cela
              signifie normalement que vous compilez pour le même
              type de machine que celui que vous utilisez.

       -V version
              L'argument  version  spécifie quelle version de GNU
              CC utiliser.  C'est utile quand de  multiples  ver­
              sions  sont installées.  Par exemple, version pour­
              rait être `2.0', signifiant exécuter GNU CC version
              2.0.   La  version par défaut, quand vous ne spéci­
              fiez pas `-V', est contrôlée par la façon dont  GNU
              CC  est installé.  Normalement, ce sera une version
              qui est recommandée pour l'usage général.
       Chacun des types de machine cible peut avoir  ses  propres
       options spéciales, commençant par `-m', pour choisir parmi
       des modèles variés de matériel ou  de  configurations--par
       exemple,  68010  vs 68020, avec ou sans coprocesseur flot­
       tant.  Une unique version installée  du  compilateur  peut
       compiler  pour  n'importe  quel  modèle  ou configuration,
       selon les options spécifiées.

       Quelques configurations du compilateur  supportent  égale­
       ment des options spéciales additionnelles, d'habitude pour
       une compatibilité en ligne de commandes avec d'autres com­
       pilateurs sur la même plate-forme.

       Voici les options `-m' définies pour la série 68000 :

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

       -m68020

       -mc68020
              Générer une sortie  pour  un  68020  (plutôt  qu'un
              68000).   C'est le comportement par défaut quand le
              compilateur est configuré pour les systèmes à  base
              de 68020.

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

       -m68030
              Générer une sortie pour un 68030.   C'est  le  com­
              portement  par défaut quand le compilateur est con­
              figuré pour les systèmes à base de 68030.

       -m68040
              Générer une sortie pour un 68040.   C'est  le  com­
              portement  par défaut quand le compilateur est con­
              figuré pour les systèmes à base de 68040.

       -m68020-40
              Générer une sortie pour un 68040, sans utiliser une
              seule  des nouvelles instructions.  Ceci résulte en
              un code qui peut tourner relativement  efficacement
              sur  un 68020/68881 ou un 68030 ou encore un 68040.

       -mfpa  Générer une sortie contenant des  instructions  Sun
              FPA pour flottants.

       -msoft-float
              Générer  une  sortie  contenant  des  appels de li­
              brairie pour les flottants.  AVERTISSEMENT: Les li­
              brairies  requises  ne  font  pas partie de GNU CC.
              Normalement, les facilités du compilateur  C  usuel
              de  cette machine sont utilisées, mais ceci ne peut
              être fait directement en  compilation  multi-plate­
              formes.   Vous devez vous arranger pour fournir les
              fonctions de librairies convenant à la  compilation
              multi-plateformes.

       -mshort
              Considérer  que  le  type int à 16 bits de largeur,
              comme short int.

       -mnobitfield
              Ne pas  utiliser  les  instructions  utilisant  des
              champs-bit.  `-m68000' implique `-mnobitfield'.

       -mbitfield
              Utiliser les instructions utilisant des champs-bit.
              `-m68020' implique  `-mbitfield'.   C'est  le  com­
              portement  par  défaut si vous utilisez des sources
              non modifiées.

       -mrtd  Utiliser  une  convention   d'appel   de   fonction
              différente,  dans laquelle les fonctions prenant un
              nombre fixé  d'arguments  retournent  à  l'appelant
              avec  l'instruction  rtd , qui dépile ses arguments
              en sortant.  Ceci épargne une instruction  à  l'ap­
              pelant  qui n'a alors pas besoin de dépiler les ar­
              guments.  Cette convention d'appel est incompatible
              avec  celle  utilisée  normalement  sous Unix, donc
              vous ne pourrez  l'utiliser  si  vous  avez  besoin
              d'appeler des librairies compilées avec le compila­
              teur Unix.  Aussi, vous devez  fournir  des  proto­
              types  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  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 ig­
              norés sans dommage.)  L'instruction  rtd  est  sup­
              portée par les processeurs 68010 et 68020, mais pas
              par le 68000.

       Ces options `-m' sont définies pour le Vax:

       -munix Ne pas  produire  certaines  instructions  de  saut
              (aobleq  etc.)  que  l'assembleur  Unix pour Vax ne
              peut traiter sur une grande portée.

       -mgnu  produire ces instructions de saut, en supposant que
              vous assemblerez avec l'assembleur GNU.

       -mg    Produire du code pour le format g des nombres flot­
              tants au lieu du format d.

       Ces interrupteurs `-m' sont supportés sur le SPARC :

       -mfpu

       -mhard-float
              Générer une sortie contenant des instructions flot­
              tantes.  C'est le comportement par défaut.

       -mno-fpu

       -msoft-float
              Générer  une  sortie  contenant  les  appels de li­
              brairie pour les flottants.  Attention : il  n'y  a
              pas  de librairie GNU pour les flottants sur SPARC.
              Normalement,  les  facilités   du   compilateur   C
              habituel de la machine sont utilisées, mais ceci ne
              peut être fait directement avec la compilation mul­
              ti-plateformes.   Vous  devez  vous  arranger  pour
              fournir des fonctions de librairie convenant  à  la
              compilation multi-plateformes.  -msoft-float Change
              la convention d'appel dans le  fichier  de  sortie;
              donc,  c'est  seulement utile si vous compilez tout
              un programme avec cette option.

       -mno-epilogue

       -mepilogue
              With -mepilogue (le comportement  par  défaut),  le
              compilateur émet toujours du code pour la sortie de
              fonction à la fin de chaque fonction.  Chaque  sor­
              tie de fonction au milieu de la fonction (comme une
              instruction return en C) génèrera un saut  vers  le
              code  de  sortie  à  la  fin  de la fonction.  Avec
              -mno-epilogue, le compilateur essaie  d'émettre  du
              code  de  sortie  en ligne à chaque sortie de fonc­
              tion.

       -mno-v8

       -mv8

       -msparclite
              Ces trois options séléctionnent  des  variantes  de
              l'architecture  SPARC.   Par défaut (à moins d'être
              spécialement configuré pour le Fujitsu  SPARClite),
              GCC  génère du code pour la variante v7 de l'archi­
              tecture SPARC.  -mv8 vous donnera du code SPARC v8.
              La  seule différence par rapport au code v7 est que
              le compilateur émet des instructions de multiplica­
              tion et de division entières qui existent sur SPARC
              v8 mais pas sur SPRC v7.  -msparclite vous  donnera
              du  code  SPARClite.  Ceci ajoute la multiplication
              entière, le pas de division entière et les instruc­
              tions  d'examen  (ffs)  qui  existent sur SPARClite
              mais pas sur SPARC v7.

       -mcypress

       -msupersparc
              Ces deux options sélectionnent le  processeur  pour
              lequel  le  code  est optimisé.  Avec -mcypress (le
              comportement par défaut), le  compilateur  optimise
              le code pour la puce Cypress CY7C602, utilisée dans
              la série  SparcStation/SparcServer  3xx.  Ceci  est
              également  approprié pour les plus anciennes Sparc­
              Station 1, 2, IPX etc.  Avec -msupersparc le compi­
              lateur  optimise  le code pour le processeur Super­
              Sparc, utilisé par les séries SparcStation 10, 1000
              et  2000. Ce drapeau active également l'utilisation
              de l'ensemble complet des instructions du SPARC v8.

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

       -mc1   Générer  une sortiee pour un C1. C'est le comporte­
              ment par défaut quand le compilateur est  configuré
              pour un C1.

       -mc2   Générer  une sortiee pour un C2. C'est le comporte­
              ment par défaut quand le compilateur est  configuré
              pour un C2.

       -margcount
              Générer  du  code  qui  place le nombre d'arguments
              dans le mot  précédant  chaque  liste  d'arguments.
              Quelques programmes Convex et Vax non portables ont
              besoin de ce mot.  (Les déboggeurs n'en ont pas be­
              soin, sauf pour les fonctions avec des listes d'ar­
              guments variables; cette information  est  présente
              dans la table des symboles.)
       -mnoargcount
              Omettre  le  mot  comptant  le  nombre d'arguments.
              C'est le comportement par défaut si  vous  utilisez
              les sources non modifiées.

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

       -mdw   Générer  du  code qui suppose que le bit DW est al­
              lumé, çàd que les opérations sur les octets et  les
              demi-mots   sont   directement  supportées  par  le
              matériel.  C'est le comportement par défaut.

       -mnodw Générer du code qui suppose que le bit DW n'est pas
              allumé.

       -mbw   Générer du code qui suppose que le système supporte
              les opérations d'écritures d'octet et de  demi-mot.
              C'est le comportement par défaut.

       -mnbw  Générer  du code qui suppose que le système ne sup­
              porte pas les opérations d'écritures d'octet et  de
              demi-mot.  Cela implique `-mnodw'.

       -msmall
              Utiliser un modèle de mémoire restreint qui suppose
              que toutes les adresses de fonction  sont  ou  bien
              dans  un  seul  segement  de  256 Ko, ou bien à une
              adresse absolue de moins de 256Ko.  Cela  permet  à
              l'instruction  call  d'être  utilisée au lieu d'une
              séquence const, consth, et calli .

       -mlarge
              Ne pas supposer que l'instruction  call  peut  être
              utilisée ; c'est le comportement par défaut.

       -m29050
              Générer du code pour l'Am29050.

       -m29000
              Générer du code pour l'Am29000.  C'est le comporte­
              ment par défaut.

       -mkernel-registers
              Générer des références aux registres  gr64-gr95  au
              lieu   des  gr96-gr127.   Cette  option  peut  être
              utilisée lors de la compilation d'un noyau qui veut
              un  ensemble de registres globaux disjoint de celui
              utilisé par le code en mode utilisateur.  Notez que
              quand  cette  option est utilisée, les noms de reg­
              istres dans les drapeaux `-f' doivent utiliser  les
              noms normaux en mode utilisateur.

       -muser-registers
              Utiliser  l'ensemble  normal  de registres globaux,
              gr96-gr127.  C'est le comportement par défaut.

       -mstack-check
              Insérer un appel à __msp_check après chaque ajuste­
              ment  de  pile.  C'est souvent utilisé dans le code
              du noyau.

       Ces options -m' sont définies pour les  architectures  Mo­
       torola 88K :

       -m88000
              Générer  du  code qui fonctionnera sur le m88100 et
              le m88110.

       -m88100
              Générer du code qui fonctionnera le  mieux  sur  le
              m88100, mais qui tourenera aussi sur un m88110.

       -m88110
              Générer  du  code  qui fonctionnera le mieux sur le
              m88100, mais qui ne tournera peut-être pas  sur  un
              m88110.

       -midentify-revision
              Inclure  une  directive ident dans la sortie assem­
              bleur enregistrant le nom du fichier source, le nom
              et  la  version  du compilateur, le cachet temporel
              (time stamp, çàd le moment de  la  compilation)  et
              les drapeaux de compilation utilisés.

       -mno-underscores
              Dans la sortie assembleur, émettre les noms de sym­
              boles sans ajouter de caractère de soulignement  au
              début  de  chaque  nom.  Le comportement par défaut
              est d'utiliser un "_" comme préfixe de chaque  nom.

       -mno-check-zero-division

       -mcheck-zero-division
              Les  modèles  anciens de l'architecture 88K avaient
              des problèmes avec la division par zéro; en partic­
              ulier,  beaucoup  d'entre  eux ne la piégaient pas.
              Utilisez ces options pour éviter d'avoir à  inclure
              (où  d'inclure  explicitement)  du code additionnel
              pour détecter les divisions par  zéro  et  signaler
              une  exception.  Toutes les configurations GCC pour
              le  88K   utilisent   `-mcheck-zero-division'   par
              défaut.

       -mocs-debug-info

       -mno-ocs-debug-info
              Inclure  (ou omettre) de l'information de déboggage
              additionnelle  (sur  les  registres  utilisés  dans
              chaque  cadre  de pile) comme spécifié par le Stan­
              dard de Compatibilité d'Objet 88Open, "OCS".  Cette
              information  supplémentaire  n'est pas nécessaire à
              GDB.  C'est le comportement  par  défaut  pour  les
              DG/UX, SVr4, et Delta 88 SVr3.2 est d'inclure cette
              information; d'autres configurations  88K  omettent
              cette information par défaut.

       -mocs-frame-position

       -mno-ocs-frame-position
              Force  (ou  pas)  les  valeurs  de  registre à être
              stockées à un endroit particulier dans  les  cadres
              de  pile, comme spécifié par l'OCS.  Les configura­
              tions  DG/UX,  Delta88  SVr3.2  et  BCS   utilisent
              `-mocs-frame-position'; d'autres configuraration 88
              ont      le      comportement      par       défaut
              `-mno-ocs-frame-position'.

       -moptimize-arg-area

       -mno-optimize-arg-area
              Contrôle  comment stocker les arguments de fonction
              dans les  cadres  de  pile.   `-moptimize-arg-area'
              épargne  de  l'espace,  mais  peut crasher certains
              déboggeurs (pas GDB).  `-mno-optimize-arg-area'  se
              conforme  mieux  aux  standards.   Par  défaut, GCC
              n'optimise pas la zône des arguments.

       -mshort-data-nombre
              nombre Générer des références de données  plus  pe­
              tites  en les rendant relatives à r0, qui permet de
              charger une valeur en utilisant une seule  instruc­
              tion  (plutôt que les deux habituelles).  Vous con­
              trôlez quelles références de données sont affectées
              en  spécifiant nombre avec cette option.  Par exem­
              ple, si vous  spécifiez  `-mshort-data-512',  alors
              les références de données affectées sont celles qui
              impliquent des déplacements de moins de 512 octets.
              `-mshort-data-nombre'  n'est  pas  en  vigueur pour
              nombre supérieur à 64K.

       -mserialize-volatile

       -mno-serialize-volatile
              Générer (ou ne pas le faire) du code pour  garantir
              la  consistance séquentielle des référence mémoires
              volatiles.  GNU CC garantit toujours la consistance
              par  défaut,  pour  le  sous-modèle  de  processeur
              préféré.   Comment  cela   est   fait   dépend   du
              sous-modèle.  Le processeur m88100 ne réordonne pas
              les références mémoires et fournit  ainsi  toujours
              la  consistance  séquentielle.   Si  vous  utilisez
              `-m88100', GNU CC ne génère aucune instruction sup­
              plémentaire   pour   la  consistance  séquentielle.
              L'orde des références mémoires  effectuées  par  le
              m88110  ne correspond pas toujours avec l'ordre des
              instructions requérant ces références.  En  partic­
              ulier,   une   instruction   de   chargement   peut
              s'exécuter avant une instruction de stockage préal­
              able.  De tels réordonnancements violent la consis­
              tance séquentielle des référence mémoires volatiles
              quand  il y a de multiples processeurs.  Quand vous
              utilisez le  `-m88000'  ou  le  `-m88110',  GNU  CC
              génère  des  instructions  spéciales quand cela est
              approprié, pour forcer l'exécution des instructions
              dans  le  bon ordre.  Le code supplémentaire généré
              pour garantir la consistance peut affecter la  per­
              formance  de  votre application.  Si vous savez que
              vous pouvez en  toute  sécurité  renoncer  à  cette
              garantie,    vous    pouvez    utiliser    l'option
              `-mno-serialize-volatile'.  Si vous utilisez  l'op­
              tion   `-m88100'   mais  requérrez  la  consistance
              séquentielle quand vous tournez sur  un  processeur
              m88110,         vous        devriez        utiliser
              `-mserialize-volatile'.

       -msvr4

       -msvr3 Active (`-msvr4') ou désactive (`-msvr3')  les  ex­
              tensions  du  compilateur  relatives à System V re­
              lease 4 (SVr4).  Ceci contrôle les points  suivants
              :

          ·   Quelle  variante  de  la syntaxe assembleur émettre
              (que vous  pouvez  sélectionner  indépendamment  en
              utilisant `-mversion-03.00').

          ·   `-msvr4'   faire  reconnaître  au  préprocesseur  C
              `#pragma weak'

          ·   `-msvr4' faire produire à  GCC  des  directives  de
              déclaration additionnelles utilisées dans SVr4.

       `-msvr3'  est  le  comportement par défaut pour toutes les
       configurations m88k sauf la configuration SVr4.

       -mtrap-large-shift

       -mhandle-large-shift
              Inclure du code pour détecter les décalages-bits de
              plus   de  31  bits;  respectivement  pour  bloquer
              (piéger) de tels décalages ou pour émettre du  code
              pour  les  traiter  proprement.  Par défaut, GCC ne
              prend aucune disposition  pour  les  décalages-bits
              importants.

       -muse-div-instruction
              De  très  anciens  modèles  de  l'architecture  88K
              n'avaient pas  d'instructions  de  division,  c'est
              pourquoi  GCC  évite  cette instruction par défaut.
              Utilisez cette option pour spécifier qu'il est  sûr
              d'utiliser l'instruction de division.

       -mversion-03.00
              Dans  la configuration DG/UX, il y a deux "parfums"
              de  SVr4.   Cette  option   modifie   -msvr4   pour
              séléctionner  si  le  parfum  hybride COFF ou celui
              réel ELF est utilisé.  Toutes les autres configura­
              tions ignorent cette option.

       -mwarn-passed-structs
              Avertir  quand  une  fonction  passe  une structure
              comme argument ou comme résultat.  Les  conventions
              de passage de structures ont changé durant l'évolu­
              tion du langage C, et sont  souvent  la  source  de
              problèmes  de portabilité.  Par défaut, GCC ne pro­
              duit aucun de ces avertissements.

       Ces options sont définies pour l'IBM RS6000:

       -mfp-in-toc

       -mno-fp-in-toc
              Contrôle si les constantes réelles flottantes  vont
              ou  ne  vont  pas dans la Table des Contenus (TDC),
              une table de toutes les variables globales  et  des
              adresses  de  fonction.   Par défaut, GCC y met les
              constantes réelles flottantes; si la  TDC  déborde,
              `-mno-fp-in-toc'  empêchera  les  flottants d'aller
              dans la TDC, ce qui peut éviter un débordement.

       Ces options`-m' sont définies pour l'IBM RT PC:

       -min-line-mul
              Utiliser une séquence de code  en  ligne  pour  les
              multiplications  d'entiers.   C'est le comportement
              par défaut.

       -mcall-lib-mul
              Appelle lmul$$ pour la multiplications des entiers.

       -mfull-fp-blocks
              Générer  des  blocs de données flottantes de taille
              complète, incluant le montant minimal  d'espace  de
              scratch  recommandé par IBM.  C'est le comportement
              par défaut.

       -mminimum-fp-blocks
              Ne pas inclure d'espace de  scratch  supplémentaire
              dans les blocs de données flottantes.  Cela résulte
              en un code plus court, mais à  une  exécution  plus
              lente, puisque l'espace de scratch doit être alloué
              dynamiquement.

       -mfp-arg-in-fpregs
              Utiliser une séquence d'appel incompatible avec  la
              convention  d'appel d'IBM dans lequel les arguments
              flottants sont passés dans des registres flottants.
              Notez  que varargs.h et stdargs.h ne fonctionneront
              pas  avec  les  flottants  si  cette   option   est
              spécifiée.

       -mfp-arg-in-gregs
              Utiliser la convention d'appel normale pour les ar­
              guments  flottants.   C'est  le  comportement   par
              défaut.

       -mhc-struct-return
              Retourner  les  structures  de  plus  d'un  mot  en
              mémoire, plutôt que dans un registre.  Ceci fournit
              la compatibilité avec le compilateur MetaWare HighC
              (hc).  Utilisez `-fpcc-struct-return' pour la  com­
              patibilité  avec le compilateur Portable C Compiler
              (pcc).

       -mnohc-struct-return
              Retourner certaines structures  de  plus  d'un  mot
              dans des registres, quand c'est opportun.  C'est le
              comportement par  défaut.   Pour  la  compatibilité
              avec  les compilateurs fournis par IBM, utilisez ou
              bien      `-fpcc-struct-return'       ou       bien
              `-mhc-struct-return'.

       Ces  options  `-m' sont définies pour la famille d'ordina­
       teurs MIPS :

       -mcpu=type_de_processeur
              Suppose le comportement par défaut pour le type  de
              machines  type_de_processeur  quand  on ordonne les
              instructions.  Le type_de_processeur par défaut est
              default,  qui  sélectionne  les plus longs temps de
              cycles pour toutes les machines, de  sorte  que  le
              code  tourne  à  des cadences raisonnables sur tous
              les  processeurs   MIPS.    D'autres   choix   pour
              type_de_processeur  sont  r2000,  r3000,  r4000, et
              r6000.  Bien que sélectionner un type_de_processeur
              spécifique  planifiera  les  choses de façon appro­
              priée pour cette puce particulière, le  compilateur
              ne  génèrera  aucun  code qui ne soit pas en accord
              avec le niveau 1 du MIPS ISA (architecture de l'en­
              semble  d'instructions)  sans que les interrupteurs
              -mips2 ou -mips3 ne soient utilisés.

       -mips2 Utiliser les instructions du niveau 2 du  MIPS  ISA
              (branchement  possible,  instructions  de  prise de
              racine  carrée).   L'interrupteur  -mcpu=r4000   ou
              -mcpu=r6000  doit  être utilisé en conjonction avec
              -mips2.

       -mips3 Utiliser les instructions du niveau 3 du  MIPS  ISA
              (instructions  64 bit).  L'interrupteur -mcpu=r4000
              doit être utilisé en conjonction avec -mips2.

       -mint64

       -mlong64

       -mlonglong128
              Ces options ne fonctionnent pas pour le moment.

       -mmips-as
              Générer du code pour l'assembleur MIPS, et invoquer
              mips-tfile  pour ajouter de l'information de débog­
              gage normale.  C'est  le  comportement  par  défaut
              pour toutes les plate-formes sauf la plate-forme de
              référence  OSF/1,  qui  utilise  le  format   objet
              OSF/rose.   Si  n'importe  lequel des interrupteurs
              -ggdb, -gstabs, ou -gstabs+ est  utilisé,  le  pro­
              gramme   mips-tfile   encapsulera   les   stabs   à
              l'intérieur de MIPS ECOFF.

       -mgas  Générer du code pour l'assembleur  GNU.   C'est  le
              comportement  par  défaut  sur  la  plate-forme  de
              référence OSF/1.

       -mrnames

       -mno-rnames
              L'interrupteur -mrnames dit  de  produire  du  code
              utilisant  les  noms  logiciels  MIPS pour les reg­
              istres, au lieu des noms matériels  (p.ex.,  a0  au
              lieu  de  $4).   L'assembleur  GNU  ne supporte pas
              l'interrupteur -mrnames , et l'assembleur MIPS sera
              informé  de  lancer  le préprocesseur C MIPS sur le
              fichier source.  L'interrupteur -mno-rnames est par
              défaut.

       -mgpopt

       -mno-gpopt
              L'interrupteur  -mgpopt  dit  d'écrire  toutes  les
              déclarations de données avant les instructions dans
              la  section  de  texte  pour  que l'assembleur MIPS
              génère des références  d'un  mot  mémoire  au  lieu
              d'utiliser  deux  mots  pour les courts éléments de
              données globaux ou statiques.  C'est  le  comporte­
              ment  par  défaut  uniquement si l'optimisation est
              sélectionnée.
       -mstats

       -mno-stats
              Pour chaque fonction non en ligne traitée, l'inter­
              rupteur -mstats oblige le compilateur à émettre une
              ligne dans le fichier standard d'erreurs  pour  im­
              primer des statistiques sur le programme (nombre de
              registres sauvegardés, taille de la pile, etc.).

       -mmemcpy

       -mno-memcpy
              L'interrupteur -mmemcpy fait  appeler  à  tous  les
              déplacements  de  blocs  la  fonction de chaînes de
              caractères appropriée (memcpy ou bcopy) au lieu  de
              générer éventuellement du code en ligne.

       -mmips-tfile

       -mno-mips-tfile
              L'interrupteur  -mno-mips-tfile  oblige le compila­
              teur à ne pas post-traiter le fichier objet avec le
              programme  mips-tfile  après  que l'assembleur MIPS
              l'ait généré pour ajouter un support au  déboggage.
              Si  mips-tfile  n'est pas lancé, alors aucune vari­
              able locale ne sera accessible  au  déboggeur.   En
              plus,  les objets stage2 et stage3 verront les noms
              des fichiers temporaires passés à l'assembleur  en­
              castrés  dans le fichier objet, ce qui signifie que
              les objets  ne  seront  pas  comparés  comme  étant
              égaux.

       -msoft-float
              Générer  une  sortie  contenant  des  appels de li­
              brairie pour les flottants.   AVERTISSEMENT  :  les
              librairies  requises  ne font pas partie de GNU CC.
              Normalement, les facilités du compilateur  C  usuel
              de  cette machine sont utilisées, mais ceci ne peut
              être fait directement en  compilation  multi-plate­
              formes.   Vous devez vous arranger pour fournir les
              fonctions de librairies convenant à la  compilation
              multi-plateformes.

       -mhard-float
              Générer une sortie contenant des instructions flot­
              tantes.  C'est le comportement par défaut  si  vous
              utilisez des sources non modifiées.

       -mfp64 Suppose  que  le  bit FR dans le mot d'état est al­
              lumé, et qu'il y a des  registres  flottants  32/64
              bit,  au  lieu de registres 32/32 bit.  Vous pouvez
              aussi spécifier les  interrupteurs  -mcpu=r4000  et
              -mips3

       -mfp32 Suppose  qu'il  y a des registres 32/32 bit.  C'est
              le comportement par défaut.

       -mabicalls

       -mno-abicalls
              Emettre (ou pas) les  pseudo-opérations  .abicalls,
              .cpload, et .cprestore que certains portages System
              V.4 utilisent pour du code indépendant de la  posi­
              tion.

       -mhalf-pic

       -mno-half-pic
              L'interrupteur  -mhalf-pic  dit de placer les poin­
              teurs vers des références externes dans la  section
              des données et de les charger, plutôt que de placer
              les références dans la section texte.  Cette option
              ne  fonctionne pas pour le moment.  -Gnombre Placer
              les éléments globaux et statiques  plus  petits  ou
              égaux à nombre octets dans les sections des données
              courtes ou dans les sections bss au lieu de la sec­
              tion  de  données ou de bss normale.  Cela permet à
              l'assembleur d'émettre des instructions portant sur
              une  référence d'un mot mémoire basées sur le poin­
              teur global (gp ou $28), au lieu des deux mots nor­
              malement utilisés.  Par défaut, nombre vaut 8 quand
              l'aasembleur MIPS est utilisé, et 0 quand  l'assem­
              bleur GNU est utilisé.  L'interrupteur -Gnombre est
              aussi passé  à  l'assembleur  et  à  l'éditeur  des
              liens.   Tous  les  modules devraient être compilés
              avec la même valeur de -Gnombre

       -nocpp Dit à l'assembleur MIPS de ne pas lancer son propre
              préprocesseur   sur  les  fichiers  assembleurs  de
              l'utilisateur (par un suffixe `.s' ) quand  il  les
              assemble.

       Ces  options  `-m' sont définies pour la famille d'ordina­
       teurs Intel 80386 : -m486

       -mno-486
              Contrôle si le code est ou n'est pas optimisé  pour
              un  486  au  lieu d'un 386.  Le code généré pour un
              486 tournera sur un 386 et inversément.

       -msoft-float
              Générer  une  sortie  contenant  des  appels de li­
              brarire  pour  les  flottants.  Avertissement : les
              librairies requises ne font pas partie de  GNU  CC.
              Normalement,  les  facilités du compilateur C usuel
              de cette machine sont utilisées, mais ceci ne  peut
              être  fait  directement en compilation multi-plate­
              formes.  Vous devez vous arranger pour fournir  les
              fonctions  de librairies convenant à la compilation
              multi-plateformes.  Sur les machines où  une  fonc­
              tion  renvoie  des résultats flottants dans la pile
              de  rsgistres  80384,  quelques  codes  opératoires
              flottants  peuvent être émis même si `-msoft-float'
              est utilisé.

       -mno-fp-ret-in-387
              Ne pas utiliser les registres FPU  (Floating  Point
              Unit  : unité flottante) pour les valeurs de retour
              des fonctions.  La  convention  d'appel  habituelle
              met  les  valeurs de retour des fonctions des types
              float et double dans un registre FPU, même s'il n'y
              a  pas  de  FPU.   L'idée  est que le système d'ex­
              ploitation  devrait  émuler  une   FPU.    L'option
              `-mno-fp-ret-in-387'  oblige  à  renvoyer de telles
              valeurs dans des  registres  CPU  ordinaires  à  la
              place.

       Ces  options  `-m' sont définies pour la famille d'ordina­
       teurs HPPA :

       -mpa-risc-1-0
              Générer du code pour un processeur PA 1.0.

       -mpa-risc-1-1
              Générer du code pour un processeur PA 1.1.

       -mkernel
              Générer du code convenant à l'usage dans  des  noy­
              aux.   Spécifiquement,  éviter les instructions add
              dans lesquelles un des arguments  est  le  registre
              DP; générer des instructions addil à la place.  Ce­
              ci évite un bogue assez  grave  dans  l'éditeur  de
              liens HP-UX.

       -mshared-libs
              Générer  du  code  qui  peut  être lié avec les li­
              brairies partagées HP-UX.  Cette option  n'est  pas
              encore  totalement  fonctionnelle, et n'est pas ac­
              tivée par défaut sur  n'importe  quelle  cible  PA.
              Utiliser  cette option peut faire générer au compi­
              lateur un code incorrect.

       -mno-shared-libs
              Ne pas générer de code qui sera lié  avec  des  li­
              brairies  partagées.   C'est  le  comportement  par
              défaut de toutes les cibles PA.

       -mlong-calls
              Générer du code qui permet d'effectuer des appels à
              des  fonctions  plus  grandes que 256K en dehors de
              l'appelant quand l'appelant et l'appelé  sont  dans
              le même fichier source.  N'activez pas cette option
              à moins que le code refuse d'être lié avec des "er­
              reurs  de  branchement hors de portée" de l'éditeur
              de liens.

       -mdisable-fpregs
              Empêche l'utilisation  de  registres  flottants  de
              quelque manière que ce soit.  C'est nécessaire pour
              compiler des noyaux qui effectuent  la  commutation
              de contexte paresseuse des registres flottants.  Si
              vous utilisez cette option et  essayez  d'effectuer
              des opérations portant sur des flottants, le compi­
              lateur abandonnera la compilation.

       -mdisable-indexing
              Empêche  le  compilateur   d'utiliser   les   modes
              d'adressage    indexés.    Ceci   évite   d'obscurs
              problèmes qui peuvent apparaître lors de la  compi­
              lation de code MIG sous MACH.

       -mtrailing-colon
              Ajoute  un  deux-point ":" à la fin des définitions
              de labels (pour les assembleurs ELF).

       Ces options `-m' sont définies pour la  famille  d'ordina­
       teurs 80960 :

       -mtype_de_processeur
              Suppose  le comportement par défaut pour le type de
              machines type_de_processeur pour  les  instructions
              et   la   disponibilité  et  l'alignement  du  mode
              d'adressage.  Le type_de_processeur par défaut  est
              kb;  les  autres  choix sont ka, mc, ca, cf, sa, et
              sb.

       -mnumerics

       -msoft-float
              L'option -mnumerics indique que le processeur  sup­
              porte   les   instructions   flottantes.   L'option
              -msoft-float indique que l'on ne doit pas  supposer
              que  les instructions flottantes soient supportées.

       -mleaf-procedures

       -mno-leaf-procedures
              Essayer (ou pas) d'altérer les procédures  feuilles
              pour  être  appelables avec l'instruction bal aussi
              bien qu'avec call.  Cela résultera en un code  plus
              efficace  pour  les  appels  explicites quand l'in­
              struction bal peut être substituée par l'assembleur
              ou  l'éditeur de liens, mais du code moins efficace
              dans les autres cas, tels que les  appels  via  des
              pointeurs  de  fonction, ou en utilisant un éditeur
              de liens qui ne supporte pas cette optimisation.
       -mtail-call

       -mno-tail-call
              Faire  (ou  pas)  des  tentatives   supplémentaires
              (au-delà de celles des portions indépendantes de la
              machine du compilateur) pour optimiser  les  appels
              récursifs  terminaux  dans  les branchements.  Vous
              pourriez ne pas vouloir ça car la détection des cas
              où  cela n'est pas valide n'est pas totalement com­
              plète.    Le   comportement    par    défaut    est
              -mno-tail-call.

       -mcomplex-addr

       -mno-complex-addr
              Supposer  (ou  pas)  que  l'utilisation  d'un  mode
              d'adressage complexe est  un  gain  sur  cette  im­
              plémentation  du  i960.  Les modes d'adressage com­
              plexes peuvent ne pas être dignes d'intérêt sur les
              séries  K,  mais elles le sont certainement sur les
              séries C.  Le comportement par défaut est actuelle­
              ment  -mcomplex-addr pour tous les processeurs sauf
              sur les CB et CC.

       -mcode-align

       -mno-code-align
              Aligner (ou pas) le  code  sur  des  limites  de  8
              octets  pour une extraction plus rapide.  Actuelle­
              ment, cette option est activée par  défaut  unique­
              ment sur les implémentations des séries C.

       -mic-compat

       -mic2.0-compat

       -mic3.0-compat
              Permet  la compatibilité avec l'iC960 v2.0 or v3.0.

       -masm-compat

       -mintel-asm
              Permet la compatibilité avec l'assembleur iC960.

       -mstrict-align

       -mno-strict-align
              Ne permet pas (permet) d'accès non-alignés.

       -mold-align
              Permet la compatibilité avec l'alignement de struc­
              tures  de  la  version 1.3 du gcc d'Intel (basé sur
              gcc 1.37).  Actuellement, c'est boggé dans le  sens
              où  l'on  suppose toujours #pragma align 1 , et qui
              ne peut pas être désactivé.

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

       -mno-soft-float

       -msoft-float
              Utiliser   (ou  pas)  les  instructions  flottantes
              matérielles pour les opérations flottantes.   Quand
              -msoft-float   est   spécifié,   les  fonctions  de
              `libgcc1.c' seront  utilisées  pour  effectuer  des
              opérations  flottantes.  A moins qu'elles ne soient
              remplacées  par  des  opérations  qui  émulent  les
              opérations flottantes, où qu'elles soient compilées
              d'une façon telle qu'elles appellent  des  routines
              d'émulation,  ces  routines effectueront des opéra­
              tions flottantes.  Si vous compilez pour  un  Alpha
              sans opérations flottantes, vous devez vous assurer
              que la librairie est construite d'une  façon  telle
              qu'elle  ne  les  appelle  pas.   Notez que des im­
              plémentations Alpha sans opérations flottantes sont
              requises pour avoir des registres flottants.

       -mfp-reg

       -mno-fp-regs
              Générer  du  code  qui  utilise (ou pas) l'ensemble
              d'instructions flottantes.   -mno-fp-regs  implique
              -msoft-float.   Si  l'ensemble d'instructions flot­
              tantes n'est pas utilisé, les opérandes  flottantes
              sont passées à des registres entiers comme si elles
              étaient des entiers  et  les  résultats  flottantes
              sont  passés  à  $0  au  lieu  de  $f0.   C'est une
              séquence d'appel non standard; ainsi,  toute  fonc­
              tion avec un argument ou une valeur de retour flot­
              tant(e) appelée par du code compilé  avec  -mno-fp-
              regs  doit  aussi  être compilée avec cette option.
              Une utilisation typique de cette option est de con­
              struire  un  noyau  qui  n'utilise pas de registres
              flottants, et donc n'a pas besoin de les sauver  ou
              de les restaurer.

       Ces  options  supplémentaires sont disponible sur System V
       Release 4 pour assurer la compatibilité avec d'autres com­
       pilateurs sur ces systèmes :

       -G     Sur  les  systèmes  SVr4, gcc accepte l'option `-G'
              (et la transmet à l'éditeur de liens  du  système),
              pour  assurer la compatibilité avec d'autres compi­
              lateurs.  Néanmoins, nous suggérons que vous  util­
              isiez `-symbolic' ou `-shared' de façon appropriée,
              au lieu de fournir des options d'édition  de  liens
              sur la ligne de commande gcc
       -Qy    Identifie la version de chaque outil utilisé par le
              compilateur, dans une directive  assembleur  .ident
              dans la sortie.

       -Qn    S'abstenir  d'ajouter des directives .ident dans le
              fichier  de  sortie  (c'est  le  comportement   par
              défaut).

       -YP,répertoires
              Rechercher  dans  les  répertoires  répertoires, et
              dans aucun autre, les  librairies  spécifiées  avec
              `-l'.   Vous  pouvez séparer les entrées des réper­
              toires dans répertoires par des deux-points.

       -Ym,répertoire
              Recherche dans le répertoire répertoire pour  trou­
              ver  le  préprocesseur  M4.   L'assembleur  utilise
              cette option.
       Ces options indépendantes de  la  machine  contrôlent  les
       conventions  d'interfaces  utilisées dans la génération de
       code.

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

       -fnonnull-objects
              Suppose  que les objets atteints par des références
              sont non null (C++ uniquement).   Normalement,  GNU
              C++  fait des suppositions prudentes sur les objets
              atteints par des références.  Par exemple, le  com­
              pilateur doit vérifier que a n'est pas null dans du
              code comme le suivant : obj &a =  g  ();  a.f  (2);
              Vérifier  des références de ce type demande du code
              supplémentaire, et n'est  pas  nécessaire  pour  de
              nombreux    programmes.    Vous   pouvez   utiliser
              `-fnonnull-objects' pour omettre les  vérifications
              pour  null,  si  votre programme ne requiert pas de
              vérification.

       -fpcc-struct-return
              Utiliser la  même  convention  pour  retourner  des
              valeurs  de  type struct et union que celle qui est
              utilisée par le compilateur C  habituel  sur  votre
              système.   Cette convention est moins efficace pour
              les petites structures  et,  sur  beaucoup  de  ma­
              chines,  elle  n'est  pas  réentrante;  mais elle a
              l'avantage de permettre  l'interappelabilité  entre
              du  code  compilé  avec GCC et du code compilé avec
              PCC.

       -freg-struct-return
              Utiliser la convention  que  les  valeurs  de  type
              struct  et union sont retournées dans des registres
              si c'est possible.  C'est plus  efficace  pour  les
              petites  structures  que  -fpcc-struct-return.   Si
              vous  ne  spécifiez   ni   -fpcc-struct-return   ni
              -freg-struct-return,  GNU  CC  se comporte comme la
              convention standard par défaut sur la cible.   S'il
              n'y  a  pas de convention standard, le comportement
              par défaut de GNU CC est -fpcc-struct-return.

       -fshort-enums
              Alloue à un type enum uniquement le nombre d'octets
              dont  il  a besoin pour son rang déclaré de valeurs
              possibles.   Spécifiquement,  le  type  enum   sera
              équivalent  au  plus petit type entier suffisamment
              grand pour supporter les valeurs de ce type.

       -fshort-double
              Utiliser la même taille pour double que pour  float
              .

       -fshared-data
              Requiert que les données et les variables non-const
              de cette compilation soient  partagées  plutôt  que
              d'être  des données privées.  La distinction n'a de
              sens que dans certains systèmes d'exploitation,  où
              les données partagées sont partagées entre des pro­
              cessus exécutant le même programme, alors  que  les
              données privées existent avec une copie par proces­
              sus.

       -fno-common
              Alloue même les variables globales non initialisées
              dans la section bss du fichier objet, plutôt que de
              les générer comme des blocs communs.  Ceci  a  pour
              effet  que  si  la même variable est déclarée (sans
              extern) dans deux  différentes  compilations,  vous
              aurez  une erreur quand vous essayerez de les lier.
              La seule raison pour que ceci  soit  utile  est  de
              vouloir  vérifier que le programme pourrait tourner
              sur d'autres systèmes qui travaillent  toujours  de
              cette façon.

       -fno-ident
              Ignore la directive `#ident'.

       -fno-gnu-linker
              Ne  pas  sortir  les initialisations globales (tels
              que les constructeurs et destructeurs C++) dans  la
              forme  utilisée par l'éditeur de liens GNU (sur les
              sytèmes où l'éditeur de liens GNU  est  la  méthode
              standard  pour les traiter).  Utilisez cette option
              quand vous voulez utiliser un éditeur de liens  non
              GNU,  qui  requiert également le programme collect2
              pour être sûr que l'éditeur des  liens  du  système
              inclue   des  constructeurs  et  des  destructeurs.
              (collect2 est inclus dans la distribution GNU  CC.)
              Pour  les sytèmes qui doivent utiliser collect2, le
              pilote du compilateur gcc est configuré pour  faire
              cela automatiquement.

       -finhibit-size-directive
              Ne  pas produire de directive assembleur .size , ou
              quoi que ce soit d'autre qui causerait  des  ennuis
              si  la  fonction était coupée en son milieu, et que
              les deux moitiés étaient placées dans des  emplace­
              ments  fortement  séparés en mémoire.  Cette option
              est utilisés quand on compile `crtstuff.c'; vous ne
              devriez  pas  l'utiliser  pour  quoi  que  ce  soit
              d'autre.

       -fverbose-asm
              Ajouter des commentaires  supplémentaires  au  code
              assembleur  généré  pour  le  rendre  plus lisible.
              Cette option n'est généralement utile qu'à ceux qui
              ont  réellement  besoin  de lire le code assembleur
              généré (peut-être pendant le déboggage du  compila­
              teur lui-même).

       -fvolatile
              Considère  toutes les références mémoires à travers
              des pointeurs comme étant volatiles.

       -fvolatile-global
              Considère toutes  les  références  mémoires  à  des
              éléments de données globales comme étant volatiles.

       -fpic  Si supporté par la machine cible, générer  du  code
              indépendant  de la position, convenant à l'utilisa­
              tion dans une librairie partagée.

       -fPIC  Si supporté par la machine cible, générer  du  code
              indépendant de la position, convenant à une édition
              de liens dynamique, et ce même si les  branchements
              nécessitent de grands déplacements.

       -ffixed-registre
              Traite  le  registre  nommé registre comme étant un
              registre fixe; le code généré ne devrait jamais  le
              référencer  (sauf peut-être en tant que pointeur de
              pile, pointeur de cadre où dans d'autres rôles bien
              fixés).   registre  doit être le nom d'un registre.
              Les noms de registres acceptés sont  spécifiques  à
              la  machines  et  sont définis dans la macro REGIS­
              TER_NAMES dans le fichier de macros de descriptions
              de  la  machine.   Ce  drapeau  n'a  pas  de  forme
              négative, car il spécifie un triple choix.

       -fcall-used-registre
              Traite le registre nommé registre en tant que  reg­
              istre  allouable  qui  est  écrasé lors d'appels de
              fonctions.  Il peut être alloué pour des  variables
              temporaires ou des variables qui ne survivent pas à
              un appel.  Les fonctions compilées de  cette  façon
              ne  sauveront  ni  ne restaureront le registre reg­
              istre.  L'utilisation de ce drapeau  pour  un  reg­
              istre qui a un rôle déterminant fixé dans le modèle
              d'exécution de la machine, tel que le  pointeur  de
              pile  ou  le pointeur de cadre, produira des résul­
              tats désastreux.   Ce  drapeau  n'a  pas  de  forme
              négative car il spécifie un choix triple.

       -fcall-saved-registre
              Traite le registre nommé registre comme un registre
              allouable sauvé par des fonctions.   Il  peut  être
              alloué  même  pour des variables temporaires ou des
              variables qui survivent à un appel.  Les  fonctions
              compilées  de cette façon sauveront et restaureront
              le registre registre si elles l'utilisent.  L'util­
              isation  de  ce  drapeau  pour un registre qui a un
              role déterminant fixé dans le modèle d'exécution de
              la machine, tel que le pointeur de pile ou le poin­
              teur de cadre, produira des  résultats  désastreux.
              Une autre sorte de désastre résultera de l'utilisa­
              tion de ce drapeau pour un registre dans lequel des
              valeurs  de  retour  de  fonctions peuvent être re­
              tournées.  Ce drapeau n'a pas de forme négative car
              il spécifie un choix triple.

PRAGMAS
       Deux  directives  `#pragma'  sont  supportées par GNU C++,
       pour permettre d'utiliser le même fichier d'entête à  deux
       fins  différentes  :  en  tant que définition d'interfaces
       d'une classe d'un objet donné, et en tant définition  com­
       plète du contenu de cette classe d'objets.

       #pragma interface
              (C++  uniquement.)   Utilisez  cette directive dans
              des fichiers d'entête qui définissent  des  classes
              d'objets, pour épargner de l'espace dans la plupart
              des fichiers  objets  qui  utilisent  ces  classes.
              Normalement, les copies locales de certaines infor­
              mations (copies de sauvegarde de fonctions  membres
              en  ligne,  information de déboggage, et les tables
              internes qui implémentent les fonctions virtuelles)
              doivent  être  conservées dans chaque fichier objet
              qui inclut des définitions de  classes.   Quand  un
              fichier  d'entête contenant `#pragma interface' est
              inclus lors d'une  compilation,  cette  information
              auxiliaire  ne  sera  pas  générée  (à moins que le
              fichier source d'entrée utilise  lui-même  `#pragma
              implementation').   Au lieu de ça, les fichiers ob­
              jets  contiendront  des   références   qui   seront
              résolues au moment de l'édition des liens.

       #pragma implementation

       #pragma implementation "objets.h"
              (C++  uniquement.)   Utilisez  ce  pragma  dans  un
              fichier d'entrée principal, quand vous  voulez  une
              sortie  complète  des  fichiers d'entête inclus qui
              vont être générés (et rendus visibles globalement).
              Le  fichier  d'entête  inclus,  à son tour, devrait
              utiliser `#pragma interface'.  Les copies de sauve­
              garde  de  fonction membres en ligne, l'information
              de déboggage, et les tables internes utilisées pour
              implémenter  les  fonctions  virtuelles sont toutes
              générées dans des  fichiers  d'implémentation.   Si
              vous  utilisez  `#pragma implementation' sans argu­
              ment, il s'applique à un fichier inclu avec le même
              nom  de base que votre fichier source; par exemple,
              dans `allclass.cc',  `#pragma  implementation'  par
              lui-même  est  équivalent à `#pragma implementation
              "allclass.h"'.  Utilisez l'argument chaîne de  car­
              actères  si  vous  voulez  un  simple fichier d'im­
              plémentation pour  inclure  du  code  de  multiples
              fichiers  d'entête.   Il  n'y  a  aucune manière de
              découper le contenu d'un simple fichier d'entête en
              de multiples fichiers d'implémentation.

FICHIERS
       file.c             fichier source C
       file.h             fichier d'entête C (du préprocesseur)
       file.i             fichier source C prétraité
       file.C             fichier source C++
       file.cc            fichier source C++
       file.cxx           fichier source C++
       file.m             fichier source Objective-C
       file.s             fichier en langage assembleur
       file.o             fichier objet
       a.out              sortie liée
       TMPDIR/cc*         fichiers temporaires
       LIBDIR/cpp         préprocesseur
       LIBDIR/cc1         compilateur pour C
       LIBDIR/cc1plus     compilateur pour C
       LIBDIR/collect     frontal pour l'éditeur de liens, nécessaire sur certaines machines
       LIBDIR/libgcc.a    librairie de sous-routines GCC
       /lib/crt[01n].o    routine de démarrage
       LIBDIR/ccrt0       routine de démarrage additionnelle pour le C++
       /lib/libc.a        librairie C standard, voir
       intro(3)
       /usr/include       répertoire standard pour les fichiers #include
       LIBDIR/include     répertoire gcc standard pour les fichiers #include
       LIBDIR/g++-include répertoire g++ additionnel pour #include
       LIBDIR  est habituellement /usr/local/lib/machine/version.
       TMPDIR vient de la variable  d'environnement  TMPDIR  (par
       défaut /usr/tmp si disponible, /tmp sinon).

VOIR AUSSI
       cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
       `gcc', `cpp', `as', `ld', and `gdb' entries in info.
       Using  and  Porting  GNU  CC (for version 2.0), Richard M.
       Stallman; The C Preprocessor, Richard M. Stallman;  Debug­
       ging  with  GDB: the GNU Source-Level Debugger, Richard M.
       Stallman et Roland H. Pesch; Using as: the GNU  Assembler,
       Dean  Elsner,  Jay Fenlason & friends; ld: the GNU linker,
       Steve Chamberlain et Roland Pesch.

BUGS
       Pour des instructions sur comment  rapporter  des  bogues,
       voyez le manuel de GCC.

COPYING
       Copyright  1991, 1992, 1993 Free Software Foundation, Inc.

       L'autorisation est donnée de créer et  de  distribuer  des
       copies  textuelles de ce manuel, à condition que la notice
       de copyright et la notice de permission soient  préservées
       dans toutes les copies.

       L'autorisation est donnée de copier et distribuer des ver­
       sions modifiées de ce manuel sous les conditions de  copie
       textuelle,  à  condition que l'entièreté du travail dérivé
       résultant soit distribuée sous les termes d'une  autorisa­
       tion identique à celle-ci.

       L'autorisation est donnée de copier et distribuer des tra­
       ductions de ce manuel dans n'importe  quel  autre  langue,
       sous les conditions ci-dessus pour les versions modifiées,
       sauf que cette notice de permission peut être incluse dans
       des traductions approuvées par la Free Software Foundation
       au lieu de l'anglais originel.

AUTEURS
       Voyez le Manuel GNU CC pour connaître  les  collaborateurs
       de GNU CC.

TRADUCTION
       Frédéric Delanoy, 2000.

 

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *