AnglaisFrançaisAllemandItalienPortugaisRusseEspagnol

Icône de favori OnWorks

mips-linux-gnu-gfortran - En ligne dans le Cloud

Exécutez mips-linux-gnu-gfortran dans le fournisseur d'hébergement gratuit OnWorks sur Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS

Il s'agit de la commande mips-linux-gnu-gfortran qui peut être exécutée dans le fournisseur d'hébergement gratuit OnWorks en utilisant l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS

PROGRAMME:

PRÉNOM


gfortran - compilateur GNU Fortran

SYNOPSIS


gfortran [-c|-S|-E]
[-g] [-pg] [-Oniveau]
[-Wprévenir...] [-pédant]
[-Idir...] [-Ldir...]
[-Dmacro[=défn]...] [-Umacro]
[-foption...]
[-moption-machine...]
[-o fichier de sortie] dans le fichier...

Seules les options les plus utiles sont répertoriées ici ; voir ci-dessous pour le reste.

DESCRIPTION


La Gfortran La commande prend en charge toutes les options prises en charge par le gcc commander. Seules les options
spécifiques à GNU Fortran sont documentés ici.

Toutes les options GCC et GNU Fortran sont acceptées à la fois par Gfortran et par gcc (ainsi que tout
d'autres pilotes construits en même temps, tels que g ++), depuis l'ajout de GNU Fortran au GCC
distribution permet l'acceptation des options GNU Fortran par tous les pilotes concernés.

Dans certains cas, les options ont des formes positives et négatives ; la forme négative de -ffou pourra
be -fno-foo. Ce manuel documente un seul de ces deux formulaires, celui qui n'est pas le
défaut.

OPTIONS


Voici un récapitulatif de toutes les options spécifiques à GNU Fortran, regroupées par type.
Les explications se trouvent dans les sections suivantes.

Fortran Langue Options :
-chute-intrinsèque -fbackslash -fcray-pointeur -fd-lines-as-code -fd-lines-as-commentaires
-fdefault-double-8 -fdefault-entier-8 -fdefault-réel-8 -fdollar-ok
-longueur-de-ligne-fixe-n -fixed-line-length-aucun -flibre-forme -flibre-ligne-longueur-n
-ffree-line-length-aucun -fimplicite-aucun -finteger-4-entier-8 -fmax-identifiant-longueur
-fmodule-privé -forme-fixe -fno-range-check -fopenacc -fopenmp -fral-4-real-10
-fral-4-real-16 -fral-4-real-8 -fral-8-real-10 -fral-8-real-16 -fral-8-real-4
-std=std

Prétraitement Options :
-UNE-question[=répondre] -Aquestion=répondre -C -CC -Dmacro[=défn] -H -P -Umacro -cpp -dD
-dI -dM -dN -dU -frépertoire-de-travail -imultilib dir -ipréfixe filet -Je cite -isysroot dir
-isystem dir -nocpp -nostdinc -undef

Erreur et Attention, Options :
-Waliasing -Mur -Wampersand -Warray-limites -Wc-fixation-type -Wcaractère-troncature
-Wconversion -Wfonction-élimination -Wimplicit-interface -Wimplicit-procédure
-Wintrinsic-ombre -Wuse-sans-seulement -Wintrinsics-std -Troncation Wline
-Wno-align-commons -Wno-onglets -Wreal-q-constante -Wsurprenant -Wunderflow
-Wunused-paramètre -Wrealloc-lhs -Wrealloc-lhs-all - Durée de vie cible -fmax-erreurs=n
-fsyntaxe-seulement -pédant -pédant-erreurs

Débogage Options :
-fbacktrace -fdump-fortran-optimisé -fdump-fortran-original -fdump-parse-tree
-ffpe-piège=liste -ffpe-résumé=liste

Directory Options :
-Idir -Jdir -chemin-modules-fintrinsique dir

Lien Options :
-statique-libgfortran

Runtime Options :
-fconvert=Conversion -fmax-sous-enregistrement-longueur=longueur -frecord-marqueur=longueur -fsign-zéro

Code Génération Options :
-fagressif-fonction-élimination -fblas-matmul-limit=n -fbounds-check
-fcheck-tableau-temporaires -fcheck=
-fcoarray= -fexternal-blas -ff2c -ffrontend-optimiser
-finit-caractère=n -finit-entier=n -finit-local-zéro -finit-logique=
-finit-réel= -fmax-array-constructor=n -fmax-stack-var-size=n
-fno-align-commons -fno-automatique -fno-protect-parens -fno-soulignement
-fsecond-trait de soulignement -fpack-dérivé -fralloc-lhs -frecursif -frepack-tableaux
-fshort-enums -fstack-tableaux

Options : contrôle Fortran dialecte
Les options suivantes contrôlent les détails du dialecte Fortran accepté par le compilateur :

-flibre-forme
-forme-fixe
Spécifiez la mise en page utilisée par le fichier source. La mise en page de forme libre a été introduite dans
Fortran 90. La forme fixe était traditionnellement utilisée dans les anciens programmes Fortran. Lorsque
aucune option n'est spécifiée, la forme source est déterminée par l'extension de fichier.

-chute-intrinsèque
Cette option fait en sorte que toutes les procédures intrinsèques (y compris les extensions spécifiques à GNU)
être accepté. Cela peut être utile avec -std=f95 forcer la conformité aux normes mais obtenir
accès à la gamme complète d'intrinsèques disponibles avec Gfortran. En conséquence,
-Wintrinsics-std sera ignoré et aucune procédure définie par l'utilisateur avec le même nom que
tout intrinsèque sera appelé sauf s'il est explicitement déclaré "EXTERNE".

-fd-lines-as-code
-fd-lines-as-commentaires
Activer un traitement spécial pour les lignes commençant par "d" ou "D" dans les sources de forme fixe.
Si la -fd-lines-as-code option est donnée, ils sont traités comme si la première colonne
contenait un blanc. Si la -fd-lines-as-commentaires option est donnée, ils sont traités comme
lignes de commentaires.

-fdollar-ok
Autoriser $ en tant que caractère non-premier valide dans un nom de symbole. Symboles commençant par $ est
rejeté car il n'est pas clair quelles règles appliquer au typage implicite comme différent
les fournisseurs appliquent des règles différentes. À l'aide de $ dans les instructions « IMPLICIT » est également rejetée.

-fbackslash
Modifier l'interprétation des barres obliques inverses dans les littéraux de chaîne à partir d'une seule barre oblique inverse
caractère en caractères d'échappement « de style C ». Les combinaisons suivantes sont étendues
"\a", "\b", "\f", "\n", "\r", "\t", "\v", "\\" et "\0" aux caractères ASCII
alerte, retour arrière, retour à la ligne, retour chariot, onglet horizontal, onglet vertical,
barre oblique inverse et NUL, respectivement. De plus, "\x"nn, "\u"nnnn et toi"nnnnnnnn
(où chaque n est un chiffre hexadécimal) sont traduits en caractères Unicode
correspondant aux points de code spécifiés. Toutes les autres combinaisons d'un caractère
précédés de \ ne sont pas développés.

-fmodule-privé
Définissez l'accessibilité par défaut des entités du module sur « PRIVÉ ». Associé à l'utilisation
les entités ne seront accessibles que si elles sont explicitement déclarées comme "PUBLIC".

-longueur-de-ligne-fixe-n
Définir la colonne après laquelle les caractères sont ignorés dans les lignes à forme fixe typiques de la
fichier source, et à travers lequel les espaces sont supposés (comme s'ils étaient remplis à cette longueur) après
les extrémités des lignes courtes de forme fixe.

Valeurs populaires pour n inclure 72 (la norme et la valeur par défaut), 80 (image de la carte) et
132 (correspondant aux options de "source étendue" dans certains compilateurs populaires). n mai
être aussi aucun, ce qui signifie que toute la ligne est significative et que le caractère continu
les constantes n'ont jamais d'espaces implicites ajoutés pour remplir la ligne.
-fixed-line-length-0 signifie la même chose que -fixed-line-length-aucun.

-flibre-ligne-longueur-n
Définir la colonne après laquelle les caractères sont ignorés dans les lignes de forme libre typiques de la source
déposer. La valeur par défaut est 132. n peut être aucun, ce qui signifie que toute la ligne est
significatif. -ffree-line-length-0 signifie la même chose que -ffree-line-length-aucun.

-fmax-identifiant-longueur=n
Spécifiez la longueur d'identifiant maximale autorisée. Les valeurs typiques sont 31 (Fortran 95) et
63 (Fortran 2003 et Fortran 2008).

-fimplicite-aucun
Spécifiez qu'aucun typage implicite n'est autorisé, à moins qu'il ne soit remplacé par un "IMPLICIT" explicite
déclarations. C'est l'équivalent d'ajouter « aucun implicite » au début de chaque
Procédure.

-fcray-pointeur
Activez l'extension de pointeur Cray, qui fournit une fonctionnalité de pointeur de type C.

-fopenacc
Activez les extensions OpenACC. Cela inclut les directives OpenACC "!$acc" sous forme libre
et les directives "c$acc", *$acc et "!$acc" sous forme fixe, "!$" compilation conditionnelle
sentinelles sous forme libre et "c$", "*$" et "!$" sentinelles sous forme fixe, et quand
la liaison permet à la bibliothèque d'exécution OpenACC d'être liée.

Notez qu'il s'agit d'une fonctionnalité expérimentale, incomplète et susceptible d'être modifiée à l'avenir
versions de GCC. Voirhttps://gcc.gnu.org/wiki/OpenACC> pour plus d'informations.

-fopenmp
Activez les extensions OpenMP. Cela inclut les directives OpenMP "!$omp" sous forme libre
et les directives "c$omp", *$omp et "!$omp" sous forme fixe, "!$" compilation conditionnelle
sentinelles sous forme libre et "c$", "*$" et "!$" sentinelles sous forme fixe, et quand
la liaison permet à la bibliothèque d'exécution OpenMP d'être liée. L'option -fopenmp
implique -frecursif.

-fno-range-check
Désactiver la vérification de plage sur les résultats de la simplification des expressions constantes pendant
compilation. Par exemple, GNU Fortran donnera une erreur au moment de la compilation lorsque
en simplifiant "a = 1. / 0". Avec cette option, aucune erreur ne sera donnée et "a" sera
attribué la valeur "+Infinity". Si une expression donne une valeur en dehors de la
plage pertinente de ["-HUGE()":"HUGE()"], alors l'expression sera remplacée par "-Inf"
ou "+Inf" selon le cas. De même, "DATA i/Z'FFFFFFFF'/" donnera un entier
débordement sur la plupart des systèmes, mais avec -fno-range-check la valeur "s'enroulera" et
"i" sera initialisé à -1 à la place.

-fdefault-entier-8
Définissez les types entiers et logiques par défaut sur un type de 8 octets. Cette option aussi
affecte le type de constantes entières comme 42. Contrairement -finteger-4-entier-8, Cela fait
ne pas promouvoir les variables avec une déclaration de genre explicite.

-fdefault-réel-8
Définissez le type réel par défaut sur un type de 8 octets. Cette option affecte également le type de
constantes réelles non doubles comme 1.0, et favorise la largeur par défaut de "DOUBLE
PRECISION" à 16 octets si possible, à moins que "-fdefault-double-8" ne soit également spécifié.
-fral-4-real-8, il ne promeut pas les variables avec une déclaration de genre explicite.

-fdefault-double-8
Réglez le type "DOUBLE PRECISION" sur un type de 8 octets. Ne rien faire si c'est déjà le cas
le défaut. Si -fdefault-réel-8 est donné, "DOUBLE PRECISION" serait à la place
promu à 16 octets si possible, et -fdefault-double-8 peut être utilisé pour empêcher cela.
Le type de constantes réelles comme "1.d0" ne sera pas modifié par -fdefault-réel-8 bien que,
donc aussi -fdefault-double-8 ne l'affecte pas.

-finteger-4-entier-8
Promouvoir toutes les entités "INTEGER(KIND=4)" en entités "INTEGER(KIND=8)". Si "GENRE=8"
n'est pas disponible, une erreur sera émise. Cette option doit être utilisée avec précaution
et peut ne pas convenir à vos codes. Les domaines de préoccupation possibles comprennent les appels à
procédures externes, alignement en "EQUIVALENCE" et/ou "COMMON", interfaces génériques,
Conversion de constantes littérales BOZ et E/S. Inspection de l'intermédiaire
représentation du code Fortran traduit, produit par -fdump-tree-original, est
suggérée.

-fral-4-real-8
-fral-4-real-10
-fral-4-real-16
-fral-8-real-4
-fral-8-real-10
-fral-8-real-16
Promouvoir toutes les entités "REAL(KIND=M)" en entités "REAL(KIND=N)". Si "REAL(KIND=N)" est
indisponible, une erreur sera émise. Tous les autres types réels ne sont pas affectés
par cette option. Ces options doivent être utilisées avec précaution et peuvent ne pas convenir aux
vos codes. Les domaines de préoccupation possibles comprennent les appels à des procédures externes, l'alignement
en "EQUIVALENCE" et/ou "COMMON", interfaces génériques, conversion de constantes littérales BOZ,
et E/S. Inspection de la représentation intermédiaire du Fortran traduit
code, produit par -fdump-tree-original, est suggéré.

-std=std
Spécifiez la norme à laquelle le programme est censé se conformer, qui peut être l'une des
f95, f2003, f2008, gnouou héritage. La valeur par défaut pour std is gnou, qui précise
un sur-ensemble de la norme Fortran 95 qui inclut toutes les extensions prises en charge par
GNU Fortran, bien que des avertissements soient donnés pour les extensions obsolètes non recommandés
à utiliser dans le nouveau code. Les héritage la valeur est équivalente mais sans les avertissements pour
extensions obsolètes et peut être utile pour les anciens programmes non standard. Les f95, f2003
et f2008 les valeurs spécifient une conformité stricte au Fortran 95, Fortran 2003 et
Normes Fortran 2008, respectivement ; des erreurs sont données pour toutes les extensions au-delà de la
norme de langue appropriée, et des avertissements sont donnés pour les fonctionnalités Fortran 77 qui
sont autorisés mais obsolètes dans les normes ultérieures. -std=f2008ts permet le Fortran 2008
standard comprenant les ajouts de la spécification technique (TS) 29113 sur
Interopérabilité de Fortran avec C et TS 18508 sur des fonctionnalités parallèles supplémentaires dans
Fortran.

Activer et personnaliser prétraitement
Options liées au préprocesseur. Voir section Prétraitement et conditionnels. compilation pour la qualité
des informations plus détaillées sur le prétraitement dans Gfortran.

-cpp
-nocpp
Activer le prétraitement. Le préprocesseur est automatiquement invoqué si l'extension de fichier
is .fpp, .FPP, .F, .POUR, .FTN, .F90, .F95, .F03 or .F08. Utilisez cette option pour manuellement
permettre le prétraitement de tout type de fichier Fortran.

Pour désactiver le prétraitement des fichiers avec l'une des extensions répertoriées ci-dessus, utilisez le
forme négative: -nocpp.

Le préprocesseur est exécuté en mode traditionnel. Toute restriction du format de fichier,
en particulier les limites de longueur de ligne, s'appliquent également à la sortie prétraitée, de sorte qu'il
serait peut-être conseillé d'utiliser le -ffree-line-length-aucun or -fixed-line-length-aucun
options.

-dM Au lieu de la sortie normale, générez une liste de directives '#define' pour tous les
macros définies lors de l'exécution du préprocesseur, y compris les macros prédéfinies.
Cela vous donne un moyen de découvrir ce qui est prédéfini dans votre version du
préprocesseur. En supposant que vous n'avez pas de fichier foo.f90, la commande

touchez foo.f90 ; gfortran -cpp -E -dM foo.f90

affichera toutes les macros prédéfinies.

-dD Cliquer sur 'j'aime' -dM sauf à deux égards : il n'inclut pas les macros prédéfinies, et il
génère à la fois les directives "#define" et le résultat du prétraitement. Les deux sortes de
sortie aller dans le fichier de sortie standard.

-dN Cliquer sur 'j'aime' -dD, mais n'émettent que les noms des macros, pas leurs extensions.

-dU Cliquer sur 'j'aime' dD sauf que seules les macros qui sont développées, ou dont la définition est testée dans
les directives du préprocesseur sont sorties ; la sortie est retardée jusqu'à l'utilisation ou le test de
la macro ; et les directives '#undef' sont également sorties pour les macros testées mais non définies à
le temps.

-dI Affiche les directives '#include' en plus du résultat du prétraitement.

-frépertoire-de-travail
Activer la génération de marqueurs de ligne dans la sortie du préprocesseur qui permettra au compilateur
connaître le répertoire de travail courant au moment du prétraitement. Lorsque cette option est
activé, le préprocesseur émettra, après le marqueur de ligne initial, un deuxième marqueur de ligne
avec le répertoire de travail courant suivi de deux barres obliques. GCC utilisera ce
répertoire, lorsqu'il est présent dans l'entrée prétraitée, comme le répertoire émis en tant que
le répertoire de travail actuel dans certains formats d'informations de débogage. Cette option est
implicitement activé si les informations de débogage sont activées, mais cela peut être inhibé avec
la forme niée -fno-répertoire-de-travail. Si l' -P flag est présent dans la commande
line, cette option n'a aucun effet, car aucune directive "#line" n'est émise.

-idirafter dir
Rechercher dir pour inclure les fichiers, mais faites-le après tous les répertoires spécifiés avec -I et
les répertoires système standard ont été épuisés. dir est traité comme un système
inclure le répertoire. Si dir commence par "=", alors le "=" sera remplacé par le
préfixe sysroot ; voir --sysroot et -isysroot.

-imultilib dir
Utiliser dir en tant que sous-répertoire du répertoire contenant les en-têtes C++ spécifiques à la cible.

-ipréfixe préfixe
Spécifier préfixe comme préfixe pour la suite -iavecpréfixe option. Si la préfixe
représente un répertoire, vous devez inclure le '/' final.

-isysroot dir
Cette option est comme la --sysroot option, mais s'applique uniquement aux fichiers d'en-tête. Voir le
--sysroot option pour plus d'informations.

-Je cite dir
Rechercher dir uniquement pour les fichiers d'en-tête demandés avec "#include "file"" ; ils ne sont pas
recherché "#include ", avant tous les répertoires spécifiés par -I et avant le
répertoires système standard. Si dir commence par "=", puis le "=" sera remplacé par
le préfixe sysroot ; voir --sysroot et -isysroot.

-isystem dir
Rechercher dir pour les fichiers d'en-tête, après tous les répertoires spécifiés par -I mais avant le
répertoires système standard. Marquez-le comme répertoire système, afin qu'il obtienne le même
traitement spécial tel qu'il est appliqué aux répertoires système standard. Si dir commence par
"=", alors le "=" sera remplacé par le préfixe sysroot ; voir --sysroot et -isysroot.

-nostdinc
Ne recherchez pas les fichiers d'en-tête dans les répertoires système standard. Seuls les répertoires
vous avez spécifié avec -I options (et le répertoire du fichier courant, si
approprié) sont recherchés.

-undef
Ne prédéfinissez aucune macro spécifique au système ou à GCC. La norme prédéfinie
les macros restent définies.

-Aprédicat=répondre
Faire une assertion avec le prédicat prédicat et répond répondre. Ce formulaire est
préféré à l'ancienne forme -A prédicat (réponse), qui est toujours pris en charge, car il
n'utilise pas de caractères spéciaux shell.

-UNE-prédicat=répondre
Annuler une assertion avec le prédicat prédicat et répond répondre.

-C Ne jetez pas les commentaires. Tous les commentaires sont transmis au fichier de sortie, sauf
pour les commentaires dans les directives traitées, qui sont supprimés avec la directive.

Vous devez être préparé aux effets secondaires lors de l'utilisation -C; cela amène le préprocesseur à
traiter les commentaires comme des jetons à part entière. Par exemple, les commentaires apparaissant à la
début de ce qui serait une ligne directive ont pour effet de transformer cette ligne en une
ligne source ordinaire, puisque le premier jeton sur la ligne n'est plus un '#'.

Attention : ceci ne gère actuellement que les commentaires de style C. Le préprocesseur n'a pas encore
reconnaître les commentaires de style Fortran.

-CC Ne supprimez pas les commentaires, y compris pendant l'expansion des macros. C'est comme -C, sauf
que les commentaires contenus dans les macros sont également transmis au fichier de sortie où
la macro est étendue.

En plus des effets secondaires de la -C option, la -CC l'option provoque tout le style C++
commentaires dans une macro à convertir en commentaires de style C. C'est pour éviter plus tard
l'utilisation de cette macro de commenter par inadvertance le reste de la ligne source.
La -CC L'option est généralement utilisée pour prendre en charge les commentaires Lint.

Attention : ceci ne gère actuellement que les commentaires de style C et C++. Le préprocesseur fait
ne reconnaissent pas encore les commentaires de style Fortran.

-Dprénom
Prédéfinissez le nom en tant que macro, avec la définition 1.

-Dprénom=définition
Le contenu de définition sont tokenisés et traités comme s'ils étaient apparus pendant
traduction phase trois dans une directive '#define'. En particulier, la définition sera
être tronqué par des caractères de nouvelle ligne intégrés.

Si vous appelez le préprocesseur à partir d'un shell ou d'un programme similaire, vous aurez peut-être besoin
d'utiliser la syntaxe des guillemets du shell pour protéger les caractères tels que les espaces qui ont un
sens dans la syntaxe du shell.

Si vous souhaitez définir une macro de type fonction sur la ligne de commande, écrivez son argument
liste entourée de parenthèses avant le signe égal (le cas échéant). Les parenthèses sont
significatif pour la plupart des shells, vous devrez donc citer l'option. Avec sh et csh,
"-D'name(args...)=definition'" fonctionne.

-D et -U les options sont traitées dans l'ordre dans lequel elles sont données sur la ligne de commande. Tous
Les options de fichier -imacros et -include sont traitées après toutes les options -D et -U.

-H Imprimez le nom de chaque fichier d'en-tête utilisé, en plus des autres activités normales. Chaque
le nom est en retrait pour montrer à quel point il se trouve dans la pile '#include'.

-P Empêcher la génération de marqueurs de ligne dans la sortie du préprocesseur. Cela pourrait être
utile lors de l'exécution du préprocesseur sur quelque chose qui n'est pas du code C, et sera envoyé
à un programme qui pourrait être confondu par les marqueurs de ligne.

-Uprénom
Annuler toute définition précédente de prénom, soit intégré, soit pourvu d'un -D option.

Options : à nécessaire or supprimer erreurs et avertissements
Les erreurs sont des messages de diagnostic qui signalent que le compilateur GNU Fortran ne peut pas compiler
le morceau de code source concerné. Le compilateur continuera à traiter le programme dans
une tentative de signaler d'autres erreurs pour aider au débogage, mais ne produira aucun compilé
sortie.

Les avertissements sont des messages de diagnostic qui signalent des constructions qui ne sont pas intrinsèquement
erronées mais qui sont risquées ou suggèrent qu'il y a probablement un bogue dans le programme.
Petite remarque, -Werreur est spécifié, ils n'empêchent pas la compilation du programme.

Vous pouvez demander de nombreux avertissements spécifiques avec des options commençant -W, Par exemple -Wimplicite
pour demander des avertissements sur les déclarations implicites. Chacune de ces options d'avertissement spécifiques a également
a une forme négative commençant -Wnon- pour désactiver les avertissements ; par exemple, -Wno-implicite.
Ce manuel ne répertorie qu'un seul des deux formulaires, celui qui n'est pas celui par défaut.

Ces options contrôlent la quantité et les types d'erreurs et d'avertissements produits par GNU Fortran :

-fmax-erreurs=n
Limite le nombre maximum de messages d'erreur à n, à quel point GNU Fortran renfloue
plutôt que d'essayer de continuer à traiter le code source. Si n est 0, il n'y a pas
limitation du nombre de messages d'erreur générés.

-fsyntaxe-seulement
Vérifiez le code pour les erreurs de syntaxe, mais ne le compilez pas réellement. Cela va générer
modules pour chaque module présent dans le code, mais aucun autre fichier de sortie.

-pédant
Émettre des avertissements pour l'utilisation d'extensions vers Fortran 95. -pédant s'applique également à
Les constructions du langage C lorsqu'elles apparaissent dans les fichiers source GNU Fortran, telles que l'utilisation de \e
dans une constante de caractère dans une directive comme "#include".

Les programmes Fortran 95 valides doivent se compiler correctement avec ou sans cette option.
Cependant, sans cette option, certaines extensions GNU et fonctionnalités Fortran traditionnelles
sont également pris en charge. Avec cette option, beaucoup d'entre eux sont rejetés.

Certains utilisateurs essaient d'utiliser -pédant pour vérifier la conformité des programmes. Ils trouvent bientôt
qu'il ne fait pas tout à fait ce qu'ils veulent --- il trouve des pratiques non standard, mais
pas tout. Cependant, les améliorations de GNU Fortran dans ce domaine sont les bienvenues.

Ceci doit être utilisé en conjonction avec -std=f95, -std=f2003 or -std=f2008.

-pédant-erreurs
Cliquer sur 'j'aime' -pédant, sauf que des erreurs sont générées plutôt que des avertissements.

-Mur
Active les options d'avertissement couramment utilisées concernant l'utilisation que nous recommandons d'éviter
et que nous croyons faciles à éviter. Cela comprend actuellement -Waliasing,
-Wampersand, -Wconversion, -Wsurprenant, -Wc-fixation-type, -Wintrinsics-std,
-Wno-onglets, -Wintrinsic-ombre, -Troncation Wline, - Durée de vie cible, -Wreal-q-constante
et -Wunutilisé.

-Waliasing
Avertir d'un éventuel alias d'arguments factices. Plus précisément, il avertit si le même
l'argument réel est associé à un argument fictif avec "INTENT(IN)" et un argument fictif
argument avec "INTENT(OUT)" dans un appel avec une interface explicite.

L'exemple suivant déclenchera l'avertissement.

interface
barre de sous-programme(a,b)
entier, intention(in) :: a
entier, intention(out) :: b
terminer le sous-programme
interface de fin
entier :: un

barre d'appel(a,a)

-Wampersand
Avertir de l'esperluette manquante dans les constantes de caractères continues. L'avertissement est donné
avec -Wampersand, -pédant, -std=f95, -std=f2003 et -std=f2008. Remarque : sans
esperluette donnée dans une constante de caractère continu, GNU Fortran suppose la continuation à
le premier caractère sans commentaire et sans espace après l'esperluette qui a lancé le
continuation.

-Warray-temporaires
Avertir sur les tableaux temporaires générés par le compilateur. Les informations générées par
cet avertissement est parfois utile en optimisation, afin d'éviter de tels temporaires.

-Wc-fixation-type
Avertir si la variable a pourrait ne pas être interopérable avec C. En particulier, avertir si le
la variable a été déclarée en utilisant un type intrinsèque avec le genre par défaut au lieu d'utiliser
un paramètre kind défini pour l'interopérabilité C dans le "ISO_C_Binding" intrinsèque
module. Cette option est impliquée par -Mur.

-Wcaractère-troncature
Avertir lorsqu'une affectation de caractère tronquera la chaîne affectée.

-Troncation Wline
Avertir lorsqu'une ligne de code source sera tronquée. Cette option est impliquée par -Mur. For
code source de forme libre, la valeur par défaut est -Werror=ligne-tronquée telle que les troncatures
sont signalés comme erreur.

-Wconversion
Avertir des conversions implicites susceptibles de modifier la valeur de l'expression
après reconversion. Impliqué par -Mur.

-Wconversion-supplémentaire
Avertir des conversions implicites entre différents types et genres. Cette option fait
pas impliquer -Wconversion.

-Wextra
Active certaines options d'avertissement pour les utilisations des fonctionnalités linguistiques qui peuvent être problématiques.
Cela comprend actuellement -Wcompare-réels et -Wunused-paramètre.

-Wimplicit-interface
Avertir si une procédure est appelée sans interface explicite. Notez que cela ne vérifie que
qu'une interface explicite est présente. Il ne vérifie pas que les interfaces déclarées
sont uniformes dans toutes les unités de programme.

-Wimplicit-procédure
Avertir si une procédure est appelée qui n'a pas d'interface explicite ni n'a été
déclaré comme "EXTERNE".

-Wintrinsics-std
Avertir si Gfortran trouve une procédure nommée comme un intrinsèque non disponible dans le
norme actuellement sélectionnée (avec -std) et la traite comme une procédure "EXTERNE" car
de cela. -chute-intrinsèque peut être utilisé pour ne jamais déclencher ce comportement et toujours lier
à l'intrinsèque quel que soit le standard sélectionné.

-Wreal-q-constante
Produit un avertissement si une constante littérale réelle contient une lettre d'exposant "q".

-Wsurprenant
Produit un avertissement lorsque des constructions de code "suspectes" sont rencontrées. Tandis que
techniquement légales, elles indiquent généralement qu'une erreur a été commise.

Cela produit actuellement un avertissement dans les circonstances suivantes :

* Une construction INTEGER SELECT a un CASE qui ne peut jamais correspondre à sa valeur inférieure
valeur est supérieure à sa valeur supérieure.

* Une construction LOGICAL SELECT a trois instructions CASE.

* Un TRANSFERT spécifie une source qui est plus courte que la destination.

* Le type d'un résultat de fonction est déclaré plusieurs fois avec le même type. Si
-pédant ou le mode conforme aux normes est activé, il s'agit d'une erreur.

* Une variable "CARACTERE" est déclarée avec une longueur négative.

-Wtabs
Par défaut, les onglets sont acceptés comme espace, mais les onglets ne sont pas membres du Fortran
Jeu de caractères. Pour les lignes de continuation, une tabulation suivie d'un chiffre entre 1 et 9 est
prise en charge. -Wtabs provoquera l'émission d'un avertissement si un onglet est rencontré. Noter,
-Wtabs est actif pour -pédant, -std=f95, -std=f2003, -std=f2008, -std=f2008ts et
-Mur.

-Wunderflow
Émettre un avertissement lorsque des expressions constantes numériques sont rencontrées, ce qui donne un
UNDERFLOW pendant la compilation. Activé par défaut.

-Wintrinsic-ombre
Avertir si une procédure définie par l'utilisateur ou une procédure de module a le même nom qu'un
intrinsèque; dans ce cas, une interface explicite ou "EXTERNE" ou "INTRINSEQUE"
une déclaration peut être nécessaire pour que les appels soient résolus plus tard au niveau souhaité
intrinsèque/procédure. Cette option est impliquée par -Mur.

-Wuse-sans-seulement
Avertir si une instruction "USE" n'a pas de qualificateur "ONLY" et importe donc implicitement tout
entités publiques du module utilisé.

-Wunused-dummy-argument
Avertir des arguments factices inutilisés. Cette option est impliquée par -Mur.

-Wunused-paramètre
Contrairement à gccle sens de -Wunused-paramètre, Gfortranla mise en œuvre de ce
L'option n'avertit pas des arguments factices inutilisés (voir -Wunused-dummy-argument), Mais
sur les valeurs "PARAMETER" inutilisées. -Wunused-paramètre est impliqué par -Wextra si aussi
-Wunutilisé or -Mur est utilisé.

-Walign-communs
Par défaut, Gfortran avertit de toute occasion de rembourrage de variables pour un bon
alignement à l'intérieur d'un bloc "COMMON". Cet avertissement peut être désactivé via
-Wno-align-commons. Voir également -falign-communs.

-Wfonction-élimination
Avertir si des appels à des fonctions sont éliminés par les optimisations permises par le
-ffrontend-optimiser option.

-Wrealloc-lhs
Avertir lorsque le compilateur peut insérer du code pour l'allocation ou la réallocation d'un
variable de tableau allouable de type intrinsèque dans les affectations intrinsèques. Dans les boucles chaudes,
la fonctionnalité de réallocation Fortran 2003 peut réduire les performances. Si le tableau est
déjà alloué avec la forme correcte, envisagez d'utiliser une spécification de tableau entier
(par exemple "(:,:,:)") pour la variable sur le côté gauche pour empêcher la réallocation
Chèque. Notez que dans certains cas, l'avertissement est affiché, même si le compilateur
optimiser les chèques de réaffectation. Par exemple, lorsque le côté droit contient
la même variable multipliée par un scalaire. Voir également -fralloc-lhs.

-Wrealloc-lhs-all
Avertir lorsque le compilateur insère du code pour l'allocation ou la réallocation d'un
variable attribuable ; cela inclut les scalaires et les types dérivés.

-Wcompare-réels
Avertir lors de la comparaison de types réels ou complexes pour l'égalité ou l'inégalité. Cette option est
Impliqué par -Wextra.

- Durée de vie cible
Avertir si le pointeur dans une affectation de pointeur peut être plus long que sa cible. Cette
l'option est impliquée par -Mur.

-Wzerotrip
Avertir si une boucle "DO" est connue pour s'exécuter zéro fois au moment de la compilation. Cette option est
Impliqué par -Mur.

-Werreur
Transforme tous les avertissements en erreurs.

Certains d'entre eux n'ont aucun effet lors de la compilation de programmes écrits en Fortran.

Options : pour la qualité débogage programme or GNU Fortran
GNU Fortran a diverses options spéciales qui sont utilisées pour déboguer votre programme ou
le compilateur GNU Fortran.

-fdump-fortran-original
Sortir l'arbre d'analyse interne après avoir traduit le programme source en interne
représentation. Seulement vraiment utile pour déboguer le compilateur GNU Fortran lui-même.

-fdump-fortran-optimisé
Générez l'arbre d'analyse après l'optimisation frontale. Seulement vraiment utile pour le débogage
le compilateur GNU Fortran lui-même.

-fdump-parse-tree
Sortir l'arbre d'analyse interne après avoir traduit le programme source en interne
représentation. Seulement vraiment utile pour déboguer le compilateur GNU Fortran lui-même.
Cette option est obsolète ; utilisez plutôt "-fdump-fortran-original".

-ffpe-piège=liste
Spécifiez une liste d'interruptions d'exception à virgule flottante à activer. Sur la plupart des systèmes, si un
une exception à virgule flottante se produit et le trap pour cette exception est activé, un SIGFPE
le signal sera envoyé et le programme abandonné, produisant un fichier de base utile pour
débogage. liste est une liste (éventuellement vide) séparée par des virgules des éléments suivants
des exceptions: invalide (opération à virgule flottante non valide, telle que "SQRT(-1.0)"), zéro
(division par zéro), débordement (débordement dans une opération en virgule flottante), débordement
(sous-dépassement dans une opération en virgule flottante), inexact (perte de précision pendant
opération), et dénormalisé (opération effectuée sur une valeur dénormalisée). Les cinq premiers
exceptions correspondent aux cinq exceptions IEEE 754, tandis que la dernière (dénormalisé)
ne fait pas partie de la norme IEEE 754 mais est disponible sur certaines architectures courantes
comme x86.

Les trois premières exceptions (invalide, zéroet débordement) indiquent souvent de graves
erreurs, et à moins que le programme ne prévoie des dispositions pour traiter ces exceptions,
activer les pièges pour ces trois exceptions est probablement une bonne idée.

De nombreuses opérations à virgule flottante, sinon la plupart, entraînent une perte de précision due à l'arrondi,
et donc le "ffpe-trap=inexact" est susceptible d'être inintéressant dans la pratique.

Par défaut, aucune interruption d'exception n'est activée.

-ffpe-résumé=liste
Spécifiez une liste d'exceptions à virgule flottante, dont l'état du drapeau est imprimé sur
"ERROR_UNIT" lors de l'appel de "STOP" et "ERROR STOP". liste peut être soit aucun, tous ou
liste séparée par des virgules des exceptions suivantes : invalide, zéro, débordement, débordement,
inexact et dénormalisé. (Voir -ffpe-piège pour une description des exceptions.)

Par défaut, un résumé pour toutes les exceptions mais inexact est montré.

-fno-trace
Lorsqu'une erreur d'exécution grave est rencontrée ou qu'un signal mortel est émis
(erreur de segmentation, instruction illégale, erreur de bus, exception à virgule flottante et
d'autres signaux POSIX qui ont l'action coeur), la bibliothèque d'exécution Fortran essaie de
générer une trace de l'erreur. "-fno-backtrace" désactive la génération de backtrace.
Cette option n'a d'influence que pour la compilation du programme principal Fortran.

Options : pour la qualité annuaire recherche
Ces options affectent la façon dont GNU Fortran recherche les fichiers spécifiés par "INCLUDE"
directive et où il recherche les modules précédemment compilés.

Cela affecte également les chemins de recherche utilisés par cpp lorsqu'il est utilisé pour prétraiter la source Fortran.

-Idir
Ceux-ci affectent l'interprétation de la directive "INCLUDE" (ainsi que de la "#include"
directive de la cpp préprocesseur).

Notez également que le comportement général de -I et "INCLUDE" est à peu près le même que de
-I avec "#include" dans le cpp préprocesseur, en ce qui concerne la recherche de en-tête.gcc
fichiers et autres choses du même genre.

Ce chemin est également utilisé pour rechercher .mod fichiers lorsque les modules précédemment compilés sont
requis par une instruction "USE".

-Jdir
Cette option spécifie où mettre .mod fichiers pour les modules compilés. Il est également ajouté
à la liste des répertoires recherchés par une instruction "USE".

La valeur par défaut est le répertoire actuel.

-chemin-modules-fintrinsique dir
Cette option spécifie l'emplacement des modules intrinsèques précompilés, s'ils ne sont pas
à l'emplacement par défaut attendu par le compilateur.

Influenceur le lien étape
Ces options entrent en jeu lorsque le compilateur lie des fichiers objets dans un exécutable
fichier de sortie. Ils n'ont aucun sens si le compilateur ne fait pas d'étape de lien.

-statique-libgfortran
Sur les systèmes qui fournissent libgfortran en tant que bibliothèque partagée et statique, cette option
force l'utilisation de la version statique. Si aucune version partagée de libgfortran a été construit
lorsque le compilateur a été configuré, cette option n'a aucun effet.

Influenceur d'exécution humain
Ces options affectent le comportement d'exécution des programmes compilés avec GNU Fortran.

-fconvert=Conversion
Spécifiez la représentation des données pour les fichiers non formatés. Valeurs valides pour la conversion
sont: indigène, le défaut; échange, permutez entre gros et petit-boutiste ; gros boutiste, utilisation
représentation big-endian pour les fichiers non formatés ; little-endian, utilisez le petit-boutiste
représentation pour les fichiers non formatés.

This option a an effet uniquement. quand d'utiliser in le principal . La "CONVERTIR" spécificateur
et le GFORTRAN_CONVERT_UNIT Environnement variable Commande le défaut spécifié by
-fconvertir.

-frecord-marqueur=longueur
Spécifiez la longueur des marqueurs d'enregistrement pour les fichiers non formatés. Valeurs valides pour longueur
sont 4 et 8. La valeur par défaut est 4. This is différent à partir de précédent versions of Gfortran,
qui a spécifié une longueur de marqueur d'enregistrement par défaut de 8 sur la plupart des systèmes. Si tu veux
lire ou écrire des fichiers compatibles avec les versions antérieures de Gfortran, utilisation
-frecord-marker=8.

-fmax-sous-enregistrement-longueur=longueur
Spécifiez la longueur maximale d'un sous-enregistrement. La valeur maximale autorisée pour la longueur est
2147483639, qui est également la valeur par défaut. Seulement vraiment utile pour une utilisation par le gfortran
suite de tests.

-fsign-zéro
Lorsqu'il est activé, les nombres à virgule flottante de valeur zéro avec le bit de signe défini sont écrits
comme nombre négatif dans la sortie formatée et traité comme négatif dans le "SIGN"
intrinsèque. -fno-signe-zéro n'imprime pas le signe négatif des valeurs nulles (ou des valeurs
arrondi à zéro pour les E/S) et considère zéro comme un nombre positif dans le "SIGN" intrinsèque
pour la compatibilité avec Fortran 77. La valeur par défaut est -fsign-zéro.

Options : pour la qualité code génération conventions
Ces options indépendantes de la machine contrôlent les conventions d'interface utilisées dans le code
génération.

La plupart d'entre eux ont à la fois des formes positives et négatives ; la forme négative de -ffou serait
-fno-foo. Dans le tableau ci-dessous, une seule des formes est répertoriée --- celle qui n'est pas la
défaut. Vous pouvez découvrir l'autre forme en supprimant no- ou en l'ajoutant.

-fno-automatique
Traitez chaque unité de programme (sauf celles marquées comme RECURSIVE) comme si l'instruction "SAVE"
ont été spécifiés pour chaque variable locale et tableau qui y sont référencés. N'affecte pas
blocs communs. (Certains compilateurs Fortran proposent cette option sous le nom -statique or
-sauver.) La valeur par défaut, qui est -fautomatique, utilise la pile pour les variables locales plus petites
que la valeur donnée par -fmax-stack-var-taille. Utilisez l'option -frecursif utiliser non
mémoire statique.

-ff2c
Générer du code conçu pour être compatible avec le code généré par g77 et f2c.

Les conventions d'appel utilisées par g77 (initialement mis en œuvre dans f2c) nécessitent des fonctions
qui renvoient le type par défaut "REAL" pour renvoyer en fait le type C "double", et les fonctions
qui renvoient le type "COMPLEX" pour renvoyer les valeurs via un argument supplémentaire dans l'appel
séquence qui indique où stocker la valeur de retour. Sous le GNU par défaut
conventions d'appel, de telles fonctions renvoient simplement leurs résultats comme elles le feraient dans GNU
C --- les fonctions "REAL" par défaut renvoient le type C "float", et les fonctions "COMPLEX" renvoient
le "complexe" de type GNU C. De plus, cette option implique la -fsecond-trait de soulignement
option, à moins que -fno-second-souligné est explicitement demandé.

Cela n'affecte pas la génération de code qui s'interface avec le libgfortran
bibliothèque.

Prudence: Ce n'est pas une bonne idée de mélanger du code Fortran compilé avec -ff2c avec code
compilé avec la valeur par défaut -fno-f2c appelant les conventions comme, appelant "COMPLEX" ou
par défaut des fonctions "REAL" entre des parties de programme qui ont été compilées avec différents
les conventions d'appel seront rompues au moment de l'exécution.

Prudence: Cela cassera le code qui passe des fonctions intrinsèques de type par défaut "REAL"
ou "COMPLEX" comme arguments réels, car les implémentations de la bibliothèque utilisent le -fno-f2c
conventions d'appel.

-fno-soulignement
Ne pas transformer les noms d'entités spécifiés dans le fichier source Fortran en ajoutant
leur souligne.

Avec -financement en effet, GNU Fortran ajoute un trait de soulignement aux noms externes
sans traits de soulignement. Ceci est fait pour assurer la compatibilité avec le code produit par de nombreux
Compilateurs UNIX Fortran.

Attention: Le comportement par défaut de GNU Fortran est incompatible avec f2c et g77, S'il vous plaît
utiliser le -ff2c option si vous voulez que les fichiers objets compilés avec GNU Fortran soient
compatible avec le code objet créé avec ces outils.

L'utilisation de -fno-soulignement n'est pas recommandé sauf si vous expérimentez des problèmes
telles que l'intégration de GNU Fortran dans les environnements système existants (vis-à-vis
bibliothèques existantes, outils, etc.).

Par exemple, avec -financement, et en supposant que "j()" et "max_count()" sont
fonctions externes tandis que "my_var" et "lvar" sont des variables locales, une instruction comme

I = J() + MAX_COUNT (MY_VAR, LVAR)

est implémenté comme quelque chose qui s'apparente à :

i = j_() + max_count__(&my_var__, &lvar);

Avec -fno-soulignement, la même instruction est implémentée que :

i = j() + max_count(&my_var, &lvar);

L'utilisation de -fno-soulignement permet la spécification directe de noms définis par l'utilisateur tout en
débogage et lors de l'interfaçage du code GNU Fortran avec d'autres langages.

Notez que juste parce que les noms correspondent pas signifie que l'interface implémentée par
GNU Fortran pour un nom externe correspond à l'interface implémentée par un autre
langue pour ce même nom. C'est-à-dire que le code produit par GNU Fortran est lié à
le code produit par un autre compilateur utilisant cette méthode ou toute autre méthode ne peut être qu'un
petite partie de la solution globale --- obtenir le code généré par les deux compilateurs pour
se mettre d'accord sur des questions autres que le nommage peut exiger des efforts importants et, contrairement au nommage
désaccords, les linkers ne peuvent normalement pas détecter les désaccords dans ces autres domaines.

Notez également qu'avec -fno-soulignement, l'absence de traits de soulignement ajoutés introduit
la possibilité très réelle qu'un nom externe défini par l'utilisateur entre en conflit avec un nom
dans une bibliothèque système, ce qui pourrait rendre la recherche de bogues de référence non résolus assez
difficile dans certains cas --- ils peuvent se produire au moment de l'exécution du programme et n'apparaître que sous la forme
comportement bogué au moment de l'exécution.

Dans les futures versions de GNU Fortran, nous espérons améliorer les problèmes de nommage et de liaison afin que
le débogage implique toujours d'utiliser les noms tels qu'ils apparaissent dans la source, même si le
les noms tels que vus par l'éditeur de liens sont mutilés pour éviter toute liaison accidentelle entre
procédures avec des interfaces incompatibles.

-fsecond-trait de soulignement
Par défaut, GNU Fortran ajoute un trait de soulignement aux noms externes. Si cette option est
utilisé GNU Fortran ajoute deux traits de soulignement aux noms avec des traits de soulignement et un trait de soulignement
aux noms externes sans traits de soulignement. GNU Fortran ajoute également deux traits de soulignement à
les noms internes avec des traits de soulignement pour éviter les collisions de noms avec des noms externes.

Cette option n'a aucun effet si -fno-soulignement est en vigueur. Il est impliqué par le
-ff2c option.

Sinon, avec cette option, un nom externe tel que "MAX_COUNT" est implémenté en tant que
référence au symbole externe de temps de liaison "max_count__", au lieu de "max_count_".
Ceci est requis pour la compatibilité avec g77 et f2c, et est impliqué par l'utilisation du
-ff2c option.

-fcoarray=
aucun
Désactivez le support coarray ; en utilisant des déclarations coarray et des instructions de contrôle d'image
produira une erreur de compilation. (Défaut)

unique
Mode image unique, c'est-à-dire que "num_images()" est toujours un.

lib Parallélisation coarray basée sur une bibliothèque ; une bibliothèque coarray GNU Fortran appropriée
doit être lié.

-fcheck=
Activer la génération de contrôles d'exécution ; l'argument doit être une liste délimitée par des virgules
des mots-clés suivants.

tous Activer tous les tests d'exécution de -fcheck.

tableau-temps
Avertit au moment de l'exécution lorsque pour passer un argument réel, un tableau temporaire doit être
généré. Les informations générées par cet avertissement sont parfois utiles dans
optimisation, afin d'éviter de tels temporaires.

Remarque : l'avertissement n'est imprimé qu'une seule fois par emplacement.

bornes
Activer la génération de vérifications à l'exécution pour les indices de tableau et par rapport à la déclaration
valeurs minimales et maximales. Il vérifie également les indices de tableau pour les valeurs supposées et différées
forme des tableaux par rapport aux limites allouées réelles et garantit que toutes les chaînes
les longueurs sont égales pour les constructeurs de tableaux de caractères sans spécification de type explicite.

Certains contrôles exigent que -fcheck=limites est défini pour la compilation des principaux
.

Remarque : À l'avenir, cela peut également inclure d'autres formes de contrôle, par exemple, le contrôle
références de sous-chaîne.

do Activer la génération de vérifications à l'exécution pour la modification non valide de l'itération de la boucle
variables.

Membre Activer la génération de contrôles d'exécution pour l'allocation de mémoire. Remarque : cette option
n'affecte pas les allocations explicites à l'aide de l'instruction "ALLOCATE", qui sera
toujours vérifié.

aiguille
Activez la génération de contrôles d'exécution pour les pointeurs et les éléments attribuables.

récursion
Activer la génération de contrôles d'exécution pour les sous-routines appelées de manière récursive et
fonctions qui ne sont pas marquées comme récursives. Voir également -frecursif. Remarque : ceci
check ne fonctionne pas pour les programmes OpenMP et est désactivé s'il est utilisé avec
-frecursif et -fopenmp.

-fbounds-check
Alias ​​obsolète pour -fcheck=limites.

-fcheck-tableau-temporaires
Alias ​​obsolète pour -fcheck=tableau-temps.

-fmax-array-constructor=n
Cette option peut être utilisée pour augmenter la limite supérieure autorisée dans les constructeurs de tableaux.
Le code ci-dessous nécessite cette option pour étendre le tableau au moment de la compilation.

essai de programme
implicite aucun
entier j
entier, paramètre :: n = 100000
entier, paramètre :: i(n) = (/ (2*j, j = 1, n) /)
imprimer '(10(I0,1X))', je
test de fin de programme

Prudence: This option peut conduire à Long compiler fois et excessivement gros objet
fichiers.

La valeur par défaut pour n est 65535.

-fmax-stack-var-size=n
Cette option spécifie la taille en octets du plus grand tableau qui sera mis sur le
empiler; si la taille est dépassée, la mémoire statique est utilisée (sauf dans les procédures marquées comme
RÉCURSIF). Utilisez l'option -frecursif permettre des procédures récursives qui ne
ont un attribut RECURSIVE ou pour les programmes parallèles. Utilisation -fno-automatique ne jamais utiliser
la pile.

Cette option n'affecte actuellement que les tableaux locaux déclarés avec des limites constantes, et peut
ne s'applique pas à toutes les variables de caractères. Les futures versions de GNU Fortran pourraient améliorer cela
comportement.

La valeur par défaut pour n est 32768.

-fstack-tableaux
L'ajout de cette option obligera le compilateur Fortran à mettre tous les tableaux locaux, même ceux de
taille inconnue sur la mémoire de la pile. Si votre programme utilise de très grands tableaux locaux, il est
possible que vous deviez étendre vos limites d'exécution pour la mémoire de pile sur certains
systèmes d'exploitation. Ce drapeau est activé par défaut au niveau d'optimisation -Ofast.

-fpack-dérivé
Cette option indique à GNU Fortran de compresser les membres de type dérivés aussi étroitement que possible.
Le code compilé avec cette option est susceptible d'être incompatible avec le code compilé sans
cette option et peut s'exécuter plus lentement.

-frepack-tableaux
Dans certaines circonstances, GNU Fortran peut transmettre des sections de tableau de formes supposées via un
descripteur décrivant une zone de mémoire non contiguë. Cette option ajoute du code au
prologue de fonction pour reconditionner les données dans un bloc contigu au moment de l'exécution.

Cela devrait se traduire par des accès plus rapides à la baie. Cependant, il peut introduire
surcharge significative de l'appel de fonction, en particulier lorsque les données transmises sont
non contigu.

-fshort-enums
Cette option est fournie pour l'interopérabilité avec le code C qui a été compilé avec le
-fshort-enums option. Cela obligera GNU Fortran à choisir le plus petit type "INTEGER" a
Un ensemble d'énumérateurs donné s'intégrera et donnera à tous ses énumérateurs ce type.

-fexternal-blas
Cette option fera Gfortran générer des appels aux fonctions BLAS pour certaines matrices
opérations comme "MATMUL", au lieu d'utiliser nos propres algorithmes, si la taille du
matrices impliquées est plus grande qu'une limite donnée (voir -fblas-matmul-limite). Cela peut être
rentable si une bibliothèque BLAS de fournisseur optimisée est disponible. La bibliothèque BLAS sera
doivent être spécifiés au moment de la liaison.

-fblas-matmul-limit=n
Significatif seulement lorsque -fexternal-blas est en vigueur. Multiplication matricielle de matrices
avec une taille supérieure (ou égale à) n sera effectué par des appels aux fonctions BLAS,
tandis que d'autres seront traités par Gfortran algorithmes internes. Si les matrices concernées
ne sont pas carrés, la comparaison de taille est effectuée en utilisant la moyenne géométrique de la
dimensions des matrices argument et résultat.

La valeur par défaut pour n est 30.

-frecursif
Autorisez la récursivité indirecte en forçant tous les tableaux locaux à être alloués sur la pile.
Ce drapeau ne peut pas être utilisé avec -fmax-stack-var-size= or -fno-automatique.

-finit-local-zéro
-finit-entier=n
-finit-réel=
-finit-logique=
-finit-caractère=n
La -finit-local-zéro L'option demande au compilateur d'initialiser "INTEGER" local,
Variables "REAL" et "COMPLEX" à zéro, variables "LOGICAL" à false et "CARACTER"
variables à une chaîne d'octets nuls. Les options d'initialisation plus fines sont
fourni par -finit-entier=n, -finit-réel= (qui aussi
initialise les parties réelle et imaginaire des variables locales "COMPLEXES"),
-finit-logique=et -finit-caractère=n (OÙ n est un caractère ASCII
valeur) options. Ces options ne s'initialisent pas

* tableaux allouables

* composants de variables de type dérivé

* variables qui apparaissent dans une instruction "EQUIVALENCE".

(Ces limitations peuvent être supprimées dans les versions futures).

Notez que le -finit-réel=nan L'option initialise les variables "REAL" et "COMPLEX" avec un
NaN calme. Pour une utilisation NaN de signalisation -finit-real=snan; notez, cependant, que le temps de compilation
les optimisations peuvent les convertir en NaN silencieux et ce piégeage doit être activé
(par exemple via -ffpe-piège).

Enfin, notez que l'activation de l'un des -fini-* les options feront taire les avertissements qui
aurait été émis par -Wuninitialisé pour les variables locales affectées.

-falign-communs
Par défaut, Gfortran applique un alignement correct de toutes les variables dans un bloc "COMMON" en
les rembourrage au besoin. Sur certaines plates-formes, cela est obligatoire, sur d'autres, cela augmente
performance. Si un bloc "COMMON" n'est pas déclaré avec des types de données cohérents
partout, ce rembourrage peut causer des problèmes, et -fno-align-commons peut être utilisé pour
désactiver l'alignement automatique. La même forme de cette option doit être utilisée pour tous les fichiers
qui partagent un bloc "COMMON". Pour éviter les problèmes d'alignement potentiels dans les blocs "COMMON",
il est recommandé de classer les objets du plus grand au plus petit.

-fno-protect-parens
Par défaut, les parenthèses dans l'expression sont respectées pour tous les niveaux d'optimisation tels que
que le compilateur ne fait aucune réassociation. À l'aide de -fno-protect-parens permet la
compilateur pour réorganiser les expressions "REAL" et "COMPLEX" afin de produire un code plus rapide. Noter que
pour l'optimisation de la réassociation -fno-signé-zéros et -fno-piégeage-maths doivent
être en vigueur. La protection des parenthèses est activée par défaut, sauf si -Ofast is
donné.

-fralloc-lhs
Une partie gauche attribuable d'une affectation intrinsèque est automatiquement
(ré)alloué s'il n'est pas alloué ou a une forme différente. L'option est
activé par défaut sauf quand -std=f95 est donné. Voir également -Wrealloc-lhs.

-fagressif-fonction-élimination
Les fonctions avec des listes d'arguments identiques sont éliminées dans les instructions, peu importe
si ces fonctions sont marquées "PURE" ou non. Par exemple, dans

a = f(b,c) + f(b,c)

il n'y aura qu'un seul appel à "f". Cette option ne fonctionne que si
-ffrontend-optimiser est en vigueur.

-ffrontend-optimiser
Cette option effectue une optimisation frontale, basée sur la manipulation de pièces le Fortran
arbre d'analyse. Activé par défaut par n'importe quel -O option. Optimisations permises par ce
option inclure l'élimination des appels de fonction identiques dans les expressions, la suppression
appels inutiles à "TRIM" dans les comparaisons et les affectations et en remplaçant TRIM(a) par
"a(1:LEN_TRIM(a))". Il peut être désélectionné en spécifiant -fno-frontend-optimiser.

ENVIRONNEMENT


La Gfortran le compilateur n'utilise actuellement aucune variable d'environnement pour contrôler
son fonctionnement au-delà de ceux qui affectent le fonctionnement de gcc.

Utilisez mips-linux-gnu-gfortran en ligne en utilisant les services onworks.net


Ad


Ad

Derniers programmes en ligne Linux et Windows