aarch64-linux-gnu-gfortran - Online nel cloud

PROGRAMMA:

NOME

gfortran - compilatore GNU Fortran

SINOSSI

gfortran [-c|-S|-E]
[-g] [-pag] [-Olivello]
[-Wavvertire...] [-pedante]
[-Idir...] [-Ldir...]
[-Dmacro[=def] ...] [-Umacro]
[-fopzione...]
[-mmacchina-opzione...]
[-o file di uscita] infilare...

Qui sono elencate solo le opzioni più utili; vedi sotto per il resto.

DESCRIZIONE

I gfortran comando supporta tutte le opzioni supportate dal gcc comando. Solo opzioni
specifici per GNU Fortran sono documentati qui.

Tutte le opzioni GCC e GNU Fortran sono accettate sia da gfortran e gcc (così come qualsiasi
altri driver costruiti allo stesso tempo, come g ++), da quando è stato aggiunto GNU Fortran al GCC
La distribuzione consente l'accettazione delle opzioni GNU Fortran da parte di tutti i driver pertinenti.

In alcuni casi, le opzioni hanno forme positive e negative; la forma negativa di -foo sarebbe
be -fno-pippo. Questo manuale documenta solo una di queste due forme, qualunque non sia la
predefinito.

VERSIONI

Ecco un riepilogo di tutte le opzioni specifiche di GNU Fortran, raggruppate per tipo.
Le spiegazioni sono nelle sezioni seguenti.

Fortran Lingua Opzioni
-fall-intrinseche -barra inversa -fcray-puntatore -fd-linee-come-codice -fd-linee-come-commenti
-fdefault-doppio-8 -fdefault-intero-8 -fdefault-real-8 -fdollaro-ok
-linea-fissa-lunghezza-n -linea-fissa-lunghezza-nessuna -forma libera -lunghezza-linea-libera-n
-flunghezza-linea-nessuna -implicito-nessuno -fiteger-4-intero-8 -fmax-identificatore-lunghezza
-fmodulo-privato -forma-fissa -fno-range-check -fonacc -fopenmp -freal-4-real-10
-freal-4-real-16 -freal-4-real-8 -freal-8-real-10 -freal-8-real-16 -freal-8-real-4
-std=std

Pre-elaborazione Opzioni
-UN-domanda[=rispondere] -Adomanda=rispondere -C -CC -Dmacro[=def] -H -P -Umacro -cpp -dd
-dI -dM -dN -dU -fdirectory-di-lavoro -imultilib dir -iprefisso filetto -quoto -isysroot dir
-isistema dir -nocpp -nostdin -undif

Errore ed avvertimento Opzioni
-Walias -Parete - Sabbiosa -Warray-limiti -Wc-binding-tipo -Wcarattere-troncamento
-Conversione -Wfunction-eliminazione -Interfaccia Wimplicit -Procedura Wimplicit
-Ombra Wintrinsic -Wuse-senza-solo -Wintrinsics-std -Wline-troncamento
-No-align-commons -Wno-schede -Costante-q-Wreal -Wsorprendente -Flusso meraviglioso
-Wunused-parametro -Wrealloc-sx -Wrealloc-lhs-tutto -Wtarget-durata -fmax-errori=n
-fsintassi solo -pedante -errori-pedanti

Debug Opzioni
-fbacktrace -fdump-fortran-ottimizzato -fdump-fortran-originale -fdump-albero di analisi
-ffpe-trappola=stratagemma -ffpe-riepilogo=stratagemma

elenco Opzioni
-Idir -Jdir -percorso-moduli-fintrinsic dir

Link Opzioni
-static-libgfortran

Runtime Opzioni
-fconvert=conversione -fmax-lunghezza-subrecord=lunghezza -marcatore-frequenza=lunghezza -fsegno-zero

Code Generazione Opzioni
-eliminazione-funzione-faggressiva -fblas-matmul-limite=n -fbounds-check
-fcheck-array-temporanei -fcontrollo=
-fcoarray= -festerno-blas -ff2c -ffrontend-ottimizzare
-carattere-finito=n -finito-intero=n -finit-locale-zero -finit-logico=
-finito-reale= -fmax-array-costruttore=n -fmax-stack-var-size=n
-fno-align-comuni -fno-automatico -fno-protect-parents -fno-sottolineatura
-fsecondo-underscore -fpack-derivato -frealloc-sx -frequente -frepack-array
-fshort-enum -fstack-array

Opzioni controllo Fortran dialetto
Le seguenti opzioni controllano i dettagli del dialetto Fortran accettato dal compilatore:

-forma libera
-forma-fissa
Specificare il layout utilizzato dal file di origine. Il layout a forma libera è stato introdotto in
Fortran 90. La forma fissa era tradizionalmente utilizzata nei vecchi programmi Fortran. quando
nessuna opzione è specificata, il modulo di origine è determinato dall'estensione del file.

-fall-intrinseche
Questa opzione fa sì che tutte le procedure intrinseche (incluse le estensioni specifiche di GNU)
essere accettato. Questo può essere utile con -std=f95 forzare la conformità agli standard ma ottenere
accesso alla gamma completa di intrinseci disponibili con gfortran. Come conseguenza,
-Wintrinsics-std verrà ignorato e nessuna procedura definita dall'utente con lo stesso nome di
qualsiasi intrinseco verrà chiamato tranne quando è esplicitamente dichiarato "ESTERNO".

-fd-linee-come-codice
-fd-linee-come-commenti
Abilita un trattamento speciale per le righe che iniziano con "d" o "D" nelle origini in forma fissa.
Se l' -fd-linee-come-codice viene data l'opzione sono trattati come se la prima colonna
conteneva uno spazio vuoto. Se la -fd-linee-come-commenti l'opzione è data, sono trattati come
righe di commento.

-fdollaro-ok
Consentire $ come un carattere non primo valido in un nome di simbolo. Simboli che iniziano con $ sono
rifiutato poiché non è chiaro quali regole applicare alla tipizzazione implicita in quanto diverse
i fornitori applicano regole diverse. Usando $ anche nelle dichiarazioni "IMPLICIT" viene respinta.

-barra inversa
Modificare l'interpretazione delle barre rovesciate nelle stringhe letterali da una singola barra rovesciata
carattere a caratteri di escape "stile C". Le seguenti combinazioni sono espanse
"\a", "\b", "\f", "\n", "\r", "\t", "\v", "\\" e "\0" ai caratteri ASCII
avviso, backspace, avanzamento modulo, nuova riga, ritorno a capo, scheda orizzontale, scheda verticale,
rispettivamente barra rovesciata e NUL. Inoltre, "\x"nn, "\u"nnnn e tu"nnnnnnnn
(dove ciascuno n è una cifra esadecimale) sono tradotti nei caratteri Unicode
corrispondenti ai punti di codice specificati. Tutte le altre combinazioni di un personaggio
preceduti da \ non sono espansi.

-fmodulo-privato
Imposta l'accessibilità predefinita delle entità del modulo su "PRIVATE". Associato all'uso
le entità non saranno accessibili a meno che non siano esplicitamente dichiarate come "PUBBLICHE".

-linea-fissa-lunghezza-n
Imposta la colonna dopo la quale i caratteri vengono ignorati nelle tipiche righe a forma fissa nel
file sorgente, e attraverso il quale vengono assunti gli spazi (come se fossero riempiti fino a quella lunghezza) dopo
le estremità di brevi linee a forma fissa.

Valori popolari per n includono 72 (lo standard e il valore predefinito), 80 (immagine della scheda) e
132 (corrispondente alle opzioni "fonte estesa" in alcuni compilatori popolari). n può
anche essere nessuna, il che significa che l'intera linea è significativa e quel carattere continuato
alle costanti non vengono mai aggiunti spazi impliciti per riempire la riga.
-lunghezza-riga-fissa-0 significa la stessa cosa di -linea-fissa-lunghezza-nessuna.

-lunghezza-linea-libera-n
Imposta la colonna dopo la quale i caratteri vengono ignorati nelle tipiche righe in formato libero nel sorgente
file. Il valore predefinito è 132. n può essere nessuna, il che significa che l'intera linea è
significativo. -flunghezza-riga-0 significa la stessa cosa di -flunghezza-linea-nessuna.

-fmax-identificatore-lunghezza=n
Specificare la lunghezza massima consentita dell'identificatore. I valori tipici sono 31 (Fortran 95) e
63 (Fortran 2003 e Fortran 2008).

-implicito-nessuno
Specificare che non è consentita la digitazione implicita, a meno che non venga sovrascritto da "IMPLICIT" esplicito
dichiarazioni. Questo è l'equivalente di aggiungere "nessuno implicito" all'inizio di ogni
procedura.

-fcray-puntatore
Abilita l'estensione del puntatore Cray, che fornisce funzionalità di puntatore di tipo C.

-fonacc
Abilita le estensioni OpenACC. Ciò include le direttive OpenACC "!$acc" in forma libera
e le direttive "c$acc", *$acc e "!$acc" in forma fissa, compilazione condizionale "!$"
sentinelle in forma libera e sentinelle "c$", "*$" e "!$" in forma fissa, e quando
collegamento fa in modo che la libreria runtime di OpenACC venga collegata.

Tieni presente che questa è una funzionalità sperimentale, incompleta e soggetta a modifiche in futuro
versioni di GCC. Vederehttps://gcc.gnu.org/wiki/OpenACC> per maggiori informazioni.

-fopenmp
Abilita le estensioni OpenMP. Ciò include le direttive OpenMP "!$omp" in forma libera
e le direttive "c$omp", *$omp e "!$omp" in forma fissa, compilazione condizionale "!$"
sentinelle in forma libera e sentinelle "c$", "*$" e "!$" in forma fissa, e quando
il collegamento fa in modo che la libreria di runtime di OpenMP venga collegata. L'opzione -fopenmp
implica -frequente.

-fno-range-check
Disabilita il controllo dell'intervallo sui risultati della semplificazione delle espressioni costanti durante
compilazione. Ad esempio, GNU Fortran darà un errore in fase di compilazione quando
semplificando "a = 1. / 0". Con questa opzione, non verrà dato alcun errore e sarà "a"
assegnato il valore "+Infinito". Se un'espressione restituisce un valore al di fuori di
intervallo rilevante di ["-HUGE()":"HUGE()"], l'espressione verrà sostituita da "-Inf"
o "+Inf" come appropriato. Allo stesso modo, "DATA i/Z'FFFFFFFF'/" risulterà in un numero intero
overflow sulla maggior parte dei sistemi, ma con -fno-range-check il valore si "avvolgerà" e
"i" verrà invece inizializzato su -1.

-fdefault-intero-8
Imposta i tipi intero e logico predefiniti su un tipo di larghezza di 8 byte. Anche questa opzione
influenza il tipo di costanti intere come 42. Diversamente -fiteger-4-intero-8, lo fa
non promuovere variabili con dichiarazione di tipo esplicita.

-fdefault-real-8
Imposta il tipo reale predefinito su un tipo largo 8 byte. Questa opzione influisce anche sul tipo di
costanti reali non doppie come 1.0 e promuove la larghezza predefinita di "DOUBLE
PRECISIONE" a 16 byte se possibile, a meno che non venga fornito anche "-fdefault-double-8". Diversamente
-freal-4-real-8, non promuove variabili con dichiarazione di tipo esplicita.

-fdefault-doppio-8
Impostare il tipo "DOUBLE PRECISION" su un tipo largo 8 byte. Non fare nulla se questo è già
il predefinito. Se -fdefault-real-8 è dato, "DOPPIO PRECISIONE" sarebbe invece
promosso a 16 byte, se possibile, e -fdefault-doppio-8 può essere utilizzato per impedirlo.
Il tipo di costanti reali come "1.d0" non verrà modificato da -fdefault-real-8 anche se,
quindi anche -fdefault-doppio-8 non lo influenza.

-fiteger-4-intero-8
Promuovi tutte le entità "INTEGER(KIND=4)" a entità "INTEGER(KIND=8)". Se "TIPO=8"
non è disponibile, verrà emesso un errore. Questa opzione deve essere utilizzata con cautela
e potrebbe non essere adatto ai tuoi codici. Le aree di possibile preoccupazione includono le chiamate a
procedure esterne, allineamento in "EQUIVALENZA" e/o "COMUNE", interfacce generiche,
Conversione costante letterale BOZ e I/O. Ispezione dell'intermedio
rappresentazione del codice Fortran tradotto, prodotto da -fdump-tree-originale, è
suggerito.

-freal-4-real-8
-freal-4-real-10
-freal-4-real-16
-freal-8-real-4
-freal-8-real-10
-freal-8-real-16
Promuovi tutte le entità "REAL(KIND=M)" a entità "REAL(KIND=N)". Se "REALE(TIPO=N)" è
non disponibile, verrà emesso un errore. Tutti gli altri tipi di tipo reale non sono interessati
da questa opzione. Queste opzioni devono essere utilizzate con cautela e potrebbero non essere adatte a
i tuoi codici Le aree di possibile preoccupazione includono chiamate a procedure esterne, allineamento
in "EQUIVALENZA" e/o "COMUNE", interfacce generiche, conversione costante letterale BOZ,
e I/O. Ispezione della rappresentazione intermedia del Fortran . tradotto
codice, prodotto da -fdump-tree-originale, è suggerito.

-std=std
Specificare lo standard a cui ci si aspetta che il programma sia conforme, che può essere uno di
f95, f2003, f2008, gnu, o eredità. Il valore predefinito per std is gnu, che specifica
un superset dello standard Fortran 95 che include tutte le estensioni supportate da
GNU Fortran, anche se verranno forniti avvisi per estensioni obsolete non consigliate
per l'uso nel nuovo codice. Il eredità value è equivalente ma senza gli avvertimenti per
estensioni obsolete e può essere utile per vecchi programmi non standard. Il f95, f2003
ed f2008 i valori specificano la stretta conformità a Fortran 95, Fortran 2003 e
standard Fortran 2008, rispettivamente; vengono forniti errori per tutte le estensioni oltre a
standard linguistico pertinente e vengono fornite avvertenze per le funzionalità del Fortran 77 che
sono consentiti ma obsoleti negli standard successivi. -std=f2008ts permette il Fortran 2008
standard che include le integrazioni della Specifica Tecnica (TS) 29113 su Ulteriori
Interoperabilità di Fortran con C e TS 18508 su funzionalità parallele aggiuntive in
Fortran.

permettere ed personalizzare pre-elaborazione
Opzioni relative al preprocessore. Vedi sezione Pre-elaborazione ed condizionale compilazione per
informazioni più dettagliate sulla pre-elaborazione in gfortran.

-cpp
-nocpp
Abilita la pre-elaborazione. Il preprocessore viene invocato automaticamente se l'estensione del file
is .fpp, .FPP, .F, .PER, .FTN, .F90, .F95, .F03 or .F08. Usa questa opzione per manualmente
abilitare la preelaborazione di qualsiasi tipo di file Fortran.

Per disabilitare la pre-elaborazione dei file con una delle estensioni sopra elencate, utilizzare il pulsante
forma negativa: -nocpp.

Il preprocessore viene eseguito in modalità tradizionale. Eventuali restrizioni del formato del file,
in particolare i limiti sulla lunghezza della linea, si applicano anche all'output preelaborato, quindi
potrebbe essere consigliabile utilizzare il -flunghezza-linea-nessuna or -linea-fissa-lunghezza-nessuna
opzioni.

-dM Invece del normale output, genera un elenco di direttive '#define' per tutte le
macro definite durante l'esecuzione del preprocessore, incluse le macro predefinite.
Questo ti dà un modo per scoprire cosa è predefinito nella tua versione del
preprocessore. Supponendo che tu non abbia file foo.f90, il comando

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

mostrerà tutte le macro predefinite.

-dd Come -dM tranne per due aspetti: non include le macro predefinite e
restituisce sia le direttive "#define" che il risultato della preelaborazione. Entrambi i tipi di
l'output va al file di output standard.

-dN Come -dd, ma emettono solo i nomi delle macro, non le loro espansioni.

-dU Come dD tranne che solo le macro che sono espanse o la cui definizione è testata in
le direttive del preprocessore vengono emesse; l'uscita viene ritardata fino all'utilizzo o al test di
la macro; e le direttive '#undef' vengono emesse anche per le macro testate ma non definite in
il tempo.

-dI Direttive di output '#include' oltre al risultato della preelaborazione.

-fdirectory-di-lavoro
Abilita la generazione di linemarker nell'output del preprocessore che consentirà al compilatore
conoscere la directory di lavoro corrente al momento della preelaborazione. Quando questa opzione è
abilitato, il preprocessore emetterà, dopo il linemarker iniziale, un secondo linemarker
con la directory di lavoro corrente seguita da due barre. GCC userà questo
directory, quando è presente nell'input preelaborato, come directory emessa come
la directory di lavoro corrente in alcuni formati di informazioni di debug. Questa opzione è
abilitato implicitamente se le informazioni di debug sono abilitate, ma questo può essere inibito con
la forma negata -fno-directory-di-lavoro. Se il -P flag è presente nel comando
line, questa opzione non ha effetto, poiché non vengono emesse direttive "#line".

-idirafter dir
Cerca dir per i file include, ma fallo dopo tutte le directory specificate con -I ed
le directory di sistema standard sono state esaurite. dir viene trattato come un sistema
includi directory. Se dir inizia con "=", allora "=" sarà sostituito da
prefisso sysroot; vedere --sysroot ed -isysroot.

-imultilib dir
Usa il dir come sottodirectory della directory contenente le intestazioni C++ specifiche della destinazione.

-iprefisso prefisso
Specificare prefisso come prefisso per il successivo -icon prefisso opzioni. Se la prefisso
rappresenta una directory, dovresti includere la '/' finale.

-isysroot dir
Questa opzione è come la --sysroot opzione, ma si applica solo ai file di intestazione. Vedi il
--sysroot opzione per ulteriori informazioni.

-quoto dir
Cerca dir solo per i file header richiesti con "#include "file""; non sono
cercato "#include ", prima di tutte le directory specificate da -I e prima del
directory di sistema standard. Se dir inizia con "=", quindi "=" sarà sostituito da
il prefisso sysroot; vedere --sysroot ed -isysroot.

-isistema dir
Cerca dir per i file di intestazione, dopo tutte le directory specificate da -I ma prima del
directory di sistema standard. Contrassegnalo come directory di sistema, in modo che ottenga lo stesso
trattamento speciale applicato alle directory di sistema standard. Se dir inizia con
"=", quindi "=" sarà sostituito dal prefisso sysroot; vedere --sysroot ed -isysroot.

-nostdin
Non cercare file di intestazione nelle directory di sistema standard. Solo le directory
hai specificato con -I opzioni (e la directory del file corrente, se
appropriato) vengono cercati.

-undif
Non predefinire macro specifiche del sistema o GCC. Lo standard predefinito
le macro rimangono definite.

-Apredicato=rispondere
Fare un'asserzione con il predicato predicato e rispondi rispondere. Questo modulo è
preferito alla forma più vecchia -A predicato(risposta), che è ancora supportata, perché
non usa caratteri speciali della shell.

-UN-predicato=rispondere
Annulla un'asserzione con il predicato predicato e rispondi rispondere.

-C Non scartare i commenti. Tutti i commenti vengono passati al file di output, tranne
per i commenti nelle direttive elaborate, che vengono eliminati insieme alla direttiva.

Dovresti essere preparato agli effetti collaterali durante l'utilizzo -C; fa sì che il preprocessore
trattare i commenti come token a sé stanti. Ad esempio, i commenti che compaiono su
l'inizio di quella che sarebbe una linea direttiva ha l'effetto di trasformare quella linea in un
linea di origine ordinaria, poiché il primo token sulla linea non è più un '#'.

Avvertenza: attualmente gestisce solo i commenti in stile C. Il preprocessore non lo fa ancora
riconoscere i commenti in stile Fortran.

-CC Non scartare i commenti, anche durante l'espansione della macro. Questo è come -C, ad eccezione
che i commenti contenuti nelle macro vengano passati anche al file di output dove
la macro è espansa.

Oltre agli effetti collaterali del -C opzione, il -CC opzione causa tutto lo stile C++
commenti all'interno di una macro da convertire in commenti in stile C. Questo per prevenire dopo
l'uso di quella macro per commentare inavvertitamente il resto della riga di origine.
I -CC L'opzione viene generalmente utilizzata per supportare i commenti lint.

Avvertenza: attualmente gestisce solo i commenti in stile C e C++. Il preprocessore lo fa
non riconosce ancora i commenti in stile Fortran.

-DNome
Predefinire il nome come macro, con definizione 1.

-DNome=definizione
Il contenuto di definizione vengono tokenizzati ed elaborati come se apparissero durante
fase di traduzione tre in una direttiva '#define'. In particolare, la definizione sarà
essere troncato da caratteri di nuova riga incorporati.

Se stai invocando il preprocessore da una shell o da un programma simile a una shell potresti aver bisogno
per usare la sintassi delle virgolette della shell per proteggere caratteri come gli spazi che hanno a
significato nella sintassi della shell.

Se desideri definire una macro simile a una funzione sulla riga di comando, scrivi il suo argomento
elenco racchiuso tra parentesi prima del segno di uguale (se presente). Le parentesi sono
significativo per la maggior parte delle shell, quindi dovrai citare l'opzione. Con sh e csh,
"-D'name(args...)=definition'" funziona.

-D ed -U le opzioni vengono elaborate nell'ordine in cui vengono fornite sulla riga di comando. Tutto
-imacros file e -include file options vengono elaborate dopo tutte le opzioni -D e -U.

-H Stampa il nome di ogni file di intestazione utilizzato, oltre alle altre normali attività. Ogni
name è rientrato per mostrare quanto è profondo nello stack '#include'.

-P Inibire la generazione di linemarker nell'output del preprocessore. Questo potrebbe essere
utile quando si esegue il preprocessore su qualcosa che non è codice C e verrà inviato
a un programma che potrebbe essere confuso dai linemarker.

-UNome
Annulla qualsiasi definizione precedente di Nome, sia integrato che dotato di a -D opzione.

Opzioni a richiesta or reprimere errori ed avvertenze
Gli errori sono messaggi diagnostici che segnalano che il compilatore GNU Fortran non può compilare
il pezzo di codice sorgente pertinente. Il compilatore continuerà a elaborare il programma in
un tentativo di segnalare ulteriori errori per aiutare nel debug, ma non produrrà alcun compilato
produzione.

Gli avvisi sono messaggi diagnostici che segnalano costruzioni che non sono intrinsecamente
errati ma che sono rischiosi o suggeriscono che è probabile che ci sia un bug nel programma.
Salvo che -Errore è specificato, non impediscono la compilazione del programma.

Puoi richiedere molti avvisi specifici con le opzioni che iniziano -W, Per esempio - Wimplicit
per richiedere avvisi su dichiarazioni implicite. Ognuna di queste specifiche opzioni di avviso anche
ha una forma negativa che inizia -No- disattivare gli avvisi; Per esempio, -Non-implicito.
Questo manuale elenca solo uno dei due moduli, qualunque non sia quello predefinito.

Queste opzioni controllano la quantità e i tipi di errori e avvisi prodotti da GNU Fortran:

-fmax-errori=n
Limita il numero massimo di messaggi di errore a n, a quel punto GNU Fortran si salva
piuttosto che tentare di continuare a elaborare il codice sorgente. Se n è 0, non c'è
limite al numero di messaggi di errore prodotti.

-fsintassi solo
Controlla il codice per errori di sintassi, ma non compilarlo effettivamente. Questo genererà
file di modulo per ogni modulo presente nel codice, ma nessun altro file di output.

-pedante
Emetti avvisi per l'uso di estensioni a Fortran 95. -pedante vale anche per
Costrutti in linguaggio C dove si trovano nei file sorgente GNU Fortran, come l'uso di \e
in un carattere costante all'interno di una direttiva come "#include".

I programmi Fortran 95 validi dovrebbero essere compilati correttamente con o senza questa opzione.
Tuttavia, senza questa opzione, alcune estensioni GNU e le tradizionali funzionalità Fortran
sono anche supportati. Con questa opzione, molti di loro vengono rifiutati.

Alcuni utenti provano a usare -pedante per verificare la conformità dei programmi. Trovano presto
che non fa esattamente quello che vogliono --- trova alcune pratiche non standard, ma
non tutto. Tuttavia, i miglioramenti a GNU Fortran in quest'area sono i benvenuti.

Questo dovrebbe essere usato insieme a -std=f95, -std=f2003 or -std=f2008.

-errori-pedanti
Come -pedante, tranne per il fatto che vengono prodotti errori anziché avvisi.

-Parete
Abilita le opzioni di avviso di uso comune relative all'utilizzo che consigliamo di evitare
e che riteniamo facili da evitare. Questo attualmente include -Walias,
- Sabbiosa, -Conversione, -Wsorprendente, -Wc-binding-tipo, -Wintrinsics-std,
-Wno-schede, -Ombra Wintrinsic, -Wline-troncamento, -Wtarget-durata, -Costante-q-Wreal
ed -Wunusato.

-Walias
Avvisa del possibile aliasing di argomenti fittizi. Nello specifico, avvisa se lo stesso
l'argomento effettivo è associato a un argomento fittizio con "INTENT(IN)" e un fittizio
argomento con "INTENT(OUT)" in una chiamata con un'interfaccia esplicita.

L'esempio seguente attiverà l'avviso.

interfaccia
barra delle subroutine(a,b)
intero, intento (in) :: a
intero, intent(out) :: b
fine sottoprogramma
interfaccia finale
intero :: a

chiamata bar(a,a)

- Sabbiosa
Avvisa della e commerciale mancante nelle costanti di carattere continue. L'avvertimento è dato
con - Sabbiosa, -pedante, -std=f95, -std=f2003 ed -std=f2008. Nota: con no
e commerciale data in un carattere costante costante, GNU Fortran assume la continuazione a
il primo carattere non di commento, non di spazio bianco dopo la e commerciale che ha avviato il
continuazione.

-Warray-temporanei
Avvisa degli array temporanei generati dal compilatore. Le informazioni generate da
questo avviso è talvolta utile nell'ottimizzazione, per evitare tali temporanei.

-Wc-binding-tipo
Avvisa se una variabile potrebbe non essere interoperabile in C. In particolare, avvisare se il
la variabile è stata dichiarata usando un tipo intrinseco con tipo predefinito invece di usare
un parametro gentile definito per l'interoperabilità C nell'intrinseco "ISO_C_Binding"
modulo. Questa opzione è implicata da -Parete.

-Wcarattere-troncamento
Avvisa quando l'assegnazione di un carattere troncherà la stringa assegnata.

-Wline-troncamento
Avvisa quando una riga di codice sorgente verrà troncata. Questa opzione è implicata da -Parete. For
codice sorgente in formato libero, l'impostazione predefinita è -Errore=troncamento di riga tale che i troncamenti
vengono segnalati come errore.

-Conversione
Avvisa delle conversioni implicite che potrebbero modificare il valore dell'espressione
dopo la conversione. Implicito da -Parete.

-Wconversione-extra
Avvisa delle conversioni implicite tra tipi e tipi diversi. Questa opzione non
non implicare -Conversione.

-Wextra
Abilita alcune opzioni di avviso per l'utilizzo di funzioni linguistiche che potrebbero essere problematiche.
Questo attualmente include -Confronto-reali ed -Wunused-parametro.

-Interfaccia Wimplicit
Avvisa se una procedura viene chiamata senza un'interfaccia esplicita. Nota che questo controlla solo
che sia presente un'interfaccia esplicita. Non verifica che le interfacce dichiarate
sono coerenti tra le unità di programma.

-Procedura Wimplicit
Avvisa se viene chiamata una procedura che non ha né un'interfaccia esplicita né è stata
dichiarato come "ESTERNO".

-Wintrinsics-std
Avvisa se gfortran trova una procedura denominata come un intrinseco non disponibile nel
standard attualmente selezionato (con -std) e la tratta come procedura "ESTERNA" perché
di questo. -fall-intrinseche può essere utilizzato per non attivare mai questo comportamento e collegare sempre
all'intrinseco indipendentemente dallo standard selezionato.

-Costante-q-Wreal
Produci un avviso se una costante letterale reale contiene una lettera esponente "q".

-Wsorprendente
Genera un avviso quando vengono rilevati costrutti di codice "sospetti". Mentre
tecnicamente legali questi di solito indicano che è stato commesso un errore.

Questo attualmente produce un avviso nelle seguenti circostanze:

* Un costrutto INTEGER SELECT ha un CASE che non può mai essere abbinato come suo inferiore
valore è maggiore del suo valore superiore.

* Un costrutto LOGICAL SELECT ha tre istruzioni CASE.

* Un TRASFERIMENTO specifica una sorgente più corta della destinazione.

* Il tipo di un risultato di funzione è dichiarato più di una volta con lo stesso tipo. Se
-pedante o è abilitata la modalità conforme allo standard, si tratta di un errore.

* Viene dichiarata una variabile "CHARACTER" con lunghezza negativa.

-Wtab
Per impostazione predefinita, le schede sono accettate come spazi bianchi, ma le schede non sono membri del Fortran
Set di caratteri. Per le righe di continuazione, una tabulazione seguita da una cifra compresa tra 1 e 9 è
supportato. -Wtab causerà l'emissione di un avviso se viene rilevata una scheda. Nota,
-Wtab è attivo per -pedante, -std=f95, -std=f2003, -std=f2008, -std=f2008ts ed
-Parete.

-Flusso meraviglioso
Produrre un avviso quando si incontrano espressioni numeriche costanti, che producono un
UNDERFLOW durante la compilazione. Abilitato per impostazione predefinita.

-Ombra Wintrinsic
Avvisa se una procedura definita dall'utente o modulo ha lo stesso nome di un
intrinseco; in questo caso un'interfaccia esplicita o "ESTERNA" o "INTRINSECA"
potrebbe essere necessaria una dichiarazione per ottenere le chiamate in seguito risolte nel desiderato
intrinseco/procedura. Questa opzione è implicata da -Parete.

-Wuse-senza-solo
Avvisa se un'istruzione "USE" non ha il qualificatore "ONLY" e quindi importa implicitamente tutto
enti pubblici del modulo utilizzato.

-Argomento-dummy-Wunused
Avvisa degli argomenti fittizi non utilizzati. Questa opzione è implicata da -Parete.

-Wunused-parametro
Contrario a gccil significato di -Wunused-parametro, gfortranl'implementazione di questo
l'opzione non avvisa degli argomenti fittizi non utilizzati (vedi -Argomento-dummy-Wunused), ma
sui valori "PARAMETER" non utilizzati. -Wunused-parametro è implicato da -Wextra se anche
-Wunusato or -Parete viene utilizzato.

-Walign-comuni
Per impostazione predefinita, gfortran avverte di ogni occasione in cui le variabili vengono riempite per il corretto
allineamento all'interno di un blocco "COMMON". Questo avviso può essere disattivato tramite
-No-align-commons. Vedi anche -falsi-comuni.

-Wfunction-eliminazione
Avvisa se eventuali chiamate alle funzioni vengono eliminate dalle ottimizzazioni abilitate dal
-ffrontend-ottimizzare opzione.

-Wrealloc-sx
Avvisa quando il compilatore potrebbe inserire codice per l'allocazione o la riallocazione di an
variabile array allocabile di tipo intrinseco nelle assegnazioni intrinseche. Nei circuiti caldi,
la funzione di riallocazione Fortran 2003 può ridurre le prestazioni. Se l'array è
già allocato con la forma corretta, considerare l'utilizzo di un array-spec dell'intero array
(es. "(:,:,:)") per la variabile a sinistra per impedire la riallocazione
dai un'occhiata. Nota che in alcuni casi viene mostrato l'avviso, anche se il compilatore lo farà
ottimizzare i controlli di riallocazione. Ad esempio, quando il lato destro contiene
la stessa variabile moltiplicata per uno scalare. Guarda anche -frealloc-sx.

-Wrealloc-lhs-tutto
Avvisa quando il compilatore inserisce il codice per l'allocazione o la riallocazione di an
variabile allocabile; questo include scalari e tipi derivati.

-Confronto-reali
Avvisa quando si confrontano tipi reali o complessi per l'uguaglianza o la disuguaglianza. Questa opzione è
implicito da -Wextra.

-Wtarget-durata
Avvisa se il puntatore in un'assegnazione di puntatore potrebbe essere più lungo della sua destinazione. Questo
l'opzione è implicita in -Parete.

-Wzerotrip
Avvisa se è noto che un ciclo "DO" viene eseguito zero volte in fase di compilazione. Questa opzione è
implicito da -Parete.

-Errore
Trasforma tutti gli avvisi in errori.

Alcuni di questi non hanno effetto quando si compilano programmi scritti in Fortran.

Opzioni per debug il tuo Programma or GNU Fortran
GNU Fortran ha varie opzioni speciali che vengono utilizzate per eseguire il debug del tuo programma o
il compilatore GNU Fortran.

-fdump-fortran-originale
Emetti l'albero di analisi interno dopo aver tradotto il programma sorgente in internal
rappresentazione. Davvero utile solo per il debug del compilatore GNU Fortran stesso.

-fdump-fortran-ottimizzato
Emetti l'albero di analisi dopo l'ottimizzazione front-end. Davvero utile solo per il debug
il compilatore GNU Fortran stesso.

-fdump-albero di analisi
Emetti l'albero di analisi interno dopo aver tradotto il programma sorgente in internal
rappresentazione. Davvero utile solo per il debug del compilatore GNU Fortran stesso.
Questa opzione è deprecata; usa invece "-fdump-fortran-original".

-ffpe-trappola=stratagemma
Specificare un elenco di trap di eccezioni a virgola mobile da abilitare. Sulla maggior parte dei sistemi, se a
si verifica un'eccezione in virgola mobile e il trap per tale eccezione è abilitato, un SIGFPE
segnale verrà inviato e il programma verrà interrotto, producendo un file core utile per
debug. stratagemma è un elenco (possibilmente vuoto) dei seguenti elementi separati da virgole
eccezioni: invalido (operazione in virgola mobile non valida, ad esempio "SQRT(-1.0)"), zero
(divisione per zero), traboccare (overflow in un'operazione in virgola mobile), sottoflusso
(underflow in un'operazione in virgola mobile), falso (perdita di precisione durante
operazione), e denormale (operazione eseguita su un valore denormale). I primi cinque
corrispondono alle cinque eccezioni IEEE 754, mentre l'ultima (denormale)
non fa parte dello standard IEEE 754 ma è disponibile su alcune architetture comuni
come x86.

Le prime tre eccezioni (invalido, zeroe traboccare) spesso indicano seri
errori e, a meno che il programma non disponga di disposizioni per gestire queste eccezioni,
abilitare le trap per queste tre eccezioni è probabilmente una buona idea.

Molte, se non la maggior parte, delle operazioni in virgola mobile subiscono una perdita di precisione a causa dell'arrotondamento,
e quindi è probabile che "ffpe-trap=inesact" non sia interessante nella pratica.

Per impostazione predefinita, non sono abilitati trap di eccezione.

-ffpe-riepilogo=stratagemma
Specificare un elenco di eccezioni in virgola mobile, il cui stato flag viene stampato su
"ERROR_UNIT" quando si invoca "STOP" e "ERROR STOP". stratagemma può essere uno dei due nessuna, contro tutti i o
elenco separato da virgole delle seguenti eccezioni: invalido, zero, traboccare, sottoflusso,
falso ed denormale. (Vedi -ffpe-trappola per una descrizione delle eccezioni.)

Per impostazione predefinita, un riepilogo per tutte le eccezioni ma falso è mostrato.

-fno-backtrace
Quando si verifica un grave errore di runtime o viene emesso un segnale mortale
(errore di segmentazione, istruzione non valida, errore del bus, eccezione in virgola mobile e il
altri segnali POSIX che hanno l'azione core), la libreria runtime Fortran tenta di
produrre un backtrace dell'errore. "-fno-backtrace" disabilita la generazione del backtrace.
Questa opzione ha effetto solo sulla compilazione del programma principale Fortran.

Opzioni per elenco Ricerca
Queste opzioni influenzano il modo in cui GNU Fortran cerca i file specificati da "INCLUDE"
direttiva e dove cerca i moduli compilati in precedenza.

Influisce anche sui percorsi di ricerca utilizzati da cpp quando usato per preelaborare il sorgente Fortran.

-Idir
Questi influenzano l'interpretazione della direttiva "INCLUDE" (così come del "#include"
direttiva del cpp preprocessore).

Si noti inoltre che il comportamento generale di -I e "INCLUDE" è praticamente lo stesso di
-I con "#include" nel cpp preprocessore, per quanto riguarda la ricerca di intestazione.gcc
file e altre cose del genere.

Questo percorso viene utilizzato anche per cercare .mod file quando i moduli compilati in precedenza sono
richiesto da un'istruzione "USE".

-Jdir
Questa opzione specifica dove mettere .mod file per moduli compilati. Si aggiunge anche
all'elenco delle directory da ricercare con un'istruzione "USE".

L'impostazione predefinita è la directory corrente.

-percorso-moduli-fintrinsic dir
Questa opzione specifica la posizione dei moduli intrinseci precompilati, se non lo sono
nella posizione predefinita prevista dal compilatore.

influenzare , il collegamento passo
Queste opzioni entrano in gioco quando il compilatore collega i file oggetto in un eseguibile
file di uscita. Sono privi di significato se il compilatore non esegue un passaggio di collegamento.

-static-libgfortran
Su sistemi che forniscono libgfortran come libreria condivisa e statica, questa opzione
impone l'uso della versione statica. Se nessuna versione condivisa di libgfortran fu costruito
quando il compilatore è stato configurato, questa opzione non ha effetto.

influenzare runtime comportamento
Queste opzioni influenzano il comportamento di runtime dei programmi compilati con GNU Fortran.

-fconvert=conversione
Specificare la rappresentazione dei dati per i file non formattati. Valori validi per la conversione
siamo: nativo, il predefinito; swap, scambia tra big- e little-endian; big endian, Utilizzare
rappresentazione big-endian per file non formattati; little endian, usa little-endian
rappresentazione per file non formattati.

La sezione opzione ha an effetto esclusivamente quando utilizzato in , il principale . I "CONVERTIRE" specificatore
ed , il GFORTRAN_CONVERT_UNIT ambiente variabile Override , il difetto specificato by
-fconvert.

-marcatore-frequenza=lunghezza
Specificare la lunghezza degli indicatori di record per i file non formattati. Valori validi per lunghezza
sono 4 e 8. Il valore predefinito è 4. La sezione is diverso da precedente versioni of gfortran,
che specificava una lunghezza predefinita dell'indicatore di registrazione di 8 sulla maggior parte dei sistemi. Se lo desidera
leggere o scrivere file compatibili con versioni precedenti di gfortran, Utilizzare
-marcatore-frequenza=8.

-fmax-lunghezza-subrecord=lunghezza
Specificare la lunghezza massima per un sottorecord. Il valore massimo consentito per la lunghezza è
2147483639, che è anche l'impostazione predefinita. Davvero utile solo per l'uso da parte del gfortran
suite di prova.

-fsegno-zero
Quando abilitato, vengono scritti i numeri in virgola mobile di valore zero con il bit di segno impostato
come numero negativo nell'output formattato e trattato come negativo nel "SIGN"
intrinseco. -fno-segno-zero non stampa il segno negativo di zero valori (o valori
arrotondato a zero per I/O) e considera zero come numero positivo nel "SIGN" intrinseco
per compatibilità con Fortran 77. L'impostazione predefinita è -fsegno-zero.

Opzioni per codice ELETTRICA convenzioni
Queste opzioni indipendenti dalla macchina controllano le convenzioni di interfaccia utilizzate nel codice
generazione.

La maggior parte di loro ha forme sia positive che negative; la forma negativa di -foo sarebbe
-fno-pippo. Nella tabella sottostante è elencata solo una delle forme --- quella che non è la
predefinito. Puoi capire l'altra forma rimuovendo no- o aggiungendolo.

-fno-automatico
Tratta ogni unità di programma (eccetto quelle contrassegnate come RECURSIVE) come se l'istruzione "SAVE"
sono stati specificati per ogni variabile locale e array a cui si fa riferimento. Non influisce
blocchi comuni. (Alcuni compilatori Fortran forniscono questa opzione sotto il nome -statico or
-Salva.) Il valore predefinito, che è -fautomatico, usa lo stack per le variabili locali più piccole
rispetto al valore dato da -fmax-stack-var-size. Usa l'opzione -frequente usare no
memoria statica.

-ff2c
Genera codice progettato per essere compatibile con il codice generato da g77 ed f2c.

Le convenzioni di chiamata utilizzate da g77 (originariamente implementato in f2c) richiedono funzioni
che restituiscono il tipo predefinito "REALE" per restituire effettivamente il tipo C "doppio" e funzioni
che restituiscono il tipo "COMPLEX" per restituire i valori tramite un argomento aggiuntivo nella chiamata
sequenza che punta a dove memorizzare il valore restituito. Sotto GNU . predefinito
convenzioni di chiamata, tali funzioni restituiscono semplicemente i loro risultati come farebbero in GNU
C --- le funzioni "REAL" predefinite restituiscono il tipo C "float" e le funzioni "COMPLEX" restituiscono
il tipo GNU C "complesso". Inoltre, questa opzione implica il -fsecondo-underscore
opzione, a meno che -fno-secondo-underscore viene esplicitamente richiesto.

Ciò non pregiudica la generazione del codice che si interfaccia con il libgfortran
biblioteca.

Attenzione: Non è una buona idea mescolare il codice Fortran compilato con -ff2c con il codice
compilato con il default -fno-f2c chiamando le convenzioni come, chiamando "COMPLEX" o
funzioni "REALI" predefinite tra parti di programma che sono state compilate con differenti
le convenzioni di chiamata si interromperanno al momento dell'esecuzione.

Attenzione: Questo interromperà il codice che passa funzioni intrinseche di tipo predefinito "REAL"
o "COMPLEX" come argomenti effettivi, poiché le implementazioni della libreria usano il -fno-f2c
convenzioni di chiamata.

-fno-sottolineatura
Non trasformare i nomi delle entità specificate nel file sorgente Fortran aggiungendo
sottolinea loro.

Con - Punteggio finanziatori in effetti, GNU Fortran aggiunge un carattere di sottolineatura ai nomi esterni
senza sottolineature. Questo viene fatto per garantire la compatibilità con il codice prodotto da many
Compilatori UNIX Fortran.

Attenzione: Il comportamento predefinito di GNU Fortran è incompatibile con f2c ed g77, Per favore
Usa il -ff2c opzione se vuoi che i file oggetto compilati con GNU Fortran siano
compatibile con il codice oggetto creato con questi strumenti.

L'uso di -fno-sottolineatura non è raccomandato a meno che non si stiano sperimentando problemi
come l'integrazione di GNU Fortran in ambienti di sistema esistenti (vis-a-vis
librerie esistenti, strumenti e così via).

Ad esempio, con - Punteggio finanziatorie supponendo che "j()" e "max_count()" siano
funzioni esterne mentre "my_var" e "lvar" sono variabili locali, un'istruzione come

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

è implementato come qualcosa di simile a:

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

Con -fno-sottolineatura, la stessa affermazione è implementata come:

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

L'uso di -fno-sottolineatura consente la specifica diretta dei nomi definiti dall'utente mentre
debugging e interfacciando il codice GNU Fortran con altri linguaggi.

Nota che solo perché i nomi corrispondono non significa che l'interfaccia implementata da
GNU Fortran per un nome esterno corrisponde all'interfaccia implementata da qualche altro
lingua per lo stesso nome. Cioè, ottenere il codice prodotto da GNU Fortran a cui collegarsi
il codice prodotto da un altro compilatore che utilizza questo o qualsiasi altro metodo può essere solo a
piccola parte della soluzione complessiva --- ottenere il codice generato da entrambi i compilatori per
concordare su questioni diverse dalla denominazione può richiedere uno sforzo significativo e, a differenza della denominazione
disaccordi, i linker normalmente non possono rilevare disaccordi in queste altre aree.

Inoltre, tieni presente che con -fno-sottolineatura, la mancanza di trattini bassi aggiunti introduce
la possibilità molto reale che un nome esterno definito dall'utente sia in conflitto con un nome
in una libreria di sistema, il che potrebbe rendere abbastanza facile la ricerca di bug di riferimento irrisolti
difficile in alcuni casi --- potrebbero verificarsi durante l'esecuzione del programma e apparire solo come
comportamento difettoso in fase di esecuzione.

Nelle future versioni di GNU Fortran speriamo di migliorare i problemi di denominazione e collegamento in modo che
il debugging implica sempre l'uso dei nomi così come appaiono nel sorgente, anche se
i nomi visti dal linker sono alterati per prevenire il collegamento accidentale tra
procedure con interfacce incompatibili.

-fsecondo-underscore
Per impostazione predefinita, GNU Fortran aggiunge un carattere di sottolineatura ai nomi esterni. Se questa opzione è
usato GNU Fortran aggiunge due caratteri di sottolineatura ai nomi con caratteri di sottolineatura e un carattere di sottolineatura
a nomi esterni senza trattini bassi. GNU Fortran aggiunge anche due trattini bassi a
nomi interni con caratteri di sottolineatura per evitare collisioni di nomi con nomi esterni.

Questa opzione non ha effetto se -fno-sottolineatura è in vigore. È implicito nel
-ff2c opzione.

Altrimenti, con questa opzione, un nome esterno come "MAX_COUNT" viene implementato come a
riferimento al simbolo esterno del tempo di collegamento "max_count__", invece di "max_count_".
Questo è necessario per la compatibilità con g77 ed f2c, ed è implicito nell'uso di
-ff2c opzione.

-fcoarray=
nessuna
Disabilita il supporto del coarray; usando dichiarazioni coarray e dichiarazioni di controllo dell'immagine
produrrà un errore in fase di compilazione. (Predefinito)

singolo
La modalità a immagine singola, cioè "num_images()" è sempre una.

lib Parallelizzazione coarray basata su libreria; una libreria coarray GNU Fortran adatta
deve essere collegato.

-fcontrollo=
Abilitare la generazione di controlli in fase di esecuzione; l'argomento deve essere un elenco delimitato da virgole
delle seguenti parole chiave.

contro tutti i Abilita tutti i test di runtime di -fcontrolla.

array-temp
Avvisa in fase di esecuzione quando per passare un argomento effettivo doveva essere un array temporaneo
generato. Le informazioni generate da questo avviso sono talvolta utili in
ottimizzazione, al fine di evitare tali temporaneità.

Nota: l'avviso viene stampato solo una volta per posizione.

limiti
Abilita la generazione di controlli di runtime per i pedici dell'array e contro il dichiarato
valori minimi e massimi. Controlla anche gli indici di array per presunto e differito
matrici di forma rispetto ai limiti effettivamente allocati e garantisce che tutte le stringhe
le lunghezze sono uguali per i costruttori di array di caratteri senza un typespecific esplicito.

Alcuni controlli lo richiedono -fcheck=limiti è impostato per la compilazione del main
.

Nota: in futuro questo potrebbe includere anche altre forme di controllo, ad esempio il controllo
riferimenti di sottostringa.

do Abilita la generazione di controlli in fase di esecuzione per la modifica non valida dell'iterazione del ciclo
variabili.

mem Abilita la generazione di controlli in fase di esecuzione per l'allocazione della memoria. Nota: questa opzione
non influisce sulle allocazioni esplicite utilizzando l'istruzione "ALLOCATE", che sarà
sempre controllato.

pointer
Abilita la generazione di controlli in fase di esecuzione per puntatori e allocabili.

ricorsione
Abilita la generazione di controlli in fase di esecuzione per le subroutine richiamate in modo ricorsivo e
funzioni che non sono contrassegnate come ricorsive. Guarda anche -frequente. Nota: questo
check non funziona per i programmi OpenMP ed è disabilitato se usato insieme a
-frequente ed -fopenmp.

-fbounds-check
Alias ​​obsoleto per -fcheck=limiti.

-fcheck-array-temporanei
Alias ​​obsoleto per -fcheck=temps-array.

-fmax-array-costruttore=n
Questa opzione può essere utilizzata per aumentare il limite massimo consentito nei costruttori di array.
Il codice seguente richiede questa opzione per espandere l'array in fase di compilazione.

prova del programma
implicito nessuno
intero j
intero, parametro :: n = 100000
intero, parametro :: i(n) = (/ (2*j, j = 1, n) /)
print '(10(I0,1X))', i
test di fine programma

Attenzione: La sezione opzione può portare a lungo compilare volte ed eccessivamente grandi oggetto
File.

Il valore predefinito per n è 65535.

-fmax-stack-var-size=n
Questa opzione specifica la dimensione in byte dell'array più grande che verrà inserito nel
pila; se la dimensione viene superata viene utilizzata la memoria statica (tranne nelle procedure contrassegnate come
RICORSIVO). Usa l'opzione -frequente per consentire procedure ricorsive che non lo fanno
avere un attributo RECURSIVE o per programmi paralleli. Utilizzo -fno-automatico da non usare mai
la pila.

Questa opzione attualmente riguarda solo gli array locali dichiarati con limiti costanti e potrebbe
non si applica a tutte le variabili carattere. Le versioni future di GNU Fortran potrebbero migliorarlo
comportamento.

Il valore predefinito per n è 32768.

-fstack-array
L'aggiunta di questa opzione farà sì che il compilatore Fortran metta tutti gli array locali, anche quelli di
dimensione sconosciuta nella memoria dello stack. Se il tuo programma utilizza array locali molto grandi, lo è
possibile che tu debba estendere i tuoi limiti di runtime per la memoria dello stack su alcuni
sistemi operativi. Questo flag è abilitato per impostazione predefinita a livello di ottimizzazione - Veloce.

-fpack-derivato
Questa opzione dice a GNU Fortran di comprimere i membri di tipo derivato il più vicino possibile.
È probabile che il codice compilato con questa opzione sia incompatibile con il codice compilato senza
questa opzione e potrebbe essere eseguita più lentamente.

-frepack-array
In alcune circostanze GNU Fortran può passare sezioni di array di forme presunte tramite a
descrittore che descrive un'area di memoria non contigua. Questa opzione aggiunge il codice al
prologo della funzione per reimballare i dati in un blocco contiguo in fase di esecuzione.

Ciò dovrebbe comportare accessi più rapidi all'array. Tuttavia può introdurre
sovraccarico significativo per la chiamata di funzione, specialmente quando i dati passati sono
non contiguo.

-fshort-enum
Questa opzione è fornita per l'interoperabilità con il codice C che è stato compilato con il
-fshort-enum opzione. Farà in modo che GNU Fortran scelga il tipo "INTEGER" più piccolo a
dato insieme di enumeratori si adatterà e darà a tutti i suoi enumeratori questo tipo.

-festerno-blas
Questa opzione renderà gfortran generare chiamate a funzioni BLAS per alcune matrici
operazioni come "MATMUL", invece di utilizzare i nostri algoritmi, se la dimensione del
matrici coinvolte è maggiore di un dato limite (vedi -fblas-matmul-limite). Può essere
redditizio se è disponibile una libreria BLAS del fornitore ottimizzata. La biblioteca BLAS lo farà
devono essere specificati al momento del collegamento.

-fblas-matmul-limite=n
Significativo solo quando -festerno-blas è in vigore. Moltiplicazione matriciale di matrici
con taglia maggiore di (o uguale a) n sarà eseguito da chiamate alle funzioni BLAS,
mentre altri saranno gestiti da gfortran algoritmi interni. Se le matrici coinvolte
non sono quadrati, il confronto delle dimensioni viene eseguito utilizzando la media geometrica del
dimensioni delle matrici argomento e risultato.

Il valore predefinito per n è 30.

-frequente
Consenti la ricorsione indiretta forzando l'allocazione di tutti gli array locali nello stack.
Questo flag non può essere utilizzato insieme a -fmax-stack-var-size= or -fno-automatico.

-finit-locale-zero
-finito-intero=n
-finito-reale=
-finit-logico=
-carattere-finito=n
I -finit-locale-zero opzione indica al compilatore di inizializzare "INTEGER" locale
Variabili "REALE" e "COMPLEX" su zero, variabili "LOGICHE" su false e "CARATTERE"
variabili in una stringa di byte null. Le opzioni di inizializzazione a grana più fine sono
fornito dal -finito-intero=n, -finito-reale= (che anche
inizializza le parti reale e immaginaria delle variabili locali "COMPLEX"),
-finit-logico=e -carattere-finito=n (dove n è un carattere ASCII
valore) opzioni. Queste opzioni non si inizializzano

* array allocabili

* componenti di variabili di tipo derivato

* variabili che compaiono in un'istruzione "EQUIVALENZA".

(Queste limitazioni potrebbero essere rimosse nelle versioni future).

Notare quello -finito-reale=nan l'opzione inizializza le variabili "REAL" e "COMPLEX" con a
tranquillo NaN. Per una segnalazione utilizzare NaN -finito-reale=snan; nota, tuttavia, che il tempo di compilazione
le ottimizzazioni possono convertirli in NaN silenzioso e il trapping deve essere abilitato
(ad es. via -ffpe-trappola).

Infine, tieni presente che abilitando uno qualsiasi dei -finito-* le opzioni silenzieranno gli avvisi che
sarebbe stato emesso da -Non inizializzato per le variabili locali interessate.

-falsi-comuni
Per impostazione predefinita, gfortran impone il corretto allineamento di tutte le variabili in un blocco "COMMON" di
riempiendoli secondo necessità. Su alcune piattaforme è obbligatorio, su altre aumenta
prestazione. Se un blocco "COMMON" non viene dichiarato con tipi di dati coerenti
ovunque, questa imbottitura può causare problemi e -fno-align-comuni può essere utilizzato per
disattivare l'allineamento automatico. La stessa forma di questa opzione dovrebbe essere usata per tutti i file
che condividono un blocco "COMUNE". Per evitare potenziali problemi di allineamento nei blocchi "COMMON",
si consiglia di ordinare gli oggetti dal più grande al più piccolo.

-fno-protect-parents
Per impostazione predefinita le parentesi nell'espressione sono rispettate per tutti i livelli di ottimizzazione come
che il compilatore non esegua alcuna riassociazione. Usando -fno-protect-parents consente
compilatore per riordinare le espressioni "REAL" e "COMPLEX" per produrre codice più veloce. Notare che
per l'ottimizzazione della riassociazione -fno-signed-zero ed -fno-trapping-matematica necessario
essere in vigore. La protezione tra parentesi è abilitata per impostazione predefinita, a meno che - Veloce is
dato.

-frealloc-sx
Un lato sinistro allocabile di un'assegnazione intrinseca è automaticamente
(ri)allocato se non è allocato o ha una forma diversa. L'opzione è
abilitato per impostazione predefinita tranne quando -std=f95 viene data. Guarda anche -Wrealloc-sx.

-eliminazione-funzione-faggressiva
Le funzioni con elenchi di argomenti identici vengono eliminate all'interno delle istruzioni, a prescindere
se queste funzioni sono contrassegnate come "PURE" o meno. Ad esempio, in

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

ci sarà una sola chiamata a "f". Questa opzione funziona solo se
-ffrontend-ottimizzare è in vigore.

-ffrontend-ottimizzare
Questa opzione esegue l'ottimizzazione front-end, basata sulla manipolazione di parti del Fortran
analizzare l'albero. Abilitato per impostazione predefinita da qualsiasi -O opzione. Ottimizzazioni abilitate da questo
l'opzione include l'eliminazione di chiamate di funzione identiche all'interno delle espressioni, rimozione
chiamate non necessarie a "TRIM" nei confronti e nelle assegnazioni e sostituendo TRIM(a) con
"a(1:LEN_TRIM(a))". Può essere deselezionato specificando -fno-frontend-ottimizzare.

AMBIENTE

I gfortran il compilatore attualmente non fa uso di alcuna variabile d'ambiente da controllare
il suo funzionamento al di là di quelli che influiscono sul funzionamento di gcc.

Usa aarch64-linux-gnu-gfortran online usando i servizi onworks.net