gcc

Nom

Synopsis

Avertissement

Cette page de manuel n'est pas tenue à jour à moins que des volontaires ne veuillent la maintenir. Si vous trouvez une contradiction entre la page de manuel et le programme, 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 à partir du fichier source Texinfo gcc.texinfo.

Description

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

.o    Fichier objet
.a    Fichier archive

Options

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 comportement 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étraitement, 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 objet à 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'assemblage) avec l'option -c.

-S

S'arrêter après l'étape de la compilation proprement dite; ne pas assembler. La sortie est un fichier de code assembleur pour chaque fichier d'entrée non assembleur spécifié. Par défaut, GCC crée le nom du fichier assembleur à partir du fichier source en remplaçant le suffixe `.c', `.i', etc., par `.s'. Utilisez -o pour sélectionner un autre nom. GCC ignore tout fichier d'entrée ne requé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'entré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 commandes exécutées pour lancer les étapes de la compilation. Imprimer également le numéro de version du programme pilote du compilateur, du préprocesseur et du compilateur proprements dits.

-pipe

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

Options De Langage

-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 identificateurs. Les mots-clés alternatifs __asm__, __extension__, __inline__ et __typeof__ continuent à fonctionner malgré `-ansi'. Vous ne voudriez naturellemnt 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 incluent _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éclarations 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éclaration 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 compilateurs C traditionnels. Pour les détails, voyez le manuel GNU C; la liste dupliquée ici a été supprimé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éprocesseurs 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 identificateurs (C++ uniquement). Vous pouvez également utiliser `-fno-dollars-in-identifiers' pour interdire explicitement l'usage de `$'. (Le C++ GNU autorise `$' 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 arranger pour que les instanciations nécessaires apparaî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 instanciations de templates sont explicitement internes.

-fall-virtual

Traite tous les fonctions membres possible en tant que fonctions virtuelles implicitement. Toutes les fonctions membres (excepté les fonctions constructeurs 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 circonstances, le compilateur peut déterminer qu'un appel à une fonction virtuelle donnée peut être fait directement; dans ce cas, les appels sont directs.

-fcond-mismatch

Autorise les expressions conditionnelles avec de mauvais types dans les deuxième et troisième arguments. 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'affectation 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é descendante, 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 inverse, vous permettent de créer un programme qui fonctionne avec le comportement opposé par défaut. Le type char est toujours un type distinct de signed char et unsigned char, même si son comportement est toujours celui d'un de ces deux là.

-fsigned-char

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éanmoins, 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 caractè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 !

Options Du Preprocesseur

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 fichier 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 principale. Le préprocesseur évalue n'importe quelle option `-D' et `-U' présente sur la ligne de commandes 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épertoires 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'instructions `#line'. Utilisé avec l'option `-E'.

-M  [ -MG ]

Dire au préprocessuer de générer une règle convenant à 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 inclus 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 programme C prétraité. `-M' implique `-E'. `-MG' informe 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 `#include "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 compiler les fichiers comme spécifié--`-MD' n'interdit pas la compilation ordinaire comme `-M' le fait. L'utilitaire Mach `md' peut être utilisé pour fusionner 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 conditionnelle du préprocesseur telle que `#if #question(réponse)'. `-A-' désactive les assertions standards qui décrivent normalement la machine 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 options `-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éfinitions 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 multiple options aux emplacements des virgules.

Options De L'editeur De 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 objets 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épertoires, librairie qui est en fait un fichier s'appelant `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 objets. L'éditeur de liens manipule un fichier archive en l'examinant pour trouver les membres qui ont déjà été référencés mais pas encore définis. Néanmoins, si l'éditeur de liens trouve un fichier objet ordinaire au lieu d'une librairie, le fichier objet est lié de la façon habituelle. La seule différence entre utiliser l'option `-l' et spécifier un nom de fichier est que `-l' entoure librairie avec `lib' et `.a' et cherche dans plusieurs répertoires.

-lobjc

Vous avez besoin de ce cas particulier de l'option -l afin d'effectuer l'édition des liens d'un programme 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 dynamique, 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 construisant 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 argument, vous devez utiliser `-Xlinker' deux fois, la première pour l'option et la seconde pour l'argument. Par exemple, pour passer ` -assert definitions', vous devez écrire ` -Xlinker -assert -Xlinker definitions'. Cela ne fonctionne pas d'écrire ` -Xlinker "-assert definitions"', car cela passe la chaîne de caractères entière comme un seul argument, ce qui n'est pas à quoi s'attend l'éditeur 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 librairies pour le définir. Vous pouvez utiliser `-u' de multiples fois avec différents symboles pour forcer le chargement de modules additionnels de librairies.

Options De Repertoires

-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 compilateur lui-même. Le programme pilote du compilateur 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 pilote 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écessaire. Vous pouvez obtenir un résultat similaire àgrâce à la variable d'environnement GCC_EXEC_PREFIX; 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.

Options D'avertissements

-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'utilisation de #import.

-pedantic

Fournit tous les avertissement demandés par le standard ANSI C strict ; rejette tous les programmes 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 requierrent `-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éanmoins, seuls les fichiers d'entête du système devraient utiliser ces sorties de secours; les programmes d'application devraient les éviter.

-pedantic-errors

Comme `-pedantic', sauf que des erreurs sont produites plutôt que des avertissements.

-W

Imprime des messages d'avertissement supplémentaires 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 considéré comme ne retourner aucune valeur.) Par exemple, cette fonction engendrerait un tel avertissement :

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 reviendront 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-declaration.

-Wmain

Avertir si la fonction main est déclarée ou définie avec un type suspect. Typiquement, c'est une fonction 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 inutilisé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é explicitement.

-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 avertissement de se produire.) Les labels case en dehors 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 rencontré (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 optimisante, 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'avertissement au sujet d'une variable qui est utilisée uniquement pour calculer une valeur qui n'est elle-même jamais utilisée, car de tels calculs peuvent être supprimés par l'analyse du flux de données avant que les avertissements ne soient affichés. Ces avertissements ont été 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 erreur. 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 initialisé. Certains avertissements intempestifs peuvent être évités si vous déclarez volatile toutes les fonctions que vous utilisez et qui ne retournent jamais à leur appelant.

-Wparentheses

Avertir si des parenthèses sont omises dans certains 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 comportent 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 traditionnel, mais font partie intégrante de la constante en C ANSI.

   ·

Une fonction déclarée externe dans un bloc et ensuite 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 distincts sont identiques dans les premiers len caractères. Ceci peut vous aider à préparer un programme qui pourra être compilé dans certains compilateurs 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 entiers 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 moment 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 utilisant const dans les déclarations et les prototypes. Sinon, cela ne pourrait qu'être nuisible; voilà pourquoi nous n'avons pas inclu ces avertissements 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 promotion 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éfinition de fonction écrite dans l'ancien style est permise sans avertissement si elle est précédée par une déclaration qui spécifie le type des arguments.)

-Wmissing-prototypes

Avertir si une fonction globale est définie sans déclaration de prototype préalable. Cet avertissement 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 correspondre à la signature des types d'une fonction virtuelle déclarée dans la classe de base. Utilisez cette option pour requérir des avertissements 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 avertissemnt.

Options De Deboggage

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 format natif du système d'exploitation (stabs, COFF, XCOFF, ou DWARF). GDB peut travailler avec ces informations de déboggage. Sur la plupart des systèmes utilisant le format stabs, `-g' active l'utilisation d'informations de déboggage supplémentaires que seul GDB peut utiliser ; ces informations 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 programmes 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 format natif (s'il est supporté) incluant les extensions GDB si c'est possible.

-gstabs

Produire des informations de déboggage dans le format 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 format stabs (s'il est supporté), en utilisant les extensions 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 format COFF (s'il est supporté). C'est le format utilisé par SDB sur la plupart des systèmes System V antérieurs à System V Release 4.

-gxcoff

Produire des informations de déboggage dans le format 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 format XCOFF (s'il est supporté), en utilisant les extensions 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 format 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 format DWARF (s'il est supporté), en utilisant les extensions 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'information requis. Le niveau par défaut est 2. Le niveau 1 produit une information minimale, suffisante 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 descriptions 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 informations 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 pourrait ê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 profilage 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 activé. 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 exclue 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 signification 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 compilateur. 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 compiler. 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 retardé, 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 commentaire 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 format de flottants que la machine hôte. Ceci provoque une sortie incorrecte des constantes flottantes réelles, mais la séquence réelle d'instructions 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' produirait les fichiers `foo.cpp' et `foo.s', aussi bien que `foo.o'.

-print-file-name=librairie

Imprimer le nom de fichier absolu complet du fichier 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 programme tel que `cpp'.

Options D'optimisation

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 permettre au déboggage de produire les résultats escomptés. Les instructions sont indépendantes : si vous stoppez le programme avec un point d'arrêt entre des instructions, vous pouvez attribuer une nouvelle valeur à n'importe quelle variable ou modifier l'indicateur d'instruction courante (program counter) pour le faire pointer vers n'importe quelle autre instruction 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 produit 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 activées. Sur les machines ayant des tranches de temps retardées (delay slot), l'option `-fdelayed-branch' est désactivée. Pour ces machines 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 optimisations supportées qui n'impliquent pas un compromis 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 compilation 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 drapeaux dépendants de la machine. La plupart des drapeaux ont à la fois les formes positive et négative; la forme négative de `-ffoo' serait`-fno-foo'. 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 programmes 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 rapidement (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 conversions de type doivent être faites); et (3) vérifier la visibilité de la fonction membre par l'appelant. Tout ceci s'ajoute pour ralentir la compilation. Normalement, la seconde fois qu'un appel est fait vers cette fonction membre (ou qu'un membre 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. Malheureusemnt, 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écution. `-fmemoize-lookups' active le cache logiciel. 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 à compiler, 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++ uniquement).

-fno-defer-pop

Toujours dépiler les arguments de chaque appel de fonction dès que la fonction se termine. Pour les machines qui doivent dépiler les arguments après un appel de fonction, le compilateur laisse normalement les arguments s'accumuler sur la pile pour plusieurs appels de fonctions, et les dépile tous en une 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 communes. Quand elles ne sont pas des sous-expressions communes, la combinaison d'instructions devrait éliminer le chargement séparé dans des registres.

-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 produire 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 heuristiquement quelles fonctions sont suffisamment simples pour valoir la peine d'être intégrées de cette façon. Si tous les appels à une fonction donnée sont intégrés, et si la fonction est déclarée static, alors 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 registres qui seront écrasés lors d'appels de fonction, 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 machines, celles qui n'ont d'habitude pas de registres 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 registres; 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 programmes 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 optimisations 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ération.

-fthread-jumps

Effectuer des optimisations où l'on vérifie si un saut se branche vers un emplacement où une autre comparaison englobée par la première est trouvée. Si c'est le cas, le premier branchement est redirigé soit vers la destination du second branchement, soit sur le point le suivant immédiatement, 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 simple instruction if sans clause else, `-fcse-skip-blocks' oblige CSE à suivre le saut autour du corps du if.

-frerun-cse-after-loop

Relancer l'élimination des sous-expressions communes après que les optimisations de boucles aient été effectuées.

-felide-constructors

Elider les constructeurs quand cela semble plausible (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 temporaire; 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 fonctionner votre programme différemment, puique certains 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éordonner les instructions pour exploiter des slots d'instruction disponibles après des instructions de branchement différé.

-fschedule-insns

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

-fschedule-insns2

Similaire à `-fschedule-insns', mais requiert une passe supplémentaire d'ordonnancement des instructions après que l'allocation registre ait été effectuée. Ceci est spécialement utile sur des machine avec un nombre de registres relativement petit 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-plateformes, 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 installé GNU CC en tant que compilateur multi-plateformes. La valeur à utiliser pour machine est la même que celle spécifiée au moment de la configuration de GNU CC comme un compilateur multi-plateformes. Par exemple, si un compilateur multi-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-plateformes. 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 versions sont installées. Par exemple, version pourrait être `2.0', signifiant exécuter GNU CC version 2.0. La version par défaut, quand vous ne spécifiez 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.

Options Dependantes De La Machine

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 flottant. 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 également des options spéciales additionnelles, d'habitude pour une compatibilité en ligne de commandes avec d'autres compilateurs 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 comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68030.

-m68040

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

-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 librairie 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-plateformes. 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 comportement 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'appelant qui n'a alors pas besoin de dépiler les arguments. 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 compilateur Unix. Aussi, vous devez fournir des prototypes de fonction pour toutes les fonctions qui prennent un nombre variable d'arguments (incluant printf); sinon, du code incorrect sera généré pour les appels à ces fonctions. En plus, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.) L'instruction rtd est supporté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 flottants 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 flottantes. C'est le comportement par défaut.

-mno-fpu

-msoft-float

Générer une sortie contenant les appels de librairie 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 multi-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 sortie 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 fonction.

-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'architecture 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 multiplication 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 instructions 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 SparcStation 1, 2, IPX etc. Avec -msupersparc le compilateur optimise le code pour le processeur SuperSparc, 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 comportement par défaut quand le compilateur est configuré pour un C1.

-mc2

Générer une sortiee pour un C2. C'est le comportement 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 besoin, sauf pour les fonctions avec des listes d'arguments 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 allumé, çà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 supporte 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 comportement 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 registres dans les drapeaux `-f' doivent utiliser les noms normaux en mode utilisateur.

-muser-registers

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

-mstack-check

Insérer un appel à __msp_check après chaque ajustement de pile. C'est souvent utilisé dans le code du noyau.

Ces options -m' sont définies pour les architectures Motorola 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 assembleur 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 symboles 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 particulier, 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 Standard 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 configurations 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 petites en les rendant relatives à r0, qui permet de charger une valeur en utilisant une seule instruction (plutôt que les deux habituelles). Vous contrôlez quelles références de données sont affectées en spécifiant nombre avec cette option. Par exemple, si vous spécifiez `-mshort-data-512', alors les références de données affectées sont celles 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 supplé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 particulier, une instruction de chargement peut s'exécuter avant une instruction de stockage préalable. De tels réordonnancements violent la consistance 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 performance 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'option `-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 extensions du compilateur relatives à System V release 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 configurations 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'évolution du langage C, et sont souvent la source de problèmes de portabilité. Par défaut, GCC ne produit 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 arguments flottants. C'est le comportement par défaut.

-mhc-struct-return

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

-mnohc-struct-return

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

Ces options `-m' sont définies pour la famille d'ordinateurs 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 approprié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'ensemble 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éboggage 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 programme 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 registres, 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 comportement par défaut uniquement si l'optimisation est sélectionnée.

-mstats

-mno-stats

Pour chaque fonction non en ligne traitée, l'interrupteur -mstats oblige le compilateur à émettre une ligne dans le fichier standard d'erreurs pour imprimer 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 compilateur à 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 variable locale ne sera accessible au déboggeur. En plus, les objets stage2 et stage3 verront les noms des fichiers temporaires passés à l'assembleur encastré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 librairie 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-plateformes. 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 flottantes. 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 allumé, 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 position.

-mhalf-pic

-mno-half-pic

L'interrupteur -mhalf-pic dit de placer les pointeurs 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 section 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 pointeur global (gp ou $28), au lieu des deux mots normalement utilisés. Par défaut, nombre vaut 8 quand l'aasembleur MIPS est utilisé, et 0 quand l'assembleur 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'ordinateurs 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 librarire 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-plateformes. Vous devez vous arranger pour fournir les fonctions de librairies convenant à la compilation multi-plateformes. Sur les machines où une fonction 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'exploitation 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'ordinateurs 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 noyaux. Spécifiquement, éviter les instructions add dans lesquelles un des arguments est le registre DP; générer des instructions addil à la place. Ceci é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 librairies partagées HP-UX. Cette option n'est pas encore totalement fonctionnelle, et n'est pas activée par défaut sur n'importe quelle cible PA. Utiliser cette option peut faire générer au compilateur un code incorrect.

-mno-shared-libs

Ne pas générer de code qui sera lié avec des librairies 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 `erreurs 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 compilateur 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 compilation 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'ordinateurs 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 supporte 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'instruction 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 complè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 implémentation du i960. Les modes d'adressage complexes 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 actuellement -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. Actuellement, cette option est activée par défaut uniquement 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 structures 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érations 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 implémentations Alpha sans opérations flottantes sont requises pour avoir des registres flottants.

-mfp-reg

-mno-fp-regs

Générer du code qui utilise (ou pas) l'ensemble d'instructions flottantes. -mno-fp-regs implique -msoft-float. Si l'ensemble d'instructions flottantes 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 fonction avec un argument ou une valeur de retour flottant(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 construire 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 compilateurs 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 compilateurs. Néanmoins, nous suggérons que vous utilisiez `-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épertoires dans répertoires par des deux-points.

-Ym,répertoire

Recherche dans le répertoire répertoire pour trouver le préprocesseur M4. L'assembleur utilise cette option.

Options De Generation De Code

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 compilateur 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 machines, 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 processus exécutant le même programme, alors que les données privées existent avec une copie par processus.

-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 emplacements 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 compilateur 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'utilisation 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 REGISTER_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 registre 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 registre. L'utilisation de ce drapeau pour un registre 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ésultats 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'utilisation 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 pointeur de cadre, produira des résultats désastreux. Une autre sorte de désastre résultera de l'utilisation de ce drapeau pour un registre dans lequel des valeurs de retour de fonctions peuvent être retournées. Ce drapeau n'a pas de forme négative car il spécifie un choix triple.

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 complè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 informations (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 objets 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 sauvegarde 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 argument, 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 caractères si vous voulez un simple fichier d'implé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) ,