g++-4.7 - Online nel cloud

PROGRAMMA:

NOME

gcc - compilatore C e C++ del progetto GNU

SINOSSI

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

Qui sono elencate solo le opzioni più utili; vedi sotto per il resto. g ++ accetta
per lo più le stesse opzioni di gcc.

DESCRIZIONE

Quando invochi GCC, normalmente esegue la preelaborazione, la compilazione, l'assemblaggio e il collegamento.
Le "opzioni generali" consentono di interrompere questo processo in una fase intermedia. Per
esempio, il -c opzione dice di non eseguire il linker. Quindi l'output è costituito da oggetto
file emessi dall'assemblatore.

Altre opzioni vengono trasferite a una fase dell'elaborazione. Alcune opzioni controllano il
preprocessore e altri il compilatore stesso. Ancora altre opzioni controllano l'assemblatore e
linker; la maggior parte di questi non sono documentati qui, poiché raramente è necessario utilizzarli.

La maggior parte delle opzioni della riga di comando che puoi usare con GCC sono utili per i programmi C; quando
un'opzione è utile solo con un altro linguaggio (di solito C++), la spiegazione dice così
esplicitamente. Se la descrizione di una particolare opzione non menziona una fonte
lingua, è possibile utilizzare tale opzione con tutte le lingue supportate.

I gcc il programma accetta opzioni e nomi di file come operandi. Molte opzioni hanno multi-
nomi di lettere; quindi più opzioni a lettera singola possono non essere raggruppato: -dv è molto
diversa da -d -v.

Puoi combinare opzioni e altri argomenti. Per la maggior parte, l'ordine che usi non lo fa
questione. L'ordine è importante quando si utilizzano più opzioni dello stesso tipo; per esempio, se
si specifica -L più di una volta, le directory vengono cercate nell'ordine specificato. Anche,
il posizionamento del -l l'opzione è significativa.

Molte opzioni hanno nomi lunghi che iniziano con -f o con -W---Per esempio,
-fmove-loop-invarianti, -Formato W e così via. La maggior parte di questi ha sia positivi che negativi
forme; la forma negativa di -foo sarebbe -fno-pippo. Questo manuale documenta solo uno dei
queste due forme, qualunque delle due non sia quella predefinita.

VERSIONI

Opzione Sommario
Ecco un riepilogo di tutte le opzioni, raggruppate per tipologia. Le spiegazioni sono nelle seguenti
.

Totale Opzioni
-c -S -E -o filetto -nessun-prefisso-canonico -tubo -pass-exit-code -x Lingua -v
-### --Aiuto[=classe[, ...]] --target-aiuto --versione -involucro @filetto -fplugin=filetto
-fplugin-arg-Nome=arg -fdump-ada-spec[-sottile] -fdump-go-spec =filetto

C Lingua Opzioni
-ansi -std=Standard -fgnu89-in linea -aux-info Nome del file
-funzioni-variadiche-senza-parametri -fno-asm -fno-integrato -fno-integrato-function
-ospitato -autoportante -fopenmp -fms-estensioni -fplan9-estensioni -trigrafie
-no-integrato-cpp -tradizionale -tradizionale-cpp -Fallow-single-precision
-fcond-mancata corrispondenza -conversioni-vettoriali-di-lino -fcampi-bitfirmati -fsigned-carattere
-campi di bit con segno divertente -funsigned-carattere

C++ Lingua Opzioni
-fabi-versione=n -fno-controllo-accesso -fcheck-nuovo -fconserve-spazio
-fconstexpr-profondità=n -ffriend-iniezione -fno-elide-costruttori -fno-enforce-eh-spec
-per-scopo -fno-per-scope -fno-gnu-parole chiave -fno-modelli-impliciti
-fno-modelli-inline-impliciti -fno-implementare-inline -fms-estensioni
-fno-nonansi-integrati -fnothrow-opt -fno-nomi-operatore -fno-opzionale-diags
-fpermissivo -fno-pretty-modelli -frepo -fno-rtti -fstats -ftemplate-profondità=n
-fno-threadsafe-statics -fuse-cxa-uscita -fno-debole -nostdin++ -fno-default-inline
-fvisibility-inlines-nascosto -fvisibility-ms-compat -Wabi -Wconversione-null
-Wctor-dtor-privacy -Wdelete-non-virtuale-dtor -Stringendo -Non tranne
-Wnon-virtuale-dtor -Riordina -Weffc++ -Wstrict-null-sentinella
-Wno-non-modello-amico -Wold-stile-cast -Woverloaded-virtuale -Wno-pmf-conversioni
-Wsign-promozione

Objective-C ed Obiettivo-C++ Lingua Opzioni
-fclasse-stringa-costante=nome della classe -fgnu-runtime -fnext-runtime -fno-nil-ricevitori
-fobjc-abi-versione=n -fobjc-call-cxx-cdtors -fobjc-invio-diretto -fobjc-eccezioni
-fobjc-gc -fobjc-nilcheck -fobjc-std=objc1 -classi-freplace-objc -fzero-collegamento
-gen-decl -Wassign-intercetta -Wno-protocollo -Wselettore -Wstrict-selettore-match
-Selettore-dichiarato-wund

Lingua Competenza Opzioni
-flunghezza-messaggio=n -fdiagnostics-show-location=[una volta|ogni riga]
-fno-diagnostica-show-option

avvertimento Opzioni
-fsintassi solo -fmax-errori=n -pedante -errori-pedanti -w -Wextra -Parete
-Indirizzo -Waggregato-ritorno -Warray-limiti -Wno-attributi
-Wno-built-in-macro-redefined -Wc++-compatibile -Wc++11-compatibile -Allineamento Wcast -Wcast-qual
-Wchar-pedici -Wobbed -Wcommento -Conversione -Wcoverage-mancata corrispondenza -No-cpp
-Wno-deprecato -Wno-deprecato-dichiarazioni -Wdisabled-ottimizzazione -Wno-div-per-zero
-Wdoppia-promozione -Wempty-corpo -Wenum-confronta -Wno-endif-etichette -Errore -Errore=*
-Errori fatali -Wfloat-uguale -Formato W -Wformato=2 -Wno-formato-contiene-nul
-Wno-format-extra-args -Wformat-non letterale -Wformat-sicurezza -Wformato-y2k
-Wframe-maggiore-di=len -Wno-free-non-oggetto-heap -Wjump-miss-init
-Qualificatori senza nome - Wimplicit -Dichiarazione-funzione-Wimplicit -Wimplicit-int
-Winit-auto -Linea vincente -Wforse-non inizializzato -Wno-int-to-puntatore-cast
-No-compensazione-non-valida -Winvalid-pch -Wmaggiore-di=len -Ottimizzazioni del ciclo Wunsafe
-Wlogico-op -Wlong-lungo -Wprincipale -Wforse-non inizializzato -Wmissing-bretelle
-Wmissing-field-inizializzatori -Attributo-formato-mancante -Wmissing-include-dirs
-Wno-parafango -No-multichar -Non nullo -No-overflow -Stringhe di lunghezza totale -Imballato
-Wpacked-bitfield-compatibile -Imbottito -Wparentesi -Wpedantic-ms-formato
-Wno-pedante-ms-formato -Wpointer-arith -Wno-pointer-to-int-cast -Wredundant-dichiarazioni
-Tipo Wreturn -Wpunto-sequenza -Ombra -Wsign-confronta -Wsign-conversione
-Wstack-protezione -Wstack-utilizzo=len -Wstrict-alias -Wstrict-alias=n
-Wstrict-overflow -Wstrict-overflow=n -Wsuggest-attributo=[puro|const|senza ritorno]
-Winterruttore -Wswitch-predefinito -Wswitch-enumerazione -Wsync-nand -Wsystem-header -Wtrampolini
-Scritte -Wtype-limiti -Wundef -Non inizializzato -Wunknown-pragma -Wno-pragma
-Wuncostanti-float suffissi -Wunusato -Funzione Wunused -Etichetta-Wunused
-Wdefinizioni di tipo locale non utilizzate -Wunused-parametro -Risultato-non-utilizzato -Valore-inutilizzato
-Variabile-Wunused -Parametro-non-utilizzato-ma-impostato -Wunused-ma-set-variable
-Wvariadic-macro -Wvettore-operazione-prestazioni -Wvla -W registro-volatile-var
-Wwrite-stringhe -Wzero-as-null-pointer-costante

C ed Solo obiettivo C avvertimento Opzioni
-Wbad-funzione-cast -Dichiarazioni-mancanti -Wmissing-tipo-parametro
-Wmissing-prototipi -Wnned-externs -Dichiarazione in stile Wold -Definizione in stile Wold
-Wstrict-prototipi -Wtradizionale -Conversione-tradizionale
-Wdichiarazione-dopo-dichiarazione -Wpointer-segno

Debug Opzioni
-dlettere -spec -macchina del dump -versione dump -fdbg-cnt-elenco -fdbg-cnt=contro-
lista-valori -fdisable-ipa-nome_pass -fdisable-rtl-nome_pass -fdisable-rtl-passaggio-
Nome=elenco-gamma -fdisable-albero-nome_pass -fdisable-albero-nome-pass=elenco-gamma
-fdump-noaddr -fdump-non numerato -fdump-link-non-numerati -fdump-unità-di-traduzione[-n]
-fdump-classe-gerarchia[-n] -fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-pass -fdump-statistiche -fdump-albero-tutto -fdump-tree-originale[-n]
-fdump-tree-ottimizzato[-n] -fdump-albero-cfg -fdump-albero-vcg -fdump-albero-alias
-fdump-albero-ch -fdump-albero-ssa[-n] -fdump-albero-pre[-n] -fdump-albero-ccp[-n]
-fdump-albero-dce[-n] -fdump-albero-gimple[-crudo] -fdump-albero-parafango[-n]
-fdump-albero-dom[-n] -fdump-albero-dse[-n] -fdump-albero-phiprop[-n] -fdump-albero-phiopt[-n]
-fdump-albero-forwprop[-n] -fdump-tree-copyrename[-n] -fdump-albero-nrv -fdump-albero-vect
-fdump-albero-lavello -fdump-albero-sra[-n] -fdump-albero-forwprop[-n] -fdump-albero-fre[-n]
-fdump-albero-vrp[-n] -ftree-vettoriatore-verbose=n -fdump-tree-storeccp[-n]
-fdump-final-insns=filetto -fcompare-debug[=opta] -fcompare-debug-secondo
-feliminate-nano2-dups -feliminare-i-tipi-debug-inutilizzati
-feliminare-simboli-debug-inutilizzati -femit-class-debug-sempre -accettabile-tipo-passare
-accettabile-tipo-passare=elenco-gamma -fdebug-types-sezione -fmem-rapporto -fpre-ipa-mem-report
-fpost-ipa-mem-report -fprofile-archi -frandom-seme=stringa -fsched-verbose=n
-fsel-sched-verboso -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -fstack-uso
-ftest-copertura -ftime-rapporto -fvar-tracciamento -fvar-tracciamento-assegnazioni
-fvar-tracciamento-assegnazioni-toggle -g -glivello -gattiva/disattiva -gcoff -gnano-versione -ggdb
-grecord-gcc-switch -gno-record-gcc-switch -gstabs -gstabs+ -gstrict-nano
-gno-severo-nano -gvms -gxcoff -gxcoff+ -fno-merge-debug-stringhe
-fno-nano2-cfi-asm -fdebug-prefisso-mappa=vecchio=nuovi -femit-struct-debug-baseonly
-femit-struct-debug-ridotto -femit-struct-debug-dettagliato[=lista-specifiche] -p -pag
-stampa-nome-file=biblioteca -print-libgcc-nome-file -stampa-multi-directory
-stampa-multi-lib -stampa-directory-multi-os -print-nome-programma=Programma
-stampa-dir-ricerca -Q -print-sysroot -print-sysroot-headers-suffisso -salva-temps
-save-temps=cwd -salva-temps=obj -tempo[=filetto]

OTTIMIZZAZIONE Opzioni
-funzioni-false[=n] -falsi-salti[=n] -etichette-false[=n] -falign-loop[=n]
-math-fassociativo -fauto-inc-dec -fbranch-probabilità -fbranch-target-load-ottimizzare
-fbranch-target-load-optimize2 -fbtr-bb-esclusiva -fcaller-salva -fcheck-data-deps
-fcombine-stack-regolazioni -fconserve-stack -fcompare-elimina -fcprop-registri
-salto incrociato -fcse-segue-salti -fcse-salta-blocchi -fcx-fortran-regole
-fcx-intervallo limitato -fdata-sezioni -fdce -framo-ritardato -fdelete-controlli-puntatore-null
-fdevirtualizza -fdse -fearly-inline -fipa-sra -ottimizzazioni-economiche
-ffat-lto-oggetti -fast-matematica -finite-math-only -float-negozio
-fexcess-precisione=style -in avanti-propagare -ffp-contratto=style -ffunzioni-sezioni
-fgcse -fgcse-dopo-reload -fgcse-las -fgcse-lm -fgraphite-identità -fgcse-sm
-fif-conversione -fif-conversione2 -findirect-inline -funzioni-finline
-funzioni-finline-chiamate-una volta -fine-limit=n -finline-piccole-funzioni -fipa-cp
-fipa-cp-clone -fipa-matrice-reorg -fipa-pta -fipa-profilo -fipa-puro-const
-fipa-riferimento -fira-algoritmo=algoritmo -regione-fira=regione -fira-loop-pressione
-fno-ira-share-save-slot -fno-ira-share-spill-slot -fira-verboso=n -cinque punti
-fkeep-inline-funzioni -fkeep-static-const -blocco floop -floop-appiattire
-floop-interscambio -flop-strip-mio -floop-parallelizza-tutto -flto
-flto-livello-di-compressione -flto-partizione=alg -flto-report -funisci-tutte-costanti
-fmerge-costanti -fmodulo-sched -fmodulo-sched-to-regys -fmove-loop-invarianti
parafango -fmudflapir -fflapth -fno-ramo-conteggio-reg -fno-default-inline
-fno-defer-pop -fno-funzione-cse -fno-indovina-ramo-probabilità -fno-in linea
-fno-matematica-errno -fno-spioncino -fno-spioncino2 -fno-sched-interblocco -fno-sched-spec
-fno-signed-zero -fno-toplevel-riordina -fno-trapping-matematica
-fno-zero-inizializzato-in-bss -puntatore-frame-fomit -fottimizzare-registrare-spostare
-A-CALLS FOPTIMIZZAZIONE -fpartial-inline -fpeel-loop -fpredictive-comune
-fprefetch-loop-array -fcorrezione del profilo -fdir-profilo=sentiero -fprofile-genera
-fprofile-genera=sentiero -fprofile-uso -fuso-profilo=sentiero -fprofile-valori
- matematica-freciproca Senza - Fregmuovi -frename-registri -blocchi-freddo
-blocchi-e-partizioni di freorder -funzioni-freorder -frerun-cse-dopo-loop
-Freschedule-moduli-schemate -matematica-fondamentale -fsched2-usa-superblocchi
-fsched-pressione -fsched-spec-load -fsched-spec-carico-pericoloso
-fsched-stallo-insns-dep[=n] -fsched-stallo-insns[=n] -fsched-gruppo-euristico
-fsched-percorso-critico-euristico -fsched-spec-insn-euristica -fsched-rank-euristico
-fsched-last-insn-euristica -fsched-dep-count-euristico -fschedule-insns
-fschedule-insns2 -fsection-ancore -fprogrammazione-selettiva -fprogrammazione-selettiva2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loop -finvolucro termoretraibile
-fsegnalazione-nans -fcostante-di-precisione-singola -fsplit-ivs-in-unroller
-fsplit-wide-tipi -fstack-protettore -fstack-protettore-tutto -fstrict-alias
-fstrict-overflow -fthread-salta -tracer -ftree-bit-ccp -ftree-built-in-call-dce
-ftree-ccp -ftree-ch -ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copia-prop
-ftree-rinominacopia -ftree-dce -ftree-dominatore-opt -ftree-dse -ftree-forwprop
-ftree-fre -ftree-loop-se-converti -ftree-loop-if-convert-stores -ftree-loop-im
-ftree-phiprop -distribuzione-ftree-loop -ftree-loop-distribuire-pattern
-ftree-loop-ivcanon -ftree-loop-lineare -ftree-loop-ottimizzare -ftree-parallelizza-loop=n
-ftree-pre -ftree-parziale-pre -ftree-pta -ftree-riassoc -ftree-lavello -ftree-sra
-ftree-switch-conversione -fusione a coda di albero -ftree-ter -ftree-vect-loop-versione
-ftree-vettorizzare -ftree-vrp -divertimento alla volta -funroll-tutti i loop -funroll-loop
-ottimizzazioni funsafe-loop -funsafe-math-ottimizzazioni -funswitch-loop
-fespansione-variabile-in-unroller -fvect-cost-modello -fvpt -fweb -fintero-programma -fwpa
-fuse-ld=Links -plug-in-fuse-linker --parami Nome=APPREZZIAMO -O -O0 -O1 -O2 -O3 -Voi
- Veloce

preprocessore Opzioni
-Adomanda=rispondere -UN-domanda[=rispondere] -C -dd -dI -dM -dN -Dmacro[=def] -E -H
-idirafter dir -includere filetto -imacro filetto -iprefisso filetto -icon prefisso dir
-icon prefisso prima dir -isistema dir -imultilib dir -isysroot dir -M -MM -MF -MG
-deputato -MQ - MT -nostdin -P -fdebug-cpp -ftrack-macro-espansione -fdirectory-di-lavoro
-rimappa -trigrafie -undif -Umacro -Wp,opzione -Xpreprocessore opzione

Assembler Opzione
-Wa,opzione -Xassemblatore opzione

link Opzioni
nome-file-oggetto -lbiblioteca -nostartfiles -nodefaultlibs -nostdlib -torta -rdinamico -s
-statico -static-libgcc -static-libstdc++ -condiviso -libgcc-condivisa -simbolico -T copione
-Wl,opzione -Xlinker opzione -u simbolo

elenco Opzioni
-Bprefisso -Idir -iplugindir=dir -quotodir -Ldir -specifiche=filetto -IO- --sysroot=dir

Confezionatrici Verticali VFFS Dipendente Opzioni
AAArch64 Opzioni -big endian -mittle-endian -mgeneral-regs-only -mcmodel=piccolo
-mcmodel=piccolo -mcmodel=grande -mstrict-align -puntatore-cornice-foglia-momit
-mno-omit-leaf-frame pointer -mtls-dialetto=desc -mtls-dialect=tradizionale -marzo=Nome
-mcpu=Nome -mtune=Nome

Adatta Epifania Opzioni -metà-file-reg -mprefer-breve-insn-regs -mbranch-costo=num
-mcsposta -mnop=num -msoft-cmpsf -msplit-lohi -mpost-inc -mpost-modifica
-mstack-offset=num -mround-più vicino -mlong-chiamate -mshort-call -mpiccolo16 -modalità-mfp=modo
-mvect-doppio -max-vect-align=num -msplit-vecmove-presto -m1reg-reg

ARM Opzioni -mapcs-frame -mno-aps-frame -mabi=Nome -mapcs-stack-check
-mno-apc-stack-check -mapcs-flottante -mno-apc-float -mapcs-rientrante
-mno-apc-rientrante -msched-prologo -mno-sched-prolog -mittle-endian -big endian
-mwords-little-endian -mfloat-abi=Nome -mfpe -mfp16-formato=Nome -mthumb-interazione
-mno-pollice-interwork -mcpu=Nome -marzo=Nome -mfpu=Nome -mstruttura-dimensione-confine=n
-mabort-su-mancato ritorno -mlong-chiamate -mno-chiamate lunghe -mssingle-pic-base
-mno-singola-pic-base -registro-mpic=reg -mnop-fun-dllimport -mcirrus-fix-insns-non-validi
-mno-cirrus-fix-insns-non-validi -nome-funzione-mpoke - pollice -marma -mtpcs-telaio
-mtpcs-foglia-frame -mcaller-super-interazione -mcallee-super-interazione -mtp=Nome
-mtls-dialetto=dialetto -mword-rilocazioni -mfix-corteccia-m3-ldrd -accesso-munitario
-mneon-per-64bit

AVR Opzioni -mmcu=MCU -macculate-args -mbranch-costo=costo -mcall-prologhi -menta8
-mno-interrupt -rilassati -mshort-call -mstrict-X -pila piccola

Blackfin Opzioni -mcpu=cpu[-sirevisione] -msim -puntatore-cornice-foglia-momit
-mno-omit-leaf-frame pointer -mspecld-anomalia -mno-specld-anomalia -mcsync-anomalia
-mno-csync-anomalia -mbasso-64k -mno-low64k -mstack-check-l1 -mid-libreria-condivisa
-mno-id-libreria-condivisa -m-id-libreria condivisa=n -mleaf-id-libreria-condivisa
-mno-leaf-id-libreria-condivisa -msep-dati -mno-set-data -mlong-chiamate -mno-chiamate lunghe
-mfast-fp -minline-plt -multicore -mcorea -mcoreb -msdram -microfono

C6X Opzioni -big endian -mittle-endian -marzo=cpu -msim -msdati=sdata-tipo

CRIS Opzioni -mcpu=cpu -marzo=cpu -mtune=cpu -mmax-stack-frame=n
-melinux-stacksize=n -metrax4 -metrax100 -mpdebug -mcc-init -mno-effetti collaterali
-mstack-align -mdata-align -mconst-align -m32 bit -m16 bit -m8 bit
-mno-prologo-epilogo -mno-gotplt -melf -maut -Melinux -mlinux -sim -sim2
-mmul-bug-soluzione alternativa -mno-mul-bug-soluzione

CR16 Opzioni -mmac -mcr16cplus -mcr16c -msim -menta32 -mbit-ops -mdata-modello=modello

Darwin Opzioni -tutto_carico -client_consentito -arco -arch_errors_fatale -solo_arco
-bind_at_load -fascio -caricatore_bundle -nome del cliente -versione_compatibilità
-Versione corrente -striscia_morta -file-di-dipendenza -dylib_file -dylinker_nome_installazione
-dinamico -libreria dinamica -elenco_simboli_esportati -elenco file -spazio dei nomi_piatto
-force_cpusubtype_ALL -force_flat_namespace -headerpad_max_install_names -iframework
-base_immagine -dentro -nome_installazione -keep_private_externs -multi_modulo
-moltiplicare_definito -moltiplicare_definito_non utilizzato -noall_load
-no_dead_strip_inits_and_terms -nofix preassociazione -nomultidef -nessun previncolo
-noseglinkedit -dimensione_paginazero -prelegare -prebind_all_twolevel_modules -Private_Bundle
-read_only_relocas -settalign -settooggettisimboli -perché -seg1ind -setta creare
-settooggettisimboli -settore -segadr -segs_read_only_addr -segs_read_write_addr
-seg_addr_tabella -seg_addr_nome_file_tabella -Seglinkedit -segprot -segs_read_only_addr
-segs_read_write_addr -modulo_singolo -statico -sub_libreria -sub_ombrello
-spazio dei nomi a due livelli -ombrello -non definito -lista_simboli_non esportati
-weak_reference_dismatches -cosa è stato caricato -F -gusto -pieno -mmacosx-versione-min=versione
-mkernel -monete-byte-bool

Dicembre Alpha Opzioni -mno-fp-regs -msoft-flottante -malfa-as -mgas -mieee
-mieee-con-inesatto -mieee-conforme -mfp-modalità trap=modo -mfp-modalità-arrotondamento=modo
-mtrap-precisione=modo -mbuild-costanti -mcpu=tipo di CPU -mtune=tipo di CPU -mbwx -mmax
-mfix -mcix -mfloat-vax -mfloat-ieee -Mexplicit-relocs -msmall-data -mlarge-dati
-mtesto-piccolo -mlarge-testo -memoria-latenza=tempo

Dicembre Alfa/VMS Opzioni -codici-di-ritorno-mvms -mdebug-main=prefisso -mmalloc64

FR30 Opzioni -mpiccolo-modello -mno-lsim

VRF Opzioni -mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64 -mhard-flottante -msoft-flottante
-maloc-cc -mfisso-cc -mdparola -mno-dword -mdoppio -mno-doppio -media -mno-media
-mmulad -mno-mulad -mfdpic -minline-plt -mgprel-ro -multilib-libreria-pic
-mlinked-fp -mlong-chiamate -etichette-maligne -mlibrary-pic -mac-4 -mac-8 -mpack
-mno-pacchetto -mno-flag -mcond-mossa -mno-cond-mossa -moptimize-membar
-mno-ottimizzare-membar -mscc -mno-scc -mcond-exec -mno-cond-exec -mvliw-ramo
-mno-vliw-ramo -mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-statistiche -mTLS -ml -mcpu=cpu

GNU / Linux Opzioni -mglibc -muclibc -mbionico -mandroide -tno-android-cc -tno-android-ld

H8 / 300 Opzioni -rilassati -mh -SM -min -menta32 -maligno-300

HPPA Opzioni -marzo=tipo di architettura -grande-interruttore -mdisable-fpregs
-mdisable-indicizzazione -mfast-chiamate-indirette -mgas -mgnu-ld -mhp-ld
-mintervallo-fisso=registro-intervallo -m salto in ritardo -mlinker-opz -mlong-chiamate
-mlong-load-store -mno-grande-interruttore -mno-disabilita-fpregs -mno-disable-indicizzazione
-mno-chiamate-indirette-veloci -mnogas -mno-salto-in-ritardo -mno-archivio-caricamento-lungo
-mno-runtime-portatile -mno-morbido-flottante -mno-spazio-regs -msoft-flottante -MPA-RISC-1-0
-MPA-RISC-1-1 -MPA-RISC-2-0 -portable-runtime -msprogramma=tipo di CPU -mspace-reg
-msio -mwsio -Munix =unix-std -nolibldl -statico -threads

i386 ed x86-64 Opzioni -mtune=tipo di CPU -marzo=tipo di CPU -mfpmth=unità -masm=dialetto
-mno-fantasia-matematica-387 -mno-fp-ret-in-387 -msoft-flottante -mno-wide-moltiplicazione -mrtd
-maligno-doppio -preferred-stack-boundary=num -confine-stack-minima=num -mld
-mcx16 -msaf -Movbe -mcrc32 -mrecip -mrecip=optare -mvzeroupper -mprefer-avx128 -mmmmx
-msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -max -mavx2 -maes -mpclmul
-mfsgsbase -signorrnd -mf16c -mfma -msse4a -m3dora -mpocnt -mamm -mbmi -mtbm -mfma4
-mxop -mlzcnt -mbmi2 -mlwp -mthread -mno-align-stringops -minline-all-stringops
-minline-stringops-dinamicamente -mstringop-strategia=alg -mpush-args
-maccumulate-in-uscita-args -m128bit-lungo-doppio -m96bit-lungo-doppio -mregparm=num
-msseregparm -mveclibabi=Digitare -mvect8-ret-in-mem -mpc32 -mpc64 -mpc80 -mstackrealign
-puntatore-cornice-foglia-momit -mno-zona-rossa -mno-tls-direct-seg-refs -mcmodello=codice-modello
-mabi=Nome -modalità-madre=modo -M32 -M64 -mx32 -mlarge-data-soglia=num -msse2avx
-mfentry -m8bit-idiv -mavx256-split-carico non allineato -mavx256-split-negozio-non-allineato

i386 ed x86-64 Windows Opzioni -mconsole -Mcygwin -mno-cygwin -mdll
-mnop-fun-dllimport -mthread -municodice -mwin32 -mfinestre -fno-set-stack-eseguibile

IA-64 Opzioni -big endian -mittle-endian -mgnu-as -mgnu-ld -mno-foto
-mvolatile-asm-stop -mregister-nomi -msdata -mno-sdata -mcostante-gp -mauto-pic
-mfuso-pazzo -minline-float-divide-min-latenza -minline-float-divide-max-throughput
-mno-inline-float-divide -minline-int-divide-min-latenza
-minline-int-divide-max-throughput -mno-inline-int-divide -minline-sqrt-min-latenza
-minline-sqrt-max-throughput -mno-inline-sqrt -mdwarf2-asm -merda-stop-bit
-mintervallo-fisso=registro-intervallo -mtls-dimensione=dimensione tls -mtune=tipo di CPU -milp32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -spec-controllo-msched -msched-br-in-data-spec
-msched-ar-in-data-spec -msched-in-control-spec -msched-spec-ldc
-msched-spec-controllo-ldc -msched-prefer-non-data-spec-insns
-msched-prefer-non-spec-insns -msched-stop-bits-dopo-ogni-ciclo
-msched-count-spec-in-critical-path -msel-sched-dont-check-control-spec
-msched-fp-mem-deps-a-costo-zero -msched-max-memory-insns-hard-limit
-msched-max-memoria-insns=max-insns

IA-64/VMS Opzioni -codici-di-ritorno-mvms -mdebug-main=prefisso -mmalloc64

LM32 Opzioni -mbarrel-shift-abilitato -mdivide abilitato -mmultiply-abilitato
-msign-extend-abilitato -abilitato per l'utente

M32R/D Opzioni -m32r2 -m32rx -m32r -mdebug -maligno-loop -mno-align-loop
-tasso di emissione=numero -mbranch-costo=numero -mmodello=codice-dimensione-modello-tipo -msdati=sdata-
Digitare -mno-flush-funzione -mflush-funzione=Nome -mno-trappola-incasso -mflush-trappola=numero -G num

M32C Opzioni -mcpu=cpu -msim -memreg=numero

M680x0 Opzioni -marzo=arco -mcpu=cpu -mtune=sintonizzare -M68000 -M68020 -m68020-40
-m68020-60 -M68030 -M68040 -M68060 -mcpu32 -M5200 -m5206e -m528x -M5307 -M5407
-mcfv4e -mbitfield -mno-campo di bit -mc68000 -mc68020 -mnobitfield -mrtd -mno-rtd
-div -mno-div -mbreve -mno-corto -mhard-flottante -M68881 -msoft-flottante -mpcrel
-maligno-int -mstrict-align -msep-dati -mno-set-data -m-id-libreria-condivisa=n
-mid-libreria-condivisa -mno-id-libreria-condivisa -Mxgot -mno-xgot

MCore Opzioni -illuminato -mno-illuminato -div -mno-div -mrelax-immediati
-mno-relax-immediato -mwide-bitfield -mno-bitfields -m4byte-funzioni
-mno-4byte-funzioni -mcallgraph-dati -mno-callgraph-dati -mslow-byte
-mno-lento-byte -mno-lsim -mittle-endian -big endian -M210 -M340
-mstack-incremento

MeP Opzioni -mabsdiff -centro commerciale -la media -mbasato=n -mbitop -mc=n -mclip
-mconfig=Nome -mcp -mcop32 -mcop64 -mivc2 -mcc -div -meb -mel -mio-volatile -ml
-mleadz -mm -minmax -multiplo -mno-opt -ripetere -SM -msatur -msdram -msim -msimnovec
-mtf -minuscolo=n

Microfiamma Opzioni -msoft-flottante -mhard-flottante -msmall-divide -mcpu=cpu -Mmmpy
-mxl-morbido-mul -mxl-soft-div -mxl-barile-shift -mxl-pattern-confronta -mxl-stack-check
-mxl-gp-opz -mno-clearbss -mxl-moltiplica-alto -mxl-float-convert -mxl-float-sqrt
-modalità-mxl-modello di app

MIPS Opzioni -IL -EB -marzo=arco -mtune=arco -mips1 -mips2 -mips3 -mips4
-mips32 -mips32r2 -mips64 -mips64r2 -mips16 -mno-mips16 -mflip-mips16
-minterlink-mips16 -mno-interlink-mips16 -mabi=abi -mabicalls -mno-abicali
-mcondiviso -mno-condiviso -plt -mno-plt -Mxgot -mno-xgot -mgp32 -mgp64 -mfp32
-mfp64 -mhard-flottante -msoft-flottante -msingle-flottante -mdouble-flottante -mdsp -mno-dsp
-mdspr2 -mno-dspr2 -mfpu=tipo fpu -msmartmips -mno-smartmips -single-deteriorato
-mno-singolo-accoppiato -mdmx -mno-mdmx -mips3d -mno-mips3d -mm -mno-mt -mlsc
-mno-llsc -mlungo64 -mlungo32 -msim32 -mno-sim32 -Gnum -mlocal-sdata
-mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt -dati-membri
-mno-dati-incorporati -muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-leggibile=regolazione -msplit-indirizzi -mno-split-indirizzi -Mexplicit-relocs
-mno-reloc-esplicito -mcheck-divisione-zero -mno-check-zero-divisione -mdivide-trappole
-mdivide-interruzioni -Mmmpy -mno-memcpy -mlong-chiamate -mno-chiamate lunghe -mamma -mno-pazzo
-mfuso-pazzo -mno-fuso-madd -nocpp -mfix-24k -mno-fix-24k -mfix-r4000
-mno-fix-r4000 -mfix-r4400 -mno-fix-r4400 -mfix-r10000 -mno-fix-r10000 -mfix-vr4120
-mno-fix-vr4120 -mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-correzione-sb1
-mflush-funzione=func -mno-flush-funzione -mbranch-costo=num -mbranch-probabile
-mno-ramo-probabile -eccezioni-mfp -mno-fp-eccezioni -mvr4130-align -mno-vr4130-align
-msynci -mno-synci -mrelax-pic-chiamate -mno-relax-pic-chiamate -mmcount-ra-indirizzo

MMIX Opzioni -mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi = gnu
-mabi=mixware -mzero-estendere -mknuthdiv -mtoplevel-simboli -melf -mbranch-prevedere
-mno-ramo-previsione -indirizzi-base -mno-indirizzi-base -msuscita singola
-mno-uscita singola

MN10300 Opzioni -Mult-bug -mno-multi-bug -Mno-Am33 -mam33 -mam33-2 -mam34 -mtune=processore-
Digitare -mpuntatore-di-ritorno-su-d0 -mno-crt0 -rilassati -miw -msetlb

PDP-11 Opzioni -mfpu -msoft-flottante -mac0 -mno-ac0 -M40 -M45 -M10 -mbcopia
-mbcopy-integrato -menta32 -mno-int16 -menta16 -mno-int32 -mfloat32 -mno-flottante64
-mfloat64 -mno-flottante32 -mabshi -mno-abshi -mbranch-costoso -mbranch-economico
-munix-asm -mdec-asm

picoChip Opzioni -mae=ae_type -mvliw-lookahead=N -msimbolo-come-indirizzo
-mno-inefficiente-avvisi

PowerPC Opzioni Vedere Opzioni RS/6000 e PowerPC.

RL78 Opzioni -msim -mmul=nessuno -mmul=g13 -mmul=rl78

RS/6000 ed PowerPC Opzioni -mcpu=tipo di CPU -mtune=tipo di CPU -mcmodello=codice-modello -potenza
-mno-potenza -mpower2 -mno-potere2 -mpowerpc -mpowerpc64 -mno-powerpc -maltivec
-mno-altivoc -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt
-mmfcrf -mno-mfcrf -mpocntb -mno-popcntb -mpocntd -mno-popcntd -mfprnd
-mno-fprnd -mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mnew-mnemonici -mnemonico-stampo -mfull-toc -minimal-toc -mno-fp-in-toc
-mno-somma-in-toc -M64 -M32 -mxl-comp -mno-xl-comp -mpe -potere-maligno
-maligno-naturale -msoft-flottante -mhard-flottante -mmultiplo -mno-multiplo -msingle-flottante
-mdouble-flottante -msemplice-fpu -mstringa -mno-stringa -aggiornamento -mno-aggiornamento
-mavoid-indirizzi-indicizzati -mno-evita-indirizzi-indicizzati -mfuso-pazzo -mno-fuso-madd
-mbit-align -mno-bit-align -mstrict-align -mno-strict-align -mrilocabile
-mno-rilocabile -mrelocatable-lib -mno-relocatable-lib -toc -mno-toc -poco
-mittle-endian -grande -big endian -mdynamic-no-pic -maltivec -mswdiv
-mssingle-pic-base -prioritize-restricted-insns=priorità
-msched-costoso-dep=dipendenza_tipo -minsert-sched-nops=schema -mcall-sysv
-mcall-netbsd -maix-struct-ritorno -msvr4-struct-ritorno -mabi=abi-tipo -msecure-plt
-mbss-plt -mblock-move-inline-limit=num -Misel -mno-isel -misel=sì -Misel=n -mspe
-mno-spe -mspe=sì -mspe=n - deteriorato -mgen-cell-microcodice -mwarn-cell-microcodice
-mvrsave -mno-vrsave -mmhw -mno-mulhw -mdlmzb -mno-dlmzb -mfloat-gprs=sì
-mfloat-gprs=no -mfloat-gprs=singolo -mfloat-gprs=doppio -mprototipo -mno-prototipo
-msim -MMvme -pazzi - coltello giallo -membro -msdata -msdati=optare -mvxworks -G num
-pthread -mrecip -mrecip=optare -mno-ricetta -mrecip-precisione -mno-recip-precisione
-mveclibabi=Digitare -mfriz -mno-friz -punti-di-funzioni-annidate
-mno-puntatori-a-funzioni-annidate -msave-toc-indiretto -mno-salva-toc-indiretto

RX Opzioni -m64bit-raddoppia -m32bit-raddoppia -fpu -nofpu -mcpu= -bbig-endian-data
-mlittle-endian-dati -msmall-data -msim -mno-sim -mas100-sintassi -mno-as100-syntassi
-rilassati -mmax-dimensione-costante= -registro-menta= -pid -msave-acc-in-interrupt

S / 390 ed zSerie Opzioni -mtune=tipo di CPU -marzo=tipo di CPU -mhard-flottante -msoft-flottante
-mhard-dfp -mno-hard-dfp -mlong-doppio-64 -mlong-doppio-128 -mbackchain
-mno-backchain -packed-stack -pila-mno-imballata -msmall-exec -mno-piccolo-exec
-mmvcle -mno-mvcle -M64 -M31 -mdebug -mno-debug -mesa -mzarca -mtpf-traccia
-mno-tpf-traccia -mfuso-pazzo -mno-fuso-madd -mwarn-dimensione-frame -mwarn-stack dinamico
-mstack-dimensioni -mstack-guardia

Risultato Opzioni -meb -mel -mnhwloop -mul -mmac -punteggio 5 -mscore5u -punteggio 7 -mscore7d

SH Opzioni -M1 -M2 -m2e -m2a-nofpu -m2a-solo-singolo -m2a-singolo -m2a -M3 -m3e
-m4-nofpu -m4-solo-singolo -m4-singolo -M4 -m4a-nofpu -m4a-solo-singolo -m4a-singolo
-m4a -m4al -m5-64media -m5-64media-nofpu -m5-32media -m5-32media-nofpu -m5-compatto
-m5-compatto-nofpu -mb -ml -mdalign -rilassati -migtable -mfmovd -mitachi -mrenesa
-mno-renesas -mnomac salva -mieee -mno-ieee -mbitop -dimensione -minline-ic_invalidate
-mpdstruct -mspazio -prefergot -modalità utente -multicosto=numero -mdiv=strategia
-mdivsi3_libfunc=Nome -mintervallo-fisso=registro-intervallo -adattare-srotolare
-indirizzamento mirato -mgettrcosto=numero -mpt-fisso -maccumulate-in-uscita-args
-minvalid-simboli -msoft-atomico -mbranch-costo=num -mcbranchdi -mcpeqdi -mfuso-pazzo
-pretendere-cmove

Solaris 2 Opzioni -testo-impuro -mno-testo-impuro -pthread -pthread

SPARC Opzioni -mcpu=tipo di CPU -mtune=tipo di CPU -mcmodello=codice-modello -memory-model=me-
modello -M32 -M64 -mapp-regs -mno-app-regs -mfaster-struct -mno-strutture-più veloci
-mpiatto -mno-piatto -mfpu -mno-fpu -mhard-flottante -msoft-flottante -mhard-quad-flottante
-msoft-quad-float -mstack-bias -mno-stack-bias -munaligned-doppi
-mno-non-allineato-doppio -mv8plus -mno-v8plus -mvis -mno-vis -mvis2 -mno-vis2
-mvis3 -mno-vis3 -mfmf -mno-fmaf -mpocc -mno-popc -mfix-at697f

SPU Opzioni -mwarn-reloc -errore-reloc -msafe-dma -munsafe-dma -mbranch-suggerimenti
-mpiccolo-mem -mgrande-mem -mstdmain -mintervallo-fisso=registro-intervallo -mea32 -mea64
-conversione-spazio-indirizzo -conversione-spazio-indirizzo-mno -dimensione-mcache=dimensione della cache
-aggiornamenti-matomic -aggiornamenti mno-atomici

Sistema V Opzioni -Qy -Qn -SI,percorsi -Ym,dir

TILE-Gx Opzioni -mcpu=cpu -M32 -M64

TILEPro Opzioni -mcpu=cpu -M32

V850 Opzioni -mlong-chiamate -mno-chiamate lunghe -mep -mno-ep -funzione-mprolog
-mno-prolog-funzione -mspazio -mtda=n -msda=n -mzda=n -mapp-regs -mno-app-regs
-mdisable-chiamata -mno-disabilita-callt -mv850e2v3 -mv850e2 -mv850e1 -mv850es -mv850e
-mv850 -grande-interruttore

VAX Opzioni -mg -mgnu -munix

VxWorks Opzioni -mrtp -non statico -Bstatico -Bdinamica -Xbind-pigro -Xbind-ora

x86-64 Opzioni Vedere Opzioni i386 e x86-64.

Xstormy16 Opzioni -msim

Xtensa Opzioni -mconst16 -mno-const16 -mfuso-pazzo -mno-fuso-madd -mforce-nessuna-immagine
-mserializzare-volatile -mno-serializza-volatile -mtext-sezione-letterali
-mno-testo-sezione-letterali -mtarget-align -mno-target-align -chiamate lunghe
-mno-chiamate lunghe

zSerie Opzioni Vedere Opzioni S/390 e zSeries.

Code Generazione Opzioni
-fcall-salvato-reg -fcall-usato-reg -fissa-reg -feccezioni -fnon-chiamata-eccezioni
-funwind-tavoli -tabelle-svolgimento-fasincrono -direttiva-dimensione-finhibit
-funzioni-strumento -funzioni-strumento-exclude-function-list=sym,sym, ...
-funzioni-strumento-escludi-elenco-file=filetto,filetto, ... -fno-comune -fno-identificatore
-fpcc-struct-ritorno -fpic -fPIC -fpie -fPIE -fno-salto-tabelle -interruttori frecord-gcc
-freg-struct-ritorno -fshort-enum -fshort-doppio -fshort-wchar -fverboso-asm
-fpack-struttura[=n] -fstack-controllo -fstack-limite-register=reg -fstack-limit-simbolo=sym
-fno-stack-limite -fsplit-stack -sottolineatura-sottolineatura -ftls-modello=modello -ftrapv
-fwrapv -fbounds-check -fvisibilità -fstrict-bitfield-volatili

Opzioni Controllo , il Genere of Uscita
La compilazione può comportare fino a quattro fasi: pre-elaborazione, compilazione vera e propria, montaggio e
collegamento, sempre in quest'ordine. GCC è in grado di pre-elaborare e compilare diversi
file in più file di input dell'assemblatore o in un file di input dell'assemblatore; poi
ogni file di input dell'assemblatore produce un file oggetto e il collegamento combina tutto l'oggetto
file (quelli appena compilati e quelli specificati come input) in un file eseguibile.

Per ogni dato file di input, il suffisso del nome del file determina che tipo di compilazione è
fatto:

filetto.c
Codice sorgente C che deve essere preelaborato.

filetto.i
Codice sorgente C che non deve essere preelaborato.

filetto.ii
Codice sorgente C++ che non deve essere preelaborato.

filetto.m
Codice sorgente Objective-C. Nota che devi collegarti con il liobjc libreria per fare un
Programma di lavoro Objective-C.

filetto.mi
Codice sorgente Objective-C che non deve essere preelaborato.

filetto.mm
filetto.M
Codice sorgente Objective-C++. Nota che devi collegarti con il liobjc libreria da fare
un programma Objective-C++ funziona. Notare che .M si riferisce a una lettera maiuscola M.

filetto.mii
Codice sorgente Objective-C++ che non deve essere preelaborato.

filetto.h
File di intestazione C, C++, Objective-C o Objective-C++ da trasformare in un file di intestazione precompilato
header (predefinito) o file di intestazione C, C++ da trasformare in una specifica Ada (tramite il
-fdump-ada-spec interruttore).

filetto. Cc
filetto.cp
filetto.cxx
filettocpp
filettocpp
filetto.c++
filetto.C
Codice sorgente C++ che deve essere preelaborato. Nota che in .cxx, le ultime due lettere
devono essere entrambi letteralmente x. Allo stesso modo, .C si riferisce a una lettera maiuscola C.

filetto.mm
filetto.M
Codice sorgente Objective-C++ che deve essere preelaborato.

filetto.mii
Codice sorgente Objective-C++ che non deve essere preelaborato.

filetto.H H
filetto.H
filetto.cv
filetto.hxx
filetto.hpp
filetto.hpp
filetto.h++
filetto.tcc
File di intestazione C++ da trasformare in un'intestazione precompilata o in una specifica Ada.

filetto.f
filetto.per
filetto.ftn
Risolto il problema con il codice sorgente Fortran che non doveva essere preelaborato.

filetto.F
filetto.PER
filetto.fpp
filetto.FPP
filetto.FTN
Risolto il problema con il codice sorgente Fortran che deve essere preelaborato (con il tradizionale
preprocessore).

filetto.f90
filetto.f95
filetto.f03
filetto.f08
Codice sorgente Fortran in formato libero che non deve essere preelaborato.

filetto.F90
filetto.F95
filetto.F03
filetto.F08
Codice sorgente Fortran in formato libero che deve essere preelaborato (con il tradizionale
preprocessore).

filetto.andare
Vai al codice sorgente.

filetto.Annunci
File di codice sorgente Ada che contiene una dichiarazione di unità di libreria (una dichiarazione di a
pacchetto, sottoprogramma o generico o un'istanza generica) o un'unità di libreria
dichiarazione di ridenominazione (una dichiarazione di ridenominazione di pacchetto, generico o sottoprogramma). Tale
i file sono anche chiamati occhiali.

filetto.adb
File di codice sorgente Ada contenente un corpo dell'unità di libreria (un sottoprogramma o un corpo del pacchetto).
Tali file sono anche chiamati corpi.

filetto.s
Codice assemblatore.

filetto.S
filetto.sx
Codice assemblatore che deve essere preelaborato.

Altro
Un file oggetto da inserire direttamente nel collegamento. Qualsiasi nome di file senza riconoscimento
il suffisso viene trattato in questo modo.

È possibile specificare la lingua di input in modo esplicito con il -x opzione:

-x Lingua
Specificare esplicitamente il Lingua per i seguenti file di input (piuttosto che lasciare che
compilatore sceglie un valore predefinito in base al suffisso del nome del file). Questa opzione si applica a tutti
seguenti file di input fino al prossimo -x opzione. Valori possibili per Lingua siamo:

c c-intestazione cpp-output
c++ c++-intestazione c++-cpp-output
obiettivo-c obiettivo-c-intestazione obiettivo-c-cpp-output
obiettivo-c++ obiettivo-c++-intestazione obiettivo-c++-cpp-output
assembler assembler-con-cpp
ada
f77 ingresso f77-cpp f95 ingresso f95-cpp
go
Giava

-x nessuna
Disattiva qualsiasi specifica di una lingua, in modo che vengano gestiti i file successivi
in base ai suffissi dei loro nomi di file (come sono se -x non è stato utilizzato affatto).

-pass-exit-code
Normalmente il gcc il programma uscirà con il codice 1 se qualsiasi fase del compilatore
restituisce un codice di ritorno non riuscito. Se specifichi -pass-exit-code, le gcc Programma
tornerà invece con l'errore numericamente più alto prodotto da qualsiasi fase che è tornata
un'indicazione di errore. I frontend C, C++ e Fortran restituiscono 4, se un interno
si è verificato un errore del compilatore.

Se vuoi solo alcune delle fasi della compilazione, puoi usare -x (o suffissi dei nomi dei file)
per raccontare gcc da dove cominciare e una delle opzioni -c, -S, o -E per dire dove gcc è
fermare. Si noti che alcune combinazioni (ad esempio, -x cpp-output -E) istruire gcc fare
niente di niente.

-c Compilare o assemblare i file di origine, ma non collegare. La fase di collegamento è semplicemente
non fatto. L'output finale è sotto forma di un file oggetto per ogni file sorgente.

Per impostazione predefinita, il nome del file oggetto per un file sorgente viene creato sostituendo il suffisso .c,
.i, .s, ecc., con .o.

I file di input non riconosciuti, che non richiedono la compilazione o l'assemblaggio, vengono ignorati.

-S Stop dopo la fase di compilazione vera e propria; non montare. L'uscita è in
forma di un file di codice assembler per ogni file di input non assembler specificato.

Per impostazione predefinita, il nome del file assembler per un file sorgente viene creato sostituendo il suffisso
.c, .i, ecc., con .s.

I file di input che non richiedono la compilazione vengono ignorati.

-E Stop dopo la fase di pre-elaborazione; non eseguire il compilatore corretto. L'uscita è in
la forma di codice sorgente preelaborato, che viene inviato allo standard output.

I file di input che non richiedono la preelaborazione vengono ignorati.

-o filetto
Inserisci l'output nel file filetto. Questo vale indipendentemente da qualunque tipo di output sia
prodotto, che si tratti di un file eseguibile, un file oggetto, un file assembler o
codice C preelaborato.

If -o non è specificato, l'impostazione predefinita è inserire un file eseguibile in a. fuori, l'oggetto
file per source.suffisso in fonte.o, il suo file assembler in fonti, un precompilato
file di intestazione in source.suffisso.gche tutta la sorgente C preelaborata sullo standard output.

-v Stampa (su standard error output) i comandi eseguiti per eseguire le fasi di
compilazione. Stampa anche il numero di versione del programma driver del compilatore e del
preprocessore e il compilatore vero e proprio.

-###
Come -v tranne che i comandi non vengono eseguiti e gli argomenti vengono citati a meno che non siano
contenere solo caratteri alfanumerici o "./-_". Questo è utile per gli script di shell per
acquisire le righe di comando generate dal driver.

-tubo
Utilizzare pipe piuttosto che file temporanei per la comunicazione tra le varie fasi di
compilazione. Questo non funziona su alcuni sistemi in cui l'assemblatore non è in grado di leggere
da un tubo; ma l'assemblatore GNU non ha problemi.

--Aiuto
Stampa (sullo standard output) una descrizione delle opzioni della riga di comando comprese da
gcc. Se il -v l'opzione è anche specificata allora --Aiuto sarà trasmesso anche al
vari processi invocati da gcc, in modo che possano visualizzare le opzioni della riga di comando
accettano. Se la -Wextra è stata specificata anche l'opzione (prima del --Aiuto
opzione), quindi le opzioni della riga di comando a cui non è associata alcuna documentazione
verrà anche visualizzato.

--target-aiuto
Stampa (sullo standard output) una descrizione delle opzioni della riga di comando specifiche del target
per ogni strumento. Per alcuni obiettivi potrebbero essere disponibili anche informazioni aggiuntive specifiche per il target
stampato.

--aiuto={classe|[^]qualificarsi}[, ...]
Stampa (sullo standard output) una descrizione delle opzioni della riga di comando comprese da
il compilatore che si adatta a tutte le classi e ai qualificatori specificati. Queste sono le
classi supportate:

ottimizzatori
Questo mostrerà tutte le opzioni di ottimizzazione supportate dal compilatore.

avvertenze
Questo mostrerà tutte le opzioni che controllano i messaggi di avviso prodotti dal
compilatore.

bersaglio
Verranno visualizzate le opzioni specifiche del target. non mi piace il --target-aiuto opzione
tuttavia, le opzioni specifiche del target del linker e dell'assemblatore non saranno
visualizzato. Questo perché questi strumenti attualmente non supportano l'estensione
--aiuto= sintassi.

params
Verranno visualizzati i valori riconosciuti dal --parami opzione.

Lingua
Questo mostrerà le opzioni supportate per Lingua, Dove Lingua è il nome
di una delle lingue supportate in questa versione di GCC.

comune
Verranno visualizzate le opzioni comuni a tutte le lingue.

Questi sono i qualificatori supportati:

senza documenti
Visualizza solo le opzioni non documentate.

congiunto
Opzioni di visualizzazione che prendono un argomento che appare dopo un segno di uguale nello stesso
pezzo di testo continuo, come: --help=obiettivo.

separato
Opzioni di visualizzazione che prendono un argomento che appare come una parola separata dopo il
opzione originale, come: -o file di uscita.

Così, ad esempio, per visualizzare tutti gli switch specifici del target non documentati supportati da
il compilatore può essere utilizzato quanto segue:

--help=obiettivo, non documentato

Il senso di un qualificatore può essere invertito anteponendolo al prefisso ^ carattere, quindi per
esempio per visualizzare tutte le opzioni di avviso binario (cioè quelle che sono attive o disattivate
e che non accettano argomenti) che hanno una descrizione, utilizzare:

--help=avvertenze,^unito,^non documentato

L'argomento a --aiuto= non dovrebbe consistere esclusivamente di qualificatori invertiti.

È possibile combinare più classi, sebbene ciò di solito limiti l'output di
così tanto che non c'è niente da mostrare. Tuttavia, un caso in cui funziona è quando
una delle classi è bersaglio. Quindi, ad esempio, per visualizzare tutti i target specifici
opzioni di ottimizzazione possono essere utilizzate le seguenti opzioni:

--help=target, ottimizzatori

I --aiuto= l'opzione può essere ripetuta sulla riga di comando. Ogni uso successivo sarà
mostra la classe di opzioni richiesta, saltando quelle che sono già state
visualizzato.

Se l' -Q l'opzione appare sulla riga di comando prima di --aiuto= opzione, quindi il
testo descrittivo visualizzato da --aiuto= è cambiato. Invece di descrivere il visualizzato
opzioni, viene data indicazione se l'opzione è abilitata, disabilitata o impostata
ad un valore specifico (assumendo che il compilatore lo sappia nel punto in cui il
--aiuto= viene utilizzata l'opzione).

Ecco un esempio troncato dalla porta ARM di gcc:

% gcc -Q -mabi=2 --help=obiettivo -c
Le seguenti opzioni sono specifiche per il target:
-mabi=2
-mabort-on-noreturn [disabilitato]
-mapcs [disabilitato]

L'output è sensibile agli effetti delle precedenti opzioni della riga di comando, quindi per
esempio è possibile scoprire quali ottimizzazioni sono abilitate su -O2 usando:

-Q -O2 --help=ottimizzatori

In alternativa puoi scoprire quali ottimizzazioni binarie sono abilitate da -O3 usando:

gcc -c -Q -O3 --help=ottimizzatori > /tmp/O3-opts
gcc -c -Q -O2 --help=ottimizzatori > /tmp/O2-opts
diff /tmp/opzioni O2 /tmp/opzioni O3 | grep abilitato

-nessun-prefisso-canonico
Non espandere alcun collegamento simbolico, risolvere i riferimenti a /../ or /./, o fai il percorso
assoluto quando si genera un prefisso relativo.

--versione
Visualizza il numero di versione e i diritti d'autore del GCC invocato.

-involucro
Richiama tutti i sottocomandi in un programma wrapper. Il nome del programma wrapper e
i suoi parametri vengono passati come un elenco separato da virgole.

gcc -c tc -wrapper gdb,--args

Questo invocherà tutti i sottoprogrammi di gcc per gdb --arg, quindi l'invocazione di cc1
sarà gdb --arg cc1 ....

-fplugin=Nome.così
Carica il codice del plugin nel file Nome.quindi, si presume che sia un oggetto condiviso da dlopen'd by
il compilatore. Il nome di base del file oggetto condiviso viene utilizzato per identificare il plugin
ai fini dell'analisi degli argomenti (vedi -fplugin-arg-Nome-chiave=APPREZZIAMO sotto). Ogni
plugin dovrebbe definire le funzioni di callback specificate nell'API Plugin.

-fplugin-arg-Nome-chiave=APPREZZIAMO
Definire un argomento chiamato chiave con un valore di APPREZZIAMO per il plugin chiamato Nome.

-fdump-ada-spec[-sottile]
Per i file di origine e di inclusione C e C++, generare le specifiche Ada corrispondenti.

-fdump-go-spec =filetto
Per i file di input in qualsiasi lingua, genera le dichiarazioni Go corrispondenti in filetto. Questo
genera dichiarazioni Go "const", "type", "var" e "func" che possono essere un modo utile
per iniziare a scrivere un'interfaccia Go per codice scritto in qualche altra lingua.

@filetto
Leggi le opzioni della riga di comando da filetto. Le opzioni lette vengono inserite al posto di
originale @filetto opzione. Se filetto non esiste o non può essere letto, allora l'opzione
saranno trattati letteralmente e non rimossi.

opzioni in filetto sono separati da spazi bianchi. Può essere incluso un carattere di spazio bianco
in un'opzione racchiudendo l'intera opzione tra virgolette singole o doppie. Qualunque
carattere (inclusa una barra rovesciata) può essere incluso anteponendo il carattere a essere
incluso con una barra rovesciata. Il filetto può contenere a sua volta @ aggiuntivifiletto opzioni; qualunque
tali opzioni verranno elaborate in modo ricorsivo.

compilazione C++ Programmi
I file sorgente C++ usano convenzionalmente uno dei suffissi .C, . Cc, cpp, cpp, .c++, .cp, o
.cxx; I file di intestazione C++ usano spesso .H H, .hpp, .H, o (per codice modello condiviso) .tcc, E
i file C++ preelaborati usano il suffisso .ii. GCC riconosce i file con questi nomi e
li compila come programmi C++ anche se chiami il compilatore allo stesso modo della compilazione
programmi C (di solito con il nome gcc).

Tuttavia, l'uso di gcc non aggiunge la libreria C++. g ++ è un programma che chiama GCC e
tratta .c, .h ed .i file come file sorgente C++ anziché file sorgente C a meno che -x is
utilizzato e specifica automaticamente il collegamento alla libreria C++. Questo programma è anche
utile quando si precompila un file di intestazione C con a .h estensione per l'uso nelle compilazioni C++.
Su molti sistemi, g ++ è anche installato con il nome c ++.

Quando compili programmi C++, puoi specificare molte delle stesse opzioni della riga di comando che
usi per compilare programmi in qualsiasi lingua; o opzioni della riga di comando significative per C
e relative lingue; o opzioni che sono significative solo per i programmi C++.

Opzioni Controllo C Dialetto
Le seguenti opzioni controllano il dialetto del C (o i linguaggi derivati ​​dal C, come C++,
Objective-C e Objective-C++) che il compilatore accetta:

-ansi
In modalità C, questo è equivalente a -std=c90. In modalità C++, è equivalente a
-std = c ++ 98.

Questo disattiva alcune funzioni di GCC che sono incompatibili con ISO C90 (quando
compilazione di codice C), o di C++ standard (durante la compilazione di codice C++), come "asm" e
parole chiave "typeof" e macro predefinite come "unix" e "vax" che identificano il
tipo di sistema che stai utilizzando. Consente inoltre l'indesiderabile e raramente utilizzato ISO
funzione trigrafica. Per il compilatore C, disabilita il riconoscimento dello stile C++ //
commenti e la parola chiave "inline".

Le parole chiave alternative "__asm__", "__extension__", "__inline__" e "__typeof__"
continuare a lavorare nonostante -ansi. Non vorrai usarli in un programma ISO C,
certo, ma è utile inserirli in file di intestazione che potrebbero essere inclusi in
compilation fatte con -ansi. Macro predefinite alternative come "__unix__" e
Sono disponibili anche "__vax__", con o senza -ansi.

I -ansi L'opzione non fa sì che i programmi non ISO vengano rifiutati gratuitamente. Per
quella, -pedante è richiesto in aggiunta a -ansi.

La macro "__STRICT_ANSI__" è predefinita quando il -ansi viene utilizzata l'opzione. Qualche intestazione
i file possono notare questa macro e astenersi dal dichiarare determinate funzioni o definire
alcune macro che lo standard ISO non richiede; questo per evitare di interferire
con tutti i programmi che potrebbero usare questi nomi per altre cose.

Funzioni che normalmente sarebbero integrate ma non hanno una semantica definita da ISO C
(come "alloca" e "ffs") non sono funzioni integrate quando -ansi viene utilizzato.

-std=
Determina lo standard linguistico. Questa opzione è attualmente supportata solo quando
compilare C o C++.

Il compilatore può accettare diversi standard di base, come c90 or c ++ 98e dialetti GNU
di tali standard, come gnu90 or gnu++98. Specificando uno standard di base, il
il compilatore accetterà tutti i programmi che seguono quello standard e quelli che usano GNU
estensioni che non lo contraddicono. Per esempio, -std=c90 si spegne certo
caratteristiche di GCC che sono incompatibili con ISO C90, come "asm" e "typeof"
parole chiave, ma non altre estensioni GNU che non hanno significato in ISO C90, come
omettendo il termine medio di un'espressione "?:". D'altra parte, specificando un GNU
dialetto di uno standard, tutte le funzionalità supportate dal compilatore sono abilitate, anche quando quelle
le caratteristiche cambiano il significato dello standard di base e di alcuni programmi strettamente conformi
può essere rifiutato. Lo standard particolare è utilizzato da -pedante per identificare quale
le caratteristiche sono estensioni GNU data quella versione dello standard. Per esempio -std=gnu90
-pedante metterebbe in guardia sullo stile C++ // commenti, mentre -std=gnu99 -pedante sarebbe
non.

È necessario fornire un valore per questa opzione; i valori possibili sono

c90
c89
iso9899: 1990
Supporta tutti i programmi ISO C90 (alcune estensioni GNU che sono in conflitto con ISO C90
sono disabilitati). Uguale a -ansi per il codice C.

iso9899: 199409
ISO C90 come modificata nell'emendamento 1.

c99
c9x
iso9899: 1999
iso9899:199x
ISOC99. Si noti che questo standard non è ancora completamente supportato; vedere
<http://gcc.gnu.org/gcc-4.7/c99status.html> per maggiori informazioni. I nomi c9x
ed iso9899:199x sono deprecati.

c11
c1x
iso9899: 2011
ISO C11, la revisione 2011 della norma ISO C. Il supporto è incompleto e
sperimentale. Il nome c1x è deprecato.

gnu90
gnu89
Dialetto GNU di ISO C90 (incluse alcune funzionalità di C99). Questa è l'impostazione predefinita per C
codice.

gnu99
gnu9x
Dialetto GNU di ISO C99. Quando ISO C99 sarà completamente implementato in GCC, questo sarà
diventare l'impostazione predefinita. Il nome gnu9x è deprecato.

gnu11
gnu1x
Dialetto GNU di ISO C11. Il supporto è incompleto e sperimentale. Il nome gnu1x
è deprecato.

c ++ 98
Lo standard ISO C++ del 1998 più gli emendamenti. Uguale a -ansi per il codice C++.

gnu++98
dialetto GNU di -std = c ++ 98. Questa è l'impostazione predefinita per il codice C++.

c ++ 11
Lo standard ISO C++ 2011 più gli emendamenti. Il supporto per C++11 è ancora
sperimentale e potrebbe cambiare in modi incompatibili nelle versioni future.

gnu++11
dialetto GNU di -std = c ++ 11. Il supporto per C++ 11 è ancora sperimentale e potrebbe cambiare
in modi incompatibili nelle versioni future.

-fgnu89-in linea
L'opzione -fgnu89-in linea dice a GCC di usare la tradizionale semantica GNU per "inline"
funziona in modalità C99.
Questa opzione è accettata e ignorata dalle versioni GCC 4.1.3 fino a ma non incluse
4.3. Nelle versioni GCC 4.3 e successive modifica il comportamento di GCC in modalità C99. Usando
questa opzione è più o meno equivalente all'aggiunta dell'attributo della funzione "gnu_inline" a all
funzioni in linea.

L'opzione -fno-gnu89-in linea dice esplicitamente a GCC di usare la semantica C99 per
"in linea" quando è in modalità C99 o gnu99 (ovvero, specifica il comportamento predefinito). Questo
opzione è stata inizialmente supportata in GCC 4.3. Questa opzione non è supportata in -std=c90 or
-std=gnu90 modalità.

Si possono usare le macro del preprocessore "__GNUC_GNU_INLINE__" e "__GNUC_STDC_INLINE__"
per verificare quale semantica è attiva per le funzioni "inline".

-aux-info Nome del file
Output al nome file specificato dichiarazioni prototipate per tutte le funzioni dichiarate e/o
definiti in un'unità di traduzione, inclusi quelli nei file di intestazione. Questa opzione è
silenziosamente ignorato in qualsiasi lingua diversa da C.

Oltre alle dichiarazioni, il file indica, nei commenti, l'origine di ciascuna dichiarazione
(file e riga sorgente), se la dichiarazione era implicita, prototipata o
non prototipo (I, N per nuovo o O per il vecchio, rispettivamente, nel primo carattere dopo
il numero di riga e i due punti), e se provenga da una dichiarazione o da una definizione
(C or F, rispettivamente, nel carattere seguente). In caso di funzione
definizioni, è anche un elenco di argomenti in stile K&R seguito dalle loro dichiarazioni
fornito, all'interno dei commenti, dopo la dichiarazione.

-funzioni-variadiche-senza-parametri
Accetta funzioni variadiche senza parametri denominati.

Sebbene sia possibile definire tale funzione, questa non è molto utile in quanto è
non è possibile leggere gli argomenti. Questo è supportato solo per C poiché questo costrutto è
consentito dal C++.

-fno-asm
Non riconoscere "asm", "inline" o "typeof" come parole chiave, in modo che il codice possa utilizzarle
parole come identificatori. Puoi usare le parole chiave "__asm__", "__inline__" e
"__typeof__" invece. -ansi implica -fno-asm.

In C++, questa opzione riguarda solo la parola chiave "typeof", poiché "asm" e "inline" sono
parole chiave standard. Potresti voler usare il -fno-gnu-parole chiave bandiera invece, che ha
lo stesso effetto. In modalità C99 (-std=c99 or -std=gnu99), questo interruttore ha effetto solo sul
parole chiave "asm" e "typeof", poiché "inline" è una parola chiave standard in ISO C99.

-fno-integrato
-fno-integrato-function
Non riconoscere le funzioni integrate che non iniziano con __incorporato_ come prefisso.

GCC normalmente genera codice speciale per gestire alcune funzioni integrate di più
efficiente; ad esempio, le chiamate ad "alloca" possono diventare singole istruzioni che
regolare direttamente lo stack e le chiamate a "memcpy" potrebbero diventare cicli di copia in linea. Il
il codice risultante è spesso sia più piccolo che più veloce, ma poiché la funzione chiama no
appaiono più come tali, non è possibile impostare un punto di interruzione su quelle chiamate, né è possibile modificare
il comportamento delle funzioni collegandosi a una libreria diversa. Inoltre, quando
una funzione è riconosciuta come funzione incorporata, GCC può utilizzare informazioni al riguardo
funzione per segnalare problemi con le chiamate a quella funzione o per generare altro
codice efficiente, anche se il codice risultante contiene ancora chiamate a quella funzione. Per
esempio, gli avvertimenti sono forniti con -Formato W per le chiamate errate a "printf", quando "printf" è
integrato, e "strlen" è noto per non modificare la memoria globale.

Grazie alla -fno-integrato-function opzione solo la funzione integrata function è disabilitato.
function non deve iniziare con __incorporato_. Se viene denominata una funzione che non è incorporata
in questa versione di GCC, questa opzione viene ignorata. Non c'è corrispondenza
-fintegrato-function opzione; se si desidera abilitare le funzioni integrate in modo selettivo quando
utilizzando -fno-integrato or -autoportante, puoi definire macro come:

#define abs(n) __abs_integrato ((n))
#define strcpy(d, s) __builtin_strcpy ((d), (s))

-ospitato
Affermare che la compilazione avviene in un ambiente ospitato. Ciò implica -fintegrato.
Un ambiente ospitato è quello in cui è disponibile l'intera libreria standard e in
quale "main" ha un tipo restituito di "int". Gli esempi sono quasi tutto tranne a
nocciolo. Questo è equivalente a -fno-autoportante.

-autoportante
Affermare che la compilazione avviene in un ambiente indipendente. Ciò implica
-fno-integrato. Un ambiente indipendente è uno in cui la libreria standard potrebbe non essere
esiste e l'avvio del programma potrebbe non essere necessariamente "principale". L'esempio più ovvio
è un kernel del sistema operativo. Questo è equivalente a -fno-ospitato.

-fopenmp
Abilita la gestione delle direttive OpenMP "#pragma omp" in C/C++ e "!$omp" in Fortran.
Quando -fopenmp è specificato, il compilatore genera il codice parallelo secondo il
Interfaccia del programma applicativo OpenMP v3.0http://www.openmp.org/>. Questa opzione
implica -pthread, e quindi è supportato solo su obiettivi che hanno il supporto per
-pthread.

-fgnu-tm
Quando l'opzione -fgnu-tm è specificato, il compilatore genererà il codice per Linux
variante dell'attuale documento di specifica ABI per la memoria transazionale di Intel (Revisione
1.1, 6 maggio 2009). Questa è una funzionalità sperimentale la cui interfaccia potrebbe cambiare in
future versioni di GCC, poiché le specifiche ufficiali cambiano. Si prega di notare che non
tutte le architetture sono supportate per questa funzione.

Per ulteriori informazioni sul supporto di GCC per la memoria transazionale,

Si noti che la funzione di memoria transazionale non è supportata con eccezioni non chiamate
(-fnon-chiamata-eccezioni).

-fms-estensioni
Accetta alcuni costrutti non standard utilizzati nei file di intestazione di Microsoft.

Nel codice C++, ciò consente ai nomi dei membri nelle strutture di essere simili ai tipi precedenti
dichiarazioni.

typedef int UOW;
struttura ABC {
UOW UOW;
};

Alcuni casi di campi senza nome in strutture e unioni sono accettati solo con questo
opzione.

-fplan9-estensioni
Accetta alcuni costrutti non standard utilizzati nel codice Plan 9.

Ciò consente -fms-estensioni, permette di passare puntatori a strutture con anonimi
campi a funzioni che si aspettano puntatori a elementi del tipo del campo, e
permessi riferiti a campi anonimi dichiarati utilizzando un typedef. Questo è solo
supportato per C, non C++.

-trigrafie
Supporta i trigrafi ISO C. Il -ansi opzione (e -std opzioni per ISO C . rigoroso
conformità) implica -trigrafie.

-no-integrato-cpp
Esegue una compilazione in due passaggi: preelaborazione e compilazione. Questa opzione consente
un utente fornito "cc1", "cc1plus" o "cc1obj" tramite il -B opzione. L'utente ha fornito
la fase di compilazione può quindi aggiungere un'ulteriore fase di pre-elaborazione dopo la normale
pre-elaborazione ma prima della compilazione. L'impostazione predefinita è utilizzare il cpp integrato
(cpp interno)

La semantica di questa opzione cambierà se "cc1", "cc1plus" e "cc1obj" vengono uniti.

-tradizionale
-tradizionale-cpp
In precedenza, queste opzioni facevano sì che GCC tentasse di emulare un compilatore C pre-standard.
Ora sono supportati solo con il -E interruttore. Il preprocessore continua a supportare
una modalità pre-standard. Vedere il manuale GNU CPP per i dettagli.

-fcond-mancata corrispondenza
Consenti espressioni condizionali con tipi non corrispondenti nel secondo e nel terzo argomento.
Il valore di tale espressione è nullo. Questa opzione non è supportata per C++.

-conversioni-vettoriali-di-lino
Consenti conversioni implicite tra vettori con diversi numeri di elementi e/o
tipi di elementi incompatibili. Questa opzione non deve essere utilizzata per il nuovo codice.

-funsigned-carattere
Lascia che il tipo "char" sia unsigned, come "unsigned char".

Ogni tipo di macchina ha un valore predefinito per quello che dovrebbe essere "char". O è come
"unsigned char" per impostazione predefinita o come "signed char" per impostazione predefinita.

Idealmente, un programma portabile dovrebbe sempre usare "carattere firmato" o "carattere non firmato" quando
dipende dalla firma di un oggetto. Ma molti programmi sono stati scritti per essere usati
semplice "char" e aspettati che sia firmato, o aspettati che non sia firmato, a seconda del
macchine per cui sono stati scritti. Questa opzione, e il suo inverso, ti permettono di fare un tale
il programma funziona con l'impostazione predefinita opposta.

Il tipo "char" è sempre un tipo distinto da ciascuno di "signed char" o "unsigned
char", anche se il suo comportamento è sempre uguale a uno di quei due.

-fsigned-carattere
Lascia che il tipo "char" sia firmato, come "signed char".

Nota che questo è equivalente a -fno-unsigned-char, che è la forma negativa di
-funsigned-carattere. Allo stesso modo, l'opzione -fno-carattere-firmato è equivalente
-funsigned-carattere.

-fcampi-bitfirmati
-campi di bit con segno divertente
-fno-campi-di-bit con segno
-fno-bitfields senza segno
Queste opzioni controllano se un campo di bit è firmato o non firmato, quando la dichiarazione
non usa né "firmato" né "non firmato". Per impostazione predefinita, tale campo di bit è firmato,
perché questo è coerente: i tipi interi di base come "int" sono tipi con segno.

Opzioni Controllo C++ Dialetto
Questa sezione descrive le opzioni della riga di comando che sono significative solo per i programmi C++;
ma puoi anche usare la maggior parte delle opzioni del compilatore GNU indipendentemente dalla tua lingua
programma è in. Ad esempio, potresti compilare un file "firstClass.C" in questo modo:

g++ -g -frepo -O -c primaClasse.C

In questo esempio, solo -frepo è un'opzione pensata solo per i programmi C++; puoi usare il
altre opzioni con qualsiasi lingua supportata da GCC.

Ecco un elenco di opzioni che sono esclusivamente per la compilazione di programmi C++:

-fabi-versione=n
Usa la versione n dell'ABI C++. La versione 2 è la versione dell'ABI C++ che per prima
apparso in G++ 3.4. La versione 1 è la versione dell'ABI C++ che è apparsa per la prima volta in
G++ 3.2. La versione 0 sarà sempre la versione più conforme al C++
specifica ABI. Pertanto, l'ABI ottenuto utilizzando la versione 0 cambierà come ABI
i bug vengono corretti.

L'impostazione predefinita è la versione 2.

La versione 3 corregge un errore nella manipolazione di un indirizzo costante come argomento del modello.

La versione 4, apparsa per la prima volta in G++ 4.5, implementa un mangling standard per vector
tipi.

La versione 5, apparsa per la prima volta in G++ 4.6, corregge l'alterazione degli attributi
const/volatile sui tipi di puntatore a funzione, decltype di un decl semplice e uso di a
parametro della funzione nella dichiarazione di un altro parametro.

La versione 6, apparsa per la prima volta in G++ 4.7, corregge il comportamento di promozione di C++ 11
enumerazioni con scope e manipolazione dei pacchetti di argomenti del modello, const/static_cast, prefisso ++
e --, e una funzione di ambito di classe utilizzata come argomento del modello.

Vedi anche -Wabi.

-fno-controllo-accesso
Disattiva tutti i controlli di accesso. Questo interruttore è utile principalmente per aggirare i bug in
il codice di controllo accessi.

-fcheck-nuovo
Verificare che il puntatore restituito da "operator new" non sia null prima di tentare di
modificare la memoria allocata. Questo controllo non è normalmente necessario perché il C++
lo standard specifica che "operatore nuovo" restituirà 0 solo se è dichiarato gettare(),
nel qual caso il compilatore controllerà sempre il valore restituito anche senza questo
opzione. In tutti gli altri casi, quando "operatore nuovo" ha un'eccezione non vuota
specifica, l'esaurimento della memoria viene segnalato lanciando "std::bad_alloc". Guarda anche
nuovi (notro).

-fconserve-spazio
Metti le variabili globali non inizializzate o inizializzate in fase di esecuzione nel segmento comune, come
C lo fa. Ciò consente di risparmiare spazio nell'eseguibile al costo di non diagnosticare duplicati
definizioni. Se compili con questo flag e il tuo programma si blocca misteriosamente
dopo che "main()" è stato completato, potresti avere un oggetto che viene distrutto due volte
perché due definizioni sono state unite.

Questa opzione non è più utile sulla maggior parte dei bersagli, ora che è stato aggiunto il supporto per
inserire le variabili in BSS senza renderle comuni.

-fconstexpr-profondità=n
Imposta la profondità di valutazione nidificata massima per le funzioni constexpr C++ 11 su n. un limite
è necessario per rilevare la ricorsione infinita durante la valutazione dell'espressione costante. Il
minimo specificato dallo standard è 512.

-fdeduce-elenco-init
Abilita la deduzione di un parametro di tipo modello come std::initializer_list da un brace-
elenco di inizializzatori racchiuso, ad es

modello auto forward(T t) -> decltype (realfn (t))
{
restituire realfn (t);
}

vuoto f()
{
avanti({1,2}); //chiama in avanti >
}

Tale detrazione è stata attuata come possibile estensione di quanto originariamente proposto
semantica per lo standard C++ 11, ma non faceva parte dello standard finale, quindi lo è
disabilitato per impostazione predefinita. Questa opzione è deprecata e potrebbe essere rimossa in futuro
versione di G++.

-ffriend-iniezione
Inietta funzioni friend nello spazio dei nomi che le racchiude, in modo che siano visibili all'esterno
l'ambito della classe in cui sono dichiarati. Le funzioni degli amici sono state documentate
lavorare in questo modo nel vecchio Manuale di riferimento C++ con annotazioni e versioni di G++ precedenti
4.1 ha sempre funzionato così. Tuttavia, in ISO C++ una funzione amico che non lo è
dichiarato in un ambito di inclusione può essere trovato solo utilizzando la ricerca dipendente dall'argomento.
Questa opzione fa sì che gli amici vengano iniettati come nelle versioni precedenti.

Questa opzione è per compatibilità e potrebbe essere rimossa in una versione futura di G++.

-fno-elide-costruttori
Lo standard C++ consente a un'implementazione di omettere la creazione di un temporaneo che è solo
utilizzato per inizializzare un altro oggetto dello stesso tipo. Specificando questa opzione si disabilita
tale ottimizzazione e costringe G++ a chiamare il costruttore di copie in tutti i casi.

-fno-enforce-eh-spec
Non generare codice per verificare la violazione delle specifiche dell'eccezione in fase di esecuzione.
Questa opzione viola lo standard C++, ma può essere utile per ridurre la dimensione del codice in
build di produzione, proprio come definire NDEBUG. Questo non dà l'autorizzazione al codice utente
lanciare eccezioni in violazione delle specifiche di eccezione; il compilatore
ottimizza comunque in base alle specifiche, quindi verrà generata un'eccezione imprevista
comportare un comportamento indefinito.

-per-scopo
-fno-per-scope
If -per-scopo è specificato, l'ambito delle variabili dichiarate in a istruzione-for-init
è limitato a per loop stesso, come specificato dallo standard C++. Se
-fno-per-scope è specificato, l'ambito delle variabili dichiarate in a istruzione-for-init
si estende fino alla fine dell'ambito di inclusione, come nel caso delle vecchie versioni di G++, e
altre implementazioni (tradizionali) del C++.

L'impostazione predefinita se nessuno dei flag viene assegnato per seguire lo standard, ma per consentire e dare a
avviso per codice vecchio stile che altrimenti non sarebbe valido o sarebbe diverso
comportamento.

-fno-gnu-parole chiave
Non riconoscere "typeof" come parola chiave, quindi il codice può usare questa parola come un
identificatore. Puoi invece usare la parola chiave "__typeof__". -ansi implica
-fno-gnu-parole chiave.

-fno-modelli-impliciti
Non emettere mai codice per modelli non in linea che sono istanziati implicitamente (cioè da
utilizzo); emette codice solo per istanze esplicite.

-fno-modelli-inline-impliciti
Non emettere nemmeno codice per le istanze implicite dei modelli in linea. Il predefinito
è gestire le righe in modo diverso in modo che le compilazioni con e senza ottimizzazione lo facciano
necessitano dello stesso insieme di istanze esplicite.

-fno-implementare-inline
Per risparmiare spazio, non emettere copie fuori linea delle funzioni in linea controllate da
#pragma implementazione. Ciò causerà errori del linker se queste funzioni non lo sono
inline ovunque vengano chiamati.

-fms-estensioni
Disabilita gli avvisi pedanti sui costrutti utilizzati in MFC, come int implicito e
ottenere un puntatore alla funzione membro tramite sintassi non standard.

-fno-nonansi-integrati
Disabilita le dichiarazioni integrate di funzioni che non sono richieste da ANSI/ISO C. Queste
includono "ffs", "alloca", "_exit", "index", "bzero", "conjf" e altri
funzioni.

-fnothrow-opt
Tratta una specifica di eccezione "throw()" come se fosse una specifica "noException"
per ridurre o eliminare l'overhead delle dimensioni del testo relativo a una funzione senza eccezioni
specifica. Se la funzione ha variabili locali di tipo con non banale
distruttori, la specifica dell'eccezione ridurrà effettivamente la funzione
perché le pulizie EH per quelle variabili possono essere ottimizzate. Il semantico
l'effetto è che un'eccezione viene espulsa da una funzione con tale eccezione
specifica comporterà una chiamata a "terminare" piuttosto che "inaspettato".

-fno-nomi-operatore
Non trattare le parole chiave del nome dell'operatore "and", "bitand", "bitor", "compl", "not", "or"
e "xor" come sinonimi come parole chiave.

-fno-opzionale-diags
Disabilita la diagnostica che lo standard dice che un compilatore non deve emettere.
Attualmente, l'unica diagnostica di questo tipo emessa da G++ è quella per un nome che ha
molteplici significati all'interno di una classe.

-fpermissivo
Eseguire il downgrade di alcune diagnostiche relative al codice non conforme da errori ad avvisi. Così,
utilizzando -fpermissivo consentirà la compilazione di codice non conforme.

-fno-pretty-modelli
Quando un messaggio di errore fa riferimento a una specializzazione di un modello di funzione, il compilatore
normalmente stamperà la firma del modello seguita dagli argomenti del modello
e qualsiasi typedef o typename nella firma (ad esempio "void f(T) [with T = int]" piuttosto
di "void f(int)") in modo che sia chiaro quale modello è coinvolto. Quando un errore
messaggio si riferisce a una specializzazione di un modello di classe, il compilatore ometterà qualsiasi
argomenti del modello che corrispondono agli argomenti del modello predefinito per quel modello. Se
uno di questi comportamenti rende più difficile capire il messaggio di errore piuttosto che
più facile, usando -fno-pretty-modelli li disabiliterà.

-frepo
Abilita l'istanza automatica del modello al momento del collegamento. Questa opzione implica anche
-fno-modelli-impliciti.

-fno-rtti
Disabilita la generazione di informazioni su ogni classe con funzioni virtuali per l'uso da
le funzionalità di identificazione del tipo di runtime C++ (dynamic_cast ed tipoid). Se non lo fai
usa quelle parti della lingua, puoi risparmiare spazio usando questo flag. Nota
quella gestione delle eccezioni utilizza le stesse informazioni, ma le genererà secondo necessità.
I dynamic_cast operatore può ancora essere utilizzato per i cast che non richiedono runtime
informazioni sul tipo, ad esempio cast su "void *" o su classi base non ambigue.

-fstats
Emetti statistiche sull'elaborazione front-end alla fine della compilazione. Questo
le informazioni sono generalmente utili solo al team di sviluppo di G++.

-fstrict-enum
Consenti al compilatore di ottimizzare utilizzando il presupposto che un valore di tipo enumerato
può essere solo uno dei valori dell'enumerazione (come definito nello standard C++;
in sostanza, un valore che può essere rappresentato nel numero minimo di bit necessari per
rappresentano tutti gli enumeratori). Questa ipotesi potrebbe non essere valida se il programma utilizza
un cast per convertire un valore intero arbitrario nel tipo enumerato.

-ftemplate-profondità=n
Imposta la profondità massima di istanziazione per le classi modello su n. Un limite al
la profondità dell'istanza del modello è necessaria per rilevare ricorsioni infinite durante il modello
istanziazione di classe. I programmi conformi ad ANSI/ISO C++ non devono fare affidamento su un massimo
profondità maggiore di 17 (modificato in 1024 in C++11). Il valore predefinito è 900, poiché il
il compilatore può esaurire lo spazio dello stack prima di raggiungere 1024 in alcune situazioni.

-fno-threadsafe-statics
Non emettere il codice aggiuntivo per utilizzare le routine specificate nell'ABI C++ per thread-
inizializzazione sicura della statica locale. Puoi usare questa opzione per ridurre la dimensione del codice
leggermente nel codice che non ha bisogno di essere thread-safe.

-fuse-cxa-uscita
Registra distruttori per oggetti con durata di archiviazione statica con "__cxa_atexit"
funzione piuttosto che la funzione "atexit". Questa opzione è necessaria per completamente
gestione conforme agli standard dei distruttori statici, ma funzionerà solo se il tuo C
la libreria supporta "__cxa_atexit".

-fno-use-cxa-get-exception-ptr
Non utilizzare la routine di runtime "__cxa_get_exception_ptr". Questo causerà
"std::uncaught_exception" non è corretto, ma è necessario se la routine di runtime è
non disponibile.

-fvisibility-inlines-nascosto
Questa opzione dichiara che l'utente non tenta di confrontare i puntatori con inline
funzioni o metodi in cui gli indirizzi delle due funzioni sono stati presi in modo diverso
oggetti condivisi.

L'effetto di ciò è che GCC può, in modo efficace, contrassegnare i metodi in linea con
"__attribute__ ((visibility ("nascosto")))" in modo che non appaiano nell'esportazione
tabella di un DSO e non richiedono un riferimento indiretto PLT se utilizzato all'interno del DSO.
L'abilitazione di questa opzione può avere un effetto drammatico sui tempi di caricamento e collegamento di un DSO in quanto
riduce enormemente la dimensione della tabella di esportazione dinamica quando la libreria diventa pesante
uso di modelli.

Il comportamento di questo interruttore non è esattamente lo stesso di contrassegnare i metodi come nascosti
direttamente, perché non influisce sulle variabili statiche locali alla funzione o alla causa
il compilatore per dedurre che la funzione è definita in un solo oggetto condiviso.

Puoi contrassegnare un metodo come avente una visibilità in modo esplicito per negare l'effetto del
passare a quel metodo. Ad esempio, se vuoi confrontare i puntatori con a
particolare metodo in linea, potresti contrassegnarlo come con visibilità predefinita. Segnando il
racchiudere la classe con visibilità esplicita non avrà alcun effetto.

I metodi in linea esplicitamente istanziati non sono interessati da questa opzione in quanto il loro collegamento
potrebbe altrimenti attraversare un confine di libreria condivisa.

-fvisibility-ms-compat
Questo flag tenta di utilizzare le impostazioni di visibilità per creare il modello di collegamento C++ di GCC
compatibile con quello di Microsoft Visual Studio.

Il flag apporta queste modifiche al modello di collegamento di GCC:

1. Imposta la visibilità predefinita su "nascosta", come -fvisibilità=nascosto.

2. I tipi, ma non i relativi membri, non sono nascosti per impostazione predefinita.

3. La regola di una definizione è rilassata per i tipi senza visibilità esplicita
specifiche che sono definite in più di un oggetto condiviso diverso: quelli
le dichiarazioni sono consentite se sarebbero state consentite quando questa opzione era
non usato.

Nel nuovo codice è meglio usare -fvisibilità=nascosto ed esporta quelle classi che sono
destinato ad essere visibile dall'esterno. Sfortunatamente è possibile che il codice faccia affidamento,
forse accidentalmente, sul comportamento di Visual Studio.

Tra le conseguenze di questi cambiamenti vi sono i membri di dati statici dello stesso tipo
con lo stesso nome ma definito in oggetti condivisi diversi sarà diverso, quindi
cambiando uno non cambierà l'altro; e che puntatori a membri di funzione definiti
in oggetti condivisi diversi potrebbe non essere uguale. Quando viene dato questo flag, è a
violazione dell'ODR per definire diversamente i tipi con lo stesso nome.

-fno-debole
Non utilizzare un supporto debole per i simboli, anche se fornito dal linker. Per impostazione predefinita, G++
utilizzerà simboli deboli se disponibili. Questa opzione esiste solo per il test e
non dovrebbe essere utilizzato dagli utenti finali; risulterà in un codice inferiore e non ha vantaggi.
Questa opzione potrebbe essere rimossa in una futura versione di G++.

-nostdin++
Non cercare i file di intestazione nelle directory standard specifiche del C++, ma fallo
cerca ancora nelle altre directory standard. (Questa opzione viene utilizzata quando si costruisce il
libreria C++.)

Inoltre, queste opzioni di ottimizzazione, avviso e generazione di codice hanno solo un significato
per i programmi C++:

-fno-default-inline
Non assumere inline per le funzioni definite all'interno di un ambito di classe.
Nota che queste funzioni avranno collegamenti come le funzioni inline; semplicemente non lo faranno
essere in linea per impostazione predefinita.

-Wabi (solo C, Objective-C, C++ e Objective-C++)
Avvisa quando G++ genera codice che probabilmente non è compatibile con il vendor-neutral
C++ ABI. Sebbene sia stato fatto uno sforzo per mettere in guardia su tutti questi casi, ci sono
probabilmente alcuni casi di cui non si è avvertiti, anche se G++ sta generando
codice incompatibile. Ci possono essere anche casi in cui vengono emessi avvisi anche se il
il codice generato sarà compatibile.

Dovresti riscrivere il tuo codice per evitare questi avvisi se sei preoccupato per il
fatto che il codice generato da G++ potrebbe non essere compatibile a livello binario con il codice generato da
altri compilatori.

Le note incompatibilità in -fabi-versione=2 (l'impostazione predefinita) includono:

· Un modello con un parametro di modello non di tipo di tipo di riferimento è storpiato
in modo errato:

esterno interno N;
modello struttura S {};
vuoto n (S ) {2}

Questo è risolto in -fabi-versione=3.

· I tipi di vettore SIMD dichiarati usando "__attribute ((vector_size))" sono alterati in a
modo non standard che non consente il sovraccarico delle funzioni che prendono vettori
di diverse dimensioni.

Il mangling è cambiato in -fabi-versione=4.

Le note incompatibilità in -fabi-versione=1 includono:

· Gestione errata del tail-padding per i campi di bit. G++ potrebbe tentare di impacchettare i dati
nello stesso byte di una classe base. Per esempio:

struct A { vuoto virtuale f(); int f1 : 1; };
struttura B: public A { int f2: 1; };

In questo caso, G++ inserirà "B::f2" nello stesso byte di "A::f1"; altri compilatori
non. Puoi evitare questo problema aggiungendo esplicitamente "A" in modo che la sua dimensione
è un multiplo della dimensione in byte della tua piattaforma; che causerà G++ e altro
compilatori al layout "B" in modo identico.

· Gestione errata dell'imbottitura della coda per le basi virtuali. G++ non usa la coda
imbottitura durante la disposizione delle basi virtuali. Per esempio:

struct A { vuoto virtuale f(); carattere c1; };
struttura B { B(); carattere c2; };
struct C : pubblico A, pubblico virtuale B {};

In questo caso, G++ non metterà "B" nel tail-padding per "A"; Altro
i compilatori lo faranno. Puoi evitare questo problema aggiungendo esplicitamente "A" in modo che sia
la dimensione è un multiplo del suo allineamento (ignorando le classi base virtuali); quello sarà
fa in modo che G++ e altri compilatori dispongano di "C" in modo identico.

· Gestione errata di campi di bit con larghezze dichiarate maggiori di quella dei loro
tipi sottostanti, quando i campi di bit vengono visualizzati in un'unione. Per esempio:

unione U { int i : 4096; };

Supponendo che un "int" non abbia 4096 bit, G++ renderà l'unione troppo piccola
dal numero di bit in un "int".

· Le classi vuote possono essere posizionate a offset errati. Per esempio:

struttura A {};

struttura B {
Aa;
vuoto virtuale f ();
};

struttura C: pubblica B, pubblica A {};

G++ posizionerà la classe base "A" di "C" con un offset diverso da zero; dovrebbe essere posizionato
all'offset zero. G++ crede erroneamente che il membro dati "A" di "B" sia
già a offset zero.

· Nomi di funzioni template i cui tipi coinvolgono "typename" o template template
i parametri possono essere alterati in modo errato.

modello
void f(nometipo Q::X) {}

modello classe Q>
void f(nometipo Q ::X) {}

Le istanze di questi modelli potrebbero essere alterate in modo errato.

Avverte anche le modifiche relative a psABI. Le modifiche note a psABI a questo punto includono:

· Per SYSV/x86-64, quando si passa l'unione con il doppio lungo, viene modificato per passare in
memoria come specificato in psABI. Per esempio:

unione U {
lungo doppio ld;
int i;
};

"union U" sarà sempre passato in memoria.

-Wctor-dtor-privacy (solo C++ e Objective-C++)
Avvisa quando una classe sembra inutilizzabile perché tutti i costruttori o distruttori in essa
sono private e non ha né amici né funzioni membro statiche pubbliche.

-Wdelete-non-virtuale-dtor (solo C++ e Objective-C++)
Avvisa quando delete è usato per distruggere un'istanza di una classe che ha funzioni virtuali
e distruttore non virtuale. Non è sicuro eliminare un'istanza di una classe derivata
attraverso un puntatore a una classe base se la classe base non ha un virtual
distruttore. Questo avviso è abilitato da -Parete.

-Stringendo (solo C++ e Objective-C++)
Avvisa quando si verifica una conversione restrittiva vietata da C++11 all'interno { }, per esempio

int io = { 2.2 }; // errore: restringimento da double a int

Questo flag è incluso in -Parete ed -Wc++11-compatibile.

Con -std=c++11, -Non-restringimento sopprime la diagnostica richiesta dalla norma.
Si noti che ciò non influisce sul significato del codice ben formato; restringendo le conversioni
sono ancora considerati mal formati nel contesto SFINAE.

-Non tranne (solo C++ e Objective-C++)
Avvisa quando un'espressione noeccezione restituisce false a causa di una chiamata a una funzione
che non ha una specifica di eccezione non generatrice (ad es gettare() or noeccetto)
ma è noto al compilatore per non generare mai un'eccezione.

-Wnon-virtuale-dtor (solo C++ e Objective-C++)
Avvisa quando una classe ha funzioni virtuali e un distruttore non virtuale accessibile, in
nel qual caso sarebbe possibile ma non sicuro eliminare un'istanza di una classe derivata
tramite un puntatore alla classe base. Questo avviso è abilitato anche se -Weffc++ is
specificato.

-Riordina (solo C++ e Objective-C++)
Avvisa quando l'ordine degli inizializzatori dei membri fornito nel codice non corrisponde all'ordine
in cui devono essere eseguiti. Ad esempio:

struttura A {
int i;
intj;
A(): j (0), io (1) { }
};

Il compilatore riorganizzerà gli inizializzatori dei membri per i ed j per abbinare il
ordine di dichiarazione dei soci, emettendo una diffida in tal senso. Questo avviso è
abilitato da -Parete.

Le seguenti -W... le opzioni non sono influenzate da -Parete.

-Weffc++ (solo C++ e Objective-C++)
Avvisa delle violazioni delle seguenti linee guida di stile da parte di Scott Meyers Efficace
C ++, Secondo Edizione libro:

· Punto 11: definire un costruttore di copie e un operatore di assegnazione per le classi con
memoria allocata dinamicamente.

· Punto 12: Preferisci l'inizializzazione all'assegnazione nei costruttori.

· Punto 14: Rendi virtuali i distruttori nelle classi base.

· Punto 15: Chiedi a "operatore=" di restituire un riferimento a *questo.

· Articolo 23: Non tentare di restituire un riferimento quando è necessario restituire un oggetto.

Avvisa anche delle violazioni delle seguenti linee guida di stile da parte di Scott Meyers Più
Efficace C++ libro:

· Articolo 6: Distinguere tra prefisso e postfisso forme di incremento e decremento
gli operatori.

· Punto 7: Non sovraccaricare mai "&&", "||", o ",".

Quando si seleziona questa opzione, tenere presente che le intestazioni della libreria standard non obbediscono a tutte
di queste linee guida; utilizzo grep -v per filtrare quegli avvisi.

-Wstrict-null-sentinella (solo C++ e Objective-C++)
Avvisa anche dell'uso di un "NULL" non lanciato come sentinella. Quando si compila solo con
GCC questa è una sentinella valida, poiché "NULL" è definito in "__null". Anche se è un nulla
puntatore costante non un puntatore nullo, è garantito che abbia le stesse dimensioni di a
puntatore. Ma questo uso non è portabile su diversi compilatori.

-Wno-non-modello-amico (solo C++ e Objective-C++)
Disabilita gli avvisi quando vengono dichiarate funzioni amiche non basate su modelli all'interno di un modello.
Dall'avvento del supporto per le specifiche esplicite dei modelli in G++, se il nome del
amico è un ID non qualificato (cioè, Amico pippo (int)), la specifica del linguaggio C++
richiede che l'amico dichiari o definisca una funzione ordinaria, non modello. (Sezione
14.5.3). Prima che G++ implementasse la specifica esplicita, gli ID non qualificati potevano essere
interpretata come una particolare specializzazione di una funzione modellizzata. Perchè questo
il comportamento non conforme non è più il comportamento predefinito per G++,
-Wnon-modello-amico consente al compilatore di controllare il codice esistente per potenziali problemi
spot ed è attivo per impostazione predefinita. Questo nuovo comportamento del compilatore può essere disattivato con
-Wno-non-modello-amico, che mantiene il codice del compilatore conforme ma disabilita il
avviso utile.

-Wold-stile-cast (solo C++ e Objective-C++)
Avvisa se un cast vecchio stile (stile C) a un tipo non void viene utilizzato all'interno di un programma C++.
I calchi di nuovo stile (dynamic_cast, cast_statico, reinterpreta_caste const_cast) siamo
meno vulnerabili agli effetti indesiderati e molto più facili da cercare.

-Woverloaded-virtuale (solo C++ e Objective-C++)
Avvisa quando una dichiarazione di funzione nasconde funzioni virtuali da una classe base. Per
esempio, in:

struttura A {
vuoto virtuale f();
};

struttura B: pubblico A {
vuoto f(int);
};

la versione di classe "A" di "f" è nascosta in "B" e codice come:

B*b;
b->f();

non riuscirà a compilare.

-Wno-pmf-conversioni (solo C++ e Objective-C++)
Disabilitare la diagnostica per convertire un puntatore associato alla funzione membro in un semplice
puntatore.

-Wsign-promozione (solo C++ e Objective-C++)
Avvisa quando la risoluzione del sovraccarico sceglie una promozione dal tipo non firmato o enumerato a
un tipo firmato, su una conversione in un tipo senza segno della stessa dimensione. Precedente
le versioni di G++ cercherebbero di preservare l'assenza di segno, ma lo standard impone il
comportamento attuale.

struttura A {
operatore int ();
Operatore A& = (int);
};

principale ()
{
Aa,b;
un = b;
}

In questo esempio, G++ sintetizzerà un'impostazione predefinita A& operatore = (constata UN&);, mentre cfront
utilizzerà il definito dall'utente operatore =.

Opzioni Controllo Objective-C ed Obiettivo-C++ dialetti
(NOTA: questo manuale non descrive i linguaggi Objective-C e Objective-C++
loro stessi.

Questa sezione descrive le opzioni della riga di comando che sono significative solo per Objective-C
e Objective-C++, ma puoi anche usare la maggior parte dei programmi GNU . indipendenti dal linguaggio
opzioni del compilatore. Ad esempio, potresti compilare un file "some_class.m" come questo:

gcc -g -fgnu-runtime -O -c qualche_classe.m

In questo esempio, -fgnu-runtime è un'opzione pensata solo per Objective-C e Objective-C++
programmi; puoi utilizzare le altre opzioni con qualsiasi lingua supportata da GCC.

Nota che poiché Objective-C è un'estensione del linguaggio C, le compilazioni Objective-C
può anche utilizzare opzioni specifiche per il front-end C (ad es. -Wtradizionale). Allo stesso modo,
Le compilazioni Objective-C++ possono utilizzare opzioni specifiche di C++ (ad es. -Wabi).

Ecco un elenco di opzioni che sono esclusivamente per compilare Objective-C e Objective-C++
programmi:

-fclasse-stringa-costante=nome della classe
Usa il nome della classe come nome della classe da istanziare per ogni stringa letterale
specificato con la sintassi "@"..."". Il nome della classe predefinito è "NXConstantString" se
viene utilizzato il runtime GNU e "NSConstantString" se viene utilizzato il runtime NeXT
usato (vedi sotto). Il -fstringhe-cfcostanti l'opzione, se presente, prevarrà sul
-fcostante-classe-stringa impostazione e fare in modo che i letterali "@"..."" siano disposti come costanti
Stringhe CoreFoundation.

-fgnu-runtime
Genera codice oggetto compatibile con il runtime standard di GNU Objective-C. Questo è
l'impostazione predefinita per la maggior parte dei tipi di sistemi.

-fnext-runtime
Genera output compatibile con il runtime NeXT. Questa è l'impostazione predefinita per i dispositivi basati su NeXT
sistemi, inclusi Darwin e Mac OS X. La macro "__NEXT_RUNTIME__" è predefinita se
(e solo se) viene utilizzata questa opzione.

-fno-nil-ricevitori
Supponiamo che tutti i messaggi Objective-C vengano inviati ("[receiver message:arg]") in questo
l'unità di traduzione assicura che il destinatario non sia "zero". Questo permette di più
punti di ingresso efficienti nel runtime da utilizzare. Questa opzione è disponibile solo in
in combinazione con il runtime NeXT e ABI versione 0 o 1.

-fobjc-abi-versione=n
Usa la versione n dell'ABI Objective-C per il runtime selezionato. Questa opzione è
attualmente supportato solo per il runtime NeXT. In tal caso, la versione 0 è la
ABI tradizionale (32 bit) senza supporto per proprietà e altri Objective-C 2.0
aggiunte. La versione 1 è l'ABI tradizionale (32 bit) con supporto per proprietà e
altre aggiunte di Objective-C 2.0. La versione 2 è la moderna ABI (64 bit). Se niente è
specificato, l'impostazione predefinita è Versione 0 su macchine di destinazione a 32 bit e Versione 2 su 64 bit
macchine bersaglio.

-fobjc-call-cxx-cdtors
Per ogni classe Objective-C, controlla se una delle sue variabili di istanza è un oggetto C++
con un costruttore predefinito non banale. In tal caso, sintetizza uno speciale "- (id)
.cxx_construct" metodo di istanza che eseguirà costruttori predefiniti non banali su qualsiasi
tali variabili di istanza, nell'ordine, e quindi restituiscono "self". Allo stesso modo, controlla se ce ne sono
la variabile di istanza è un oggetto C++ con un distruttore non banale e, in tal caso, sintetizza
uno speciale metodo "- (void) .cxx_destruct" che eseguirà tutti questi distruttori predefiniti,
in ordine inverso.

I metodi "- (id) .cxx_construct" e "- (void) .cxx_destruct" così generati
operare solo su variabili di istanza dichiarate nella corrente classe Objective-C, e non
quelli ereditati dalle superclassi. È responsabilità dell'Obiettivo-C
runtime per richiamare tutti questi metodi nella gerarchia di ereditarietà di un oggetto. Il "- (id)
I metodi .cxx_construct" verranno invocati dal runtime subito dopo un nuovo oggetto
l'istanza è allocata; verranno invocati i metodi "- (void) .cxx_destruct"
immediatamente prima che il runtime rilasci un'istanza di oggetto.

Al momento della stesura di questo documento, solo il runtime NeXT su Mac OS X 10.4 e versioni successive ha il supporto per
invocando i metodi "- (id) .cxx_construct" e "- (void) .cxx_destruct".

-fobjc-invio-diretto
Consenti salti veloci al dispatcher di messaggi. Su Darwin questo si realizza tramite il
pagina com.

-fobjc-eccezioni
Abilita il supporto sintattico per la gestione strutturata delle eccezioni in Objective-C, simile a
ciò che viene offerto da C++ e Java. Questa opzione è necessaria per utilizzare Objective-C
parole chiave @try, @throw, @catch, @finally e @synchronized. Questa opzione è disponibile
sia con il runtime GNU che con il runtime NeXT (ma non disponibile insieme a
il runtime NeXT su Mac OS X 10.2 e versioni precedenti).

-fobjc-gc
Abilita la garbage collection (GC) nei programmi Objective-C e Objective-C++. Questa opzione
è disponibile solo con il runtime NeXT; il runtime GNU ha una spazzatura diversa
implementazione della raccolta che non richiede flag speciali del compilatore.

-fobjc-nilcheck
Per il runtime NeXT con la versione 2 dell'ABI, verifica la presenza di un metodo di ricezione nullo
invocazioni prima di eseguire la chiamata al metodo effettiva. Questa è l'impostazione predefinita e può essere
disabilitato usando -fno-objc-nilcheck. I metodi di classe e le super chiamate non vengono mai controllati
per zero in questo modo, non importa su cosa sia impostato questo flag. Attualmente questo flag funziona
nulla quando viene utilizzato il runtime GNU o una versione precedente dell'ABI runtime NeXT.

-fobjc-std=objc1
Conforme alla sintassi del linguaggio di Objective-C 1.0, il linguaggio riconosciuto da GCC 4.0.
Ciò riguarda solo le aggiunte di Objective-C al linguaggio C/C++; non influisce
conformità agli standard C/C++, che è controllata dal dialetto C/C++ separato
flag di opzione. Quando questa opzione viene utilizzata con Objective-C o Objective-C++
compilatore, qualsiasi sintassi Objective-C non riconosciuta da GCC 4.0 viene rifiutata. Questo
è utile se devi assicurarti che il tuo codice Objective-C possa essere compilato con
versioni precedenti di GCC.

-classi-freplace-objc
Emetti un indicatore speciale che istruisce ld(1) non collegare staticamente nell'oggetto risultante
file e consenti dovrebbe(1) per caricarlo invece in fase di esecuzione. Questo è usato in
insieme alla modalità di debug Fix-and-Continue, in cui il file oggetto in
la domanda può essere ricompilata e ricaricata dinamicamente nel corso del programma
esecuzione, senza la necessità di riavviare il programma stesso. Attualmente, Fix-and-
La funzionalità Continua è disponibile solo in combinazione con il runtime NeXT su Mac
OS X 10.3 e versioni successive.

-fzero-collegamento
Quando si compila per il runtime NeXT, il compilatore normalmente sostituisce le chiamate a
"objc_getClass("...")" (quando il nome della classe è noto in fase di compilazione) con
riferimenti di classe statici che vengono inizializzati al momento del caricamento, il che migliora il runtime
prestazione. Specificando il -fzero-collegamento flag sopprime questo comportamento e causa
le chiamate a "objc_getClass("...")" da mantenere. Questo è utile in Zero-Link
modalità di debug, poiché consente di modificare le implementazioni delle singole classi
durante l'esecuzione del programma. Il runtime GNU attualmente conserva sempre le chiamate a
"objc_get_class("...")" indipendentemente dalle opzioni della riga di comando.

-gen-decl
Scarica le dichiarazioni dell'interfaccia per tutte le classi viste nel file sorgente in un file denominato
nomeorigine.decl.

-Wassign-intercetta (solo Object-C e Objective-C++)
Avvisa ogni volta che un'assegnazione Objective-C viene intercettata dal Garbage Collector.

-Wno-protocollo (solo Object-C e Objective-C++)
Se una classe viene dichiarata per implementare un protocollo, viene emesso un avviso per ogni metodo
nel protocollo non implementato dalla classe. Il comportamento predefinito è di
emettere un avviso per ogni metodo non implementato esplicitamente nella classe, anche se a
l'implementazione del metodo è ereditata dalla superclasse. Se usi il -Wno-protocollo
opzione, quindi i metodi ereditati dalla superclasse sono considerati implementati,
e per loro non viene emesso alcun avviso.

-Wselettore (solo Object-C e Objective-C++)
Avvisa se vengono trovati più metodi di tipo diverso per lo stesso selettore durante
compilazione. Il controllo viene eseguito sull'elenco dei metodi nella fase finale di
compilazione. Inoltre, viene eseguito un controllo per ogni selettore che appare in a
Espressione "@selector(...)" e un metodo corrispondente per quel selettore è stato
trovato durante la compilazione. Perché questi controlli scansionano la tabella dei metodi solo alla fine
di compilazione, questi avvisi non vengono prodotti se la fase finale della compilazione è
non raggiunto, ad esempio perché viene rilevato un errore durante la compilazione, oppure perché il
-fsintassi solo l'opzione è in uso.

-Wstrict-selettore-match (solo Object-C e Objective-C++)
Avvisa se vengono trovati più metodi con argomenti e/o tipi restituiti diversi per a
dato selettore quando si tenta di inviare un messaggio utilizzando questo selettore a un destinatario di
digitare "id" o "Classe". Quando questo flag è disattivato (che è il comportamento predefinito), il
il compilatore ometterà tali avvisi se eventuali differenze trovate sono limitate a tipi che
condividono la stessa dimensione e allineamento.

-Selettore-dichiarato-wund (solo Object-C e Objective-C++)
Avvisa se viene trovata un'espressione "@selector(...)" che fa riferimento a un selettore non dichiarato. UN
selettore è considerato non dichiarato se nessun metodo con quel nome è stato dichiarato prima
l'espressione "@selector(...)", esplicitamente in una @interface o @protocol
dichiarazione o implicitamente in una sezione @implementation. Questa opzione funziona sempre
i suoi controlli non appena viene trovata un'espressione "@selector(...)", mentre -Wselettore esclusivamente
effettua le sue verifiche nella fase finale della compilazione. Questo rafforza anche la codifica
convenzione di stile secondo cui metodi e selettori devono essere dichiarati prima di essere utilizzati.

-print-objc-runtime-info
Genera un'intestazione C che descrive la struttura più grande passata per valore, se presente.

Opzioni a Control Diagnostico Messaggi formattazione
Tradizionalmente, i messaggi di diagnostica sono stati formattati indipendentemente dal dispositivo di output
aspetto (ad es. la sua larghezza, ...). Le opzioni descritte di seguito possono essere utilizzate per controllare il
algoritmo di formattazione dei messaggi di diagnostica, ad es. quanti caratteri per riga, con quale frequenza
le informazioni sulla posizione di origine devono essere riportate. Al momento, solo il front-end C++ può farlo
onora queste opzioni. Tuttavia si prevede, nel prossimo futuro, che il restante fronte
fini sarebbero in grado di digerirli correttamente.

-flunghezza-messaggio=n
Prova a formattare i messaggi di errore in modo che si adattino alle righe di circa n personaggi. Il
il valore predefinito è 72 caratteri per g ++ e 0 per il resto delle estremità anteriori supportate da
GCC. Se n è zero, non verrà eseguito il ritorno a capo; ogni messaggio di errore apparirà
su una sola riga.

-fdiagnostics-show-location=una volta
Significativo solo in modalità a capo automatico. Incarica il reporter dei messaggi diagnostici di
emettere una volta informazioni sulla posizione di origine; cioè, nel caso in cui il messaggio sia troppo lungo per adattarsi
su una singola linea fisica e deve essere avvolto, la posizione di origine non verrà emessa
(come prefisso) di nuovo, più e più volte, nelle successive righe di continuazione. Questo è il
comportamento predefinito.

-fdiagnostics-show-location=ogni-riga
Significativo solo in modalità a capo automatico. Incarica il reporter dei messaggi diagnostici di
emettono le stesse informazioni sulla posizione di origine (come prefisso) per le linee fisiche risultanti
dal processo di rottura di un messaggio che è troppo lungo per stare su una sola riga.

-fno-diagnostica-show-option
Per impostazione predefinita, ogni diagnostica emessa include il testo che indica l'opzione della riga di comando
che controlla direttamente la diagnostica (se tale opzione è nota al diagnostico
macchinari). Specificando il -fno-diagnostica-show-option la bandiera lo sopprime
comportamento.

Opzioni a RICHIEDI or Sopprimi Avvertenze
Gli avvisi sono messaggi diagnostici che segnalano costruzioni che non sono intrinsecamente
errati ma che sono rischiosi o suggeriscono che potrebbe esserci stato un errore.

Le seguenti opzioni indipendenti dalla lingua non abilitano avvisi specifici ma controllano il
tipi di diagnostica prodotti da GCC.

-fsintassi solo
Controlla il codice per errori di sintassi, ma non fare nulla oltre.

-fmax-errori=n
Limita il numero massimo di messaggi di errore a n, a quel punto GCC si salva piuttosto
piuttosto che tentare di continuare a elaborare il codice sorgente. Se n è 0 (il valore predefinito),
non c'è limite al numero di messaggi di errore prodotti. Se -Errori fatali è altresì
specificato, quindi -Errori fatali ha la precedenza su questa opzione.

-w Inibire tutti i messaggi di avviso.

-Errore
Trasforma tutti gli avvisi in errori.

-Errore=
Trasforma l'avviso specificato in un errore. Viene aggiunto l'identificatore per un avviso,
per esempio -Errore=interruttore trasforma gli avvisi controllati da -Winterruttore in errori.
Questo interruttore assume una forma negativa, da usare per negare -Errore per avvisi specifici,
per esempio -No-errore=interruttore fa -Winterruttore gli avvisi non sono errori, anche quando -Errore
è in vigore.

Il messaggio di avviso per ogni avviso controllabile include l'opzione che controlla
L'avviso. Tale opzione può quindi essere utilizzata con -Errore= ed -No-errore= come descritto
sopra. (La stampa dell'opzione nel messaggio di avviso può essere disabilitata utilizzando il tasto
-fno-diagnostica-show-option bandiera.)

Nota che specificando -Errore=foo implica automaticamente -Wfoo. Tuttavia, -No-errore=foo
non implica nulla.

-Errori fatali
Questa opzione fa sì che il compilatore interrompa la compilazione al primo errore che si verifica
piuttosto che cercare di continuare e stampare ulteriori messaggi di errore.

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. Per ulteriori,
le opzioni specifiche della lingua si riferiscono anche a C++ Dialetto Opzioni ed Objective-C ed
Obiettivo-C++ Dialetto Opzioni.

Quando viene richiesta un'opzione di avviso non riconosciuta (ad es. -Wunknown-avviso), GCC emetterà
una diagnostica che indica che l'opzione non è stata riconosciuta. Tuttavia, se il -No- la forma è
utilizzato, il comportamento è leggermente diverso: non verrà prodotta alcuna diagnostica per
-Wno-sconosciuto-avviso a meno che non vengano prodotte altre diagnosi. Ciò consente l'uso di
nuovi -No- opzioni con i vecchi compilatori, ma se qualcosa va storto, il compilatore avviserà
che è stata utilizzata un'opzione non riconosciuta.

-pedante
Emettere tutti gli avvertimenti richiesti dalla rigorosa ISO C e ISO C++; rifiuta tutti i programmi che
utilizzare estensioni vietate e alcuni altri programmi che non seguono ISO C e ISO
C++. Per ISO C, segue la versione dello standard ISO C specificato da any -std
opzione utilizzata.

I programmi ISO C e ISO C++ validi dovrebbero essere compilati correttamente con o senza questa opzione
(anche se pochi rari lo richiederanno -ansi o -std opzione che specifica la versione richiesta
dell'ISO C). Tuttavia, senza questa opzione, alcune estensioni GNU e i tradizionali C e
Sono supportate anche le funzionalità C++. Con questa opzione vengono rifiutati.

-pedante non causa messaggi di avviso per l'uso delle parole chiave alternative la cui
i nomi iniziano e finiscono con __. Anche gli avvisi pedanti sono disabilitati nell'espressione
che segue "__estensione__". Tuttavia, solo i file di intestazione di sistema dovrebbero usarli
vie di fuga; i programmi applicativi dovrebbero evitarli.

Alcuni utenti provano a usare -pedante per controllare i programmi per la rigorosa conformità ISO C. Essi
presto scoprono che non fa esattamente quello che vogliono: trova alcune pratiche non ISO,
ma non tutti --- solo quelli per i quali ISO C richiede una diagnostica, e alcuni altri per
quale diagnostica è stata aggiunta.

In alcuni casi potrebbe essere utile una funzione per segnalare qualsiasi mancata conformità alla ISO C,
ma richiederebbe un notevole lavoro aggiuntivo e sarebbe molto diverso da
-pedante. Non abbiamo in programma di supportare tale funzionalità nel prossimo futuro.

Dove lo standard specificato con -std rappresenta un dialetto GNU esteso di C, come
gnu90 or gnu99, c'è un corrispondente base Standard, la versione di ISO C su cui
si basa il dialetto esteso GNU. Avvertenze da -pedante sono dati dove sono
richiesto dalla norma di base. (Non avrebbe senso dare tali avvertimenti
solo per caratteristiche non nel dialetto GNU C specificato, poiché per definizione il GNU
i dialetti del C includono tutte le funzionalità supportate dal compilatore con l'opzione data, e
non ci sarebbe nulla da avvertire.)

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

-Parete
Ciò abilita tutti gli avvisi sulle costruzioni che alcuni utenti considerano
discutibili, e che sono facili da evitare (o modificare per evitare l'avvertimento), anche in
combinazione con le macro. Ciò abilita anche alcuni avvisi specifici della lingua descritti
in C++ Dialetto Opzioni ed Objective-C ed Obiettivo-C++ Dialetto Opzioni.

-Parete attiva i seguenti flag di avviso:

-Indirizzo -Warray-limiti (solo con -O2) -Wc++11-compatibile -Wchar-pedici
-Wenum-confronta (in C/Objc; questo è attivo per impostazione predefinita in C++) -Wimplicit-int (C e
Solo Obiettivo-C) -Dichiarazione-funzione-Wimplicit (solo C e Objective-C) -Wcommento
-Formato W -Wprincipale (solo per C/ObjC e a meno che -autoportante) -Wforse-non inizializzato
-Wmissing-bretelle -Non nullo -Wparentesi -Wpointer-segno -Riordina -Tipo Wreturn
-Wpunto-sequenza -Wsign-confronta (solo in C++) -Wstrict-alias -Wstrict-overflow=1
-Winterruttore -Scritte -Non inizializzato -Wunknown-pragma -Funzione Wunused
-Etichetta-Wunused -Valore-inutilizzato -Variabile-Wunused -W registro-volatile-var

Nota che alcuni flag di avviso non sono implicati da -Parete. Alcuni di loro mettono in guardia su
costruzioni che gli utenti generalmente non considerano discutibili, ma che
occasionalmente potresti voler controllare; altri mettono in guardia su costruzioni che sono
necessario o difficile da evitare in alcuni casi, e non esiste un modo semplice per modificare il
codice per eliminare l'avviso. Alcuni di loro sono abilitati da -Wextra ma molti di loro
devono essere abilitati singolarmente.

-Wextra
Ciò abilita alcuni flag di avviso extra che non sono abilitati da -Parete. (Questa opzione è stata utilizzata
da chiamare -W. Il nome precedente è ancora supportato, ma il nome più recente è più
descrittivo.)

-Wobbed -Wempty-corpo -Qualificatori senza nome -Wmissing-field-inizializzatori
-Wmissing-tipo-parametro (solo C) -Dichiarazione in stile Wold (solo C) -Woverride-init
-Wsign-confronta -Wtype-limiti -Non inizializzato -Wunused-parametro (solo con -Wunusato or
-Parete) -Parametro-non-utilizzato-ma-impostato (solo con -Wunusato or -Parete)

L'opzione -Wextra stampa anche messaggi di avviso per i seguenti casi:

· Un puntatore viene confrontato con l'intero zero con <, <=, >, o >=.

· (Solo C++) Un enumeratore e un non enumeratore appaiono entrambi in un condizionale
espressione.

· (solo C++) Basi virtuali ambigue.

· (Solo C++) Sottoscrivere un array che è stato dichiarato registro.

· (solo C++) Prendendo l'indirizzo di una variabile che è stata dichiarata registro.

· (Solo C++) Una classe base non è inizializzata nel costruttore di copie di una classe derivata.

-Wchar-pedici
Avvisa se un indice di array ha il tipo "char". Questa è una causa comune di errore, in quanto
i programmatori spesso dimenticano che questo tipo è firmato su alcune macchine. Questo avviso è
abilitato da -Parete.

-Wcommento
Avvisa ogni volta che una sequenza di inizio commento /* appare in a /* commento, o ogni volta che a
Barra rovesciata-Newline appare in a // commento. Questo avviso è abilitato da -Parete.

-No-copertura-mancata corrispondenza
Avvisa se i profili di feedback non corrispondono quando si utilizza il -fprofile-uso opzione. Se un
il file sorgente è stato modificato tra -fprofile-gen ed -fprofile-uso, i file con il
il feedback del profilo può non corrispondere al file di origine e GCC non può utilizzare il profilo
informazioni di riscontro. Per impostazione predefinita, questo avviso è abilitato e viene trattato come un errore.
-No-copertura-mancata corrispondenza può essere utilizzato per disabilitare l'avviso o
-Wno-error=mancata corrispondenza di copertura può essere utilizzato per disabilitare l'errore. Disabilitare l'errore
per questo avviso può risultare in codice mal ottimizzato ed è utile solo in caso di
modifiche molto minori come correzioni di bug a una base di codice esistente. Completamente disabilitante
l'avviso non è raccomandato.

-No-cpp
(solo C, Objective-C, C++, Objective-C++ e Fortran)

Sopprime i messaggi di avviso emessi dalle direttive "#warning".

-Wdoppia-promozione (solo C, C++, Objective-C e Objective-C++)
Dare un avviso quando un valore di tipo "float" viene implicitamente promosso a "double". CPU
con un'unità a virgola mobile a "precisione singola" a 32 bit implementare "float" nell'hardware,
ma emula "doppio" nel software. Su una macchina del genere, facendo calcoli usando
i valori "doppi" sono molto più costosi a causa del sovraccarico richiesto per il software
emulazione.

È facile fare calcoli accidentalmente con "doppio" perché in virgola mobile
i letterali sono implicitamente di tipo "doppio". Ad esempio, in:

area di galleggiamento (raggio di galleggiamento)
{
restituisce 3.14159 * raggio * raggio;
}

il compilatore eseguirà l'intero calcolo con "double" perché il floating-
punto letterale è un "doppio".

-Formato W
Controlla le chiamate a "printf" e "scanf", ecc., per assicurarti che gli argomenti forniti
avere tipi appropriati alla stringa di formato specificata e che le conversioni
specificato nella stringa di formato ha senso. Ciò include funzioni standard e
altri specificati dagli attributi di formato, nei campi "printf", "scanf", "strftime" e
famiglie "strfmon" (un'estensione X/Open, non nello standard C) (o altri target-
famiglie specifiche). Quali funzioni vengono controllate senza che gli attributi di formato siano stati
specificato dipende dalla versione standard selezionata, e tali controlli delle funzioni
senza l'attributo specificato sono disabilitati da -autoportante or -fno-integrato.

I formati sono confrontati con le caratteristiche del formato supportate dalla GNU libc versione 2.2.
Questi includono tutte le funzionalità ISO C90 e C99, nonché le funzionalità di Single Unix
Specifiche e alcune estensioni BSD e GNU. Altre implementazioni di librerie potrebbero non esserlo
supportare tutte queste funzionalità; GCC non supporta gli avvisi sulle funzionalità che vanno oltre
i limiti di una particolare biblioteca. Tuttavia, se -pedante è usato con -Formato W,
verranno forniti avvisi sulle caratteristiche del formato non nella versione standard selezionata (ma
non per i formati "strfmon", poiché non sono presenti in nessuna versione dello standard C).

Dal -Formato W controlla anche gli argomenti di formato nullo per diverse funzioni, -Formato W
implica anche -Non nullo.

-Formato W è incluso in -Parete. Per un maggiore controllo su alcuni aspetti del controllo del formato,
le opzioni -Wformato-y2k, -Wno-format-extra-args, -Wno-formato-lunghezza zero,
-Wformat-non letterale, -Wformat-sicurezzae -Wformato=2 sono disponibili, ma non lo sono
incluso in -Parete.

NOTA: in Ubuntu 8.10 e versioni successive questa opzione è abilitata per impostazione predefinita per C, C++,
ObjC, ObjC++. Per disabilitare, utilizzare -Wformato=0.

-Wformato-y2k
If -Formato W è specificato, avvisa anche dei formati "strftime" che possono produrre solo a
anno a due cifre.

-Wno-formato-contiene-nul
If -Formato W è specificato, non avvisare delle stringhe di formato che contengono byte NUL.

-Wno-format-extra-args
If -Formato W è specificato, non avvisare degli argomenti in eccesso a "printf" o "scanf"
funzione di formato. Lo standard C specifica che tali argomenti vengono ignorati.

Dove gli argomenti non utilizzati si trovano tra gli argomenti utilizzati specificati con $
specifiche del numero dell'operando, normalmente vengono ancora forniti avvisi, poiché il
l'implementazione non poteva sapere quale tipo passare a "va_arg" per saltare l'inutilizzato
argomenti. Tuttavia, nel caso di formati "scanf", questa opzione sopprimerà il
avviso se gli argomenti non utilizzati sono tutti puntatori, poiché la Single Unix Specification
dice che tali argomenti non utilizzati sono consentiti.

-Wno-formato-lunghezza zero
If -Formato W è specificato, non avvisare sui formati di lunghezza zero. Lo standard C
specifica che sono consentiti formati di lunghezza zero.

-Wformat-non letterale
If -Formato W è specificato, avvisa anche se la stringa di formato non è una stringa letterale e
quindi non può essere verificato, a meno che la funzione di formato non prenda i suoi argomenti di formato come a
"va_list".

-Wformat-sicurezza
If -Formato W è specificato, avvisa anche sugli usi delle funzioni di formato che rappresentano
possibili problemi di sicurezza. Al momento, questo avverte delle chiamate a "printf" e
"scanf" funzioni in cui la stringa di formato non è una stringa letterale e non ci sono
argomenti di formato, come in "printf (foo);". Questo potrebbe essere un buco di sicurezza se il formato
la stringa proviene da un input non attendibile e contiene %n. (Questo è attualmente un sottoinsieme di cosa
-Wformat-non letterale mette in guardia, ma in futuro potrebbero essere aggiunti avvertimenti a
-Wformat-sicurezza che non sono inclusi in -Wformat-non letterale.)

NOTA: in Ubuntu 8.10 e versioni successive questa opzione è abilitata per impostazione predefinita per C, C++,
ObjC, ObjC++. Per disabilitare, utilizzare -Wno-formato-sicurezza, o disabilita tutti gli avvisi di formato
con -Wformato=0. Per rendere fatali gli avvisi di sicurezza del formato, specificare
-Errore=formato-sicurezza.

-Wformato=2
permettere -Formato W più controlli di formato non inclusi in -Formato W. Attualmente equivalente a
-Formato W -Wformat-non letterale -Wformat-sicurezza -Wformato-y2k.

-Non nullo
Avvisa di passare un puntatore nullo per gli argomenti contrassegnati come richiedenti un valore non nullo
dall'attributo della funzione "non null".

-Non nullo è incluso in -Parete ed -Formato W. Può essere disabilitato con il -No-non nullo
opzione.

-Winit-auto (solo C, C++, Objective-C e Objective-C++)
Avvisa delle variabili non inizializzate che vengono inizializzate con se stesse. Nota questo
l'opzione può essere utilizzata solo con -Non inizializzato opzione.

Ad esempio, GCC avviserà che "i" non è stata inizializzata solo nel seguente frammento
quando -Winit-auto è stato specificato:

intero f()
{
int io = io;
ritorno i;
}

-Wimplicit-int (solo C e Objective-C)
Avvisa quando una dichiarazione non specifica un tipo. Questo avviso è abilitato da -Parete.

-Dichiarazione-funzione-Wimplicit (solo C e Objective-C)
Dare un avviso ogni volta che una funzione viene utilizzata prima di essere dichiarata. In modalità C99
(-std=c99 or -std=gnu99), questo avviso è abilitato per impostazione predefinita e viene trasformato in un
errore di -errori-pedanti. Questo avviso è abilitato anche da -Parete.

- Wimplicit (solo C e Objective-C)
Uguale a -Wimplicit-int ed -Dichiarazione-funzione-Wimplicit. Questo avviso è abilitato
by -Parete.

-Qualificatori senza nome (solo C e C++)
Avvisa se il tipo restituito di una funzione ha un qualificatore di tipo come "const". Per ISO C
tale qualificatore di tipo non ha effetto, poiché il valore restituito da una funzione non è un
lvalue. Per C++, l'avviso viene emesso solo per i tipi scalari o "void". ISO C
proibisce i tipi di ritorno "void" qualificati sulle definizioni di funzione, quindi tali tipi di ritorno
ricevere sempre un avviso anche senza questa opzione.

Questo avviso è abilitato anche da -Wextra.

-Wprincipale
Avvisa se il tipo di principale è sospetto. principale dovrebbe essere una funzione con external
linkage, restituendo int, prendendo zero argomenti, due o tre argomenti di
tipi appropriati. Questo avviso è abilitato per impostazione predefinita in C++ ed è abilitato da entrambi
-Parete or -pedante.

-Wmissing-bretelle
Avvisa se un inizializzatore di aggregazione o unione non è completamente tra parentesi. Nel seguente
esempio, l'inizializzatore per a non è completamente tra parentesi, ma quello per b è completamente
tra parentesi.

int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };

Questo avviso è abilitato da -Parete.

-Wmissing-include-dirs (solo C, C++, Objective-C e Objective-C++)
Avvisa se non esiste una directory di inclusione fornita dall'utente.

-Wparentesi
Avvisa se le parentesi vengono omesse in determinati contesti, ad esempio quando c'è un
assegnazione in un contesto in cui è previsto un valore di verità o quando gli operatori sono annidati
la cui precedenza le persone spesso si confondono.

Avvisa anche se un confronto mi piace x<=y<=z appare; questo è equivalente a (x<=y ? 1 : 0)
<= z, che è un'interpretazione diversa da quella della normale notazione matematica.

Avvisa anche di costruzioni in cui potrebbe esserci confusione su quale istruzione "if" e
"altro" ramo appartiene. Ecco un esempio di un caso del genere:

{
se un)
se (b)
pippo ();
altro
sbarra ();
}

In C/C++, ogni ramo "else" appartiene all'istruzione "if" più interna possibile, che
in questo esempio è "se (b)". Questo spesso non è quello che il programmatore si aspettava, come
illustrato nell'esempio sopra dal rientro scelto dal programmatore. Quando c'è
il potenziale per questa confusione, GCC emetterà un avviso quando questo flag è
specificato. Per eliminare l'avviso, aggiungi parentesi graffe esplicite attorno al "se" più interno
quindi non c'è modo che l'"else" possa appartenere all'"if" che lo racchiude. Il
il codice risultante sarebbe simile a questo:

{
se un)
{
se (b)
pippo ();
altro
sbarra ();
}
}

Avvisa anche per usi pericolosi di ?: con l'estensione GNU dell'operando centrale omesso. quando
la condizione nell'operatore ?: è un'espressione booleana il valore omesso sarà
sempre 1. Spesso l'utente si aspetta che sia un valore calcolato all'interno del condizionale
espressione invece.

Questo avviso è abilitato da -Parete.

-Wpunto-sequenza
Avvisa del codice che potrebbe avere una semantica indefinita a causa di violazioni della sequenza
regole punto negli standard C e C++.

Gli standard C e C++ definiscono l'ordine in cui le espressioni in un programma C/C++ sono
valutato in termini di sequenza punti, che rappresentano un ordinamento parziale tra i
esecuzione di parti del programma: quelle eseguite prima del punto di sequenza e quelle
eseguito dopo di esso. Questi si verificano dopo la valutazione di un'espressione completa (una che
non fa parte di un'espressione più grande), dopo la valutazione del primo operando di a
Operatore "&&", "||", "? :" o "," (virgola), prima che venga chiamata una funzione (ma dopo il
valutazione dei suoi argomenti e dell'espressione che denota la funzione chiamata), e in
certi altri luoghi. Oltre a quanto espresso dalle regole del punto di sequenza, l'ordine
di valutazione delle sottoespressioni di un'espressione non è specificato. Tutte queste regole
descrivere solo un ordine parziale piuttosto che un ordine totale, poiché, ad esempio, se due
le funzioni vengono chiamate all'interno di un'espressione senza punti di sequenza tra di loro, il
l'ordine in cui vengono chiamate le funzioni non è specificato. Tuttavia, gli standard
comitato hanno stabilito che le chiamate di funzione non si sovrappongono.

Non è specificato quando tra punti sequenza modifiche ai valori di
gli oggetti hanno effetto. I programmi il cui comportamento dipende da questo hanno un comportamento indefinito;
gli standard C e C++ specificano che "Tra il punto di sequenza precedente e successivo e
oggetto deve avere il suo valore memorizzato modificato al massimo una volta dalla valutazione di un
espressione. Inoltre, il valore precedente deve essere letto solo per determinare il valore a
essere memorizzato.". Se un programma infrange queste regole, i risultati su qualsiasi particolare
implementazione sono del tutto imprevedibili.

Esempi di codice con comportamento indefinito sono "a = a++;", "a[n] = b[n++]" e "a[i++] =
i;". Alcuni casi più complicati non vengono diagnosticati da questa opzione e può dare un
risultato falso positivo occasionale, ma in generale è stato trovato abbastanza efficace a
rilevare questo tipo di problema nei programmi.

Lo standard è formulato in modo confuso, quindi c'è qualche dibattito sul preciso
significato delle regole del punto di sequenza in casi sottili. Link alle discussioni del
problema, comprese le definizioni formali proposte, può essere trovato nella pagina delle letture del GCC,
ahttp://gcc.gnu.org/readings.html>.

Questo avviso è abilitato da -Parete per C e C++.

-Tipo Wreturn
Avvisa ogni volta che una funzione viene definita con un tipo restituito che per impostazione predefinita è "int". Anche
avvisare di qualsiasi istruzione "return" senza valore di ritorno in una funzione il cui tipo di ritorno
non è "vuoto" (la caduta dalla fine del corpo della funzione è considerata un ritorno
senza un valore), e su un'istruzione "return" con un'espressione in una funzione
il cui tipo di ritorno è "void".

Per C++, una funzione senza tipo restituito produce sempre un messaggio diagnostico, anche
quando -Wno-ritorno-tipo è specificato. Le uniche eccezioni sono principale e funzioni
definito nelle intestazioni di sistema.

Questo avviso è abilitato da -Parete.

-Winterruttore
Avvisa ogni volta che un'istruzione "switch" ha un indice di tipo enumerato e manca di un "case"
per uno o più dei codici citati di tale enumerazione. (La presenza di un "default"
etichetta impedisce questo avviso.) anche le etichette "case" al di fuori dell'intervallo di enumerazione
provoca avvisi quando viene utilizzata questa opzione (anche se è presente un'etichetta "predefinita"). Questo
l'avviso è abilitato da -Parete.

-Wswitch-predefinito
Avvisa ogni volta che un'istruzione "switch" non ha un caso "predefinito".

-Wswitch-enumerazione
Avvisa ogni volta che un'istruzione "switch" ha un indice di tipo enumerato e manca di un "case"
per uno o più dei codici citati di tale enumerazione. etichette "caso" all'esterno del
L'intervallo di enumerazione provoca anche avvisi quando viene utilizzata questa opzione. L'unica differenza
fra -Winterruttore e questa opzione è che questa opzione fornisce un avviso su un'omissione
codice di enumerazione anche se è presente un'etichetta "predefinita".

-Wsync-nand (solo C e C++)
Avvisa quando le funzioni integrate "__sync_fetch_and_nand" e "__sync_nand_and_fetch" sono
Usato. Queste funzioni hanno cambiato la semantica in GCC 4.4.

-Scritte
Avvisa se si incontrano trigrafi che potrebbero cambiare il significato del programma
(i trigrafi all'interno dei commenti non sono avvisati). Questo avviso è abilitato da -Parete.

-Parametro-non-utilizzato-ma-impostato
Avvisa ogni volta che un parametro di funzione è assegnato a, ma altrimenti inutilizzato (a parte
sua dichiarazione).

Per sopprimere questo avviso utilizzare il non usato attributo.

Questo avviso è abilitato anche da -Wunusato insieme -Wextra.

-Wunused-ma-set-variable
Avvisa ogni volta che viene assegnata una variabile locale, ma altrimenti inutilizzata (a parte la sua
dichiarazione). Questo avviso è abilitato da -Parete.

Per sopprimere questo avviso utilizzare il non usato attributo.

Questo avviso è abilitato anche da -Wunusato, che è abilitato da -Parete.

-Funzione Wunused
Avvisa ogni volta che una funzione statica viene dichiarata ma non definita o una statica non in linea
la funzione non è utilizzata. Questo avviso è abilitato da -Parete.

-Etichetta-Wunused
Avvisa ogni volta che un'etichetta viene dichiarata ma non utilizzata. Questo avviso è abilitato da -Parete.

Per sopprimere questo avviso utilizzare il non usato attributo.

-Wdefinizioni di tipo locale non utilizzate (solo C, Objective-C, C++ e Objective-C++)
Avvisa quando un typedef definito localmente in una funzione non viene utilizzato.

-Wunused-parametro
Avvisa ogni volta che un parametro di funzione non è utilizzato a parte la sua dichiarazione.

Per sopprimere questo avviso utilizzare il non usato attributo.

-Risultato-non-utilizzato
Non avvisare se un chiamante di una funzione contrassegnata con l'attributo "warn_unused_result" lo fa
non utilizzare il suo valore di ritorno. L'impostazione predefinita è -Risultato-non utilizzato.

-Variabile-Wunused
Avvisa ogni volta che una variabile locale o una variabile statica non costante non viene utilizzata a parte
sua dichiarazione. Questo avviso è abilitato da -Parete.

Per sopprimere questo avviso utilizzare il non usato attributo.

-Valore-inutilizzato
Avvisa ogni volta che un'istruzione calcola un risultato esplicitamente non utilizzato. Sopprimere
questo avviso lancia l'espressione inutilizzata a nulla. Questo include un'espressione-istruzione
o il lato sinistro di un'espressione virgola che non contiene effetti collaterali. Per
esempio, un'espressione come x[i,j] causerà un avvertimento, mentre x[(vuoto)i,j] volere
non.

Questo avviso è abilitato da -Parete.

-Wunusato
Tutto quanto sopra -Wunusato opzioni combinate.

Per ricevere un avviso su un parametro di funzione non utilizzato, è necessario specificare
-Wextra -Wunusato (nota che -Parete implica -Wunusato), o specificare separatamente
-Wunused-parametro.

-Non inizializzato
Avvisa se viene utilizzata una variabile automatica senza prima essere inizializzata o se una variabile
può essere bloccato da una chiamata "setjmp". In C++, avvisa se un riferimento non statico o non
statico const membro appare in una classe senza costruttori.

Se vuoi avvisare del codice che usa il valore non inizializzato della variabile in
il proprio inizializzatore, usa il -Winit-auto opzione.

Questi avvertimenti si verificano per singoli elementi della struttura non inizializzati o disturbati,
variabili union o array, nonché per variabili non inizializzate o clobbed
nel complesso. Non si verificano per variabili o elementi dichiarati "volatili". Perché
questi avvertimenti dipendono dall'ottimizzazione, dalle variabili o dagli elementi esatti per i quali non esistono
gli avvisi dipenderanno dalle precise opzioni di ottimizzazione e dalla versione di GCC utilizzata.

Nota che potrebbe non esserci alcun avviso su una variabile che viene utilizzata solo per calcolare a
valore che di per sé non viene mai utilizzato, perché tali calcoli possono essere cancellati dal flusso di dati
analisi prima della stampa degli avvisi.

-Wforse-non inizializzato
Per una variabile automatica, se esiste un percorso dalla voce della funzione a un uso di
la variabile che è inizializzata, ma esistono altri percorsi in cui la variabile non è
inizializzato, il compilatore emetterà un avviso se non può dimostrare il non inizializzato
i percorsi non si verificano in fase di esecuzione. Questi avvisi sono resi facoltativi perché GCC non lo è
abbastanza intelligente da vedere tutti i motivi per cui il codice potrebbe essere corretto nonostante sembri
avere un errore. Ecco un esempio di come ciò può accadere:

{
int x;
interruttore (y)
{
caso 1: x = 1;
break;
caso 2: x = 4;
break;
caso 3: x = 5;
}
pippo (x);
}

Se il valore di "y" è sempre 1, 2 o 3, allora "x" è sempre inizializzato, ma GCC
questo non lo sa. Per eliminare l'avviso, l'utente deve fornire un caso predefinito
con affermare(0) o codice simile.

Questa opzione avverte anche quando una variabile automatica non volatile potrebbe essere modificata da a
chiamata a "longjmp". Anche questi avvertimenti sono possibili solo in fase di ottimizzazione
compilazione.

Il compilatore vede solo le chiamate a "setjmp". Non può sapere dove sarà "longjmp"
chiamato; infatti, un gestore di segnale potrebbe chiamarlo in qualsiasi punto del codice. Come un
risultato, potresti ricevere un avviso anche quando in realtà non ci sono problemi perché "longjmp"
non può infatti essere chiamato nel luogo che creerebbe un problema.

Alcuni avvertimenti spuri possono essere evitati se dichiari tutte le funzioni che usi
non tornare mai come "noreturn".

Questo avviso è abilitato da -Parete or -Wextra.

-Wunknown-pragma
Avvisa quando viene rilevata una direttiva "#pragma" non compresa da GCC. Se questo
viene utilizzata l'opzione della riga di comando, verranno emessi avvisi anche per pragma sconosciuti in
file di intestazione di sistema. Questo non è il caso se gli avvisi sono stati abilitati solo dal
-Parete opzione della riga di comando.

-Wno-pragma
Non avvisare di usi impropri di pragma, come parametri errati, sintassi non valida o
conflitti tra pragma. Guarda anche -Wunknown-pragma.

-Wstrict-alias
Questa opzione è attiva solo quando -fstrict-alias è attivo. Avverte del codice che
potrebbe violare le rigide regole di aliasing utilizzate dal compilatore per l'ottimizzazione.
L'avviso non rileva tutti i casi, ma tenta di rilevare i più comuni
insidie. È incluso in -Parete. È equivalente a -Wstrict-alias=3

-Wstrict-alias=n
Questa opzione è attiva solo quando -fstrict-alias è attivo. Avverte del codice che
potrebbe violare le rigide regole di aliasing utilizzate dal compilatore per l'ottimizzazione.
Livelli più alti corrispondono a una maggiore precisione (meno falsi positivi). Livelli più alti
corrispondono anche a uno sforzo maggiore, in modo simile al modo in cui funziona -O. -Wstrict-alias is
equivalente -Wstrict-alias=n, con n=3.

Livello 1: Più aggressivo, veloce, meno preciso. Forse utile quando i livelli sono più alti
non avvisare ma -fstrict-aliasing rompe ancora il codice, poiché ha pochissimi falsi
negativi. Tuttavia, ha molti falsi positivi. Avvisa per tutte le conversioni del puntatore
tra tipi eventualmente incompatibili, anche se mai dereferenziati. Corre davanti
solo fine.

Livello 2: Aggressivo, veloce, non troppo preciso. Potrebbe avere ancora molti falsi positivi (non
fino al livello 1) e pochi falsi negativi (ma forse più del livello 1).
A differenza del livello 1, avvisa solo quando viene preso un indirizzo. Avverte sui tipi incompleti.
Funziona solo nella parte anteriore.

Livello 3 (predefinito per -Wstrict-alias): Dovrebbe avere pochissimi falsi positivi e pochi
falsi negativi. Leggermente più lento dei livelli 1 o 2 quando l'ottimizzazione è abilitata.
Si occupa del modello comune di gioco di parole + dereference nel front-end:
"*(int*)&some_float". Se l'ottimizzazione è abilitata, viene eseguita anche nel back-end, dove
si occupa di più casi di istruzione utilizzando informazioni point-to sensibili al flusso.
Avvisa solo quando il puntatore convertito viene dereferenziato. Non avverte di incompleto
tipi.

-Wstrict-overflow
-Wstrict-overflow=n
Questa opzione è attiva solo quando -fstrict-overflow è attivo. Avverte sui casi
dove il compilatore ottimizza in base al presupposto che l'overflow con segno non lo fa
verificarsi. Nota che non avverte di tutti i casi in cui il codice potrebbe traboccare: è
avverte solo dei casi in cui il compilatore implementa alcune ottimizzazioni. Così questo
avviso dipende dal livello di ottimizzazione.

Un'ottimizzazione che presuppone che non si verifichi un overflow con segno è perfettamente sicura se
i valori delle variabili in gioco sono tali che l'overflow non fa mai, infatti,
verificarsi. Pertanto questo avviso può facilmente dare un falso positivo: un avviso sul codice
questo non è in realtà un problema. Per aiutare a concentrarsi su questioni importanti, diversi avvertimenti
i livelli sono definiti. Non vengono emessi avvisi per l'uso di overflow firmato indefinito
quando si stima quante iterazioni richiederà un ciclo, in particolare quando
determinare se un ciclo verrà eseguito.

-Wstrict-overflow=1
Avverti dei casi discutibili e facili da evitare. Ad esempio: "x +
1 > x"; con -fstrict-overflow, il compilatore lo semplificherà a 1. Questo livello
of -Wstrict-overflow è abilitato da -Parete; i livelli più alti non sono, e devono essere
esplicitamente richiesto.

-Wstrict-overflow=2
Avvisa anche di altri casi in cui un confronto è semplificato a una costante. Per
esempio: "abs (x) >= 0". Questo può essere semplificato solo quando -fstrict-overflow è in
effetto, perché "abs (INT_MIN)" va in overflow a "INT_MIN", che è minore di zero.
-Wstrict-overflow (senza livello) è lo stesso di -Wstrict-overflow=2.

-Wstrict-overflow=3
Avvisa anche di altri casi in cui il confronto è semplificato. Ad esempio: "x + 1
> 1" sarà semplificato in "x > 0".

-Wstrict-overflow=4
Avvertire anche su altre semplificazioni non contemplate dai casi di cui sopra. Per
esempio: "(x * 10) / 5" sarà semplificato in "x * 2".

-Wstrict-overflow=5
Avvisa anche dei casi in cui il compilatore riduce la grandezza di una costante
coinvolti in un confronto. Ad esempio: "x + 2 > y" sarà semplificato in "x + 1
>= y". Questo viene segnalato solo al livello di avviso più alto perché questo
la semplificazione si applica a molti confronti, quindi questo livello di avviso darà un'impressione molto
numero elevato di falsi positivi.

-Wsuggest-attributo=[puro|const|senza ritorno]
Avvisa per i casi in cui l'aggiunta di un attributo può essere utile. Gli attributi attualmente
supportati sono elencati di seguito.

-Wsuggest-attributo=puro
-Wsuggest-attributo=const
-Wsuggest-attributo=noreturn
Avvisa delle funzioni che potrebbero essere candidate per gli attributi "puro", "const" o
"senza ritorno". Il compilatore avverte solo delle funzioni visibili in altre compilazioni
unità o (nel caso di "puro" e "const") se non può dimostrare che la funzione
ritorna normalmente. Una funzione restituisce normalmente se non contiene un infinito
loop né ritorna in modo anomalo lanciando, chiamando "abort()" o trapping. Questo
l'analisi richiede un'opzione -fipa-puro-const, che è abilitato per impostazione predefinita in -O ed
più alto. Livelli di ottimizzazione più elevati migliorano l'accuratezza dell'analisi.

-Warray-limiti
Questa opzione è attiva solo quando -ftree-vrp è attivo (predefinito per -O2 e al di sopra). Esso
avverte sugli indici degli array che sono sempre fuori dai limiti. Questo avviso è
abilitato da -Parete.

-Wno-div-per-zero
Non avvisare della divisione intera in fase di compilazione per zero. Divisione in virgola mobile per
zero non viene avvertito, in quanto può essere un modo legittimo per ottenere infiniti e
NaN.

-Wsystem-header
Stampa messaggi di avviso per i costrutti trovati nei file di intestazione del sistema. Avvertenze da
le intestazioni di sistema sono normalmente soppresse, partendo dal presupposto che di solito non lo fanno
indicano problemi reali e renderebbero solo l'output del compilatore più difficile da leggere. Usando
questa opzione della riga di comando dice a GCC di emettere avvisi dalle intestazioni di sistema come se
avvenuta nel codice utente. Tuttavia, tieni presente che usando -Parete in combinazione con questa opzione
volere non avvisare di pragma sconosciuti nelle intestazioni di sistema --- per questo, -Wunknown-pragma
deve essere utilizzato anche.

-Wtrampolini
Avvisa dei trampolini generati per i puntatori a funzioni nidificate.

Un trampolino è un piccolo pezzo di dati o codice che viene creato durante la corsa
tempo nello stack quando viene preso l'indirizzo di una funzione annidata, e
viene utilizzato per chiamare indirettamente la funzione annidata. Per alcuni obiettivi, è
è costituito da soli dati e quindi non richiede alcun trattamento speciale. Ma,
per la maggior parte dei target, è costituito da codice e quindi richiede lo stack
essere reso eseguibile per il corretto funzionamento del programma.

-Wfloat-uguale
Avvisa se i valori a virgola mobile vengono utilizzati nei confronti di uguaglianza.

L'idea alla base di questo è che a volte è conveniente (per il programmatore)
considerare i valori in virgola mobile come approssimazioni a numeri reali infinitamente precisi.
Se lo stai facendo, allora devi calcolare (analizzando il codice, o in qualche
in altro modo) l'errore massimo o probabile massimo che il calcolo introduce, e
consentirlo quando si eseguono confronti (e quando si produce output, ma questo è un
problema diverso). In particolare, invece di verificare l'uguaglianza, dovresti controllare
per vedere se i due valori hanno intervalli che si sovrappongono; e questo è fatto con il
operatori relazionali, quindi i confronti di uguaglianza sono probabilmente errati.

-Wtradizionale (solo C e Objective-C)
Avvisa di alcuni costrutti che si comportano in modo diverso in C tradizionale e ISO. Inoltre
mettere in guardia sui costrutti ISO C che non hanno un equivalente C tradizionale e/o problematici
costrutti da evitare.

· Parametri macro che appaiono all'interno di stringhe letterali nel corpo della macro. In
la tradizionale sostituzione delle macro C avviene all'interno di stringhe letterali, ma non lo fa
nell'ISO C.

· Nel C tradizionale, alcune direttive del preprocessore non esistevano. Tradizionale
i preprocessori considererebbero una linea una direttiva solo se # apparso in
colonna 1 sulla riga. Perciò -Wtradizionale mette in guardia sulle direttive che
tradizionale C capisce ma ignorerebbe perché il # non appare come il
primo carattere della riga. Suggerisce anche di nascondere direttive come #pragma
non compreso dal C tradizionale facendoli rientrare. Alcuni tradizionali
le implementazioni non riconoscerebbero #elif, quindi suggerisce di evitarlo del tutto.

· Una macro simile a una funzione che appare senza argomenti.

· L'operatore unario più.

· Il U suffisso della costante intera, o il F or L suffissi costanti in virgola mobile.
(Il C tradizionale supporta il L suffisso sulle costanti intere.) Nota, questi
i suffissi appaiono nelle macro definite nelle intestazioni di sistema della maggior parte dei sistemi moderni,
ad esempio il _Min/_MASSIMO macro in " ". L'uso di queste macro nel codice utente potrebbe
normalmente portano ad avvertimenti spuri, tuttavia il preprocessore integrato di GCC ha
contesto sufficiente per evitare di avvertire in questi casi.

· Una funzione dichiarata esterna in un blocco e poi utilizzata dopo la fine del
blocco.

· Un'istruzione "switch" ha un operando di tipo "long".

· Una dichiarazione di funzione non "statica" segue una "statica". Questo costrutto non è
accettato da alcuni compilatori C tradizionali.

· Il tipo ISO di una costante intera ha una larghezza o un segno diverso dal suo
tipo tradizionale. Questo avviso viene emesso solo se la base della costante è dieci.
Ad esempio, i valori esadecimali o ottali, che in genere rappresentano modelli di bit, non lo sono
avvertito.

· Viene rilevato l'utilizzo della concatenazione di stringhe ISO.

· Inizializzazione degli aggregati automatici.

· L'identificatore è in conflitto con le etichette. Il C tradizionale non ha uno spazio dei nomi separato per
etichette.

· Inizializzazione dei sindacati. Se l'inizializzatore è zero, l'avviso viene omesso.
Questo viene fatto partendo dal presupposto che appaia l'inizializzatore zero nel codice utente
condizionato ad es. "__STDC__" per evitare di perdere gli avvisi dell'inizializzatore e si basa su
inizializzazione predefinita a zero nel caso C tradizionale.

· Conversioni da prototipi tra valori a virgola fissa/mobile e viceversa. Il
l'assenza di questi prototipi durante la compilazione con il C tradizionale causerebbe gravi
i problemi. Questo è un sottoinsieme dei possibili avvisi di conversione, per l'insieme completo
uso -Conversione-tradizionale.

· Utilizzo di definizioni di funzioni in stile ISO C. Questo avviso è intenzionalmente non rilasciato
per dichiarazioni di prototipi o funzioni variadic perché queste funzionalità ISO C lo faranno
appaiono nel codice quando si utilizzano le tradizionali macro di compatibilità C di libiberty,
"PARAM" e "VPARAM". Questo avviso viene ignorato anche per le funzioni nidificate
perché quella funzione è già un'estensione GCC e quindi non è rilevante per
compatibilità C tradizionale.

-Conversione-tradizionale (solo C e Objective-C)
Avvisa se un prototipo provoca una conversione di tipo diversa da quella che accadrebbe
allo stesso argomento in assenza di un prototipo. Ciò include le conversioni di
punto fisso a mobile e viceversa, e conversioni modificando la larghezza o
firma di un argomento a virgola fissa tranne quando è uguale alla promozione predefinita.

-Wdichiarazione-dopo-dichiarazione (solo C e Objective-C)
Avvisa quando viene trovata una dichiarazione dopo un'istruzione in un blocco. Questo costrutto, noto
da C++, è stato introdotto con ISO C99 ed è consentito per impostazione predefinita in GCC. Non è
supportato da ISO C90 e non era supportato dalle versioni GCC precedenti a GCC 3.0.

-Wundef
Avvisa se un identificatore non definito viene valutato in an #Se Direttiva.

-Wno-endif-etichette
Non avvisare ogni volta che #else o un #endif sono seguiti dal testo.

-Ombra
Avvisa ogni volta che una variabile locale o una dichiarazione di tipo nasconde un'altra variabile,
parametro, tipo o membro della classe (in C++) o ogni volta che una funzione incorporata è
ombreggiato. Nota che in C++, il compilatore non avviserà se una variabile locale nasconde a
struct/class/enum, ma avviserà se nasconde un typedef esplicito.

-Wmaggiore-di=len
Avvisa ogni volta che un oggetto di dimensioni maggiori di len byte è definito.

-Wframe-maggiore-di=len
Avvisa se la dimensione di un frame di funzione è maggiore di len byte. Il calcolo fatto
determinare la dimensione dello stack frame è approssimativo e non conservativo. L'attuale
i requisiti possono essere leggermente superiori a len anche se non ricevi un avviso. In
inoltre, qualsiasi spazio allocato tramite "alloca", array di lunghezza variabile o correlati
costrutti non è incluso dal compilatore nel determinare se emettere o meno a
avvertimento.

-Wno-free-non-oggetto-heap
Non avvisare quando si tenta di liberare un oggetto che non è stato allocato nell'heap.

-Wstack-utilizzo=len
Avvisa se l'utilizzo dello stack di una funzione potrebbe essere maggiore di len byte. Il calcolo
fatto per determinare l'utilizzo dello stack è conservativo. Qualsiasi spazio assegnato tramite "alloca",
array a lunghezza variabile o costrutti correlati sono inclusi dal compilatore quando
determinare se emettere o meno un avvertimento.

Il messaggio è in linea con l'output di -fstack-uso.

· Se l'utilizzo dello stack è completamente statico ma supera l'importo specificato, è:

avviso: l'utilizzo dello stack è 1120 byte

· Se l'utilizzo dello stack è (parzialmente) dinamico ma limitato, è:

avviso: l'utilizzo dello stack potrebbe essere di 1648 byte

· Se l'utilizzo dello stack è (parzialmente) dinamico e non limitato, è:

avviso: l'utilizzo dello stack potrebbe essere illimitato

-Ottimizzazioni del ciclo Wunsafe
Avvisa se il ciclo non può essere ottimizzato perché il compilatore non può assumere nulla su
i limiti degli indici di loop. Insieme a -ottimizzazioni funsafe-loop avvisa se il compilatore
fatto tali ipotesi.

-Wno-pedante-ms-formato (solo obiettivi MinGW)
Disabilita gli avvisi sugli identificatori di larghezza del formato "printf" / "scanf" non ISO "I32",
"I64" e "I" utilizzati su destinazioni Windows a seconda del runtime MS, quando si utilizza
le opzioni -Formato W ed -pedante senza estensioni gnu.

-Wpointer-arith
Avvisa di tutto ciò che dipende dalla "dimensione" di un tipo di funzione o da "void". GNU C
assegna a questi tipi una dimensione di 1, per comodità nei calcoli con "void *"
puntatori e puntatori a funzioni. In C++, avvisa anche quando un'operazione aritmetica
coinvolge "NULL". Questo avviso è abilitato anche da -pedante.

-Wtype-limiti
Avvisa se un confronto è sempre vero o sempre falso a causa dell'intervallo limitato del
tipo di dati, ma non avvisare per le espressioni costanti. Ad esempio, avvisa se un non firmato
la variabile viene confrontata con zero con < or >=. Questo avviso è abilitato anche da
-Wextra.

-Wbad-funzione-cast (solo C e Objective-C)
Avvisa ogni volta che viene eseguito il cast di una chiamata di funzione a un tipo non corrispondente. Ad esempio, avvisa se
"int malloc()" viene convertito in "anything *".

-Wc++-compatibile (solo C e Objective-C)
Avvisa dei costrutti ISO C che sono al di fuori del sottoinsieme comune di ISO C e ISO
C++, ad esempio richiesta di conversione implicita da "void *" a un puntatore a non "void"
tipo.

-Wc++11-compatibile (solo C++ e Objective-C++)
Avvisa dei costrutti C++ il cui significato differisce tra ISO C++ 1998 e ISO C++ 2011,
ad es. identificatori in ISO C++ 1998 che sono parole chiave in ISO C++ 2011. Questo avviso
si accende -Stringendo ed è abilitato da -Parete.

-Wcast-qual
Avvisa ogni volta che viene lanciato un puntatore in modo da rimuovere un qualificatore di tipo dal tipo di destinazione.
Ad esempio, avvisa se un "const char *" viene convertito in un normale "char *".

Avvisa anche quando si esegue un cast che introduce un qualificatore di tipo in modo non sicuro. Per
esempio, trasmettere "char **" a "const char **" non è sicuro, come in questo esempio:

/* p è char ** valore. */
const carattere **q = (const carattere **) p;
/* L'assegnazione della stringa di sola lettura a const char * è OK. */
*q = "stringa";
/* Ora il puntatore char** punta alla memoria di sola lettura. */
**p = 'b';

-Allineamento Wcast
Avvisa ogni volta che un puntatore viene lanciato in modo tale che l'allineamento richiesto del bersaglio sia
è aumentato. Ad esempio, avvisa se un "char *" viene lanciato su un "int *" su macchine dove
gli interi sono accessibili solo ai limiti di due o quattro byte.

-Wwrite-stringhe
Quando si compila C, dare alle costanti di stringa il tipo "const char[lunghezza]" in modo che la copia
l'indirizzo di uno in un puntatore "char *" non "const" riceverà un avviso. Queste
gli avvisi ti aiuteranno a trovare in fase di compilazione il codice che può provare a scrivere in una stringa
costante, ma solo se sei stato molto attento a usare "const" nelle dichiarazioni
e prototipi. Altrimenti, sarà solo un fastidio. Questo è il motivo per cui non abbiamo fatto
-Parete richiedere questi avvisi.

Quando si compila C++, avvisare della conversione deprecata da letterali stringa a "char
*". Questo avviso è abilitato per impostazione predefinita per i programmi C++.

-Wobbed
Avvisa per le variabili che potrebbero essere modificate da longjmp or vfork. Questo avvertimento è anche
abilitato da -Wextra.

-Conversione
Avvisa per le conversioni implicite che possono alterare un valore. Questo include le conversioni
tra reale e intero, come "abs (x)" quando "x" è "doppio"; conversioni tra
firmato e non firmato, come "unsigned ui = -1"; e conversioni in tipi più piccoli, come
"sqrtf (M_PI)". Non avvisare per cast espliciti come "abs ((int) x)" e "ui =
(unsigned) -1", o se il valore non viene modificato dalla conversione come in "abs (2.0)".
Gli avvisi sulle conversioni tra interi con segno e senza segno possono essere disabilitati da
utilizzando -Wno-sign-conversione.

Per C++, avvisa anche per la risoluzione dell'overload confusa per le conversioni definite dall'utente; e
conversioni che non utilizzeranno mai un operatore di conversione di tipo: conversioni a "void", il
stesso tipo, una classe base o un riferimento ad essi. Avvertenze sulle conversioni tra
gli interi con segno e senza segno sono disabilitati per impostazione predefinita in C++ a meno che -Wsign-conversione
è esplicitamente abilitato.

-Wno-conversione-null (solo C++ e Objective-C++)
Non avvisare per le conversioni tra i tipi "NULL" e non puntatore. -Wconversione-null is
abilitato per impostazione predefinita.

-Wzero-as-null-pointer-costante (solo C++ e Objective-C++)
Avvisa quando viene utilizzato uno '0' letterale come costante del puntatore nullo. Questo può essere utile per
facilitare la conversione in "nullptr" in C++11.

-Wempty-corpo
Avvisa se si verifica un corpo vuoto in an if, altro or do while dichiarazione. Questo avviso è
abilitato anche da -Wextra.

-Wenum-confronta
Avvisa di un confronto tra valori di diversi tipi enumerati. In C++ enumerativo
vengono diagnosticate anche le discrepanze nelle espressioni condizionali e l'avviso è abilitato da
predefinito. In C questo avviso è abilitato da -Parete.

-Wjump-miss-init (C, solo Obiettivo-C)
Avvisa se un'istruzione "goto" o un'istruzione "switch" salta in avanti attraverso il
inizializzazione di una variabile, o salta indietro a un'etichetta dopo che la variabile è stata
inizializzato. Questo avverte solo delle variabili che vengono inizializzate quando lo sono
dichiarato. Questo avviso è supportato solo per C e Objective-C; in C++ questo tipo di
ramo è un errore in ogni caso.

-Wjump-miss-init è incluso in -Wc++-compatibile. Può essere disabilitato con il
-Wno-jump-miss-init opzione.

-Wsign-confronta
Avvisa quando un confronto tra valori con segno e senza segno potrebbe produrre un errore
risultato quando il valore con segno viene convertito in unsigned. Anche questo avviso è abilitato
by -Wextra; per ricevere gli altri avvisi di -Wextra senza questo avviso, usa -Wextra
-Wno-sign-confronta.

-Wsign-conversione
Avvisa per le conversioni implicite che possono cambiare il segno di un valore intero, come
assegnazione di un'espressione intera con segno a una variabile intera senza segno. Un esplicito
cast mette a tacere l'avvertimento. In C, questa opzione è abilitata anche da -Conversione.

-Indirizzo
Avvisa in caso di usi sospetti degli indirizzi di memoria. Questi includono l'utilizzo dell'indirizzo di a
funzione in un'espressione condizionale, come "void func(void); if (func)", e
confronti con l'indirizzo di memoria di una stringa letterale, ad esempio "if (x == "abc")".
Tali usi indicano tipicamente un errore del programmatore: l'indirizzo di una funzione sempre
restituisce true, quindi il loro uso in un condizionale di solito indica che il programmatore
dimenticato le parentesi in una chiamata di funzione; e confronti con stringhe letterali
comportano un comportamento non specificato e non sono portabili in C, quindi di solito indicano
che il programmatore intendeva utilizzare "strcmp". Questo avviso è abilitato da -Parete.

-Wlogico-op
Avvisa sugli usi sospetti degli operatori logici nelle espressioni. Questo include l'uso
operatori logici in contesti in cui è probabile che sia previsto un operatore bit per bit.

-Waggregato-ritorno
Avvisa se vengono definite o chiamate funzioni che restituiscono strutture o unioni. (In
lingue in cui è possibile restituire un array, questo suscita anche un avviso.)

-Wno-attributi
Non avvisare se viene utilizzato un "__attribute__" imprevisto, come attributi non riconosciuti,
attributi della funzione applicati alle variabili, ecc. Questo non fermerà gli errori per
uso errato degli attributi supportati.

-Wno-built-in-macro-redefined
Non avvisare se alcune macro integrate vengono ridefinite. Questo sopprime gli avvisi per
ridefinizione di "__TIMESTAMP__", "__TIME__", "__DATE__", "__FILE__", e
"__BASE_FILE__".

-Wstrict-prototipi (solo C e Objective-C)
Avvisa se una funzione è dichiarata o definita senza specificare i tipi di argomento. (Un
la definizione di funzione vecchio stile è consentita senza preavviso se preceduta da a
dichiarazione che specifica i tipi di argomento.)

-Dichiarazione in stile Wold (solo C e Objective-C)
Avvertire per usi obsoleti, secondo la norma C, in una dichiarazione. Per
esempio, avvisa se gli identificatori di classe di archiviazione come "statico" non sono le prime cose in a
dichiarazione. Questo avviso è abilitato anche da -Wextra.

-Definizione in stile Wold (solo C e Objective-C)
Avvisa se viene utilizzata una definizione di funzione vecchio stile. Viene dato un avvertimento anche se c'è
un prototipo precedente.

-Wmissing-tipo-parametro (solo C e Objective-C)
Un parametro di funzione viene dichiarato senza un identificatore di tipo nelle funzioni in stile K&R:

vuoto foo(bar) { }

Questo avviso è abilitato anche da -Wextra.

-Wmissing-prototipi (solo C e Objective-C)
Avvisa se una funzione globale è definita senza una precedente dichiarazione di prototipo. Questo
viene emesso un avviso anche se la definizione stessa fornisce un prototipo. L'obiettivo è quello di
rileva le funzioni globali che non sono dichiarate nei file di intestazione.

-Dichiarazioni-mancanti
Avvisa se una funzione globale è definita senza una dichiarazione precedente. Fallo anche se
la definizione stessa fornisce un prototipo. Usa questa opzione per rilevare globale
funzioni che non sono dichiarate nei file di intestazione. In C++ non vengono emessi avvisi per
modelli di funzione o per funzioni in linea o per funzioni in spazi dei nomi anonimi.

-Wmissing-field-inizializzatori
Avvisa se l'inizializzatore di una struttura ha alcuni campi mancanti. Ad esempio, il seguente
codice causerebbe un tale avviso, perché "xh" è implicitamente zero:

struttura s { int f, g, h; };
struttura sx = { 3, 4 };

Questa opzione non avvisa degli inizializzatori designati, quindi la seguente modifica
non attiverebbe un avviso:

struttura s { int f, g, h; };
struttura sx = { .f = 3, .g = 4 };

Questo avviso è incluso in -Wextra. Per ottenere altro -Wextra avvisi senza questo,
uso -Wextra -Wno-mancanti-inizializzatori di campo.

-Attributo-formato-mancante
Avvisa dei puntatori a funzione che potrebbero essere candidati per gli attributi di "formato". Nota
questi sono solo candidati possibili, non assoluti. GCC indovinerà quella funzione
puntatori con attributi di "formato" utilizzati nell'assegnazione, inizializzazione,
le istruzioni di passaggio o di restituzione dei parametri dovrebbero avere un attributo "formato" corrispondente
nel tipo risultante. Cioè il lato sinistro dell'assegnazione o dell'inizializzazione,
il tipo della variabile parametro, o il tipo restituito dalla funzione contenitore
rispettivamente dovrebbe avere anche un attributo "format" per evitare l'avviso.

GCC avviserà anche delle definizioni di funzione che potrebbero essere candidate per "formato"
attributi. Anche in questo caso, questi sono solo possibili candidati. GCC indovinerà quel "formato"
gli attributi potrebbero essere appropriati per qualsiasi funzione che chiama una funzione come "vprintf"
o "vscanf", ma potrebbe non essere sempre così, e alcune funzioni per le quali
Gli attributi "format" sono appropriati potrebbero non essere rilevati.

-No-multichar
Non avvisa se una costante multicarattere ('FOO') viene utilizzato. Di solito indicano a
errore di battitura nel codice dell'utente, in quanto hanno valori definiti dall'implementazione e non dovrebbero essere
utilizzato nel codice portatile.

-Wnormalizzato=
In ISO C e ISO C++, due identificatori sono diversi se sono sequenze diverse di
caratteri. Tuttavia, a volte quando i caratteri sono al di fuori del set di caratteri ASCII di base
vengono utilizzati, è possibile avere due diverse sequenze di caratteri che hanno lo stesso aspetto. Evitare
confusione, lo standard ISO 10646 stabilisce alcuni normalizzazione norme che quando applicato
assicurarsi che due sequenze che sembrano uguali vengano trasformate nella stessa sequenza. GCC
può avvisarti se stai utilizzando identificatori che non sono stati normalizzati; questa opzione
controlla quell'avviso.

Ci sono quattro livelli di avviso supportati da GCC. L'impostazione predefinita è -Wnormalizzato=nfc,
che avverte di qualsiasi identificatore che non sia nella forma normalizzata ISO 10646 "C",
NFC. NFC è la forma consigliata per la maggior parte degli usi.

Sfortunatamente, ci sono alcuni caratteri consentiti negli identificatori da ISO C e ISO C++
che, una volta trasformati in NFC, non sono ammessi negli identificatori. Cioè, non c'è modo
per utilizzare questi simboli in ISO C o C++ portatile e avere tutti i tuoi identificatori in NFC.
-Wnormalizzato=id sopprime l'avviso per questi caratteri. Si spera che il futuro
le versioni degli standard coinvolti correggeranno questo problema, motivo per cui questa opzione non lo è
il predefinito.

Puoi disattivare l'avviso per tutti i caratteri scrivendo -Wnormalizzato=nessuno. È
vorrei farlo solo se stavi usando qualche altro schema di normalizzazione (come
"D"), perché altrimenti puoi facilmente creare bug che sono letteralmente impossibili da
vedere.

Alcuni caratteri in ISO 10646 hanno significati distinti ma sembrano identici in alcuni caratteri
o metodologie di visualizzazione, soprattutto una volta applicata la formattazione. Ad esempio
"\u207F", "SUPERSCRIPT LATIN SMALL LETTER N", verrà visualizzato come una normale "n"
che è stato messo in apice. ISO 10646 definisce il NFKC normalizzazione
schema per convertire anche tutti questi in un modulo standard e GCC avviserà se il tuo
il codice non è in NFKC se usi -Wnormalizzato=nfkc. Questo avviso è paragonabile a
avviso su ogni identificatore che contiene la lettera O perché potrebbe essere confuso
con la cifra 0, quindi non è l'impostazione predefinita, ma può essere utile come codifica locale
convenzione se l'ambiente di programmazione non può essere riparato per visualizzarli
caratteri distintamente.

-Wno-deprecato
Non avvisare dell'utilizzo di funzionalità deprecate.

-Wno-deprecato-dichiarazioni
Non avvisare dell'uso di funzioni, variabili e tipi contrassegnati come deprecati da
utilizzando l'attributo "deprecato".

-No-overflow
Non avvisare dell'overflow in fase di compilazione nelle espressioni costanti.

-Woverride-init (solo C e Objective-C)
Avvisa se un campo inizializzato senza effetti collaterali viene sovrascritto quando si utilizza designato
inizializzatori.

Questo avviso è incluso in -Wextra. Per ottenere altro -Wextra avvisi senza questo,
uso -Wextra -Wno-override-init.

-Imballato
Avvisa se a una struttura viene assegnato l'attributo compresso, ma l'attributo compresso non ha
effetto sulla disposizione o sulle dimensioni della struttura. Tali strutture possono essere disallineate per
piccolo beneficio. Ad esempio, in questo codice, la variabile "fx" in "struct bar" sarà
essere disallineato anche se "struct bar" non ha di per sé l'attributo compresso:

struttura foo {
int x;
carattere a, b, c, d;
} __attribute __ ((impacchettato));
barra della struttura {
carattere z;
struttura foo f;
};

-Wpacked-bitfield-compatibile
Le serie 4.1, 4.2 e 4.3 di GCC ignorano l'attributo "packed" sui campi di bit di tipo
"cara". Questo è stato corretto in GCC 4.4 ma la modifica può portare a differenze nel
disposizione della struttura. GCC ti informa quando l'offset di tale campo è cambiato in GCC
4.4. Ad esempio non c'è più un riempimento a 4 bit tra il campo "a" e "b" in questo
struttura:

struttura foo
{
carattere a:4;
carattere b:8;
} __attributo__ ((confezionato));

Questo avviso è abilitato per impostazione predefinita. Utilizzo -Wno-packed-bitfield-compat per disabilitarlo
avvertimento.

-Imbottito
Avvisa se il padding è incluso in una struttura, sia per allineare un elemento del
struttura o per allineare l'intera struttura. A volte quando questo accade è possibile
riorganizzare i campi della struttura per ridurre l'imbottitura e quindi rendere il
struttura più piccola.

-Wredundant-dichiarazioni
Avvisare se qualcosa è dichiarato più di una volta nello stesso ambito, anche nei casi in cui
la dichiarazione multipla è valida e non cambia nulla.

-Wnned-externs (solo C e Objective-C)
Avvisa se viene rilevata una dichiarazione "extern" all'interno di una funzione.

-Linea vincente
Avvisa se una funzione non può essere inline ed è stata dichiarata come inline. Anche con questo
opzione, il compilatore non avviserà degli errori nelle funzioni inline dichiarate in
intestazioni di sistema.

Il compilatore utilizza una varietà di euristiche per determinare se inserire o meno a
funzione. Ad esempio, il compilatore tiene conto della dimensione della funzione essendo
inline e la quantità di inline già eseguita nella funzione corrente.
Pertanto, cambiamenti apparentemente insignificanti nel programma sorgente possono causare il
avvisi prodotti da -Linea vincente apparire o scomparire.

-No-compensazione-non-valida (solo C++ e Objective-C++)
Elimina gli avvisi dall'applicazione del offset di macro a un tipo non POD. Secondo
lo standard ISO C++ del 1998, applicando offset di a un tipo non POD non è definito. In
implementazioni C++ esistenti, tuttavia, offset di in genere dà risultati significativi
anche quando applicato a determinati tipi di tipi non POD. (Come un semplice struct che
non riesce ad essere un tipo POD solo in virtù dell'avere un costruttore.) Questo flag è per
utenti che sono consapevoli di scrivere codice non portabile e che hanno deliberatamente
scelto di ignorare l'avvertimento al riguardo.

Le restrizioni su offset di potrebbe essere rilassato in una versione futura dello standard C++.

-Wno-int-to-puntatore-cast
Elimina gli avvisi dai cast al tipo di puntatore di un numero intero di dimensioni diverse. In
C++, la trasmissione a un tipo di puntatore di dimensioni inferiori è un errore. Wint-to-puntatore-cast is
abilitato per impostazione predefinita.

-Wno-pointer-to-int-cast (solo C e Objective-C)
Elimina gli avvisi dai cast da un puntatore a un tipo intero di dimensioni diverse.

-Winvalid-pch
Avvisa se un'intestazione precompilata viene trovata nel percorso di ricerca ma non può essere utilizzata.

-Wlong-lungo
Avvisa se lungo lungo tipo viene utilizzato. Questo è abilitato da entrambi -pedante or -Wtradizionale
nelle modalità ISO C90 e C++98. Per inibire i messaggi di avviso, utilizzare -Wno-lungo-lungo.

-Wvariadic-macro
Avvisa se le macro variadiche vengono utilizzate nella modalità pedante ISO C90 o nella sintassi alternativa GNU
quando si è in modalità ISO C99 pedante. Questa è l'impostazione predefinita. Per inibire i messaggi di avviso, utilizzare
-Wno-macro-variadiche.

-Wvettore-operazione-prestazioni
Avvisa se il funzionamento del vettore non è implementato tramite le funzionalità SIMD dell'architettura.
Utile principalmente per l'ottimizzazione delle prestazioni. È possibile implementare l'operazione vettoriale
"a tratti", il che significa che l'operazione scalare viene eseguita su ogni vettore
elemento; "in parallelo", il che significa che l'operazione vettoriale è implementata usando
scalari di tipo più ampio, che normalmente è più efficiente in termini di prestazioni; e "da single
scalare", il che significa che il vettore si adatta a un tipo scalare.

-Wvla
Avvisa se nel codice viene utilizzato un array di lunghezza variabile. -Wno-vla impedirà il
-pedante avviso dell'array a lunghezza variabile.

-W registro-volatile-var
Avvisa se una variabile di registro è dichiarata volatile. Il modificatore volatile no
inibire tutte le ottimizzazioni che possono eliminare le letture e/o le scritture nel registro
variabili. Questo avviso è abilitato da -Parete.

-Wdisabled-ottimizzazione
Avvisa se un passaggio di ottimizzazione richiesto è disabilitato. Questo avviso generalmente non funziona
indicare che c'è qualcosa di sbagliato nel tuo codice; indica semplicemente che i GCC
gli ottimizzatori non erano in grado di gestire il codice in modo efficace. Spesso il problema è che
il tuo codice è troppo grande o troppo complesso; GCC si rifiuterà di ottimizzare i programmi quando il
è probabile che l'ottimizzazione stessa richieda una quantità eccessiva di tempo.

-Wpointer-segno (solo C e Objective-C)
Avvisa per il passaggio o l'assegnazione di argomenti del puntatore con un segno diverso. Questo
L'opzione è supportata solo per C e Objective-C. È implicito da -Parete e
-pedante, che può essere disabilitato con -Wno-puntatore-segno.

-Wstack-protezione
Questa opzione è attiva solo quando -fstack-protettore è attivo. Avverte sulle funzioni
che non sarà protetto dallo stack smashing.

-Wno-parafango
Sopprimere gli avvisi sui costrutti che non possono essere strumentati da -fparaspruzzi.

-Stringhe di lunghezza totale
Avvisa delle costanti di stringa più lunghe della lunghezza "minima massima"
specificato nella norma C. I compilatori moderni generalmente consentono costanti stringa che
sono molto più lunghi del limite minimo dello standard, ma i programmi molto portabili dovrebbero
evitare di utilizzare stringhe più lunghe.

Il limite si applica dopo stringa concatenazione costante e non conta il finale
NULLA. In C90, il limite era di 509 caratteri; in C99, è stato portato a 4095. C++98 lo fa
non specifichiamo un minimo normativo massimo, quindi non diagnostichiamo stringhe di lunghezza eccessiva in
C ++.

Questa opzione è implicata da -pedante, e può essere disabilitato con -No-stringhe di lunghezza eccessiva.

-Wuncostanti-float suffissi (solo C e Objective-C)
GCC emetterà un avviso per qualsiasi costante mobile che non ha un suffisso. quando
usato insieme a -Wsystem-header avviserà di tali costanti nell'intestazione di sistema
File. Questo può essere utile quando si prepara il codice da utilizzare con "FLOAT_CONST_DECIMAL64"
pragma dall'estensione decimale in virgola mobile a C99.

Opzioni per Debug Trasferimento da aeroporto a Sharm Programma or GCC
GCC ha varie opzioni speciali che vengono utilizzate per il debug del tuo programma o di GCC:

-g Produrre informazioni di debug nel formato nativo del sistema operativo (stabs, COFF,
XCOFF, o NANO 2). GDB può lavorare con queste informazioni di debug.

Sulla maggior parte dei sistemi che utilizzano il formato stabs, -g consente l'uso di ulteriori informazioni di debug
che solo GDB può utilizzare; queste informazioni extra fanno funzionare meglio il debug in GDB ma
probabilmente farà crashare altri debugger o si rifiuterà di leggere il programma. Se vuoi
per controllare con certezza se generare le informazioni aggiuntive, utilizzare -gstabs+,
-gstabs, -gxcoff+, -gxcoff, o -gvms (vedi sotto).

GCC ti permette di usare -g con -O. Le scorciatoie prese dal codice ottimizzato possono
a volte producono risultati sorprendenti: alcune variabili che hai dichiarato potrebbero non esistere in
Tutti; il flusso di controllo può spostarsi brevemente dove non te lo aspettavi; alcune affermazioni possono
non essere eseguiti perché calcolano risultati costanti o i loro valori erano già a
mano; alcune istruzioni possono essere eseguite in posti diversi perché sono state spostate fuori
loop.

Tuttavia è possibile eseguire il debug dell'output ottimizzato. Questo lo rende ragionevole
per utilizzare l'ottimizzatore per programmi che potrebbero contenere bug.

Le seguenti opzioni sono utili quando GCC viene generato con la capacità di più
di un formato di debug.

-ggdb
Produrre informazioni di debug per l'utilizzo da parte di GDB. Questo significa usare il più espressivo
formato disponibile (DWARF 2, stabs o il formato nativo se nessuno di questi lo è
supportato), comprese le estensioni GDB, se possibile.

-gstabs
Produrre informazioni di debug in formato stabs (se supportato), senza GDB
estensioni. Questo è il formato utilizzato da DBX sulla maggior parte dei sistemi BSD. Su MIPS, Alpha e
Sistemi System V Release 4 questa opzione produce output di debug di stab che non lo è
compreso da DBX o SDB. Sui sistemi System V Release 4 questa opzione richiede GNU
assemblatore.

-feliminare-simboli-debug-inutilizzati
Produrre informazioni di debug in formato stabs (se supportato), solo per simboli
che vengono effettivamente utilizzati.

-femit-class-debug-sempre
Invece di emettere informazioni di debug per una classe C++ in un solo file oggetto,
emetterlo in tutti i file oggetto utilizzando la classe. Questa opzione dovrebbe essere utilizzata solo con
debugger che non sono in grado di gestire il modo in cui GCC emette normalmente le informazioni di debug
per le classi perché l'uso di questa opzione aumenterà la dimensione delle informazioni di debug
di un fattore due.

-fno-sezione-tipi-di-debug
Per impostazione predefinita, quando si utilizza DWARF v4 o superiore, i DIE di tipo verranno inseriti nei propri
.debug_types invece di renderli parte della sezione .debug_info. è
più efficiente metterli in sezioni comdat separate poiché il linker sarà quindi
in grado di rimuovere i duplicati. Ma non tutti i consumatori DWARF supportano le sezioni .debug_types
ancora.

-gstabs+
Produrre informazioni di debug in formato stabs (se supportato), utilizzando GNU
estensioni comprese solo dal debugger GNU (GDB). L'uso di queste estensioni è
è probabile che altri debugger si blocchino o si rifiutino di leggere il programma.

-gcoff
Produrre informazioni di debug in formato COFF (se supportato). Questo è il
formato utilizzato da SDB sulla maggior parte dei sistemi System V prima di System V Release 4.

-gxcoff
Produce informazioni di debug in formato XCOFF (se supportato). Questo è il
formato utilizzato dal debugger DBX sui sistemi IBM RS/6000.

-gxcoff+
Produrre informazioni di debug in formato XCOFF (se supportato), utilizzando GNU
estensioni comprese solo dal debugger GNU (GDB). L'uso di queste estensioni è
rischia di causare l'arresto anomalo di altri debugger o il rifiuto di leggere il programma e può causare
assemblatori diversi dall'assemblatore GNU (GAS) falliscono con un errore.

-gnano-versione
Produce informazioni di debug in formato DWARF (se supportato). Questo è il
formato utilizzato da DBX su IRIX 6. Il valore di versione può essere 2, 3 o 4; il
la versione predefinita è 2.

Nota che con DWARF versione 2 alcune porte richiedono, e utilizzeranno sempre, alcune porte non
estensioni DWARF 3 in conflitto nelle tabelle di svolgimento.

La versione 4 potrebbe richiedere GDB 7.0 e -fvar-tracciamento-assegnazioni per il massimo beneficio.

-grecord-gcc-switch
Questa opzione fa sì che le opzioni della riga di comando utilizzate per invocare il compilatore che potrebbe
influenzare la generazione del codice da aggiungere all'attributo DW_AT_producer in DWARF
informazioni di debug. Le opzioni sono concatenate con spazi che le separano da
tra loro e dalla versione del compilatore. Guarda anche -interruttori frecord-gcc per un altro
modo di memorizzare le opzioni del compilatore nel file oggetto.

-gno-record-gcc-switch
Non consentire l'aggiunta di opzioni della riga di comando all'attributo DW_AT_producer in DWARF
informazioni di debug. Questa è l'impostazione predefinita.

-gstrict-nano
Non consentire l'utilizzo di estensioni della versione standard DWARF successiva rispetto a quella selezionata con
-gnano-versione. Sulla maggior parte dei bersagli che utilizzano estensioni DWARF non in conflitto da successive
sono consentite le versioni standard.

-gno-severo-nano
Consenti l'utilizzo di estensioni della versione standard DWARF successiva rispetto a quella selezionata con
-gnano-versione.

-gvms
Produrre informazioni di debug nel formato di debug VMS (se supportato). Questo è il
formato utilizzato da DEBUG sui sistemi VMS.

-glivello
-ggdblivello
-gstabslivello
-gcofflivello
-gxcofflivello
-gvmslivello
Richiedi informazioni di debug e usa anche livello per specificare quante informazioni. Il
il livello predefinito è 2.

Il livello 0 non produce alcuna informazione di debug. Così, -g0 nega -g.

Il livello 1 produce informazioni minime, sufficienti per fare backtrace in parti del
programma di cui non intendi eseguire il debug. Ciò include le descrizioni delle funzioni e
variabili esterne, ma nessuna informazione sulle variabili locali e nessun numero di riga.

Il livello 3 include informazioni extra, come tutte le definizioni macro presenti nel
programma. Alcuni debugger supportano l'espansione delle macro quando si utilizza -g3.

-gnano-2 non accetta un livello di debug concatenato, perché GCC era solito supportare un
opzione -gnano che significava generare informazioni di debug nella versione 1 di DWARF
format (che è molto diverso dalla versione 2), e sarebbe stato troppo confuso.
Quel formato di debug è obsoleto da tempo, ma l'opzione non può essere modificata ora. Invece usa
un ulteriore -glivello opzione per modificare il livello di debug per DWARF.

-gattiva/disattiva
Disattiva la generazione delle informazioni di debug, se l'assenza di questa opzione l'avrebbe generata,
o accendilo al livello 2 altrimenti. La posizione di questo argomento nella riga di comando
non importa, ha effetto dopo che tutte le altre opzioni sono state elaborate e lo fa
solo una volta, non importa quante volte viene dato. Questo è principalmente destinato all'uso
con -fcompare-debug.

-fdump-final-insns[=filetto]
Scarica la rappresentazione interna finale (RTL) su filetto. Se l'argomento opzionale è
omesso (o se filetto è "."), il nome del file dump sarà determinato aggiungendo
".gkd" al nome del file di output della compilazione.

-fcompare-debug[=opta]
Se non si verifica alcun errore durante la compilazione, eseguire il compilatore una seconda volta, aggiungendo opta ed
-fcompare-debug-secondo agli argomenti passati alla seconda compilazione. scarica il
rappresentazione interna finale in entrambe le compilazioni e stampa un errore se differiscono.

Se il segno di uguale viene omesso, il valore predefinito -gattiva/disattiva viene utilizzato.

La variabile d'ambiente GCC_COMPARE_DEBUG, se definito, non vuoto e diverso da zero,
implicitamente abilita -fcompare-debug. Se GCC_COMPARE_DEBUG è definito da una stringa
inizia con un trattino, quindi viene utilizzato per opta, altrimenti il ​​default -gattiva/disattiva is
Usato.

-fcompare-debug=, con il segno di uguale ma senza opta, è equivalente a
-fno-confronta-debug, che disabilita il dumping della rappresentazione finale e il
seconda compilazione, impedendo anche GCC_COMPARE_DEBUG dall'entrata in vigore.

Per verificare la copertura completa durante -fcompare-debug test, set GCC_COMPARE_DEBUG dire
-fcompare-debug-not-override, che GCC rifiuterà come opzione non valida in qualsiasi
compilazione effettiva (piuttosto che pre-elaborazione, assemblaggio o collegamento). Per ottenere solo un
avviso, impostazione GCC_COMPARE_DEBUG a -w%n-fcompare-debug non sovrascritto andrà bene.

-fcompare-debug-secondo
Questa opzione viene implicitamente passata al compilatore per la seconda compilazione richiesta
by -fcompare-debug, insieme alle opzioni per disattivare gli avvisi e omettere altre opzioni
ciò causerebbe output del compilatore con effetti collaterali su file o sullo standard output.
I file dump e i file temporanei conservati vengono rinominati in modo da contenere il ".gk"
estensione aggiuntiva durante la seconda compilazione, per evitare di sovrascriverli
generato dal primo.

Quando questa opzione viene passata al driver del compilatore, provoca il prima di tutto compilazione a
essere ignorato, il che lo rende utile per poco altro che per il debug del compilatore vero e proprio.

-feliminate-nano2-dups
Comprimi le informazioni di debug di DWARF2 eliminando le informazioni duplicate su ciascuna
simbolo. Questa opzione ha senso solo quando si generano informazioni di debug DWARF2
con -gnano-2.

-femit-struct-debug-baseonly
Emette informazioni di debug per i tipi struct-like solo quando il nome di base del
il file di origine della compilazione corrisponde al nome di base del file in cui è stata definita la struttura.

Questa opzione riduce sostanzialmente la dimensione delle informazioni di debug, ma a
significativa perdita potenziale di informazioni sul tipo per il debugger. Vedere
-femit-struct-debug-ridotto per un'opzione meno aggressiva. Vedere
-femit-struct-debug-dettagliato per un controllo più dettagliato.

Questa opzione funziona solo con DWARF 2.

-femit-struct-debug-ridotto
Emette informazioni di debug per i tipi struct-like solo quando il nome di base del
il file di origine della compilazione corrisponde al nome di base del file in cui è stato definito il tipo,
a meno che la struttura non sia un modello o definita in un'intestazione di sistema.

Questa opzione riduce significativamente la dimensione delle informazioni di debug, con alcuni
potenziale perdita di informazioni sul tipo per il debugger. Vedere -femit-struct-debug-baseonly
per un'opzione più aggressiva. Vedere -femit-struct-debug-dettagliato per maggiori dettagli
controllare.

Questa opzione funziona solo con DWARF 2.

-femit-struct-debug-dettagliato[=lista-specifiche]
Specificare i tipi di tipo struct per i quali il compilatore genererà le informazioni di debug.
L'intento è quello di ridurre le informazioni di debug della struttura duplicate tra diversi oggetti
file all'interno dello stesso programma.

Questa opzione è una versione dettagliata di -femit-struct-debug-ridotto ed
-femit-struct-debug-baseonly, che servirà per la maggior parte delle esigenze.

Una specifica ha la sintassi[direzione:|ind:][ordine:|genere:](in qualsiasi|sys|base|nessuna)

La prima parola facoltativa limita la specifica alle strutture che vengono utilizzate direttamente
(direzione:) o utilizzato indirettamente (ind:). Un tipo struct viene utilizzato direttamente quando è il tipo
di una variabile, membro. Gli usi indiretti derivano da puntatori a struct. Questo è,
quando l'uso di una struttura incompleta sarebbe legale, l'uso è indiretto. Un esempio è
struct prima diretto; struct seconda * indiretto;.

La seconda parola facoltativa limita la specifica alle strutture ordinarie (ordine:) o puoi
strutture generiche (genere:). Le strutture generiche sono un po' complicate da spiegare. Per C++,
queste sono specializzazioni non esplicite di classi modello o classi non modello
all'interno di quanto sopra. Altri linguaggi di programmazione hanno generici, ma
-femit-struct-debug-dettagliato non li attua ancora.

La terza parola specifica i file sorgente per quelle strutture per le quali il compilatore
emetterà informazioni di debug. I valori nessuna ed in qualsiasi hanno il significato normale. Il
APPREZZIAMO base significa che la base del nome del file in cui la dichiarazione del tipo
appare deve corrispondere alla base del nome del file di compilazione principale. In pratica,
questo significa che i tipi dichiarati in foo.c ed foo.h avrà informazioni di debug, ma
i tipi dichiarati in un'altra intestazione non lo faranno. Il valore sys significa quei tipi che soddisfano
base o dichiarato nelle intestazioni di sistema o del compilatore.

Potrebbe essere necessario sperimentare per determinare le impostazioni migliori per la tua applicazione.

L'impostazione predefinita è -femit-struct-debug-detailed=tutto.

Questa opzione funziona solo con DWARF 2.

-fno-merge-debug-stringhe
Indica al linker di non unire le stringhe nelle informazioni di debug che sono
identici in diversi file oggetto. La fusione non è supportata da tutti gli assemblatori o
collegatori. L'unione riduce la dimensione delle informazioni di debug nel file di output in
il costo dell'aumento del tempo di elaborazione del collegamento. L'unione è abilitata per impostazione predefinita.

-fdebug-prefisso-mappa=vecchio=nuovi
Quando si compilano file nella directory vecchio, registra le informazioni di debug descrivendole come
in nuovi anziché.

-fno-nano2-cfi-asm
Emetti le informazioni di svolgimento di DWARF 2 come sezione ".eh_frame" generata dal compilatore invece di usare
Direttive GAS ".cfi_*".

-p Genera codice aggiuntivo per scrivere informazioni sul profilo adatte al programma di analisi
prof. È necessario utilizzare questa opzione durante la compilazione dei file di origine di cui si desiderano i dati,
e devi anche usarlo durante il collegamento.

-pag Genera codice aggiuntivo per scrivere informazioni sul profilo adatte al programma di analisi
gprof. È necessario utilizzare questa opzione durante la compilazione dei file di origine di cui si desiderano i dati,
e devi anche usarlo durante il collegamento.

-Q Fa in modo che il compilatore stampi ogni nome di funzione mentre viene compilato e ne stampa alcuni
statistiche su ogni passaggio quando finisce.

-ftime-rapporto
Fa in modo che il compilatore stampi alcune statistiche sul tempo consumato da ogni passaggio quando lo fa
finiture.

-fmem-rapporto
Fa in modo che il compilatore stampi alcune statistiche sull'allocazione permanente della memoria quando
finiture.

-fpre-ipa-mem-report
-fpost-ipa-mem-report
Fa in modo che il compilatore stampi alcune statistiche sull'allocazione permanente della memoria prima di o
dopo l'ottimizzazione interprocedurale.

-fstack-uso
Rende le informazioni sull'utilizzo dello stack di output del compilatore per il programma, su una funzione
base. Il nome del file per il dump viene creato aggiungendo .SU Vai all’email nome aux. nome aux is
generato dal nome del file di output, se specificato esplicitamente e non è un
eseguibile, altrimenti è il nome di base del file sorgente. Una voce è composta da
tre campi:

· Il nome della funzione.

· Un numero di byte.

· Uno o più qualificatori: "statico", "dinamico", "limitato".

Il qualificatore "static" significa che la funzione manipola lo stack staticamente: a
numero fisso di byte vengono assegnati per il frame all'ingresso della funzione e rilasciati su
uscita dalla funzione; altrimenti non vengono effettuate regolazioni dello stack nella funzione. Il secondo
campo è questo numero fisso di byte.

Il qualificatore "dinamico" significa che la funzione manipola lo stack dinamicamente: in
Oltre all'allocazione statica sopra descritta, le regolazioni dello stack vengono effettuate nel
corpo della funzione, ad esempio per eseguire il push/pop degli argomenti attorno alle chiamate di funzione. Se la
è presente anche il qualificatore "limitato", l'importo di queste rettifiche è limitato a
tempo di compilazione e il secondo campo è un limite superiore della quantità totale di stack utilizzato
dalla funzione. Se non è presente, l'importo di tali rettifiche non è limitato
in fase di compilazione e il secondo campo rappresenta solo la parte delimitata.

-fprofile-archi
Aggiungi codice in modo che il programma scorra archi sono strumentati. Durante l'esecuzione il programma
registra quante volte ogni ramo e chiamata viene eseguita e quante volte viene presa
o ritorna. Quando il programma compilato esce salva questi dati in un file chiamato
nomeaux.gcda per ogni file sorgente. I dati possono essere utilizzati per il profilo diretto
ottimizzazioni (-fbranch-probabilità), o per l'analisi della copertura del test
(-ftest-copertura). Ogni file oggetto nome aux è generato dal nome del
file di output, se specificato esplicitamente e non è l'eseguibile finale, altrimenti lo è
è il nome di base del file sorgente. In entrambi i casi viene rimosso qualsiasi suffisso (es
foo.gcda per il file di input dir/foo.c, o dir/foo.gcda per il file di output specificato come -o
dir/foo.o).

--copertura
Questa opzione viene utilizzata per compilare e collegare il codice strumentato per l'analisi della copertura. Il
opzione è sinonimo di -fprofile-archi -ftest-copertura (durante la compilazione) e -lgcov
(durante il collegamento). Vedere la documentazione per queste opzioni per maggiori dettagli.

· Compilare i file sorgente con -fprofile-archi oltre a ottimizzazione e generazione di codice
opzioni. Per l'analisi della copertura del test, utilizzare l'addizionale -ftest-copertura opzione.
Non è necessario profilare ogni file sorgente in un programma.

· Collega i tuoi file oggetto con -lgcov or -fprofile-archi (quest'ultimo implica il
ex).

· Eseguire il programma su un carico di lavoro rappresentativo per generare il profilo dell'arco
informazione. Questo può essere ripetuto un numero qualsiasi di volte. Puoi correre contemporaneamente
istanze del programma e, a condizione che il file system supporti il ​​blocco,
i file di dati verranno aggiornati correttamente. Vengono rilevate anche le chiamate "fork" e
gestito correttamente (il doppio conteggio non avverrà).

· Per le ottimizzazioni orientate al profilo, compila nuovamente i file sorgente con lo stesso
opzioni di ottimizzazione e generazione del codice plus -fbranch-probabilità.

· Per l'analisi della copertura del test, utilizzare gcov per produrre informazioni leggibili dall'uomo da
, il .gcno ed .gcda File. Fare riferimento a gcov documentazione per ulteriori informazioni
informazioni.

Con -fprofile-archi, per ogni funzione del tuo programma GCC crea un flusso di programma
graph, quindi trova un albero ricoprente per il grafico. Solo archi che non sono sul
spanning tree devono essere strumentati: il compilatore aggiunge il codice per contare il numero di
volte che questi archi vengono eseguiti. Quando un arco è l'unica uscita o l'unico ingresso a
un blocco, il codice della strumentazione può essere aggiunto al blocco; altrimenti, una nuova base
deve essere creato un blocco per contenere il codice della strumentazione.

-ftest-copertura
Produrre un file di note che il gcov l'utilità di copertura del codice può essere utilizzata per mostrare il programma
copertura. Viene chiamato il file delle note di ogni file sorgente nomeaux.gcno. Fare riferimento a
-fprofile-archi opzione sopra per una descrizione di nome aux e istruzioni su come
generare dati di copertura del test. I dati di copertura corrisponderanno più da vicino ai file di origine,
se non ottimizzi

-fdbg-cnt-elenco
Stampa il nome e il limite superiore del contatore per tutti i contatori di debug.

-fdbg-cnt=lista-controvalore
Imposta il limite superiore del contatore di debug interno. lista-controvalore è separato da virgole
lista di Nome:APPREZZIAMO coppie che imposta il limite superiore di ogni contatore di debug Nome a
APPREZZIAMO. Tutti i contatori di debug hanno il limite superiore iniziale di UINT_MAX, COSI ' dbg_cnt()
restituisce sempre true a meno che il limite superiore non sia impostato da questa opzione. ad es. con
-fdbg-cnt=dce:10,tail_call:0 dbg_cnt(dce) restituirà true solo per i primi 10
invocazioni

-accettabile-tipo-passare
-fdisabilita-tipo-passare=elenco-gamma
Questo è un insieme di opzioni di debug che vengono utilizzate per disabilitare/abilitare esplicitamente
passaggi di ottimizzazione. Per gli utenti del compilatore, opzioni regolari per abilitare/disabilitare i passaggi
dovrebbe essere usato invece.

*<-fdisable-ipa-passare>
Disabilita il pass ipa passare. passare è il nome del passaggio. Se lo stesso passaggio è statico
invocato nel compilatore più volte, il nome del passaggio dovrebbe essere aggiunto con a
numero progressivo a partire da 1.

*<-fdisable-rtl-passare>
*<-fdisable-rtl-passare=elenco-gamma>
Disabilita rtl pass passare. passare è il nome del passaggio. Se lo stesso passaggio è statico
invocato nel compilatore più volte, il nome del passaggio dovrebbe essere aggiunto con a
numero progressivo a partire da 1. elenco-gamma è un elenco separato da virgole di
intervalli di funzioni o nomi di assembler. Ogni intervallo è una coppia di numeri separati da a
colon. La gamma è inclusiva in entrambe le estremità. Se l'intervallo è banale, il numero
coppia può essere semplificata come un singolo numero. Se il nodo cgraph della funzione è uid is
rientrando in uno degli intervalli specificati, il passare è disabilitato per questo
funzione. Il uid è mostrato nell'intestazione della funzione di un file dump e il pass
i nomi possono essere scaricati usando l'opzione -fdump-pass.

*<-fdisable-tree-passare>
*<-fdisable-tree-passare=elenco-gamma>
Disabilita il passaggio dell'albero passare. Vedere -fdisable-rtl per la descrizione dell'opzione
argomenti.

*<-fenable-ipa-passare>
Abilita ipa pass passare. passare è il nome del passaggio. Se lo stesso passaggio è statico
invocato nel compilatore più volte, il nome del passaggio dovrebbe essere aggiunto con a
numero progressivo a partire da 1.

**<-fenable-rtl-passare>
**<-fenable-rtl-passare=elenco-gamma>
Abilita rtl pass passare. Vedere -fdisable-rtl per la descrizione dell'argomento opzione e
esempi.

*<-albero-fenable-passare>
*<-albero-fenable-passare=elenco-gamma>
Abilita passaggio albero passare. Vedere -fdisable-rtl per la descrizione degli argomenti delle opzioni.

# disabilita ccp1 per tutte le funzioni
-fdisable-albero-ccp1
# disabilita lo srotolamento completo per la funzione il cui uid del nodo cgraph è 1
-fenable-tree-cunroll=1
# disabilita gcse2 per le funzioni nei seguenti intervalli [1,1],
# [300,400] e [400,1000]
# disabilita gcse2 per le funzioni foo e foo2
-fdisable-rtl-gcse2=pippo,pippo2
# disabilita l'inserimento anticipato
-fdisable-albero-einline
# disabilita l'inline ipa
-fdisable-ipa-inline
# abilita lo srotolamento completo dell'albero
-fenable-albero-srotolare

-dlettere
-fdump-rtl-passare
Dice di eseguire dump di debug durante la compilazione nei momenti specificati da lettere. Questo
viene utilizzato per il debug dei passaggi basati su RTL del compilatore. I nomi dei file per la maggior parte
delle discariche vengono effettuate aggiungendo un numero di pass e una parola al nome dump, e il
i file vengono creati nella directory del file di output. Nota che il numero di pass è
calcolati in modo statico man mano che i passaggi vengono registrati nel gestore dei passaggi. Così il
la numerazione non è correlata all'ordine dinamico di esecuzione delle passate. In particolare,
un passaggio installato da un plugin potrebbe avere un numero superiore a 200 anche se eseguito abbastanza
presto. nome dump viene generato dal nome del file di output, se esplicitamente
specificato e non è un eseguibile, altrimenti è il nome di base della sorgente
file. Questi interruttori possono avere effetti diversi quando -E viene utilizzato per la preelaborazione.

I dump di debug possono essere abilitati con a -fdump-rtl interruttore o qualcosa del genere -d opzione lettere. Qui
sono le possibili lettere da usare in passare ed letteree il loro significato:

-fdump-rtl-allineamenti
Scarica dopo che sono stati calcolati gli allineamenti dei rami.

-fdump-rtl-asmcons
Eseguire il dump dopo aver corretto le istruzioni rtl che hanno vincoli in/out non soddisfatti.

-fdump-rtl-auto_inc_dec
Eseguire il dump dopo il rilevamento di auto-inc-dec. Questo passaggio viene eseguito solo su architetture che
avere istruzioni auto inc o auto dec.

-fdump-rtl-barriere
Scarica dopo aver ripulito le istruzioni della barriera.

-fdump-rtl-bbpart
Eseguire il dump dopo il partizionamento dei blocchi di base caldi e freddi.

-fdump-rtl-bbro
Dump dopo il riordino dei blocchi.

-fdump-rtl-btl1
-fdump-rtl-btl2
-fdump-rtl-btl1 ed -fdump-rtl-btl2 abilitare il dumping dopo il target dei due rami
passaggi di ottimizzazione del carico.

-fdump-rtl-bypass
Scarico dopo il bypass del salto e ottimizzazione del flusso di controllo.

-fdump-rtl-combina
Dump dopo il passaggio della combinazione di istruzioni RTL.

-fdump-rtl-compgotos
Scarica dopo aver duplicato i goto calcolati.

-fdump-rtl-ce1
-fdump-rtl-ce2
-fdump-rtl-ce3
-fdump-rtl-ce1, -fdump-rtl-ce2e -fdump-rtl-ce3 abilitare il dumping dopo le tre
se la conversione passa.

-fdump-rtl-cprop_hardreg
Dump dopo la propagazione della copia del registro cartaceo.

-fdump-rtl-csa
Scarica dopo aver combinato le regolazioni dello stack.

-fdump-rtl-cse1
-fdump-rtl-cse2
-fdump-rtl-cse1 ed -fdump-rtl-cse2 abilitare il dumping dopo i due comuni sub-
passaggi di eliminazione dell'espressione.

-fdump-rtl-dce
Eseguire il dump dopo l'eliminazione del codice morto autonomo.

-fdump-rtl-dbr
Dump dopo la pianificazione della filiale ritardata.

-fdump-rtl-dce1
-fdump-rtl-dce2
-fdump-rtl-dce1 ed -fdump-rtl-dce2 abilitare il dumping dopo i due negozi morti
passaggi di eliminazione.

-fdump-rtl-eh
Dump dopo la finalizzazione del codice di gestione EH.

-fdump-rtl-eh_range
Dump dopo la conversione delle regioni dell'intervallo di gestione EH.

-fdump-rtl-espandi
Dump dopo la generazione di RTL.

-fdump-rtl-fwprop1
-fdump-rtl-fwprop2
-fdump-rtl-fwprop1 ed -fdump-rtl-fwprop2 abilitare il dumping dopo i due forward
passaggi di propagazione.

-fdump-rtl-gcse1
-fdump-rtl-gcse2
-fdump-rtl-gcse1 ed -fdump-rtl-gcse2 abilitare il dumping dopo il comune globale
eliminazione della sottoespressione.

-fdump-rtl-init-regs
Dump dopo l'inizializzazione dei registri.

-fdump-rtl-initvals
Dump dopo il calcolo dei set di valori iniziali.

-fdump-rtl-into_cfglayout
Scarica dopo la conversione in modalità cfglayout.

-fdump-rtl-ira
Dump dopo l'allocazione del registro iterata.

-fdump-rtl-salto
Scarica dopo la seconda ottimizzazione del salto.

-fdump-rtl-loop2
-fdump-rtl-loop2 abilita il dump dopo che l'ottimizzazione del ciclo rtl è passata.

-fdump-rtl-mach
Eseguire il dump dopo aver eseguito il passaggio di riorganizzazione dipendente dalla macchina, se tale passaggio
esiste.

-fdump-rtl-mode_sw
Eseguire il dump dopo aver rimosso gli interruttori di modalità ridondanti.

-fdump-rtl-rnreg
Dump dopo la rinumerazione del registro.

-fdump-rtl-outof_cfglayout
Scarica dopo la conversione dalla modalità cfglayout.

-fdump-rtl-spioncino2
Discarica dopo il passaggio dello spioncino.

-fdump-rtl-postreload
Scarica dopo le ottimizzazioni post-ricarica.

-fdump-rtl-pro_and_epilogo
Eseguire il dump dopo aver generato la funzione prologhi ed epiloghi.

-fdump-rtl-regmove
Dump dopo il passaggio di spostamento del registro.

-fdump-rtl-sched1
-fdump-rtl-sched2
-fdump-rtl-sched1 ed -fdump-rtl-sched2 abilitare il dump dopo il blocco di base
pass di programmazione.

-fdump-rtl-vedi
Dump dopo l'eliminazione dell'estensione del segno.

-fdump-rtl-seqabstr
Dump dopo il rilevamento della sequenza comune.

-fdump-rtl-accorcia
Scarica dopo aver accorciato i rami.

-fdump-rtl-fratello
Eseguire il dump dopo l'ottimizzazione delle chiamate tra fratelli.

-fdump-rtl-split1
-fdump-rtl-split2
-fdump-rtl-split3
-fdump-rtl-split4
-fdump-rtl-split5
-fdump-rtl-split1, -fdump-rtl-split2, -fdump-rtl-split3, -fdump-rtl-split4 ed
-fdump-rtl-split5 abilitare il dumping dopo cinque turni di suddivisione delle istruzioni.

-fdump-rtl-sms
Dump dopo la pianificazione del modulo. Questo passaggio viene eseguito solo su alcune architetture.

-fdump-rtl-stack
Scarica dopo la conversione dai registri "flat register file" di GCC agli x87
registri a pila. Questo passaggio viene eseguito solo su varianti x86.

-fdump-rtl-sottoreg1
-fdump-rtl-sottoreg2
-fdump-rtl-sottoreg1 ed -fdump-rtl-sottoreg2 abilitare il dumping dopo i due subreg
passaggi di espansione.

-fdump-rtl-unshare
Scarica dopo che tutto rtl è stato annullato.

-fdump-rtl-vartrack
Dump dopo l'inseguimento variabile.

-fdump-rtl-vregs
Eseguire il dump dopo aver convertito i registri virtuali in registri rigidi.

-fdump-rtl-web
Dump dopo la suddivisione dell'intervallo in tempo reale.

-fdump-rtl-regclass
-fdump-rtl-subregs_of_mode_init
-fdump-rtl-subregs_of_mode_finish
-fdump-rtl-dfinit
-fdump-rtl-finish
Questi dump sono definiti ma producono sempre file vuoti.

-in
-fdump-rtl-tutto
Produci tutte le discariche sopra elencate.

-da Annota l'output dell'assemblatore con varie informazioni di debug.

-dd Scarica tutte le definizioni macro, alla fine della preelaborazione, oltre al normale
produzione.

-dH Produce un core dump ogni volta che si verifica un errore.

-dp Annota l'output dell'assemblatore con un commento che indica quale modello e
è stata utilizzata l'alternativa. Viene stampata anche la lunghezza di ciascuna istruzione.

-dP Scarica l'RTL nell'output dell'assemblatore come commento prima di ogni istruzione. Anche
si accende -dp annotazione.

-dv Per ciascuno degli altri file di dump indicati (-fdump-rtl-passare), discarica a
rappresentazione del grafico del flusso di controllo adatto per la visualizzazione con VCG a
file.pass.vcg.

-dx Basta generare RTL per una funzione invece di compilarla. Solitamente utilizzato con
-fdump-rtl-espandi.

-fdump-noaddr
Quando si eseguono dump di debug, eliminare l'output dell'indirizzo. Questo rende più fattibile
usa diff sui dump di debug per le chiamate del compilatore con diversi binari del compilatore
e/o diverse posizioni di inizio testo / bss / data / heap / stack / dso.

-fdump-non numerato
Quando si eseguono dump di debug, eliminare i numeri di istruzione e l'output degli indirizzi. Questo
rende più fattibile l'uso di diff sui dump di debug per le chiamate del compilatore con
diverse opzioni, in particolare con e senza -g.

-fdump-link-non-numerati
Quando si eseguono dump di debug (vedere -d opzione sopra), sopprimere i numeri di istruzione per il
collegamenti alle istruzioni precedenti e successive in sequenza.

-fdump-unità-di-traduzione (solo C++)
-fdump-unità-di-traduzione-Opzioni (solo C++)
Scarica una rappresentazione della struttura ad albero per l'intera unità di traduzione in un file.
Il nome del file viene creato aggiungendo .Voi al nome del file di origine e il file è
creato nella stessa directory del file di output. Se la -Opzioni viene utilizzata la forma,
Opzioni controlla i dettagli del dump come descritto per il -fdump-albero opzioni.

-fdump-classe-gerarchia (solo C++)
-fdump-gerarchia-classi-Opzioni (solo C++)
Scarica una rappresentazione della gerarchia di ogni classe e del layout della tabella delle funzioni virtuali in a
file. Il nome del file viene creato aggiungendo .classe al nome del file sorgente e il file
viene creato nella stessa directory del file di output. Se la -Opzioni viene utilizzata la forma,
Opzioni controlla i dettagli del dump come descritto per il -fdump-albero opzioni.

-fdump-ipa-interruttore
Controllare il dumping nelle varie fasi dell'albero linguistico di analisi interprocedurale per a
file. Il nome del file viene generato aggiungendo un suffisso specifico per lo switch alla sorgente
nome file e il file viene creato nella stessa directory del file di output. Il
sono possibili i seguenti dump:

contro tutti i Abilita tutti i dump di analisi interprocedurali.

cgrafico
Scarica le informazioni sull'ottimizzazione del grafico delle chiamate, la rimozione delle funzioni inutilizzate e
decisioni in linea.

inline
Dump dopo l'inlining della funzione.

-fdump-pass
Scarica l'elenco dei passaggi di ottimizzazione attivati ​​e disattivati ​​dalla corrente
opzioni della riga di comando.

-statistiche-fdump-opzione
Abilita e controlla il dump delle statistiche sui passaggi in un file separato. Il nome del file è
generato aggiungendo un suffisso che termina in .statistiche al nome del file di origine e
file viene creato nella stessa directory del file di output. Se la -opzione la forma è
Usato, -statistiche farà sì che i contatori vengano sommati sull'intera unità di compilazione mentre
-dettagli scaricherà ogni evento man mano che i passaggi li generano. Il valore predefinito senza
l'opzione è sommare i contatori per ogni funzione compilata.

-fdump-albero-interruttore
-fdump-albero-interruttore-Opzioni
Controllare il dumping nelle varie fasi dell'elaborazione dell'albero linguistico intermedio per
un file. Il nome del file viene generato aggiungendo un suffisso specifico dell'interruttore al
nome del file di origine e il file viene creato nella stessa directory del file di output.
Se l' -Opzioni viene utilizzata la forma, Opzioni è un elenco di - opzioni separate che controllano
i dettagli della discarica. Non tutte le opzioni sono applicabili a tutti i dump; quelli che sono
non significativo verrà ignorato. Sono disponibili le seguenti opzioni

indirizzo
Stampa l'indirizzo di ogni nodo. Di solito questo non è significativo in quanto cambia
in base all'ambiente e al file sorgente. Il suo uso principale è per legare a
dump con un ambiente di debug.

nomenome
Se "DECL_ASSEMBLER_NAME" è stato impostato per un determinato decl, utilizzalo nel dump
invece di "DECL_NAME". Il suo uso principale è la facilità d'uso lavorando a ritroso da
nomi alterati nel file di assieme.

sottile
Inibire il dumping di membri di un ambito o di un corpo di una funzione semplicemente perché
portata è stata raggiunta. Scarica tali articoli solo quando sono direttamente raggiungibili da
qualche altra strada. Quando si scaricano alberi con belle stampe, questa opzione inibisce lo scarico
gli organi delle strutture di controllo.

crudo Stampa una rappresentazione grezza dell'albero. Per impostazione predefinita, gli alberi sono stampati in modo grazioso
una rappresentazione tipo C.

dettagli
Abilita dump più dettagliati (non rispettato da ogni opzione di dump).

stats
Abilita il dump di varie statistiche sul pass (non onorato da ogni dump
opzione).

blocchi
Abilita la visualizzazione dei limiti di blocco di base (disabilitato nei dump non elaborati).

vop
Abilita la visualizzazione degli operandi virtuali per ogni istruzione.

lino
Abilita la visualizzazione dei numeri di riga per le istruzioni.

uid Abilita la visualizzazione dell'ID univoco ("DECL_UID") per ogni variabile.

verboso
Abilita la visualizzazione del dump dell'albero per ogni istruzione.

eh Abilita la visualizzazione del numero di regione EH che contiene ogni istruzione.

scev
Abilita la visualizzazione dei dettagli dell'analisi dell'evoluzione scalare.

contro tutti i Attiva tutte le opzioni, tranne crudo, sottile, verboso ed lino.

Sono possibili i seguenti dump dell'albero:

i
Eseguire il dump prima di qualsiasi ottimizzazione basata su albero, a file.originale.

ottimizzati
Scarica dopo tutta l'ottimizzazione basata sugli alberi, a file.ottimizzato.

mentire
Scarica ogni funzione prima e dopo il passaggio di gimplificazione in un file. Il file
il nome è fatto aggiungendo .gimple al nome del file di origine.

CFG Scarica il grafico del flusso di controllo di ciascuna funzione in un file. Il nome del file è creato da
aggiungendo .cfg al nome del file di origine.

vcg Scarica il grafico del flusso di controllo di ciascuna funzione in un file in formato VCG. Il file
il nome è fatto aggiungendo .vcg al nome del file di origine. Nota che se il file
contiene più di una funzione, il file generato non può essere utilizzato direttamente da
VCG. Dovrai tagliare e incollare il grafico di ciascuna funzione in un proprio separato
prima il file.

ch Scarica ogni funzione dopo aver copiato le intestazioni del ciclo. Il nome del file viene creato aggiungendo
. Ch al nome del file di origine.

ssa Scarica le informazioni relative alla SSA in un file. Il nome del file viene creato aggiungendo . Ssa
al nome del file di origine.

alias
Scarica le informazioni sull'aliasing per ogni funzione. Il nome del file viene creato aggiungendo
.alias al nome del file di origine.

ccp Scarica ogni funzione dopo CCP. Il nome del file viene creato aggiungendo .ccp Vai all’email
nome del file di origine.

storeccp
Scarica ogni funzione dopo STORE-CCP. Il nome del file viene creato aggiungendo .storeccp
al nome del file di origine.

pre Alberi di scarico dopo l'eliminazione parziale della ridondanza. Il nome del file è creato da
aggiungendo .pre al nome del file di origine.

fre Scaricare gli alberi dopo l'eliminazione completa della ridondanza. Il nome del file viene creato aggiungendo
.fre al nome del file di origine.

copyprop
Scarica gli alberi dopo la propagazione della copia. Il nome del file viene creato aggiungendo .copyprop
al nome del file di origine.

store_copyprop
Scarica gli alberi dopo la propagazione della copia del negozio. Il nome del file viene creato aggiungendo
.store_copyprop al nome del file di origine.

dc Scarica ogni funzione dopo l'eliminazione del codice morto. Il nome del file è creato da
aggiungendo .dce al nome del file di origine.

paraspruzzi
Scarica ogni funzione dopo aver aggiunto la strumentazione del paraspruzzi. Il nome del file è creato da
aggiungendo .paraspruzzi al nome del file di origine.

SRA Scarica ogni funzione dopo aver eseguito la sostituzione scalare degli aggregati. Il file
il nome è fatto aggiungendo .sra al nome del file di origine.

Lavello
Scarica ogni funzione dopo aver eseguito l'affondamento del codice. Il nome del file è creato da
aggiungendo .Lavello al nome del file di origine.

dom Scarica ogni funzione dopo aver applicato le ottimizzazioni dell'albero del dominatore. Il nome del file è
fatto aggiungendo .dom al nome del file di origine.

dire Scarica ogni funzione dopo aver applicato l'eliminazione dei depositi morti. Il nome del file è fatto
aggiungendo .dse al nome del file di origine.

phiopt
Scarica ogni funzione dopo aver ottimizzato i nodi PHI in codice straightline. Il file
il nome è fatto aggiungendo .phiopt al nome del file di origine.

elica di prua
Scarica ogni funzione dopo aver propagato in avanti le variabili monouso. Il nome del file
è fatto aggiungendo .elica di prua al nome del file di origine.

rinomina
Scarica ogni funzione dopo aver applicato l'ottimizzazione della ridenominazione della copia. Il nome del file è
fatto aggiungendo .copyrename al nome del file di origine.

NRV Scarica ogni funzione dopo aver applicato l'ottimizzazione del valore restituito denominato su generic
alberi. Il nome del file viene creato aggiungendo .nv al nome del file di origine.

vect
Scarica ogni funzione dopo aver applicato la vettorizzazione dei loop. Il nome del file è fatto
aggiungendo .vet al nome del file di origine.

slp Scarica ogni funzione dopo aver applicato la vettorizzazione dei blocchi di base. Il nome del file è
fatto aggiungendo .slp al nome del file di origine.

VRP Scarica ogni funzione dopo la propagazione dell'intervallo di valori (VRP). Il nome del file è creato da
aggiungendo .vrp al nome del file di origine.

contro tutti i Abilita tutti i dump dell'albero disponibili con i flag forniti in questa opzione.

-ftree-vettoriatore-verbose=n
Questa opzione controlla la quantità di output di debug che il vectorizer stampa. Questo
le informazioni vengono scritte nell'errore standard, a meno che -fdump-albero-tutto or -fdump-albero-vect
è specificato, nel qual caso viene emesso nel consueto file di elenco dei dump, .vet. For
n=0 non vengono riportate informazioni diagnostiche. Se n=1 il vectorizer riporta ogni ciclo
che è stato vettorializzato e il numero totale di loop che sono stati vettorializzati. Se n=2 il
vectorizer riporta anche i loop non vettorizzati che hanno superato la prima fase di analisi
(vect_analyze_loop_form) - cioè numerabile, più interno, single-bb, single-entry/exit
loop. Questo è lo stesso livello di verbosità che -fdump-tree-vect-stats usi. Più alto
livelli di verbosità significano o più informazioni scaricate per ogni ciclo segnalato, o lo stesso
quantità di informazioni riportate per più loop: if n=3, modello di costo del vettorizzatore
informazioni sono riportate. Se n=4, le informazioni relative all'allineamento vengono aggiunte a
rapporti. Se n=5, informazioni relative ai riferimenti ai dati (ad es. dipendenze della memoria, memoria
access-patterns) viene aggiunto ai report. Se n=6, il vectorizer riporta anche non-
loop più interni vettorizzati che non hanno superato la prima fase di analisi (cioè, potrebbero non
essere numerabile o avere un flusso di controllo complicato). Se n=7, il vectorizer riporta
anche loop nidificati non vettorizzati. Se n=8, le informazioni relative a SLP vengono aggiunte a
rapporti. Per n=9, tutte le informazioni che il vectorizer genera durante la sua analisi
e viene segnalata la trasformazione. Questo è lo stesso livello di verbosità che
-fdump-tree-vect-dettagli utilizza.

-frandom-seme=stringa
Questa opzione fornisce un seme che GCC usa quando altrimenti userebbe numeri casuali.
Viene utilizzato per generare determinati nomi di simboli che devono essere diversi in ogni
file compilato. Viene anche utilizzato per inserire timbri univoci nei file di dati di copertura e il
file oggetto che li producono. Puoi usare il -frandom-seme possibilità di produrre
file oggetto riproducibilmente identici.

I stringa dovrebbe essere diverso per ogni file che compili.

-fsched-verbose=n
Sui target che utilizzano la pianificazione delle istruzioni, questa opzione controlla la quantità di
l'output di debug viene stampato dallo scheduler. Queste informazioni vengono scritte nell'errore standard,
salvo che -fdump-rtl-sched1 or -fdump-rtl-sched2 è specificato, nel qual caso viene emesso
al solito file di elenco dei dump, .sched1 or .sched2 rispettivamente. Tuttavia per n
maggiore di nove, l'output viene sempre stampato con l'errore standard.

Nel n maggiore di zero, -fsched-verboso emette le stesse informazioni di
-fdump-rtl-sched1 ed -fdump-rtl-sched2. For n maggiore di uno, emette anche basic
probabilità di blocco, informazioni dettagliate sull'elenco pronto e informazioni su unità/insn. Per n
maggiore di due, include RTL al punto di interruzione, flusso di controllo e informazioni sulle regioni. e
per n più di quattro, -fsched-verboso include anche informazioni sulla dipendenza.

-salva-temps
-save-temps=cwd
Memorizza permanentemente i soliti file intermedi "temporanei"; mettili nella corrente
directory e denominarli in base al file di origine. Quindi, compilando foo.c con -c
-salva-temps produrrebbe file foo.i ed foo.s, così come foo.o. Questo crea un file
preelaborato foo.i file di output anche se il compilatore ora normalmente usa an
preprocessore integrato.

Se utilizzato in combinazione con il -x opzione della riga di comando, -salva-temps è ragionevole
abbastanza per evitare di sovrascrivere un file sorgente di input con la stessa estensione di un
file intermedio. Il file intermedio corrispondente può essere ottenuto rinominandolo
il file sorgente prima dell'uso -salva-temps.

Se invochi GCC in parallelo, compilando diversi file sorgente che condividono a
nome di base comune in diverse sottodirectory o lo stesso file sorgente compilato per
più destinazioni di output, è probabile che i diversi compilatori paralleli lo facciano
interferiscono tra loro e sovrascrivono i file temporanei. Ad esempio:

gcc -save-temps -o outdir1/foo.o indir1/foo.c&
gcc -save-temps -o outdir2/foo.o indir2/foo.c&

può comportare foo.i ed foo.o essere scritti contemporaneamente da entrambi i compilatori.

-salva-temps=obj
Memorizza permanentemente i soliti file intermedi "temporanei". Se la -o viene utilizzata l'opzione,
i file temporanei sono basati sul file oggetto. Se la -o l'opzione non è utilizzata, il
-salva-temps=obj l'interruttore si comporta come -salva-temps.

Per esempio:

gcc -save-temps=obj -c foo.c
gcc -save-temps=obj -c bar.c -o dir/xbar.o
gcc -save-temps=obj foobar.c -o dir2/yfoobar

creerebbe foo.i, foo.s, dir/xbar.i, dir/xbar.s, dir2/yfoobar.i, dir2/yfoobar.se
dir2/yfoobar.o.

-tempo[=filetto]
Riporta il tempo di CPU impiegato da ogni sottoprocesso nella sequenza di compilazione. Per C
file sorgente, questo è il compilatore corretto e l'assemblatore (più il linker se il collegamento è
fatto).

Senza la specifica di un file di output, l'output ha questo aspetto:

# cc1 0.12 0.01
# come 0.00 0.01

Il primo numero su ogni riga è il "tempo utente", ovvero il tempo impiegato per eseguire il
programma stesso. Il secondo numero è "tempo di sistema", il tempo impiegato per l'esecuzione dell'operazione
routine di sistema per conto del programma. Entrambi i numeri sono in secondi.

Con la specifica di un file di output, l'output viene aggiunto al file denominato,
e sembra così:

0.12 0.01 cc1
0.00 0.01 as

L'"ora dell'utente" e l'"ora del sistema" vengono spostate prima del nome del programma e il
vengono visualizzate le opzioni passate al programma, in modo che si possa in seguito dire quale file era
in fase di compilazione e con quali opzioni.

-fvar-tracciamento
Esegui il passaggio di monitoraggio della variabile. Calcola dove sono memorizzate le variabili in ogni posizione
nel codice. Vengono quindi generate migliori informazioni di debug (se le informazioni di debug)
formato supporta queste informazioni).

È abilitato di default quando si compila con l'ottimizzazione (-Voi, -O, -O2, ...),
informazioni di debug (-g) e il formato delle informazioni di debug lo supporta.

-fvar-tracciamento-assegnazioni
Annotare le assegnazioni alle variabili utente all'inizio della compilazione e tentare di portarle
le annotazioni su tutta la compilation fino alla fine, nel tentativo
per migliorare le informazioni di debug durante l'ottimizzazione. Uso di -gnano-4 è consigliato insieme
con esso.

Può essere abilitato anche se il var-tracking è disabilitato, nel qual caso le annotazioni saranno
creato e mantenuto, ma scartato alla fine.

-fvar-tracciamento-assegnazioni-toggle
Toggle -fvar-tracciamento-assegnazioni, allo stesso modo -gattiva/disattiva alterna -g.

-stampa-nome-file=biblioteca
Stampa il nome assoluto completo del file della libreria biblioteca che verrebbe usato quando
collegamento --- e non fare nient'altro. Con questa opzione, GCC non compila né collega
nulla; stampa solo il nome del file.

-stampa-multi-directory
Stampa il nome della directory corrispondente alla multilib selezionata da qualsiasi altro switch
presente nella riga di comando. Questa directory dovrebbe esistere in GCC_EXEC_PREFIX.

-stampa-multi-lib
Stampa la mappatura dai nomi delle directory multilib alle opzioni del compilatore che li abilitano.
Il nome della directory è separato dagli interruttori da ;, e ogni interruttore inizia con un
@ invece del -, senza spazi tra più interruttori. Questo dovrebbe
facilità di elaborazione della shell.

-stampa-directory-multi-os
Stampa il percorso delle librerie del sistema operativo per la multilib selezionata, relativa ad alcune lib
sottodirectory. Se le librerie del sistema operativo sono presenti nel lib sottodirectory e nessuna multilibs
sono usati, questo di solito è solo ., se le librerie del sistema operativo sono presenti in libsuffisso fratello
directory che vengono stampate, ad es ../lib64, ../ lib or ../lib32, o se le librerie del sistema operativo sono
presente in lib/sottodirectory sottodirectory che stampa ad es amd64, sparcv9 or ev6.

-stampa-multiarcata
Stampa il percorso delle librerie del sistema operativo per il multiarch selezionato, relativo ad alcuni lib
sottodirectory.

-print-nome-programma=Programma
Come -stampa-nome-file, ma cerca un programma come cpp.

-print-libgcc-nome-file
Uguale a -nome-file-stampa=libgcc.a.

Questo è utile quando usi -nostdlib or -nodefaultlibs ma vuoi collegarti con
libgcc.a. Tu puoi fare

gcc -nostdlib ... `gcc -print-libgcc-nome-file`

-stampa-dir-ricerca
Stampa il nome della directory di installazione configurata e un elenco di programmi e
directory delle biblioteche gcc cercherà --- e non farà nient'altro.

Questo è utile quando gcc stampa il messaggio di errore installazione problema, non può exec
cpp0: Non tale filetto or elenco. Per risolvere questo è necessario mettere CPP0 e la
altri componenti del compilatore dove gcc si aspetta di trovarli, oppure puoi impostare il
variabile d'ambiente GCC_EXEC_PREFIX nella directory in cui li hai installati. non farlo
dimentica il finale /.

-print-sysroot
Stampa la directory sysroot di destinazione che verrà utilizzata durante la compilazione. Questo è il
sysroot di destinazione specificato al momento della configurazione o utilizzando il --sysroot opzione,
possibilmente con un suffisso extra che dipende dalle opzioni di compilazione. Se nessun obiettivo
sysroot è specificato, l'opzione non stampa nulla.

-print-sysroot-headers-suffisso
Stampa il suffisso aggiunto alla sysroot di destinazione durante la ricerca di intestazioni, o dai un
errore se il compilatore non è configurato con un tale suffisso --- e non fa nulla
altro.

-macchina del dump
Stampa la macchina di destinazione del compilatore (ad esempio, i686-pc-linux-gnu)---e non farlo
qualunque altra cosa.

-versione dump
Stampa la versione del compilatore (ad esempio, 3.0)---e non fare nient'altro.

-spec
Stampa le specifiche integrate del compilatore --- e non fare nient'altro. (Questo è usato quando
GCC stesso è in costruzione.)

-feliminare-i-tipi-debug-inutilizzati
Normalmente, quando si produce un output DWARF2, GCC emetterà informazioni di debug per tutti
tipi dichiarati in un'unità di compilazione, indipendentemente dal fatto che siano effettivamente o meno
utilizzato in quell'unità di compilazione. A volte questo è utile, come se, nel debugger,
vuoi trasmettere un valore a un tipo che non è effettivamente utilizzato nel tuo programma (ma è
dichiarato). Più spesso, tuttavia, ciò si traduce in una notevole quantità di spazio sprecato.
Con questa opzione, GCC eviterà di produrre l'output del simbolo di debug per i tipi che sono
da nessuna parte utilizzato nel file sorgente in fase di compilazione.

Opzioni Che Control OTTIMIZZAZIONE
Queste opzioni controllano vari tipi di ottimizzazioni.

Senza alcuna opzione di ottimizzazione, l'obiettivo del compilatore è ridurre il costo di compilazione
e per fare in modo che il debug produca i risultati attesi. Le dichiarazioni sono indipendenti: se tu
arrestare il programma con un punto di interruzione tra le istruzioni, è quindi possibile assegnare un nuovo valore a
qualsiasi variabile o cambia il contatore del programma in qualsiasi altra istruzione nella funzione e ottieni
esattamente i risultati che ti aspetteresti dal codice sorgente.

L'attivazione dei flag di ottimizzazione fa sì che il compilatore tenti di migliorare le prestazioni e/o
dimensione del codice a scapito del tempo di compilazione ed eventualmente della possibilità di eseguire il debug del
.

Il compilatore esegue l'ottimizzazione in base alla conoscenza che ha del programma.
La compilazione di più file contemporaneamente in una singola modalità file di output consente al compilatore di utilizzare
informazioni ottenute da tutti i file durante la compilazione di ciascuno di essi.

Non tutte le ottimizzazioni sono controllate direttamente da un flag. Solo ottimizzazioni che hanno a
flag sono elencati in questa sezione.

La maggior parte delle ottimizzazioni sono abilitate solo se un -O livello è impostato sulla riga di comando. Altrimenti
sono disattivati, anche se vengono specificati singoli flag di ottimizzazione.

A seconda del target e di come è stato configurato GCC, un insieme leggermente diverso di
le ottimizzazioni possono essere abilitate ad ogni -O livello rispetto a quelli qui elencati. Puoi invocare GCC
con -Q --help=ottimizzatori per scoprire l'esatto insieme di ottimizzazioni abilitate su
ogni livello.

-O
-O1 Ottimizzare. L'ottimizzazione della compilazione richiede un po' più di tempo e molta più memoria per
una grande funzione.

Con -O, il compilatore cerca di ridurre la dimensione del codice e il tempo di esecuzione, senza eseguire
tutte le ottimizzazioni che richiedono molto tempo per la compilazione.

-O attiva i seguenti flag di ottimizzazione:

-fauto-inc-dec -fcompare-elimina -fcprop-registri -fdce -fdefer-pop -framo-ritardato
-fdse -fguess-ramo-probabilità -fif-conversione2 -fif-conversione -fipa-puro-const
-fipa-profilo -fipa-riferimento -fmerge-costanti -fsplit-wide-tipi -ftree-bit-ccp
-ftree-built-in-call-dce -ftree-ccp -ftree-ch -ftree-rinominacopia -ftree-dce
-ftree-dominatore-opt -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -ftree-sra
-ftree-pta -ftree-ter -divertimento alla volta

-O si accende anche -puntatore-frame-fomit su macchine dove ciò non interferisce
con debug.

-O2 Ottimizza ancora di più. GCC esegue quasi tutte le ottimizzazioni supportate che non lo fanno
comportano un compromesso spazio-velocità. Paragonato a -O, questa opzione aumenta entrambi
tempo di compilazione e le prestazioni del codice generato.

-O2 attiva tutti i flag di ottimizzazione specificati da -O. Si accende anche quanto segue
flag di ottimizzazione: -fthread-salta -funzioni-false -falsi-salti -falign-loop
-etichette-false -fcaller-salva -salto incrociato -fcse-segue-salti -fcse-salta-blocchi
-fdelete-controlli-puntatore-null -fdevirtualizza -ottimizzazioni-economiche -fgcse
-fgcse-lm -finline-piccole-funzioni -findirect-inline -fipa-sra
-A-CALLS FOPTIMIZZAZIONE -fpartial-inline -fspioncino2 - Fregmuovi -blocchi-freddo
-funzioni-freorder -frerun-cse-dopo-loop -fsched-interblocco -fsched-spec
-fschedule-insns -fschedule-insns2 -fstrict-alias -fstrict-overflow
-ftree-switch-conversione -fusione a coda di albero -ftree-pre -ftree-vrp

Si prega di notare l'avviso sotto -fgcse sull'invocazione -O2 su programmi che utilizzano computer
andare a S.

NOTA: in Ubuntu 8.10 e versioni successive, -D_FORTIFY_SOURCE=2 è impostato di default, ed è
attivato quando -O è impostato su 2 o più. Ciò consente ulteriore tempo di compilazione e
il runtime controlla diverse funzioni libc. Per disabilitare, specificare sia
-U_FORTIFY_SOURCE or -D_FORTIFY_SOURCE=0.

-O3 Ottimizza ancora di più. -O3 attiva tutte le ottimizzazioni specificate da -O2 e si accende anche
, il -funzioni-finline, -funswitch-loop, -fpredictive-comune, -fgcse-dopo-reload,
-ftree-vettorizzare, -ftree-parziale-pre ed -fipa-cp-clone opzioni.

-O0 Riduci i tempi di compilazione e fai in modo che il debug produca i risultati previsti. Questo è il
predefinito.

-Voi Ottimizza per le dimensioni. -Voi abilita tutti -O2 ottimizzazioni che in genere non aumentano
dimensione del codice. Esegue inoltre ulteriori ottimizzazioni progettate per ridurre le dimensioni del codice.

-Voi disabilita i seguenti flag di ottimizzazione: -funzioni-false -falsi-salti
-falign-loop -etichette-false -blocchi-freddo -blocchi-e-partizioni di freorder
-fprefetch-loop-array -ftree-vect-loop-versione

- Veloce
Ignora il rispetto degli standard rigorosi. - Veloce abilita tutti -O3 ottimizzazioni. È anche
abilita ottimizzazioni non valide per tutti i programmi conformi agli standard. Esso
si accende -fast-matematica e il Fortran-specifico -fno-protect-parents ed -fstack-array.

Se usi più -O opzioni, con o senza numeri di livello, l'ultima di queste opzioni è
quello che è efficace.

Opzioni del modulo -fbandiera specificare flag indipendenti dalla macchina. La maggior parte delle bandiere ha entrambi
forme positive e negative; la forma negativa di -foo sarebbe -fno-pippo. Sul tavolo
di seguito, è elencato solo uno dei moduli, quello che di solito utilizzerai. Puoi capire
l'altra forma rimuovendo no- o aggiungendolo.

Le seguenti opzioni controllano ottimizzazioni specifiche. Sono attivati ​​da -O
opzioni o sono correlati a quelli che lo sono. Puoi usare le seguenti bandiere nel raro
casi in cui si desidera una "messa a punto" delle ottimizzazioni da eseguire.

-fno-default-inline
Non rendere inline le funzioni membro per impostazione predefinita semplicemente perché sono definite all'interno
l'ambito della classe (solo C++). Altrimenti, quando specifichi -O, funzioni membro definite
all'interno dell'ambito della classe sono compilati in linea per impostazione predefinita; cioè, non è necessario aggiungere inline
davanti al nome della funzione membro.

-fno-defer-pop
Inserisci sempre gli argomenti per ogni chiamata di funzione non appena quella funzione ritorna. Per
macchine che devono visualizzare argomenti dopo una chiamata di funzione, il compilatore normalmente consente
gli argomenti si accumulano nello stack per diverse chiamate di funzione e li fa apparire tutti a
una volta.

Disabilitato ai livelli -O, -O2, -O3, -Voi.

-in avanti-propagare
Eseguire un passaggio di propagazione in avanti su RTL. Il pass cerca di combinare due istruzioni
e verifica se il risultato può essere semplificato. Se lo svolgimento del ciclo è attivo, due passaggi
vengono eseguiti e il secondo è programmato dopo lo srotolamento del ciclo.

Questa opzione è abilitata per impostazione predefinita ai livelli di ottimizzazione -O, -O2, -O3, -Voi.

-ffp-contratto=style
-ffp-contratto=off disabilita la contrazione delle espressioni in virgola mobile. -ffp-contratto=veloce
consente la contrazione dell'espressione in virgola mobile come la formazione di moltiplicazione aggiunta fusa
operazioni se la destinazione dispone del supporto nativo per esse. -ffp-contratto=on Abilita
contrazione dell'espressione in virgola mobile se consentita dallo standard del linguaggio. Questo è
attualmente non implementato e trattato pari a -ffp-contratto=off.

L'impostazione predefinita è -ffp-contratto=veloce.

-puntatore-frame-fomit
Non tenere il puntatore del frame in un registro per le funzioni che non ne hanno bisogno. Questo
evita le istruzioni per salvare, impostare e ripristinare i puntatori dei frame; fa anche un
registro extra disponibile in molte funzioni. It anche fa debug impossibile on
alcuni e molti altri.

Su alcune macchine, come il VAX, questo flag non ha effetto, perché lo standard
la sequenza di chiamata gestisce automaticamente il puntatore al frame e nulla viene salvato da
facendo finta che non esista. La macro di descrizione della macchina "FRAME_POINTER_REQUIRED"
controlla se una macchina di destinazione supporta questo flag.

A partire dalla versione 4.6 di GCC, l'impostazione predefinita (quando non si esegue l'ottimizzazione per le dimensioni) per
I target Linux x32 a 86 bit e Darwin x32 a 86 bit sono stati modificati in
-puntatore-frame-fomit. L'impostazione predefinita può essere ripristinata a -fno-omit-frame-pointer by
configurare GCC con il --enable-frame-pointer configurare l'opzione.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-A-CALLS FOPTIMIZZAZIONE
Ottimizza le chiamate ricorsive di pari livello e di coda.

Abilitato ai livelli -O2, -O3, -Voi.

-fno-in linea
Non espandere alcuna funzione in linea a parte quelle contrassegnate con "always_inline"
attributo. Questa è l'impostazione predefinita quando non si esegue l'ottimizzazione.

Le singole funzioni possono essere esentate dall'inline contrassegnandole con la "noinline"
attributo.

-finline-piccole-funzioni
Integra le funzioni nei chiamanti quando il loro corpo è più piccolo del previsto
codice di chiamata della funzione (quindi la dimensione complessiva del programma si riduce). Il compilatore
decide euristicamente quali funzioni sono abbastanza semplici da valere la pena di essere integrate in
Da questa parte. Questo inline si applica a tutte le funzioni, anche a quelle non dichiarate inline.

Abilitato a livello -O2.

-findirect-inline
Inline anche chiamate indirette che si scoprono conosciute in fase di compilazione grazie a
inline precedente. Questa opzione ha effetto solo quando l'inline stesso è attivato
dal -funzioni-finline or -finline-piccole-funzioni opzioni.

Abilitato a livello -O2.

-funzioni-finline
Considera tutte le funzioni per l'inline, anche se non sono dichiarate inline. Il
Il compilatore decide euristicamente quali funzioni vale la pena integrare in questo modo.

Se tutte le chiamate a una data funzione sono integrate e la funzione è dichiarata
"static", quindi la funzione non viene normalmente emessa come codice assembler a sé stante.

Abilitato a livello -O3.

-funzioni-finline-chiamate-una volta
Considera tutte le funzioni "statiche" chiamate una volta per essere incorporate nel chiamante anche se
non sono contrassegnati come "in linea". Se una chiamata a una data funzione è integrata, allora il
la funzione non viene emessa come codice assembler a sé stante.

Abilitato ai livelli -O1, -O2, -O3 ed -Voi.

-fearly-inline
Funzioni in linea contrassegnate da "always_inline" e funzioni il cui corpo sembra più piccolo di
l'overhead della chiamata di funzione prima di farlo -fprofile-genera strumentazione e
vero passaggio in linea. Ciò rende la profilazione significativamente più economica e di solito
inline più velocemente su programmi con grandi catene di funzioni wrapper annidate.

Abilitato per impostazione predefinita.

-fipa-sra
Eseguire la sostituzione scalare interprocedurale degli aggregati, la rimozione dei parametri non utilizzati
e sostituzione dei parametri passati per riferimento con parametri passati per valore.

Abilitato ai livelli -O2, -O3 ed -Voi.

-fine-limit=n
Per impostazione predefinita, GCC limita la dimensione delle funzioni che possono essere incorporate. Questo flag permette
controllo grossolano di questo limite. n è la dimensione delle funzioni che possono essere inline in
numero di pseudo istruzioni.

L'inlining è effettivamente controllato da una serie di parametri, che possono essere specificati
individualmente usando --parami Nome=APPREZZIAMO. -fine-limit=n opzione imposta alcuni di
questi parametri come segue:

max-inline-insns-singolo
è impostato su n/ 2.

Max-Inline-Insns-Auto
è impostato su n/ 2.

Vedi sotto per una documentazione dei singoli parametri che controllano l'inlining e
per i valori di default di questi parametri.

Nota: potrebbe non esserci alcun valore per -limite-finline che si traduce in un comportamento predefinito.

Nota: la pseudo istruzione rappresenta, in questo particolare contesto, un abstract
misurazione della dimensione della funzione. Non rappresenta in alcun modo un conteggio di assemblaggio
istruzioni e come tale il suo significato esatto potrebbe cambiare da una versione a un'altra
un'altra.

-fno-keep-inline-dllexport
Questa è una versione più fine di -fkeep-inline-funzioni, che si applica solo a
funzioni che vengono dichiarate utilizzando l'attributo "dllexport" o declspec

-fkeep-inline-funzioni
In C, emetti funzioni "statiche" che sono dichiarate "in linea" nel file oggetto, anche se
la funzione è stata incorporata in tutti i suoi chiamanti. Questo interruttore non ha effetto
funzioni utilizzando l'estensione "extern inline" in GNU C90. In C++, emetti qualsiasi cosa
funzioni in linea nel file oggetto.

-fkeep-static-const
Emetti variabili dichiarate "static const" quando l'ottimizzazione non è attivata, anche se il
le variabili non sono referenziate.

GCC abilita questa opzione per impostazione predefinita. Se vuoi forzare il compilatore a controllare se il
è stato fatto riferimento alla variabile, indipendentemente dal fatto che l'ottimizzazione sia attivata o meno, utilizzare
, il -fno-keep-static-const opzione.

-fmerge-costanti
Tentativo di unire costanti identiche (costanti stringa e costanti in virgola mobile)
tra le unità di compilazione.

Questa opzione è l'impostazione predefinita per la compilazione ottimizzata se l'assemblatore e il linker
supportalo. Utilizzo -fno-unisci-costanti per inibire questo comportamento.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-funisci-tutte-costanti
Tentativo di unire costanti identiche e variabili identiche.

Questa opzione implica -fmerge-costanti. Inoltre -fmerge-costanti questo
considera ad esempio anche array inizializzati costanti o variabili costanti inizializzate con
tipi integrali o a virgola mobile. Linguaggi come C o C++ richiedono ogni variabile,
includendo più istanze della stessa variabile in chiamate ricorsive, per avere distinte
posizioni, quindi l'utilizzo di questa opzione risulterà in un comportamento non conforme.

-fmodulo-sched
Eseguire la pianificazione del modulo swing immediatamente prima del primo passaggio di pianificazione. Questo
pass guarda i loop più interni e riordina le loro istruzioni sovrapponendo diversi
iterazioni.

-fmodulo-sched-to-regys
Esegui una pianificazione modulo più aggressiva basata su SMS con movimenti di registro consentiti. Di
impostando questo flag verranno eliminati alcuni bordi anti-dipendenza che si attiveranno
la generazione di reg-mosse basate sull'analisi del range di vita. Questa opzione è
efficace solo con -fmodulo-sched abilitato.

-fno-ramo-conteggio-reg
Non utilizzare le istruzioni "decrementa e dirama" su un registro di conteggio, ma invece
generare una sequenza di istruzioni che decrementano un registro, confrontarlo con
zero, quindi ramificare in base al risultato. Questa opzione è significativa solo su
architetture che supportano tali istruzioni, che includono x86, PowerPC, IA-64 e
S/390.

L'impostazione predefinita è -framo-count-reg.

-fno-funzione-cse
Non inserire indirizzi di funzione nei registri; rendere ogni istruzione che chiama a
la funzione costante contiene esplicitamente l'indirizzo della funzione.

Questa opzione si traduce in un codice meno efficiente, ma in alcuni strani hack che alterano il
l'output dell'assemblatore può essere confuso dalle ottimizzazioni eseguite quando questa opzioneè
non usato.

L'impostazione predefinita è -ffunzione-cse

-fno-zero-inizializzato-in-bss
Se il target supporta una sezione BSS, GCC per impostazione predefinita mette le variabili che sono
inizializzato a zero in BSS. Questo può risparmiare spazio nel codice risultante.

Questa opzione disattiva questo comportamento perché alcuni programmi si basano esplicitamente su variabili
andando alla sezione dati Ad esempio, in modo che l'eseguibile risultante possa trovare il
all'inizio di quella sezione e/o fare ipotesi basate su di essa.

L'impostazione predefinita è -fzero-inizializzato-in-bss.

-fparaspruzzi -fflapth -fmudflapir
Per i front-end che lo supportano (C e C++), strumenta tutti i puntatori/array rischiosi
operazioni di dereferenziazione, alcune funzioni stringa/heap di libreria standard e altre
costrutti associati con test di intervallo/validità. I moduli così strumentati dovrebbero essere
immune a buffer overflow, utilizzo di heap non valido e alcune altre classi di C/C++
errori di programmazione. La strumentazione si basa su una libreria di runtime separata
(libmudflap), che sarà collegato in un programma se -fparaspruzzi viene fornito al momento del collegamento.
Il comportamento in fase di esecuzione del programma strumentato è controllato dal PARAFANGO_OPTIONS
variabile d'ambiente. Vedere "env MUDFLAP_OPTIONS=-help a.out" per le sue opzioni.

Usa il -fflapth invece di -fparaspruzzi compilare e collegare se il tuo programma è multi-
filettato. Utilizzo -fmudflapir, inoltre -fparaspruzzi or -fflapth, Se
la strumentazione dovrebbe ignorare le letture del puntatore. Questo produce meno strumentazione (e
quindi un'esecuzione più rapida) e fornisce ancora una certa protezione contro la memoria totale
danneggiando le scritture, ma consente ai dati letti erroneamente di propagarsi all'interno di un programma.

-fthread-salta
Esegui ottimizzazioni in cui controlliamo se un salto si dirama in una posizione in cui
si trova un altro confronto sussunto dal primo. Se è così, il primo ramo è
reindirizzato immediatamente alla destinazione del secondo ramo o a un punto
seguendola, a seconda che la condizione sia nota per essere vera o falsa.

Abilitato ai livelli -O2, -O3, -Voi.

-fsplit-wide-tipi
Quando si utilizza un tipo che occupa più registri, come "long long" su un 32 bit
sistema, suddividere i registri e assegnarli in modo indipendente. Questo normalmente
genera codice migliore per quei tipi, ma può rendere più difficile il debug.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fcse-segue-salti
Nell'eliminazione della sottoespressione comune (CSE), eseguire la scansione delle istruzioni di salto quando
l'obiettivo del salto non è raggiunto da nessun altro percorso. Ad esempio, quando CSE incontra
un'istruzione "if" con una clausola "else", CSE seguirà il salto quando la condizione
testato è falso.

Abilitato ai livelli -O2, -O3, -Voi.

-fcse-salta-blocchi
Questo è simile a -fcse-segue-salti, ma fa sì che CSE segua i salti che
saltare condizionalmente i blocchi. Quando CSE incontra una semplice istruzione "if" con no
altra clausola, -fcse-salta-blocchi fa sì che CSE segua il salto intorno al corpo del
"Se".

Abilitato ai livelli -O2, -O3, -Voi.

-frerun-cse-dopo-loop
Riesegui l'eliminazione della sottoespressione comune dopo aver eseguito le ottimizzazioni del ciclo.

Abilitato ai livelli -O2, -O3, -Voi.

-fgcse
Eseguire un passaggio di eliminazione della sottoespressione comune globale. Questo passaggio funziona anche
costante globale e propagazione della copia.

Nota: Quando compili un programma usando goto calcolati, un'estensione GCC, potresti ottenere
migliori prestazioni in fase di esecuzione se si disabilita l'eliminazione della sottoespressione comune globale
passa aggiungendo -fno-gcse alla riga di comando.

Abilitato ai livelli -O2, -O3, -Voi.

-fgcse-lm
Quando -fgcse-lm è abilitato, l'eliminazione globale della sottoespressione comune tenterà di
spostare i carichi che vengono uccisi solo dai negozi in se stessi. Ciò consente un ciclo
contenente una sequenza di caricamento/memorizzazione da modificare in un caricamento esterno al ciclo e a
copia/memorizza all'interno del ciclo.

Abilitato per impostazione predefinita quando gcse è abilitato.

-fgcse-sm
Quando -fgcse-sm è abilitato, viene eseguito un passaggio di movimento del negozio dopo il comune globale
eliminazione della sottoespressione. Questo passaggio tenterà di spostare i negozi fuori dai cicli. quando
usato insieme a -fgcse-lm, i loop contenenti una sequenza di caricamento/memorizzazione possono essere
modificato in un caricamento prima del ciclo e un negozio dopo il ciclo.

Non abilitato a nessun livello di ottimizzazione.

-fgcse-las
Quando -fgcse-las è abilitato, il passaggio di eliminazione della sottoespressione comune globale
elimina i carichi ridondanti che vengono dopo i negozi nella stessa posizione di memoria (entrambi
licenziamenti parziali e totali).

Non abilitato a nessun livello di ottimizzazione.

-fgcse-dopo-reload
Quando -fgcse-dopo-reload è abilitato, viene eseguito un passaggio di eliminazione del carico ridondante
dopo la ricarica. Lo scopo di questo passaggio è ripulire le fuoriuscite ridondanti.

-ottimizzazioni funsafe-loop
Se fornito, l'ottimizzatore del ciclo presumerà che gli indici del ciclo non trabocchino e che
i loop con condizione di uscita non banale non sono infiniti. Ciò consente una gamma più ampia
di ottimizzazioni del ciclo anche se l'ottimizzatore del ciclo stesso non può dimostrare che queste
le ipotesi sono valide. Usando -Ottimizzazioni del ciclo Wunsafe, il compilatore ti avviserà
se trova questo tipo di loop.

-salto incrociato
Esegui la trasformazione del salto incrociato. Questa trasformazione unifica codice equivalente e
salvare la dimensione del codice. Il codice risultante può o non può funzionare meglio che senza cross-
salto.

Abilitato ai livelli -O2, -O3, -Voi.

-fauto-inc-dec
Combina incrementi o decrementi di indirizzi con accessi alla memoria. Questo passaggio è
sempre saltato su architetture che non hanno istruzioni per supportare questo.
Abilitato per impostazione predefinita su -O e superiori su architetture che supportano questo.

-fdce
Esegui l'eliminazione del codice morto (DCE) su RTL. Abilitato per impostazione predefinita su -O e più in alto.

-fdse
Esegui l'eliminazione del punto morto (DSE) su RTL. Abilitato per impostazione predefinita su -O e più in alto.

-fif-conversione
Tentativo di trasformare i salti condizionali in equivalenti senza rami. Questo include l'uso
di mosse condizionali, min, max, set flag e istruzioni addominali e alcuni trucchi fattibili
dall'aritmetica standard. L'uso dell'esecuzione condizionale sui chip dove si trova
disponibile è controllato da "if-conversion2".

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fif-conversione2
Usa l'esecuzione condizionale (ove disponibile) per trasformare i salti condizionali in
equivalenti senza branch.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fdelete-controlli-puntatore-null
Supponiamo che i programmi non possano dereferenziare in modo sicuro i puntatori nulli e che nessun codice o dati
l'elemento risiede lì. Ciò consente semplici ottimizzazioni di piegatura costanti a tutti
livelli di ottimizzazione. Inoltre, altri passaggi di ottimizzazione in GCC utilizzano questo flag per
controllare le analisi del flusso di dati globali che eliminano i controlli inutili per i puntatori nulli;
questi presuppongono che se un puntatore viene controllato dopo che è già stato dereferenziato,
non può essere nullo.

Si noti tuttavia che in alcuni ambienti questa ipotesi non è vera. Utilizzo
-fno-cancella-null-controlli-puntatore per disabilitare questa ottimizzazione per i programmi che dipendono
su quel comportamento.

Alcuni target, specialmente quelli incorporati, disabilitano questa opzione a tutti i livelli. Altrimenti
è abilitato a tutti i livelli: -O0, -O1, -O2, -O3, -Voi. Pass che utilizzano le informazioni
sono abilitati indipendentemente a diversi livelli di ottimizzazione.

-fdevirtualizza
Tentativo di convertire le chiamate in funzioni virtuali in chiamate dirette. Questo è fatto entrambi
all'interno di una procedura e interprocedurale come parte dell'inlining indiretto
("-findirect-inlining") e propagazione interprocedurale costante (-fipa-cp). Abilitato
a livelli -O2, -O3, -Voi.

-ottimizzazioni-economiche
Eseguire una serie di ottimizzazioni minori relativamente costose.

Abilitato ai livelli -O2, -O3, -Voi.

Senza
Tentativo di rimuovere le istruzioni di estensione ridondanti. Questo è particolarmente utile per
l'architettura x86-64 che implicitamente si estende a zero nei registri a 64 bit dopo
scrivendo nella loro metà inferiore a 32 bit.

Abilitato per x86 a livelli -O2, -O3.

-fottimizzare-registrare-spostare
- Fregmuovi
Tentativo di riassegnare i numeri di registro nelle istruzioni di movimento e come operandi di altri
semplici istruzioni al fine di massimizzare la quantità di vincolo di registro. Questo è
particolarmente utile su macchine con istruzioni a due operandi.

Note: - Fregmuovi ed -fottimizzare-registrare-spostare sono la stessa ottimizzazione.

Abilitato ai livelli -O2, -O3, -Voi.

-fira-algoritmo=algoritmo
Utilizzare l'algoritmo di colorazione specificato per l'allocatore di registri integrato. Il
algoritmo l'argomento può essere priorità, che specifica la colorazione prioritaria di Chow, oppure CB,
che specifica la colorazione Chaitin-Briggs. La colorazione Chaitin-Briggs non è implementata
per tutte le architetture, ma per quei target che lo supportano, è l'impostazione predefinita
perché genera codice migliore.

-regione-fira=regione
Utilizzare le regioni specificate per l'allocatore di registri integrato. Il regione argomento
dovrebbe essere uno dei seguenti:

contro tutti i Usa tutti i loop come regioni di allocazione dei registri. Questo può dare i migliori risultati per
macchine con registro piccolo e/o irregolare.

misto
Utilizzare tutti i loop ad eccezione dei loop con una piccola pressione di registro come regioni. Questo
value di solito dà i migliori risultati nella maggior parte dei casi e per la maggior parte delle architetture, e
è abilitato per impostazione predefinita durante la compilazione con l'ottimizzazione per la velocità (-O, -O2, ...).

prima Usa tutte le funzioni come una singola regione. Ciò si traduce in genere nel codice più piccolo
dimensione ed è abilitato per impostazione predefinita per -Voi or -O0.

-fira-loop-pressione
Usa IRA per valutare la pressione del registro nei cicli per le decisioni di spostare le invarianti del ciclo.
Questa opzione di solito porta alla generazione di codice più veloce e più piccolo su macchine con
file di registro di grandi dimensioni (>= 32 registri), ma può rallentare il compilatore.

Questa opzione è abilitata a livello -O3 per alcuni obiettivi.

-fno-ira-share-save-slot
Disabilita la condivisione degli slot dello stack utilizzati per salvare i registri hardware utilizzati dalle chiamate che vivono attraverso
una chiamata. Ogni registro rigido ottiene uno slot di stack separato e, di conseguenza, stack di funzioni
le cornici sono più grandi.

-fno-ira-share-spill-slot
Disabilita la condivisione degli slot dello stack allocati per gli pseudo-registri. Ogni pseudo-registro
che non ottiene un registro rigido ottiene uno slot stack separato e, di conseguenza, funzione
i frame dello stack sono più grandi.

-fira-verboso=n
Controlla la verbosità del file dump per l'allocatore di registri integrato. Il
il valore predefinito è 5. Se il valore n è maggiore o uguale a 10, viene inviato l'output del dump
a stderr utilizzando lo stesso formato di n meno 10.

-framo-ritardato
Se supportato per la macchina di destinazione, prova a riordinare le istruzioni per sfruttare
slot di istruzione disponibili dopo le istruzioni di salto ritardate.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fschedule-insns
Se supportato per la macchina di destinazione, provare a riordinare le istruzioni per eliminare
l'esecuzione si blocca a causa della mancata disponibilità dei dati richiesti. Questo aiuta le macchine che
avere istruzioni di caricamento in virgola mobile o memoria lente consentendo ad altre istruzioni di
essere emesso fino a quando non è richiesto il risultato dell'istruzione di caricamento o in virgola mobile.

Abilitato ai livelli -O2, -O3.

-fschedule-insns2
Simile a -fschedule-insns, ma richiede un ulteriore passaggio di programmazione delle istruzioni
dopo che è stata effettuata l'assegnazione del registro. Ciò è particolarmente utile su macchine con a
numero relativamente piccolo di registri e dove le istruzioni di caricamento della memoria richiedono più di
un ciclo.

Abilitato ai livelli -O2, -O3, -Voi.

-fno-sched-interblocco
Non programmare istruzioni su blocchi di base. Questo è normalmente abilitato per impostazione predefinita
quando si pianifica prima dell'assegnazione del registro, ovvero con -fschedule-insns o -O2 or
più alto.

-fno-sched-spec
Non consentire il movimento speculativo di istruzioni senza carico. Questo è normalmente abilitato da
impostazione predefinita durante la pianificazione prima dell'allocazione del registro, ovvero con -fschedule-insns o
-O2 o superiore.

-fsched-pressione
Abilita la programmazione insn sensibile alla pressione del registro prima dell'allocazione del registro.
Questo ha senso solo quando è abilitata la pianificazione prima dell'allocazione dei registri, ad es
-fschedule-insns o -O2 o più alto. L'utilizzo di questa opzione può migliorare il generato
codice e ridurne le dimensioni impedendo l'aumento della pressione di registro al di sopra del numero
dei registri rigidi disponibili e di conseguenza registrare gli sversamenti nel registro
allocazione.

-fsched-spec-load
Consentire il movimento speculativo di alcune istruzioni di carico. Questo ha senso solo quando
programmazione prima dell'assegnazione del registro, ovvero con -fschedule-insns o -O2 o superiore.

-fsched-spec-carico-pericoloso
Consenti il ​​movimento speculativo di più istruzioni di carico. Questo ha senso solo quando
programmazione prima dell'assegnazione del registro, ovvero con -fschedule-insns o -O2 o superiore.

-fsched-stallo-insns
-fsched-stallo-insns=n
Definire quanti insn (se ce ne sono) possono essere spostati prematuramente dalla coda di stalled
si inserisce nella lista dei pronti, durante il secondo passaggio di programmazione.
-fno-sched-stallo-insns significa che nessun insns sarà spostato prematuramente,
-fsched-stallo-insns=0 significa che non c'è limite al numero di messaggi in coda che possono essere spostati
prematuramente. -fsched-stallo-insns senza un valore equivale a
-fsched-stallo-insns=1.

-fsched-stallo-insns-dep
-fsched-stallo-insns-dep=n
Definire quanti gruppi insn (cicli) verranno esaminati per una dipendenza da uno stallo
insn che si candida alla prematura rimozione dalla coda degli insn in stallo. Questo
ha effetto solo durante la seconda schedulazione, e solo se
-fsched-stallo-insns viene utilizzato. -fno-sched-stallo-insns-dep è equivalente
-fsched-stallo-insns-dep=0. -fsched-stallo-insns-dep senza un valore è equivalente
a -fsched-stallo-insns-dep=1.

-fsched2-usa-superblocchi
Quando si pianifica dopo l'allocazione del registro, utilizzare l'algoritmo di pianificazione del superblocco.
La pianificazione del superblocco consente il movimento attraverso i limiti di blocco di base risultando più veloce
orari. Questa opzione è sperimentale, poiché non tutte le descrizioni delle macchine utilizzate da GCC
modellare la CPU abbastanza da vicino per evitare risultati inaffidabili dall'algoritmo.

Questo ha senso solo quando si pianifica dopo l'allocazione del registro, cioè con
-fschedule-insns2 o -O2 o superiore.

-fsched-gruppo-euristico
Abilita l'euristica del gruppo nello scheduler. Questa euristica favorisce l'istruzione
che appartiene a un gruppo di pianificazione. Questo è abilitato per impostazione predefinita quando la pianificazione è
abilitato, cioè con -fschedule-insns or -fschedule-insns2 o -O2 o superiore.

-fsched-percorso-critico-euristico
Abilita l'euristica del percorso critico nello scheduler. Questa euristica favorisce
indicazioni sul percorso critico. Questo è abilitato per impostazione predefinita quando la pianificazione è
abilitato, cioè con -fschedule-insns or -fschedule-insns2 o -O2 o superiore.

-fsched-spec-insn-euristica
Abilitare l'euristica dell'istruzione speculativa nello scheduler. Questa euristica favorisce
istruzioni speculative con maggiore debolezza alla dipendenza. Questo è abilitato per impostazione predefinita
quando la programmazione è abilitata, ovvero con -fschedule-insns or -fschedule-insns2 o -O2
o superiore.

-fsched-rank-euristico
Abilita l'euristica del rango nello scheduler. Questa euristica favorisce l'istruzione
appartenente ad un blocco base di dimensione o frequenza maggiore. Questo è abilitato per impostazione predefinita
quando la programmazione è abilitata, ovvero con -fschedule-insns or -fschedule-insns2 o -O2
o superiore.

-fsched-last-insn-euristica
Abilita l'euristica dell'ultima istruzione nello scheduler. Questa euristica favorisce il
istruzione meno dipendente dall'ultima istruzione programmata. Questo è abilitato
per impostazione predefinita quando la pianificazione è abilitata, ovvero con -fschedule-insns or -fschedule-insns2
o -O2 o superiore.

-fsched-dep-count-euristico
Abilitare l'euristica del conteggio dipendente nell'utilità di pianificazione. Questa euristica favorisce il
istruzione che ha più istruzioni a seconda di essa. Questo è abilitato per impostazione predefinita
quando la programmazione è abilitata, ovvero con -fschedule-insns or -fschedule-insns2 o -O2
o superiore.

-Freschedule-moduli-schemate
La schedulazione modulo viene prima della schedulazione tradizionale, se un ciclo era modulo
programmato, potremmo voler impedire ai successivi passaggi di programmazione di modificarlo
schedule, usiamo questa opzione per controllarlo.

-fprogrammazione-selettiva
Pianifica le istruzioni utilizzando l'algoritmo di pianificazione selettiva. Esecuzioni di pianificazione selettiva
invece del primo passaggio dello scheduler.

-fprogrammazione-selettiva2
Pianifica le istruzioni utilizzando l'algoritmo di pianificazione selettiva. Esecuzioni di pianificazione selettiva
invece del secondo passaggio dello scheduler.

-fsel-sched-pipelining
Abilita il pipelining software dei loop più interni durante la pianificazione selettiva. Questo
l'opzione non ha effetto fino a quando uno dei -fprogrammazione-selettiva or -fprogrammazione-selettiva2 is
acceso.

-fsel-sched-pipelining-outer-loop
Quando si convogliano i loop durante la programmazione selettiva, anche i loop esterni della pipeline. Questo
l'opzione non ha effetto fino a quando -fsel-sched-pipelining è acceso.

-finvolucro termoretraibile
Emetti prologhi di funzione solo prima di parti della funzione che ne hanno bisogno, piuttosto che a
la parte superiore della funzione. Questo flag è abilitato per impostazione predefinita su -O e più in alto.

-fcaller-salva
Abilitare i valori da allocare nei registri che saranno occupati dalle chiamate di funzione,
emettendo istruzioni aggiuntive per salvare e ripristinare i registri attorno a tali chiamate.
Tale allocazione viene eseguita solo quando sembra portare a un codice migliore di quello che sarebbe
altrimenti essere prodotto.

Questa opzione è sempre abilitata di default su alcune macchine, solitamente quelle che hanno
nessun registro con conservazione delle chiamate da utilizzare invece.

Abilitato ai livelli -O2, -O3, -Voi.

-fcombine-stack-regolazioni
Tiene traccia delle regolazioni dello stack (push e pop) e dei riferimenti alla memoria dello stack e quindi prova
per trovare modi per combinarli.

Abilitato per impostazione predefinita su -O1 e più in alto.

-fconserve-stack
Tentativo di ridurre al minimo l'utilizzo dello stack. Il compilatore tenterà di utilizzare meno spazio nello stack,
anche se questo rende il programma più lento. Questa opzione implica l'impostazione di grande pila-
telaio parametro a 100 e il crescita-frame-pila-grande parametro a 400.

-ftree-riassoc
Eseguire la riassociazione sugli alberi. Questo flag è abilitato per impostazione predefinita su -O e più in alto.

-ftree-pre
Eseguire l'eliminazione della ridondanza parziale (PRE) sugli alberi. Questo flag è abilitato da
predefinito a -O2 ed -O3.

-ftree-parziale-pre
Rendi più aggressiva l'eliminazione della ridondanza parziale (PRE). Questo flag è abilitato da
predefinito a -O3.

-ftree-forwprop
Eseguire la propagazione in avanti sugli alberi. Questo flag è abilitato per impostazione predefinita su -O ed
più alto.

-ftree-fre
Eseguire l'eliminazione completa della ridondanza (FRE) sugli alberi. La differenza tra FRE e
PRE è che FRE considera solo le espressioni calcolate su tutti i percorsi che portano a
il calcolo ridondante. Questa analisi è più veloce di PRE, sebbene ne esponga di meno
esuberi. Questo flag è abilitato per impostazione predefinita su -O e più in alto.

-ftree-phiprop
Eseguire il sollevamento di carichi da puntatori condizionali sugli alberi. Questo pass è abilitato da
predefinito a -O e più in alto.

-ftree-copia-prop
Eseguire la propagazione della copia sugli alberi. Questo passaggio elimina le operazioni di copia non necessarie.
Questo flag è abilitato per impostazione predefinita su -O e più in alto.

-fipa-puro-const
Scopri quali funzioni sono pure o costanti. Abilitato per impostazione predefinita su -O e più in alto.

-fipa-riferimento
Scopri quali variabili statiche non evadono non possono sfuggire all'unità di compilazione.
Abilitato per impostazione predefinita su -O e più in alto.

-fipa-pta
Eseguire l'analisi del puntatore interprocedurale e la modifica interprocedurale e
analisi di riferimento. Questa opzione può causare un uso eccessivo della memoria e del tempo di compilazione su
grandi unità di compilazione. Non è abilitato per impostazione predefinita a nessun livello di ottimizzazione.

-fipa-profilo
Eseguire la propagazione del profilo interprocedurale. Le funzioni chiamate solo da freddo
le funzioni sono contrassegnate come fredde. Anche le funzioni eseguite una volta (come "cold",
vengono identificati "noreturn", costruttori statici o distruttori). Funzioni fredde e
loop meno parti delle funzioni eseguite una volta vengono quindi ottimizzate per le dimensioni. Abilitato da
predefinito a -O e più in alto.

-fipa-cp
Eseguire la propagazione costante interprocedurale. Questa ottimizzazione analizza il programma
per determinare quando i valori passati alle funzioni sono costanti e quindi ottimizza
di conseguenza. Questa ottimizzazione può aumentare sostanzialmente le prestazioni se il
l'applicazione ha passato le costanti alle funzioni. Questo flag è abilitato per impostazione predefinita su
-O2, -Voi ed -O3.

-fipa-cp-clone
Eseguire la clonazione delle funzioni per rendere più forte la propagazione costante interprocedurale. quando
abilitata, la propagazione costante interprocedurale eseguirà la clonazione della funzione quando
la funzione visibile esternamente può essere chiamata con argomenti costanti. Perchè questo
l'ottimizzazione può creare più copie di funzioni, può aumentare significativamente
dimensione del codice (vedi --parami ipcp-unità-crescita=APPREZZIAMO). Questo flag è abilitato per impostazione predefinita su
-O3.

-fipa-matrice-reorg
Eseguire l'appiattimento e la trasposizione della matrice. L'appiattimento della matrice cerca di sostituire an
matrice m-dimensionale con la sua matrice n-dimensionale equivalente, dove n < m. Questo
riduce il livello di indiretto necessario per accedere agli elementi della matrice. Il
la seconda ottimizzazione è la trasposizione della matrice, che tenta di cambiare l'ordine del
le dimensioni della matrice al fine di migliorare la località della cache. Entrambe le ottimizzazioni richiedono il
-fintero-programma bandiera. La trasposizione è abilitata solo se le informazioni di profilazione sono
a disposizione.

-ftree-lavello
Esegui il movimento in avanti del negozio sugli alberi. Questo flag è abilitato per impostazione predefinita su -O ed
più alto.

-ftree-bit-ccp
Esegui una propagazione costante bit condizionale sparsa sugli alberi e propaga il puntatore
informazioni di allineamento. Questo passaggio opera solo su variabili scalari locali ed è
abilitato per impostazione predefinita su -O e superiore. Richiede che -ftree-ccp è abilitato.

-ftree-ccp
Eseguire la propagazione costante condizionale sparsa (CCP) sugli alberi. Solo questo passaggio
opera su variabili scalari locali ed è abilitato di default a -O e più in alto.

-ftree-switch-conversione
Eseguire la conversione di inizializzazioni semplici in uno switch in inizializzazioni da a
matrice scalare. Questo flag è abilitato per impostazione predefinita su -O2 e più in alto.

-fusione a coda di albero
Cerca sequenze di codici identiche. Quando viene trovato, sostituisci uno con un salto all'altro.
Questa ottimizzazione è nota come unione della coda o salto incrociato. Questo flag è abilitato da
predefinito a -O2 e superiore. Il tempo di compilazione in questo passaggio può essere limitato utilizzando
max-tail-merge-confronti parametro e max-tail-merge-iterazioni parametro.

-ftree-dce
Eseguire l'eliminazione del codice morto (DCE) sugli alberi. Questo flag è abilitato per impostazione predefinita su -O
e più in alto.

-ftree-built-in-call-dce
Eseguire l'eliminazione condizionale del codice morto (DCE) per le chiamate a funzioni integrate che
possono impostare "errno" ma sono altrimenti privi di effetti collaterali. Questo flag è abilitato per impostazione predefinita
at -O2 e superiore se -Voi non è anche specificato.

-ftree-dominatore-opt
Eseguire una serie di semplici pulizie scalari (propagazione costante/copia, ridondanza
eliminazione, propagazione dell'intervallo e semplificazione dell'espressione) basata su un dominatore
attraversamento degli alberi. Questo esegue anche l'infilatura di salti (per ridurre i salti a salti). Questo
flag è abilitato per impostazione predefinita su -O e più in alto.

-ftree-dse
Esegui l'eliminazione dei depositi morti (DSE) sugli alberi. Un negozio morto è un negozio in un ricordo
posizione che viene successivamente sovrascritta da un altro negozio senza carichi intermedi. In
in questo caso è possibile eliminare l'archivio precedente. Questo flag è abilitato per impostazione predefinita su -O ed
più alto.

-ftree-ch
Eseguire la copia dell'intestazione del ciclo sugli alberi. Questo è vantaggioso poiché aumenta
efficacia delle ottimizzazioni del movimento del codice. Salva anche un salto. Questa bandiera è
abilitato per impostazione predefinita su -O e superiore. Non è abilitato per -Voi, dal momento che di solito
aumenta la dimensione del codice.

-ftree-loop-ottimizzare
Eseguire ottimizzazioni del ciclo sugli alberi. Questo flag è abilitato per impostazione predefinita su -O ed
più alto.

-ftree-loop-lineare
Eseguire trasformazioni di interscambio di loop sull'albero. Uguale a -floop-interscambio. Usare
questa trasformazione del codice, GCC deve essere configurato con --con-ppl ed --con-cloog a
abilitare l'infrastruttura di trasformazione del ciclo di Graphite.

-floop-interscambio
Eseguire trasformazioni di interscambio di loop sui loop. Scambio di due loop annidati
commuta il ciclo interno ed esterno. Ad esempio, dato un ciclo come:

FARE J = 1, M
IO = 1, N
A (j, i) = a (j, i) * c
FENDO
FENDO

Lo scambio di loop trasformerà il loop come se l'utente avesse scritto:

IO = 1, N
FARE J = 1, M
A (j, i) = a (j, i) * c
FENDO
FENDO

che può essere utile quando "N" è più grande delle cache, perché in Fortran, il
gli elementi di un array sono archiviati in memoria in modo contiguo per colonna e l'originale
il ciclo itera sulle righe, creando potenzialmente ad ogni accesso un errore di cache. Questo
l'ottimizzazione si applica a tutte le lingue supportate da GCC e non è limitata a
Fortran. Per utilizzare questa trasformazione del codice, GCC deve essere configurato con --con-ppl
ed --con-cloog per abilitare l'infrastruttura di trasformazione del ciclo di grafite.

-flop-strip-mio
Esegui trasformazioni di estrazione di strip loop sui loop. L'estrazione mineraria divide un ciclo in
due anelli nidificati. L'anello esterno ha falcate uguali alla dimensione della striscia e all'interno
loop ha passi del loop originale all'interno di una striscia. La lunghezza della striscia può essere modificata
usando il loop-block-size-tile-size parametro. Ad esempio, dato un ciclo come:

IO = 1, N
A(I) = A(I) + C
FENDO

Il ciclo strip mining trasformerà il ciclo come se l'utente avesse scritto:

DO II = 1, N, 51
DO I = II, min (II + 50, N)
A(I) = A(I) + C
FENDO
FENDO

Questa ottimizzazione si applica a tutte le lingue supportate da GCC e non è limitata a
Fortran. Per utilizzare questa trasformazione del codice, GCC deve essere configurato con --con-ppl
ed --con-cloog per abilitare l'infrastruttura di trasformazione del ciclo di grafite.

-blocco floop
Eseguire trasformazioni di blocco dei loop sui loop. La striscia di blocco estrae ogni anello nel
nidificazione di loop in modo tale che gli accessi alla memoria dei loop degli elementi si adattino alle cache. Il
la lunghezza della striscia può essere modificata utilizzando il loop-block-size-tile-size parametro. Per esempio,
dato un ciclo come:

IO = 1, N
FARE J = 1, M
A(J, I) = B(I) + C(J)
FENDO
FENDO

il blocco del ciclo trasformerà il ciclo come se l'utente avesse scritto:

DO II = 1, N, 51
FARE JJ = 1, M, 51
DO I = II, min (II + 50, N)
DO J = JJ, minimo (JJ + 50, M)
A(J, I) = B(I) + C(J)
FENDO
FENDO
FENDO
FENDO

che può essere utile quando "M" è più grande delle cache, perché il ciclo più interno
itererà su una quantità minore di dati che possono essere conservati nelle cache. Questo
l'ottimizzazione si applica a tutte le lingue supportate da GCC e non è limitata a
Fortran. Per utilizzare questa trasformazione del codice, GCC deve essere configurato con --con-ppl
ed --con-cloog per abilitare l'infrastruttura di trasformazione del ciclo di grafite.

-fgraphite-identità
Abilita la trasformazione dell'identità per la grafite. Per ogni SCoP generiamo il
rappresentazione poliedrica e trasformarla di nuovo in gimple. Usando -fgraphite-identità
possiamo verificare i costi o i benefici della trasformazione di GIMPLE -> GRAPHITE -> GIMPLE.
Alcune ottimizzazioni minime vengono eseguite anche dal generatore di codice CLooG, come index
suddivisione ed eliminazione del codice morto nei cicli.

-floop-appiattire
Rimuove la struttura di nidificazione del loop: trasforma l'annidamento del loop in un singolo loop. Questo
trasformazione può essere utile come trasformazione di abilitazione per la vettorizzazione e
parallelizzazione. Questa funzione è sperimentale. Per utilizzare questa trasformazione del codice, GCC
deve essere configurato con --con-ppl ed --con-cloog per abilitare il loop Graphite
infrastruttura di trasformazione.

-floop-parallelizza-tutto
Utilizzare l'analisi della dipendenza dei dati Graphite per identificare i loop che possono essere parallelizzati.
Parallelizza tutti i loop che possono essere analizzati per non contenere dipendenze trasportate dal loop
senza verificare che sia vantaggioso parallelizzare i loop.

-fcheck-data-deps
Confronta i risultati di diversi analizzatori di dipendenza dai dati. Questa opzione è usata per
debug degli analizzatori di dipendenza dei dati.

-ftree-loop-se-converti
Tentativo di trasformare i salti condizionali nei loop più interni in branch-less
equivalenti. L'intento è rimuovere il flusso di controllo dai loop più interni in ordine
per migliorare la capacità del passaggio di vettorizzazione di gestire questi cicli. Questo è
abilitato per impostazione predefinita se la vettorizzazione è abilitata.

-ftree-loop-if-convert-stores
Tenta di eseguire anche salti condizionali if-convert contenenti scritture in memoria. Questo
la trasformazione può essere pericolosa per i programmi multi-thread poiché trasforma in modo condizionale
la memoria scrive in scritture di memoria incondizionate. Per esempio,

per (i = 0; i < N; i++)
se (cond)
A[i] = espr;

si trasformerebbe in

per (i = 0; i < N; i++)
A[i] = cond? espr: A[i];

potenzialmente produrre corse di dati.

-distribuzione-ftree-loop
Eseguire la distribuzione del ciclo. Questo flag può migliorare le prestazioni della cache su grandi loop body
e consentire ulteriori ottimizzazioni del ciclo, come la parallelizzazione o la vettorizzazione, da prendere
luogo. Ad esempio, il ciclo

IO = 1, N
A(I) = B(I) + C
D(I) = E(I) * F
FENDO

si trasforma in

IO = 1, N
A(I) = B(I) + C
FENDO
IO = 1, N
D(I) = E(I) * F
FENDO

-ftree-loop-distribuire-pattern
Eseguire la distribuzione in loop di modelli che possono essere generati dal codice con chiamate a a
biblioteca. Questo flag è abilitato per impostazione predefinita su -O3.

Questo passaggio distribuisce i cicli di inizializzazione e genera una chiamata a memset zero.
Ad esempio, il ciclo

IO = 1, N
A(io) = 0
B(I) = A(I) + I
FENDO

si trasforma in

IO = 1, N
A(io) = 0
FENDO
IO = 1, N
B(I) = A(I) + I
FENDO

e il ciclo di inizializzazione viene trasformato in una chiamata a memset zero.

-ftree-loop-im
Eseguire il movimento invariante del ciclo sugli alberi. Questo passaggio sposta solo le invarianti che sarebbero
difficile da gestire a livello RTL (chiamate di funzione, operazioni che si espandono a non banali
sequenze di inns). Insieme a -funswitch-loop muove anche operandi di condizioni che
sono invarianti fuori dal ciclo, in modo che possiamo usare solo banali analisi di invarianza
in loop unswitching. Il pass include anche il movimento del negozio.

-ftree-loop-ivcanon
Crea un contatore canonico per il numero di iterazioni nei cicli per cui determinare
numero di iterazioni richiede un'analisi complicata. Le ottimizzazioni successive potrebbero quindi
determinare facilmente il numero. Utile soprattutto in relazione allo srotolamento.

-cinque punti
Eseguire ottimizzazioni delle variabili di induzione (riduzione della forza, variabile di induzione
fusione ed eliminazione delle variabili di induzione) sugli alberi.

-ftree-parallelizza-loop=n
Parallelizzare i cicli, ovvero dividere il loro spazio di iterazione per l'esecuzione in n thread. Questo è
possibile solo per i cicli le cui iterazioni sono indipendenti e possono essere arbitrariamente
riordinato. L'ottimizzazione è redditizia solo su macchine multiprocessore, per loop
che richiedono un uso intensivo della CPU, piuttosto che vincolati, ad esempio, dalla larghezza di banda della memoria. Questa opzione
implica -pthread, e quindi è supportato solo su obiettivi che hanno il supporto per
-pthread.

-ftree-pta
Eseguire l'analisi dei punti a funzione locale sugli alberi. Questo flag è abilitato per impostazione predefinita
at -O e più in alto.

-ftree-sra
Eseguire la sostituzione scalare degli aggregati. Questo passaggio sostituisce i riferimenti alla struttura
con scalari per impedire il commit delle strutture in memoria troppo presto. Questa bandiera è
abilitato per impostazione predefinita su -O e più in alto.

-ftree-rinominacopia
Eseguire la ridenominazione delle copie sugli alberi. Questo passaggio tenta di rinominare i provvisori del compilatore in
altre variabili nelle posizioni di copia, di solito risultando in nomi di variabili che più
assomigliano molto alle variabili originarie. Questo flag è abilitato per impostazione predefinita su -O ed
più alto.

-ftree-coalesce-inline-vars
Dillo al copyrename pass (vedi -ftree-rinominacopia) per tentare di combinare piccoli utenti-
anche variabili definite, ma solo se erano inline da altre funzioni. È un
forma più limitata di -ftree-coalesce-vars. Ciò potrebbe danneggiare le informazioni di debug di tali
variabili inline, ma manterrà le variabili della funzione inline-in separate da
tra loro, in modo tale che è più probabile che contengano i valori attesi in a
sessione di debug. Questa era l'impostazione predefinita nelle versioni GCC precedenti alla 4.7.

-ftree-coalesce-vars
Dillo al copyrename pass (vedi -ftree-rinominacopia) per tentare di combinare piccoli utenti-
anche variabili definite, anziché solo temporanei del compilatore. Questo può limitare gravemente
la capacità di eseguire il debug di un programma ottimizzato compilato con -fno-var-inseguimento-assegnamenti.
Nella forma negata, questo flag impedisce la fusione SSA delle variabili utente, incluso
quelli in linea. Questa opzione è abilitata per impostazione predefinita.

-ftree-ter
Eseguire la sostituzione temporanea dell'espressione durante la fase SSA->normale. Separare
i temporanei use/single def vengono sostituiti nella loro posizione di utilizzo con la loro definizione
espressione. Ciò si traduce in codice non GIMPLE, ma offre molto di più agli espansori
alberi complessi su cui lavorare con conseguente migliore generazione di RTL. Questo è abilitato da
predefinito a -O e più in alto.

-ftree-vettorizzare
Eseguire la vettorizzazione del ciclo sugli alberi. Questo flag è abilitato per impostazione predefinita su -O3.

-ftree-slp-vettorizza
Eseguire la vettorizzazione di blocchi di base sugli alberi. Questo flag è abilitato per impostazione predefinita su -O3 ed
quando -ftree-vettorizzare è abilitato.

-ftree-vect-loop-versione
Eseguire il versionamento del ciclo quando si esegue la vettorizzazione del ciclo sugli alberi. Quando appare un ciclo
essere vettorializzabile tranne che l'allineamento dei dati o la dipendenza dai dati non possono essere determinati
in fase di compilazione, vengono generate versioni vettorializzate e non vettorializzate del ciclo
insieme ai controlli in fase di esecuzione per l'allineamento o la dipendenza per controllare quale versione è
eseguito. Questa opzione è abilitata per impostazione predefinita tranne che a livello -Voi dove è disabilitato.

-fvect-cost-modello
Abilita il modello di costo per la vettorizzazione.

-ftree-vrp
Eseguire la propagazione dell'intervallo di valori sugli alberi. Questo è simile alla propagazione costante
pass, ma al posto dei valori vengono propagati gli intervalli di valori. Questo permette al
ottimizzatori per rimuovere i controlli di intervallo non necessari come i controlli associati all'array e il puntatore nullo
controlli. Questo è abilitato per impostazione predefinita su -O2 e superiore. Eliminazione del controllo del puntatore nullo
è fatto solo se -fdelete-controlli-puntatore-null è abilitato.

-tracer
Eseguire la duplicazione della coda per ingrandire le dimensioni del superblocco. Questa trasformazione semplifica
il flusso di controllo della funzione consentendo ad altre ottimizzazioni di svolgere un lavoro migliore.

-funroll-loop
Unroll loop il cui numero di iterazioni può essere determinato al momento della compilazione o al momento della compilazione
ingresso nel ciclo. -funroll-loop implica -frerun-cse-dopo-loop. Questa opzione fa
codice più grande e può o meno farlo funzionare più velocemente.

-funroll-tutti i loop
Srotola tutti i loop, anche se il loro numero di iterazioni è incerto quando il loop è
entrato. Questo di solito rende i programmi più lenti. -funroll-tutti i loop implica il
stesse opzioni di -funroll-loop,

-fsplit-ivs-in-unroller
Consente l'espressione dei valori delle variabili di induzione nelle iterazioni successive del
ciclo srotolato usando il valore nella prima iterazione. Questo rompe la lunga dipendenza
catene, migliorando così l'efficienza dei passaggi di programmazione.

Combinazione di -fweb e CSE è spesso sufficiente per ottenere lo stesso effetto. però
nei casi in cui il corpo del ciclo è più complicato di un singolo blocco di base, questo non lo è
affidabile. Inoltre non funziona affatto su alcune delle architetture a causa di
restrizioni nel pass CSE.

Questa ottimizzazione è abilitata per impostazione predefinita.

-fespansione-variabile-in-unroller
Con questa opzione, il compilatore creerà più copie di alcune variabili locali
quando si srotola un ciclo che può risultare in codice superiore.

-fpartial-inline
Parti in linea di funzioni. Questa opzione ha effetto solo quando l'inline stesso è
acceso dal -funzioni-finline or -finline-piccole-funzioni opzioni.

Abilitato a livello -O2.

-fpredictive-comune
Eseguire l'ottimizzazione predittiva del commoning, ovvero riutilizzare i calcoli (in particolare
caricamenti e negozi di memoria) eseguiti in precedenti iterazioni di cicli.

Questa opzione è abilitata a livello -O3.

-fprefetch-loop-array
Se supportato dalla macchina di destinazione, genera istruzioni per precaricare la memoria su
migliorare le prestazioni dei loop che accedono a grandi array.

Questa opzione può generare codice migliore o peggiore; i risultati dipendono fortemente dalla
struttura dei cicli all'interno del codice sorgente.

Disabilitato a livello -Voi.

-fno-spioncino
-fno-spioncino2
Disabilita qualsiasi ottimizzazione spioncino specifica per la macchina. La differenza tra
-fno-spioncino ed -fno-spioncino2 sta nel modo in cui sono implementati nel compilatore; alcuni
i bersagli usano uno, alcuni usano l'altro, alcuni usano entrambi.

-fspioncino è abilitato per impostazione predefinita. -fspioncino2 abilitato a livelli -O2, -O3, -Voi.

-fno-indovina-ramo-probabilità
Non indovinare le probabilità dei rami utilizzando l'euristica.

GCC utilizzerà l'euristica per indovinare le probabilità del ramo se non sono fornite da
feedback sulla profilazione (-fprofile-archi). Queste euristiche si basano sul flusso di controllo
grafico. Se alcune probabilità di ramo sono specificate da __built-in_expect, Allora l'
l'euristica sarà utilizzata per indovinare le probabilità del ramo per il resto del flusso di controllo
grafico, prendendo il __built-in_expect informazioni in considerazione. Le interazioni tra i
euristica e __built-in_expect può essere complesso e, in alcuni casi, può essere utile per
disabilitare l'euristica in modo che gli effetti di __built-in_expect sono più facili
capire.

L'impostazione predefinita è -fguess-ramo-probabilità a livelli -O, -O2, -O3, -Voi.

-blocchi-freddo
Riordina i blocchi di base nella funzione compilata per ridurre il numero di prese
rami e migliorare la localizzazione del codice.

Abilitato ai livelli -O2, -O3.

-blocchi-e-partizioni di freorder
Oltre a riordinare i blocchi di base nella funzione compilata, per ridurre
numero di rami presi, partizioni blocchi di base caldi e freddi in sezioni separate
dei file assembly e .o, per migliorare le prestazioni di paging e località della cache.

Questa ottimizzazione viene disattivata automaticamente in presenza di gestione delle eccezioni,
per le sezioni linkonce, per le funzioni con un attributo di sezione definito dall'utente e su qualsiasi
architettura che non supporta le sezioni denominate.

-funzioni-freorder
Riordina le funzioni nel file oggetto per migliorare la localizzazione del codice. Questo è
implementato utilizzando le sottosezioni speciali ".text.hot" per le operazioni più frequenti
funzioni e ".text.unlikely" per funzioni eseguite improbabili. Il riordino viene effettuato da
il linker, quindi il formato del file oggetto deve supportare le sezioni denominate e il linker deve essere posizionato
loro in modo ragionevole.

Anche il feedback del profilo deve essere disponibile per rendere effettiva questa opzione. Vedere
-fprofile-archi per i dettagli.

Abilitato ai livelli -O2, -O3, -Voi.

-fstrict-alias
Consenti al compilatore di assumere le regole di aliasing più rigide applicabili alla lingua
essere compilato. Per C (e C++), questo attiva ottimizzazioni basate sul tipo di
espressioni. In particolare, si assume che un oggetto di un tipo non risieda mai al
stesso indirizzo di un oggetto di tipo diverso, a meno che i tipi non siano quasi gli stessi.
Ad esempio, un "int unsigned" può alias un "int", ma non un "void*" o un "double". UN
il tipo di carattere può alias qualsiasi altro tipo.

Presta particolare attenzione al codice come questo:

unione a_unione {
int i;
doppia d;
};

intero f() {
unione a_unione t;
td = 3.0;
ritorno ti;
}

La pratica di leggere da un membro del sindacato diverso da quello più recente
scritto (chiamato "tipo-punning") è comune. Anche con -fstrict-alias, genere-
il gioco di parole è consentito, a condizione che si acceda alla memoria tramite il tipo union. Così il
il codice sopra funzionerà come previsto. Tuttavia, questo codice potrebbe non:

intero f() {
unione a_unione t;
int*ip;
td = 3.0;
ip = &t.i;
ritorno *ip;
}

Allo stesso modo, accedi prendendo l'indirizzo, lanciando il puntatore risultante e
dereferenziare il risultato ha un comportamento indefinito, anche se il cast utilizza un tipo di unione,
per esempio:

intero f() {
doppio d = 3.0;
return ((union a_union *) &d)->i;
}

I -fstrict-alias l'opzione è abilitata ai livelli -O2, -O3, -Voi.

-fstrict-overflow
Consenti al compilatore di assumere rigide regole di overflow firmate, a seconda della lingua
essere compilato. Per C (e C++) questo significa che overflow quando si esegue l'aritmetica con
i numeri con segno non sono definiti, il che significa che il compilatore può presumere che non lo farà
accadere. Ciò consente varie ottimizzazioni. Ad esempio, il compilatore assumerà
che un'espressione come "i + 10 > i" sarà sempre vera per "i" con segno. Questo
l'assunzione è valida solo se l'overflow con segno non è definito, poiché l'espressione è falsa
se "i + 10" trabocca quando si utilizza l'aritmetica in complemento a due. Quando questa opzione è attiva
effettuare qualsiasi tentativo di determinare se un'operazione sui numeri firmati traboccherà
deve essere scritto con attenzione per non coinvolgere effettivamente l'overflow.

Questa opzione consente anche al compilatore di assumere una semantica del puntatore rigorosa: dato a
puntatore a un oggetto, se l'aggiunta di un offset a quel puntatore non produce un puntatore
allo stesso oggetto, l'addizione è indefinita. Questo permette al compilatore di concludere
che "p + u > p" è sempre vero per un puntatore "p" e un intero senza segno "u". Questo
l'assunzione è valida solo perché l'avvolgimento del puntatore non è definito, poiché l'espressione è
false se "p + u" trabocca usando l'aritmetica del complemento a due.

Vedi anche il -fwrapv opzione. Usando -fwrapv significa che l'overflow intero con segno è
completamente definito: avvolge. quando -fwrapv viene utilizzato, non c'è differenza tra
-fstrict-overflow ed -fno-rigore-overflow per interi. Insieme a -fwrapv alcuni tipi
di trabocco sono consentiti. Ad esempio, se il compilatore riceve un overflow durante l'esecuzione
aritmetica sulle costanti, il valore in overflow può ancora essere utilizzato con -fwrapv, Ma non
altrimenti.

I -fstrict-overflow l'opzione è abilitata ai livelli -O2, -O3, -Voi.

-funzioni-false
-funzioni-false=n
Allineare l'inizio delle funzioni alla successiva potenza di due maggiore di n, saltando fino a n
byte. Ad esempio, -funzioni-false=32 allinea le funzioni ai successivi 32 byte
confine, ma -funzioni-false=24 si allineerebbe al limite di 32 byte successivo solo se
questo può essere fatto saltando 23 byte o meno.

-fno-align-funzioni ed -funzioni-false=1 sono equivalenti e significano che le funzioni
non sarà allineato.

Alcuni assemblatori supportano questo flag solo quando n è una potenza di due; in tal caso, è
arrotondato.

If n non è specificato o è zero, utilizzare un valore predefinito dipendente dalla macchina.

Abilitato ai livelli -O2, -O3.

-etichette-false
-falign-etichette=n
Allinea tutti i bersagli del ramo a un limite di potenza di due, saltando fino a n byte come
-funzioni-false. Questa opzione può facilmente rendere il codice più lento, perché deve essere inserito
operazioni fittizie per quando il target di diramazione viene raggiunto nel consueto flusso del codice.

-fno-align-etichette ed -falign-etichette=1 sono equivalenti e significano che le etichette non saranno
allineato.

If -falign-loop or -falsi-salti sono applicabili e sono maggiori di questo valore, allora
i loro valori vengono invece utilizzati.

If n non è specificato o è zero, utilizzare un valore predefinito dipendente dalla macchina che è molto probabile
essere 1, ovvero nessun allineamento.

Abilitato ai livelli -O2, -O3.

-falign-loop
-falign-loop=n
Allinea i loop a un limite di potenza di due, saltando fino a n byte come -funzioni-false.
La speranza è che il ciclo venga eseguito molte volte, il che compenserà qualsiasi
esecuzione delle operazioni fittizie.

-fno-align-loop ed -falign-loop=1 sono equivalenti e significano che i loop non saranno
allineato.

If n non è specificato o è zero, utilizzare un valore predefinito dipendente dalla macchina.

Abilitato ai livelli -O2, -O3.

-falsi-salti
-falign-salta=n
Allinea i bersagli del ramo a un limite di potenza di due, per i bersagli del ramo in cui i bersagli
si raggiunge solo saltando, saltando fino a n byte come -funzioni-false. in
in questo caso, non è necessario eseguire operazioni fittizie.

-fno-align-salta ed -salti-falign=1 sono equivalenti e significano che i loop non saranno
allineato.

If n non è specificato o è zero, utilizzare un valore predefinito dipendente dalla macchina.

Abilitato ai livelli -O2, -O3.

-divertimento alla volta
Questa opzione viene lasciata per motivi di compatibilità. -divertimento alla volta non ha alcun effetto, mentre
-fno-unità-alla-volta implica -fno-toplevel-riordina ed -fno-sezione-ancore.

Abilitato per impostazione predefinita.

-fno-toplevel-riordina
Non riordinare funzioni, variabili e istruzioni "asm" di primo livello. Emettili in
nello stesso ordine in cui appaiono nel file di input. Quando si utilizza questa opzione,
le variabili statiche non referenziate non verranno rimosse. Questa opzione ha lo scopo di supportare
codice esistente che si basa su un particolare ordinamento. Per il nuovo codice, è meglio usare
attributi.

Abilitato a livello -O0. Quando disabilitato in modo esplicito, implica anche -fno-sezione-ancore,
che è altrimenti abilitato su -O0 su alcuni obiettivi.

-fweb
Costruisce i web come comunemente usati per scopi di allocazione dei registri e assegna ogni web
pseudo registro individuale. Ciò consente al pass di assegnazione del registro di operare su
pseudos direttamente, ma rafforza anche molti altri passaggi di ottimizzazione, come CSE,
ottimizzatore di loop e banale dispositivo di rimozione del codice morto. Può, tuttavia, eseguire il debug
impossibile, poiché le variabili non rimarranno più in un "registro domestico".

Abilitato per impostazione predefinita con -funroll-loop.

-fintero-programma
Supponiamo che l'unità di compilazione corrente rappresenti l'intero programma in fase di compilazione.
Tutte le funzioni e le variabili pubbliche ad eccezione di "principale" e quelle unite da
l'attributo "visibile_esterno" diventano funzioni statiche e in effetti vengono ottimizzate
in modo più aggressivo dagli ottimizzatori interprocedurali. Se oro viene utilizzato come plug-in del linker,
Gli attributi "visibili_esternamente" vengono aggiunti automaticamente alle funzioni (non ancora variabili
a causa di una corrente oro problema) a cui si accede al di fuori degli oggetti LTO in base a
file di risoluzione prodotto da oro. Per altri linker che non possono generare risoluzione
file, sono ancora necessari attributi espliciti "visibile_esterno". Mentre questa opzione
è equivalente all'uso corretto della parola chiave "static" per programmi costituiti da a
singolo file, in combinazione con l'opzione -flto questo flag può essere usato per compilarne molti
programmi su scala più piccola poiché le funzioni e le variabili diventano locali per l'insieme
unità di compilazione combinata, non per il singolo file sorgente stesso.

Questa opzione implica -fintero-file per i programmi Fortran.

-flto[=n]
Questa opzione esegue l'ottimizzatore del tempo di collegamento standard. Quando viene invocato con il codice sorgente, è
genera GIMPLE (una delle rappresentazioni interne di GCC) e lo scrive nell'ELF speciale
sezioni nel file oggetto. Quando i file oggetto sono collegati tra loro, tutti i
i corpi funzione vengono letti da queste sezioni ELF e istanziati come se fossero stati
parte della stessa unità di traduzione.

Per utilizzare l'ottimizzatore del tempo di collegamento, -flto deve essere specificato al momento della compilazione e durante
il collegamento finale. Per esempio:

gcc -c -O2 -flto foo.c
gcc -c -O2 -flto bar.c
gcc -o mioprog -flto -O2 foo.o bar.o

Le prime due invocazioni a GCC salvano una rappresentazione bytecode di GIMPLE in special
Sezioni ELF all'interno foo.o ed bar.o. L'invocazione finale legge il bytecode di GIMPLE
da foo.o ed bar.o, unisce i due file in un'unica immagine interna e compila
il risultato come al solito. Dal momento che entrambi foo.o ed bar.o sono uniti in un'unica immagine, questo
fa sì che tutte le analisi e le ottimizzazioni interprocedurali in GCC funzionino in tutto il
due file come se fossero uno solo. Ciò significa, ad esempio, che l'inliner è
in grado di incorporare funzioni in bar.o in funzioni in foo.o e viceversa.

Un altro modo (più semplice) per abilitare l'ottimizzazione del tempo di collegamento è:

gcc -o mioprog -flto -O2 foo.c bar.c

Quanto sopra genera bytecode per foo.c ed bar.c, li fonde insieme in un unico
rappresentazione GIMPLE e li ottimizza come al solito per produrre il mio programma.

L'unica cosa importante da tenere a mente è che per abilitare l'ottimizzazione del tempo di collegamento il
-flto flag deve essere passato sia al comando compile che a quello link.

Per rendere efficace l'ottimizzazione dell'intero programma, è necessario creare determinati elementi
ipotesi di programma. Il compilatore deve sapere quali funzioni e variabili possono essere
accessibile da librerie e runtime al di fuori dell'unità ottimizzata per il tempo di collegamento. quando
supportato dal linker, il plugin del linker (vedi -plug-in-fuse-linker) passa
informazioni al compilatore sui simboli utilizzati e visibili esternamente. Quando il
il plug-in del linker non è disponibile, -fintero-programma dovrebbe essere usato per consentire al compilatore
per fare queste ipotesi, il che porta a decisioni di ottimizzazione più aggressive.

Nota che quando un file viene compilato con -flto, il file oggetto generato è più grande di
un normale file oggetto perché contiene i bytecode di GIMPLE e il solito codice finale.
Ciò significa che i file oggetto con informazioni LTO possono essere collegati come oggetti normali
File; Se -flto non viene passato al linker, non sono previste ottimizzazioni interprocedurali
applicato.

Inoltre, i flag di ottimizzazione utilizzati per compilare i singoli file non lo sono
necessariamente correlati a quelli utilizzati al momento del collegamento. Ad esempio,

gcc -c -O0 -flto foo.c
gcc -c -O0 -flto bar.c
gcc -o mioprog -flto -O3 foo.o bar.o

Questo produce file oggetto individuali con codice assembler non ottimizzato, ma
binario risultante il mio programma è ottimizzato a -O3. Se invece il binario finale è
generato senza -flto, poi il mio programma non è ottimizzato.

Quando si produce il binario finale con -flto, GCC applica solo ottimizzazioni del tempo di collegamento
a quei file che contengono bytecode. Pertanto, puoi combinare e abbinare file oggetto
e librerie con bytecode GIMPLE e codice oggetto finale. GCC seleziona automaticamente
quali file ottimizzare in modalità LTO e quali file collegare senza ulteriore
trattamento.

Ci sono alcuni flag di generazione del codice conservati da GCC durante la generazione di bytecode, come
devono essere utilizzati durante la fase di collegamento finale. Attualmente, le seguenti opzioni
vengono salvati nei file bytecode di GIMPLE: -fPIC, -fcomune e tutto il -m bandiere di destinazione.

Al momento del collegamento, queste opzioni vengono lette e riapplicate. Nota che la corrente
l'implementazione non fa alcun tentativo di riconoscere valori in conflitto per queste opzioni. Se
file diversi hanno valori di opzione in conflitto (ad esempio, un file viene compilato con -fPIC
e un altro no), il compilatore usa semplicemente l'ultimo valore letto dal bytecode
File. Si consiglia, quindi, di compilare tutti i file che partecipano al
stesso collegamento con le stesse opzioni.

Se LTO incontra oggetti con collegamento C dichiarato con tipi incompatibili in separati
unità di traslazione da collegare tra loro (comportamento indefinito secondo ISO C99
6.2.7), può essere emessa una diagnosi non fatale. Il comportamento è ancora indefinito durante l'esecuzione
tempo.

Un'altra caratteristica di LTO è che è possibile applicare ottimizzazioni interprocedurali
su file scritti in lingue diverse. Ciò richiede supporto sul fronte della lingua
fine. Attualmente, i front-end C, C++ e Fortran sono in grado di emettere GIMPLE
bytecode, quindi qualcosa del genere dovrebbe funzionare:

gcc -c -flto foo.c
g ++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o mioprog -flto -O3 foo.o bar.o baz.o -lgfortran

Notare che il collegamento finale è fatto con g ++ per ottenere le librerie runtime C++ e
-lgfortran viene aggiunto per ottenere le librerie runtime Fortran. In generale, durante la miscelazione
lingue in modalità LTO, dovresti usare le stesse opzioni di comando di collegamento come durante il missaggio
lingue in una compilazione regolare (non LTO); tutto ciò che devi aggiungere è -flto per tutta la
compila e collega i comandi.

Se i file oggetto contenenti il ​​bytecode GIMPLE sono archiviati in un archivio di libreria, diciamo
libfoo.a, è possibile estrarli e utilizzarli in un collegamento LTO se si utilizza un
linker con supporto plugin. Per abilitare questa funzione, usa il flag -plug-in-fuse-linker
al momento del collegamento:

gcc -o myprog -O2 -flto -fuse-linker-plugin ao bo -lfoo

Con il plugin linker abilitato, il linker estrae i file GIMPLE necessari da
libfoo.a e li passa al GCC in esecuzione per renderli parte dell'aggregato
Immagine GIMPLE da ottimizzare.

Se non stai utilizzando un linker con supporto per plugin e/o non abiliti il ​​linker
plugin, quindi gli oggetti all'interno libfoo.a vengono estratti e collegati come al solito, ma
non partecipano al processo di ottimizzazione LTO.

Le ottimizzazioni del tempo di collegamento non richiedono la presenza dell'intero programma per funzionare.
Se il programma non richiede l'esportazione di simboli, è possibile combinare
-flto ed -fintero-programma per consentire agli ottimizzatori interprocedurali di utilizzare di più
ipotesi aggressive che possono portare a migliori opportunità di ottimizzazione. Uso di
-fintero-programma nonènecessario quando il plugin linkerèattivo (vedi -plug-in-fuse-linker).

L'attuale implementazione di LTO non tenta di generare bytecode che è
portabile tra diversi tipi di host. I file bytecode sono versionati e lì
è un rigoroso controllo della versione, quindi i file bytecode generati in una versione di GCC non lo faranno
lavorare con una versione precedente/nuova di GCC.

L'ottimizzazione del tempo di collegamento non funziona bene con la generazione di informazioni di debug.
La combinazione di -flto con -g è attualmente sperimentale e dovrebbe produrre risultati errati
risultati.

Se specifichi l'optional n, l'ottimizzazione e la generazione del codice eseguite al momento del collegamento
viene eseguito in parallelo utilizzando n lavori paralleli utilizzando un installato make .
La variabile d'ambiente FARE può essere utilizzato per sovrascrivere il programma utilizzato. Il predefinito
valore per n è 1.

Puoi anche specificare -flto=server di lavoro usare la modalità job server di GNU make per determinare
il numero di lavori paralleli. Questo è utile quando il Makefile che chiama GCC è già
esecuzione in parallelo. Devi anteporre a + alla ricetta di comando nel genitore
Makefile per farlo funzionare. Questa opzione probabilmente funziona solo se FARE è prodotto da GNU.

Questa opzione è disabilitata di default

-flto-partizione=alg
Specificare l'algoritmo di partizionamento utilizzato dall'ottimizzatore del tempo di collegamento. Il valore è
o "1to1" per specificare un partizionamento che rispecchia i file sorgente originali o
"bilanciato" per specificare il partizionamento in blocchi di dimensioni uguali (ove possibile).
Specificare "none" come algoritmo disabilita completamente il partizionamento e lo streaming. Il
il valore predefinito è "bilanciato".

-flto-livello-di-compressione=n
Questa opzione specifica il livello di compressione utilizzato per la lingua scritta intermedia
ai file oggetto LTO ed è significativo solo in combinazione con la modalità LTO (-flto).
I valori validi vanno da 0 (nessuna compressione) a 9 (compressione massima). Valori al di fuori di questo
sono fissati su 0 o 9. Se l'opzione non è data, un valore predefinito bilanciato
viene utilizzata l'impostazione di compressione.

-flto-report
Stampa un report con dettagli interni sul funzionamento dell'ottimizzatore del tempo di collegamento. Il
i contenuti di questo rapporto variano da versione a versione. È pensato per essere utile a GCC
sviluppatori durante l'elaborazione di file oggetto in modalità LTO (tramite -flto).

Disabilitato per impostazione predefinita.

-plug-in-fuse-linker
Consente l'uso di un plug-in linker durante l'ottimizzazione del tempo di collegamento. Questa opzione si basa
sul supporto dei plugin nel linker, che è disponibile in gold o in GNU ld 2.21 o
più nuovo.

Questa opzione abilita l'estrazione di file oggetto con bytecode GIMPLE fuori dalla libreria
archivi. Ciò migliora la qualità dell'ottimizzazione esponendo più codice al link-
ottimizzatore di tempo Queste informazioni specificano a quali simboli è possibile accedere dall'esterno
(per oggetto non LTO o durante il collegamento dinamico). Miglioramenti della qualità del codice risultanti attivati
i binari (e le librerie condivise che usano la visibilità nascosta) sono simili a
"-fintero programma". Vedere -flto per una descrizione dell'effetto di questo flag e come
Usalo.

Questa opzione è abilitata per impostazione predefinita quando il supporto LTO in GCC è abilitato e GCC era
configurato per l'uso con un linker che supporta i plugin (GNU ld 2.21 o successivo o gold).

-ffat-lto-oggetti
Gli oggetti Fat LTO sono file oggetto che contengono sia il linguaggio intermedio che il
codice oggetto. Ciò li rende utilizzabili sia per il collegamento LTO che per il collegamento normale. Questo
l'opzione è efficace solo quando si compila con -flto e viene ignorato al momento del collegamento.

-fno-fat-lto-oggetti migliora il tempo di compilazione rispetto al semplice LTO, ma richiede il
toolchain completa per essere a conoscenza di LTO. Richiede un linker con supporto per il plugin linker
per le funzionalità di base. Inoltre, nm, ar e ranlib devono supportare il linker
plugin per consentire un ambiente di compilazione completo (in grado di creare statico
biblioteche ecc.).

L'impostazione predefinita è -ffat-lto-oggetti ma questa impostazione predefinita è destinata a cambiare in futuro
rilascia quando gli ambienti abilitati per il plugin linker diventano più comuni.

-fcompare-elimina
Dopo l'assegnazione del registro e la suddivisione delle istruzioni di assegnazione post-registrazione, identificare
istruzioni aritmetiche che calcolano i flag del processore simili a un'operazione di confronto
in base a tale aritmetica. Se possibile, eliminare l'operazione di confronto esplicito.

Questo pass si applica solo a determinati obiettivi che non possono rappresentare esplicitamente il
operazione di confronto prima che l'allocazione del registro sia completata.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fuse-ld=oro
Usa il oro linker invece del linker predefinito.

-fuse-ld=bfd
Usa il ld.bfd linker invece del linker predefinito.

-fcprop-registri
Dopo l'allocazione dei registri e la suddivisione delle istruzioni di assegnazione post-registrazione,
eseguire un passaggio di propagazione della copia per cercare di ridurre le dipendenze di pianificazione e
eliminare occasionalmente la copia.

Abilitato ai livelli -O, -O2, -O3, -Voi.

-fcorrezione del profilo
I profili raccolti utilizzando un binario strumentato per programmi multi-thread possono essere
incoerente a causa di mancati aggiornamenti del contatore. Quando questa opzione è specificata, GCC lo farà
utilizzare l'euristica per correggere o appianare tali incongruenze. Per impostazione predefinita, GCC lo farà
emette un messaggio di errore quando viene rilevato un profilo incoerente.

-fdir-profilo=sentiero
Imposta la directory in cui cercare i file di dati del profilo in sentiero. Questa opzione
interessa solo i dati del profilo generati da -fprofile-genera, -ftest-copertura,
-fprofile-archi e utilizzato da -fprofile-uso ed -fbranch-probabilità e relativi
opzioni. Possono essere utilizzati sia percorsi assoluti che relativi. Per impostazione predefinita, GCC utilizzerà il
directory corrente come sentiero, quindi il file dei dati del profilo apparirà nello stesso
directory come file oggetto.

-fprofile-genera
-fprofile-genera=sentiero
Abilita le opzioni solitamente utilizzate per la strumentazione dell'applicazione per produrre un profilo utile
per una successiva ricompilazione con ottimizzazione basata sul feedback del profilo. Devi usare
-fprofile-genera sia durante la compilazione che durante il collegamento del programma.

Sono abilitate le seguenti opzioni: "-fprofile-arcs", "-fprofile-values", "-fvpt".

If sentiero è specificato, GCC esaminerà il sentiero per trovare i dati di feedback del profilo
File. Vedere -fdir-profilo.

-fprofile-uso
-fuso-profilo=sentiero
Abilita ottimizzazioni dirette al feedback del profilo e ottimizzazioni generalmente redditizie
solo con feedback del profilo disponibile.

Sono abilitate le seguenti opzioni: "-fbranch-probabilities", "-fvpt",
"-funroll-loops", "-fpeel-loops", "-ftracer"

Per impostazione predefinita, GCC emette un messaggio di errore se i profili di feedback non corrispondono ai
codice sorgente. Questo errore può essere trasformato in un avviso utilizzando -Wcoverage-mancata corrispondenza.
Tieni presente che ciò potrebbe comportare un codice mal ottimizzato.

If sentiero è specificato, GCC esaminerà il sentiero per trovare i dati di feedback del profilo
File. Vedere -fdir-profilo.

Le seguenti opzioni controllano il comportamento del compilatore riguardo all'aritmetica in virgola mobile.
Queste opzioni si bilanciano tra velocità e correttezza. Tutto deve essere specificamente abilitato.

-float-negozio
Non memorizzare variabili a virgola mobile nei registri e inibire altre opzioni che
potrebbe cambiare se un valore in virgola mobile viene preso da un registro o da una memoria.

Questa opzione impedisce un'eccessiva precisione indesiderata su macchine come la 68000 dove
i registri flottanti (del 68881) mantengono più precisione di quanto si supponga un "doppio"
avere. Allo stesso modo per l'architettura x86. Per la maggior parte dei programmi, l'eccesso di precisione
fa solo bene, ma alcuni programmi si basano sulla definizione precisa di IEEE floating
punto. Utilizzo -float-negozio per tali programmi, dopo averli modificati per memorizzarli tutti
calcoli intermedi pertinenti in variabili.

-fexcess-precisione=style
Questa opzione consente un ulteriore controllo sull'eccesso di precisione su macchine in cui
i registri a punti hanno una precisione maggiore rispetto ai tipi IEEE "float" e "double" e
il processore non supporta le operazioni di arrotondamento a quei tipi. Per impostazione predefinita,
-fexcess-precision=veloce è in vigore; ciò significa che le operazioni vengono eseguite in
la precisione dei registri e che sia imprevedibile nell'arrotondamento ai tipi
specificato nel codice sorgente ha luogo. Quando si compila C, se
-fexcess-precision=standard è specificato, quindi l'eccesso di precisione seguirà le regole
specificato nella ISO C99; in particolare, sia i cast che le assegnazioni fanno sì che i valori siano
arrotondati ai loro tipi semantici (mentre -float-negozio riguarda solo le assegnazioni).
Questa opzione è abilitata per impostazione predefinita per C se un'opzione di conformità rigorosa come
-std=c99 viene utilizzato.

-fexcess-precision=standard non è implementato per linguaggi diversi dal C e non ha
effetto se -funsafe-math-ottimizzazioni or -fast-matematica è specificato. Su x86, è
inoltre non ha effetto se -mfpmth=sse or -mfpmath=sse+387 è specificato; nella prima
caso, la semantica IEEE si applica senza eccessiva precisione e, in quest'ultimo, l'arrotondamento è
imprevedibile.

-fast-matematica
Set -fno-matematica-errno, -funsafe-math-ottimizzazioni, -finite-math-only,
-fno-arrotondamento-matematico, -fno-segnalazione-nans ed -fcx-intervallo limitato.

Questa opzione determina la definizione della macro del preprocessore "__FAST_MATH__".

Questa opzione non è attivata da nessuno -O opzione inoltre - Veloce poiché può risultare in
output non corretto per programmi che dipendono da un'esatta implementazione di IEEE o ISO
regole/specifiche per le funzioni matematiche. Potrebbe, tuttavia, produrre codice più veloce per
programmi che non richiedono le garanzie di queste specifiche.

-fno-matematica-errno
Non impostare ERRNO dopo aver chiamato funzioni matematiche eseguite con un singolo
istruzione, ad esempio sqrt. Un programma che si basa su eccezioni IEEE per errori matematici
la gestione potrebbe voler utilizzare questo flag per la velocità mantenendo l'aritmetica IEEE
la compatibilità.

Questa opzione non è attivata da nessuno -O opzione poiché può causare un output errato
per programmi che dipendono da un'esatta implementazione di IEEE o ISO
regole/specifiche per le funzioni matematiche. Potrebbe, tuttavia, produrre codice più veloce per
programmi che non richiedono le garanzie di queste specifiche.

L'impostazione predefinita è -fmath-errno.

Sui sistemi Darwin, la libreria matematica non imposta mai "errno". Non c'è quindi motivo
affinché il compilatore consideri la possibilità che potrebbe, e -fno-matematica-errno Europe è
predefinito.

-funsafe-math-ottimizzazioni
Consenti ottimizzazioni per l'aritmetica in virgola mobile che (a) presuppongano argomenti e
i risultati sono validi e (b) possono violare gli standard IEEE o ANSI. Se utilizzato in fase di collegamento,
può includere librerie o file di avvio che cambiano la parola di controllo FPU predefinita o
altre ottimizzazioni simili.

Questa opzione non è attivata da nessuno -O opzione poiché può causare un output errato
per programmi che dipendono da un'esatta implementazione di IEEE o ISO
regole/specifiche per le funzioni matematiche. Potrebbe, tuttavia, produrre codice più veloce per
programmi che non richiedono le garanzie di queste specifiche. Consente
-fno-signed-zero, -fno-trapping-matematica, -math-fassociativo ed - matematica-freciproca.

L'impostazione predefinita è -fno-unsafe-math-ottimizzazioni.

-math-fassociativo
Consentire la riassociazione degli operandi in serie di operazioni a virgola mobile. Questo
viola lo standard del linguaggio ISO C e C++ modificando eventualmente il risultato del calcolo.
NOTA: il riordino può cambiare il segno di zero così come ignorare i NaN e inibire o
creare underflow o overflow (e quindi non può essere utilizzato su codice che si basa sull'arrotondamento
comportamento come "(x + 2**52) - 2**52". Può anche riordinare i confronti in virgola mobile e
pertanto non può essere utilizzato quando sono richiesti confronti ordinati. Questa opzione richiede che
entrambi -fno-signed-zero ed -fno-trapping-matematica essere in vigore. Inoltre, non rende
molto senso con -matematica-fondamentale. Per Fortran l'opzione viene abilitata automaticamente quando
entrambi -fno-signed-zero ed -fno-trapping-matematica sono in vigore.

L'impostazione predefinita è -fno-associativo-math.

- matematica-freciproca
Consentire l'uso del reciproco di un valore invece di dividere per il valore se questo
consente le ottimizzazioni. Ad esempio "x / y" può essere sostituito con "x * (1/y)", che è
utile se "(1/y)" è soggetto all'eliminazione della sottoespressione comune. Nota che questo
perde precisione e aumenta il numero di flop operando sul valore.

L'impostazione predefinita è -fno-reciproco-math.

-finite-math-only
Consenti ottimizzazioni per l'aritmetica in virgola mobile che presuppongono che argomenti e
i risultati non sono NaN o +-Inf.

Questa opzione non è attivata da nessuno -O opzione poiché può causare un output errato
per programmi che dipendono da un'esatta implementazione di IEEE o ISO
regole/specifiche per le funzioni matematiche. Potrebbe, tuttavia, produrre codice più veloce per
programmi che non richiedono le garanzie di queste specifiche.

L'impostazione predefinita è -fno-finite-solo-matematica.

-fno-signed-zero
Consenti ottimizzazioni per l'aritmetica in virgola mobile che ignorano il segno di zero.
L'aritmetica IEEE specifica il comportamento di valori distinti +0.0 e -0.0, che quindi
proibisce la semplificazione di espressioni come x+0.0 o 0.0*x (anche con
-finite-math-only). Questa opzione implica che il segno di un risultato zero non è
significativo.

L'impostazione predefinita è -fsigned-zeri.

-fno-trapping-matematica
Compila il codice assumendo che le operazioni in virgola mobile non possano generare visibilità dall'utente
trappole. Queste trappole includono divisione per zero, overflow, underflow, risultato inesatto e
operazione non valida. Questa opzione richiede che -fno-segnalazione-nans essere in vigore.
L'impostazione di questa opzione può consentire un codice più veloce se si fa affidamento sull'aritmetica IEEE "non-stop",
per esempio.

Questa opzione non dovrebbe mai essere attivata da nessuno -O opzione poiché può risultare in
output non corretto per programmi che dipendono da un'esatta implementazione di IEEE o ISO
regole/specifiche per le funzioni matematiche.

L'impostazione predefinita è -trapping-matematica.

-matematica-fondamentale
Disabilita le trasformazioni e le ottimizzazioni che presuppongono l'arrotondamento a virgola mobile predefinito
comportamento. Questo è l'arrotondamento a zero per tutte le conversioni da virgola mobile a numero intero e
arrotondato al più vicino per tutti gli altri troncamenti aritmetici. Questa opzione dovrebbe essere
specificata per i programmi che modificano dinamicamente la modalità di arrotondamento FP o che potrebbero essere
eseguito con una modalità di arrotondamento non predefinita. Questa opzione disabilita il ripiegamento costante di
espressioni in virgola mobile in fase di compilazione (che possono essere influenzate dalla modalità di arrotondamento)
e trasformazioni aritmetiche che non sono sicure in presenza di dipendenti dal segno
modalità di arrotondamento.

L'impostazione predefinita è -fno-arrotondamento-matematico.

Questa opzione è sperimentale e al momento non garantisce la disattivazione di tutti i GCC
ottimizzazioni che sono influenzate dalla modalità di arrotondamento. Le versioni future di GCC potrebbero fornire
controllo più preciso di questa impostazione utilizzando il pragma "FENV_ACCESS" di C99. Questa riga di comando
verrà utilizzata per specificare lo stato predefinito per "FENV_ACCESS".

-fsegnalazione-nans
Compilare il codice presumendo che i NaN di segnalazione IEEE possano generare trap visibili dall'utente durante
operazioni in virgola mobile. L'impostazione di questa opzione disabilita le ottimizzazioni che potrebbero cambiare
il numero di eccezioni visibili con i NaN di segnalazione. Questa opzione implica
-trapping-matematica.

Questa opzione determina la definizione della macro del preprocessore "__SUPPORT_SNAN__".

L'impostazione predefinita è -fno-segnalazione-nans.

Questa opzione è sperimentale e al momento non garantisce la disattivazione di tutti i GCC
ottimizzazioni che influenzano il comportamento di segnalazione NaN.

-fcostante-di-precisione-singola
Tratta le costanti in virgola mobile come precisione singola invece di convertirle implicitamente
loro a costanti a precisione doppia.

-fcx-intervallo limitato
Quando abilitata, questa opzione indica che non è necessario un passaggio di riduzione dell'intervallo quando
eseguire divisioni complesse. Inoltre, non è possibile verificare se il risultato di a
moltiplicazione o divisione complessa è "NaN + I*NaN", con un tentativo di salvare il
situazione in quel caso. L'impostazione predefinita è -fno-cx-intervallo limitato, ma è abilitato da
-fast-matematica.

Questa opzione controlla l'impostazione predefinita del pragma ISO C99 "CX_LIMITED_RANGE".
Tuttavia, l'opzione si applica a tutte le lingue.

-fcx-fortran-regole
Le moltiplicazioni e le divisioni complesse seguono le regole del Fortran. La riduzione della portata viene eseguita come
parte di una divisione complessa, ma non si verifica se il risultato di un complesso
la moltiplicazione o la divisione è "NaN + I*NaN", con un tentativo di salvare la situazione
in quel caso.

L'impostazione predefinita è -fno-cx-fortran-regole.

Le seguenti opzioni controllano le ottimizzazioni che possono migliorare le prestazioni, ma non lo sono
abilitato da qualsiasi -O opzioni. Questa sezione include opzioni sperimentali che possono produrre
codice rotto.

-fbranch-probabilità
Dopo aver eseguito un programma compilato con -fprofile-archi, puoi compilarlo una seconda volta
utilizzando -fbranch-probabilità, per migliorare le ottimizzazioni in base al numero di volte
ogni ramo è stato preso. Quando il programma è stato compilato con -fprofile-archi esce salva
l'esecuzione di arc conta in un file chiamato nomeorigine.gcda per ogni file sorgente. Il
le informazioni in questo file di dati dipendono molto dalla struttura del generato
codice, quindi è necessario utilizzare lo stesso codice sorgente e le stesse opzioni di ottimizzazione per entrambi
compilazioni.

Con -fbranch-probabilità, GCC mette a REG_BR_PROB nota su ciascuno SALTO_INSN ed
CHIAMA_INSN. Questi possono essere utilizzati per migliorare l'ottimizzazione. Attualmente vengono utilizzati solo
in un posto: in riorg.c, invece di indovinare su quale percorso è più probabile che un ramo
prendi, il REG_BR_PROB i valori vengono utilizzati per determinare esattamente quale percorso viene preso di più
spesso.

-fprofile-valori
Se abbinato a -fprofile-archi, aggiunge codice in modo che alcuni dati sui valori di
vengono raccolte le espressioni del programma.

Con -fbranch-probabilità, rilegge i dati raccolti dai valori di profilazione di
espressioni per l'utilizzo nelle ottimizzazioni.

Abilitato con -fprofile-genera ed -fprofile-uso.

-fvpt
Se abbinato a -fprofile-archi, indica al compilatore di aggiungere un codice da raccogliere
informazioni sui valori delle espressioni.

Con -fbranch-probabilità, rilegge i dati raccolti ed esegue effettivamente il
ottimizzazioni basate su di essi. Attualmente le ottimizzazioni includono la specializzazione di
operazione di divisione utilizzando la conoscenza del valore del denominatore.

-frename-registri
Tentativo di evitare false dipendenze nel codice pianificato utilizzando i registri rimasti
dopo l'assegnazione del registro. Questa ottimizzazione andrà a vantaggio della maggior parte dei processori con
molti registri. A seconda del formato delle informazioni di debug adottato dal target,
tuttavia, può rendere impossibile il debug, poiché le variabili non rimarranno più in a
"registro di casa".

Abilitato per impostazione predefinita con -funroll-loop ed -fpeel-loop.

-tracer
Eseguire la duplicazione della coda per ingrandire le dimensioni del superblocco. Questa trasformazione semplifica
il flusso di controllo della funzione consentendo ad altre ottimizzazioni di svolgere un lavoro migliore.

Abilitato con -fprofile-uso.

-funroll-loop
Unroll loop il cui numero di iterazioni può essere determinato al momento della compilazione o al momento della compilazione
ingresso nel ciclo. -funroll-loop implica -frerun-cse-dopo-loop, -fweb ed
-frename-registri. Attiva anche il peeling completo del ciclo (cioè la rimozione completa di
cicli con un piccolo numero costante di iterazioni). Questa opzione rende il codice più grande e
può o non può farlo funzionare più velocemente.

Abilitato con -fprofile-uso.

-funroll-tutti i loop
Srotola tutti i loop, anche se il loro numero di iterazioni è incerto quando il loop è
entrato. Questo di solito rende i programmi più lenti. -funroll-tutti i loop implica il
stesse opzioni di -funroll-loop.

-fpeel-loop
Sbuccia i loop per i quali ci sono abbastanza informazioni da non rotolare molto (da
feedback sul profilo). Attiva anche il peeling completo del ciclo (cioè la rimozione completa di
cicli con un piccolo numero costante di iterazioni).

Abilitato con -fprofile-uso.

-fmove-loop-invarianti
Abilita il passaggio di movimento invariante di loop nell'ottimizzatore di loop RTL. Abilitato a livello
-O1

-funswitch-loop
Sposta rami con condizioni invarianti di loop fuori dal loop, con duplicati di
loop su entrambi i rami (modificato in base al risultato della condizione).

-ffunzioni-sezioni
-fdata-sezioni
Posiziona ogni funzione o elemento di dati nella propria sezione nel file di output se l'obiettivo
supporta sezioni arbitrarie. Il nome della funzione o il nome del dato
determina il nome della sezione nel file di output.

Usa queste opzioni sui sistemi in cui il linker può eseguire ottimizzazioni per migliorare
località di riferimento nello spazio delle istruzioni. La maggior parte dei sistemi che utilizzano l'oggetto ELF
formato e i processori SPARC che eseguono Solaris 2 dispongono di linker con tali ottimizzazioni.
AIX potrebbe avere queste ottimizzazioni in futuro.

Utilizzare queste opzioni solo quando ci sono vantaggi significativi dal farlo. Quando tu
specifica queste opzioni, l'assemblatore e il linker creeranno oggetti più grandi e
file eseguibili e sarà anche più lento. Non potrai usare "gprof" su tutti
sistemi se specifichi questa opzione e potresti avere problemi con il debug se
specificare sia questa opzione che -g.

-fbranch-target-load-ottimizzare
Eseguire l'ottimizzazione del carico del registro di destinazione del ramo prima del threading del prologo/epilogo.
L'uso dei registri di destinazione può essere tipicamente esposto solo durante la ricarica, quindi il sollevamento
carichi fuori dai cicli e l'esecuzione della pianificazione tra blocchi richiede un'ottimizzazione separata
passaggio.

-fbranch-target-load-optimize2
Esegui l'ottimizzazione del carico del registro di destinazione del ramo dopo il threading del prologo/epilogo.

-fbtr-bb-esclusiva
Quando si esegue l'ottimizzazione del carico del registro di destinazione del ramo, non riutilizzare il target del ramo
si registra all'interno di qualsiasi blocco di base.

-fstack-protettore
Emetti codice aggiuntivo per verificare la presenza di buffer overflow, come gli attacchi di distruzione dello stack. Questo
viene fatto aggiungendo una variabile guard alle funzioni con oggetti vulnerabili. Questo
include funzioni che chiamano alloca e funzioni con buffer maggiori di 8 byte.
Le protezioni vengono inizializzate all'inserimento di una funzione e poi verificate al
la funzione esce. Se un controllo di protezione fallisce, viene stampato un messaggio di errore e il programma
esce.

NOTA: in Ubuntu 6.10 e versioni successive questa opzione è abilitata per impostazione predefinita per C, C++,
ObjC, ObjC++, se nessuno di -fno-stack-protettore, -nostdlib, né -autoportante sono
trovato.

-fstack-protettore-tutto
Come -fstack-protettore tranne che tutte le funzioni sono protette.

-fsection-ancore
Prova a ridurre il numero di calcoli dell'indirizzo simbolico utilizzando un "ancoraggio" condiviso
simboli per indirizzare gli oggetti vicini. Questa trasformazione può aiutare a ridurre il numero
di voci GOT e accessi GOT su alcuni target.

Ad esempio, l'implementazione della seguente funzione "pippo":

statico int a, b, c;
int foo (vuoto) { return a + b + c; }

di solito calcola gli indirizzi di tutte e tre le variabili, ma se lo compili
con -fsection-ancore, accederà alle variabili da un punto di ancoraggio comune
Invece. L'effetto è simile al seguente pseudocodice (che non è valido C):

int foo (vuoto)
{
registra int *xr = &x;
restituisce xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}

Non tutti i target supportano questa opzione.

--parami Nome=APPREZZIAMO
In alcuni punti, GCC utilizza varie costanti per controllare la quantità di ottimizzazione che
è fatta. Ad esempio, GCC non inline funzioni che contengono più di un certo
numero di istruzioni. Puoi controllare alcune di queste costanti dalla riga di comando
usando il --parami opzione.

I nomi di parametri specifici, e il significato dei valori, sono legati al
interni del compilatore e sono soggetti a modifiche senza preavviso in futuro
stampa.

In ogni caso, il APPREZZIAMO è un numero intero. Le scelte consentite per Nome sono ceduti
la seguente tabella:

prevedibile-ramo-risultato
Quando si prevede che il ramo venga intrapreso con probabilità inferiore a questa soglia
(in percentuale), allora è considerato ben prevedibile. Il valore predefinito è 10.

max-crossjump-edge
Il numero massimo di fronti in entrata da considerare per il salto incrociato. L'algoritmo
utilizzato da -salto incrociato è O(N^2) nel numero di archi in arrivo a ciascun blocco.
L'aumento dei valori significa un'ottimizzazione più aggressiva, rendendo il tempo di compilazione
aumentare con probabilmente un piccolo miglioramento nella dimensione dell'eseguibile.

min-crossjump-insns
Il numero minimo di istruzioni che devono essere abbinate alla fine di due blocchi
prima che su di loro venga eseguito il salto incrociato. Questo valore viene ignorato nel caso
dove tutte le istruzioni nel blocco da cui si esegue il salto incrociato sono abbinate. Il
il valore predefinito è 5.

max-grow-copy-bb-insns
Il fattore di espansione della dimensione massima del codice durante la copia di blocchi di base invece di
saltare. L'espansione è relativa a un'istruzione di salto. Il valore predefinito è
8.

max-goto-duplication-insns
Il numero massimo di istruzioni da duplicare in un blocco che salta a a
goto calcolato. Per evitare il comportamento O(N^2) in un numero di passaggi, i fattori GCC
ha calcolato i goto all'inizio del processo di compilazione e li scompone fino al più tardi
possibile. Solo salti calcolati alla fine di un blocco base con non più di max-
goto-duplication-insns non sono fattorizzati. Il valore predefinito è 8.

max-delay-slot-insn-ricerca
Il numero massimo di istruzioni da considerare quando si cerca un'istruzione da
riempire uno slot di ritardo. Se più di questo numero arbitrario di istruzioni è
cercato, il risparmio di tempo per riempire lo slot di ritardo sarà minimo, quindi fermati
ricerca. Valori crescenti significano un'ottimizzazione più aggressiva, rendendo il
aumento del tempo di compilazione con probabilmente un piccolo miglioramento del tempo di esecuzione.

max-delay-slot-ricerca-live
Quando si tenta di riempire gli slot di ritardo, il numero massimo di istruzioni da considerare
durante la ricerca di un blocco con informazioni di registro live valide. Aumentando questo
valore scelto arbitrariamente significa ottimizzazione più aggressiva, aumentando il
tempo di compilazione. Questo parametro deve essere rimosso quando il codice dello slot di ritardo è
riscritto per mantenere il grafico del flusso di controllo.

max-gcse-memoria
La quantità massima approssimativa di memoria che verrà allocata per
eseguire l'ottimizzazione dell'eliminazione della sottoespressione comune globale. Se più memoria
di quanto specificato è richiesto, l'ottimizzazione non verrà eseguita.

rapporto di inserimento max-gcse
Se il rapporto tra inserimenti di espressioni e cancellazioni è maggiore di questo valore per
qualsiasi espressione, quindi RTL PRE inserirà o rimuoverà l'espressione e quindi se ne andrà
calcoli parzialmente ridondanti nel flusso di istruzioni. Il valore predefinito è
20

lunghezza-elenco-in attesa
Il numero massimo di dipendenze in sospeso che la pianificazione consentirà prima dello svuotamento
lo stato attuale e ricominciare da capo. Grandi funzioni con pochi rami o chiamate
può creare elenchi eccessivamente grandi che consumano inutilmente memoria e risorse.

max-modulo-backtrack-tentativi
Il numero massimo di tentativi di backtrack che lo scheduler dovrebbe fare quando modulo
pianificazione di un ciclo. Valori più grandi possono aumentare esponenzialmente il tempo di compilazione.

max-inline-insns-singolo
Diversi parametri controllano l'inliner dell'albero usato in gcc. Questo numero imposta il
numero massimo di istruzioni (conteggiato nella rappresentazione interna di GCC) in a
singola funzione che l'inliner dell'albero prenderà in considerazione per l'inlining. Solo questo
influenza le funzioni dichiarate in linea e i metodi implementati in una dichiarazione di classe
(C++). Il valore predefinito è 400.

Max-Inline-Insns-Auto
Quando si utilizza -funzioni-finline (incluso in -O3), molte funzioni che sarebbero
in caso contrario non verrà preso in considerazione per l'inlining da parte del compilatore. Per
quelle funzioni, un limite diverso (più restrittivo) rispetto alle funzioni
dichiarato in linea può essere applicato. Il valore predefinito è 40.

grandi funzioni-insns
Il limite che specifica funzioni veramente grandi. Per funzioni maggiori di questo limite
dopo l'inlining, l'inlining è vincolato da --parami grande-funzione-crescita. Questo
è utile principalmente per evitare tempi di compilazione estremi causati da non
algoritmi lineari utilizzati dal back-end. Il valore predefinito è 2700.

grande-funzione-crescita
Specifica la crescita massima della funzione grande causata dall'allineamento in percentuale. Il
il valore predefinito è 100 che limita la crescita della funzione di grandi dimensioni a 2.0 volte l'originale
dimensione.

grande-unità-insns
Il limite che specifica l'unità di traduzione grande. Crescita causata dall'allineamento delle unità
maggiore di questo limite è limitato da --parami crescita-unità in linea. Per piccole unità
questo potrebbe essere troppo stretto (considerare l'unità costituita dalla funzione A che è in linea e
B che chiama A solo tre volte. Se B è piccolo rispetto ad A, la crescita dell'unità
è 300\% e tuttavia tale inlining è molto sensato. Per unità molto grandi composte da
piccole funzioni inlineabili, tuttavia è necessario il limite di crescita dell'unità complessiva per
evitare l'esplosione esponenziale della dimensione del codice. Quindi per le unità più piccole, la dimensione è
aumentato a --parami grande-unità-insns prima dell'applicazione --parami crescita-unità in linea.
Il valore predefinito è 10000

crescita-unità in linea
Specifica la crescita complessiva massima dell'unità di compilazione causata dall'inline. Il
il valore predefinito è 30 che limita la crescita dell'unità a 1.3 volte la dimensione originale.

ipcp-unità-crescita
Specifica la massima crescita complessiva dell'unità di compilazione causata da interprocedurale
propagazione costante. Il valore predefinito è 10 che limita la crescita dell'unità a 1.1
volte la dimensione originale.

telaio-pila-grande
Il limite che specifica stack frame di grandi dimensioni. Durante l'inline l'algoritmo sta provando
per non superare troppo questo limite. Il valore predefinito è 256 byte.

crescita-frame-pila-grande
Specifica la crescita massima in percentuale di stack frame di grandi dimensioni causati dall'inline.
Il valore predefinito è 1000 che limita la crescita del frame dello stack di grandi dimensioni a 11 volte il
Misura originale.

max-inline-insns-ricorsivo
max-inline-insns-ricorsiva-auto
Specifica il numero massimo di istruzioni fuori linea copia di auto ricorsiva in linea
la funzione può crescere eseguendo l'inlining ricorsivo.

Per le funzioni dichiarate in linea --parami max-inline-insns-ricorsivo è preso in
account. Per la funzione non dichiarata in linea, l'inline ricorsivo si verifica solo quando
-funzioni-finline (incluso in -O3) è abilitato e --parami max-inline-insns-
ricorsivo-auto viene utilizzato. Il valore predefinito è 450.

max-inline-recursive-profondità
max-inline-profondità-ricorsiva-auto
Specifica la profondità di ricorsione massima utilizzata dall'inline ricorsivo.

Per le funzioni dichiarate in linea --parami max-inline-recursive-profondità è preso in
account. Per la funzione non dichiarata in linea, l'inline ricorsivo si verifica solo quando
-funzioni-finline (incluso in -O3) è abilitato e --parami max-inline-ricorsivo-
profondità-auto viene utilizzato. Il valore predefinito è 8.

probabilità-minima-inline-ricorsiva
L'inlining ricorsivo è redditizio solo per la funzione che ha una ricorsione profonda in
media e può danneggiare la funzione avendo poca profondità di ricorsione aumentando il
prologo dimensione o complessità del corpo funzione ad altri ottimizzatori.

Quando il feedback del profilo è disponibile (vedi -fprofile-genera) la ricorsione effettiva
la profondità può essere indovinata dalla probabilità che la funzione ricorra tramite una data chiamata
espressione. Questo parametro limita l'inline solo per chiamare l'espressione la cui
la probabilità supera una determinata soglia (in percentuale). Il valore predefinito è 10.

Early-inlining-insns
Specifica la crescita che può fare l'inliner precoce. In effetti aumenta la quantità di
inline per il codice con una grande penalità di astrazione. Il valore predefinito è 10.

iterazioni-max-early-inliner
iterazioni-max-early-inliner
Limite di iterazioni di early inliner. Questo fondamentalmente limita il numero di annidati
le chiamate indirette early inliner possono essere risolte. Le catene più profonde sono ancora gestite da tardi
inline.

comdat-sharing-probabilità
comdat-sharing-probabilità
Probabilità (in percentuale) che la funzione in linea C++ con visibilità comdat sarà
condiviso tra più unità di compilazione. Il valore predefinito è 20.

vincolato al ciclo min-vect
Il numero minimo di iterazioni sotto il quale un ciclo non verrà vettorializzato quando
-ftree-vettorizzare viene utilizzato. Il numero di iterazioni dopo la vettorizzazione deve
essere maggiore del valore specificato da questa opzione per consentire la vettorizzazione. Il
il valore predefinito è 0.

gcse-costo-distanza-rapporto
Fattore di scala nel calcolo della distanza massima di cui un'espressione può essere spostata
Ottimizzazioni GCSE. Questo è attualmente supportato solo nel passaggio di sollevamento del codice.
Maggiore è il rapporto, più aggressivo sarà il sollevamento del codice con simple
espressioni, cioè le espressioni che sono costate meno di gcse-senza restrizioni-
costo. Specificando 0 si disabiliterà il sollevamento di espressioni semplici. Il predefinito
il valore è 10.

gcse-costo illimitato
Costo, approssimativamente misurato come il costo di una singola istruzione macchina tipica, a
quali ottimizzazioni GCSE non limiteranno la distanza che un'espressione può percorrere.
Questo è attualmente supportato solo nel passaggio di sollevamento del codice. Minore è il costo,
il sollevamento del codice più aggressivo sarà. Specificare 0 consentirà tutto
espressioni per percorrere distanze illimitate. Il valore predefinito è 3.

max-paranco-profondità
La profondità di ricerca nell'albero del dominatore per le espressioni da issare. Questo è usato
per evitare comportamenti quadratici nell'algoritmo di sollevamento. Il valore 0 eviterà
limitando la ricerca, ma può rallentare la compilazione di enormi funzioni. Il predefinito
il valore è 30.

max-tail-merge-confronti
La quantità massima di pallini simili con cui confrontare un pallino. Questo è usato per evitare
comportamento quadratico nella fusione delle code degli alberi. Il valore predefinito è 10.

max-tail-merge-iterazioni
Il numero massimo di iterazioni del passaggio sulla funzione. Questo è usato per
limitare il tempo di compilazione nell'unione della coda dell'albero. Il valore predefinito è 2.

max-srotolato-insns
Il numero massimo di istruzioni che un ciclo dovrebbe avere se quel ciclo è
srotolato, e se il ciclo viene svolto, determina quante volte il codice del ciclo
è srotolato.

max-media-srotolamento-insns
Il numero massimo di istruzioni distorte dalle probabilità della loro esecuzione che
un ciclo dovrebbe avere se quel ciclo è srotolato, e se il ciclo è srotolato,
determina quante volte viene srotolato il codice del ciclo.

tempi-max-srotolamento
Il numero massimo di srotolamenti di un singolo loop.

max-pelati-insns
Il numero massimo di istruzioni che un ciclo dovrebbe avere se quel ciclo viene rimosso,
e se il ciclo viene rimosso, determina quante volte il codice del ciclo viene rimosso.

tempi massimi di peeling
Il numero massimo di peeling di un singolo ciclo.

max-completamente-pelati-insns
Il numero massimo di insns di un loop completamente spellato.

tempi-max-completamente-peel
Il numero massimo di iterazioni di un ciclo adatto per il peeling completo.

max-completamente-peel-loop-nest-profondità
La profondità massima di un nido ad anello adatto per la pelatura completa.

max-unswitch-insns
Il numero massimo di insns di un loop non commutato.

livello di disattivazione massimo
Il numero massimo di rami non commutati in un singolo loop.

lim-costoso
Il costo minimo di un'espressione costosa nel moto invariante di loop.

iv-considera-tutti-i-candidati-vincolati
Vincolato al numero di candidati per le variabili di induzione al di sotto di tutti i candidati
sono considerati per ogni uso nelle ottimizzazioni delle variabili di induzione. Solo il più
i candidati rilevanti sono presi in considerazione se ci sono più candidati, per evitare
complessità temporale quadratica.

iv-max-usi-considerati
Le ottimizzazioni delle variabili di induzione rinunciano ai loop che contengono più induzione
usi variabili.

iv-sempre-prune-cand-set-bound
Se il numero di candidati nell'insieme è inferiore a questo valore, cerchiamo sempre di
rimuovere iv non necessari dal set durante la sua ottimizzazione quando viene aggiunto un nuovo iv
sul set.

scev-max-expr-dimensione
Legato alla dimensione delle espressioni usate nell'analizzatore di evoluzioni scalari. Grande
le espressioni rallentano l'analizzatore.

scev-max-expr-complessità
Legato alla complessità delle espressioni nell'analizzatore di evoluzioni scalari.
Le espressioni complesse rallentano l'analizzatore.

omega-max-var
Il numero massimo di variabili in un sistema di vincoli Omega. Il valore predefinito
è 128.

omega-max-geq
Il numero massimo di disuguaglianze in un sistema di vincoli Omega. Il predefinito
il valore è 256.

omega-max-eq
Il numero massimo di uguaglianze in un sistema di vincoli Omega. Il valore predefinito
è 128.

omega-max-carte jolly
Il numero massimo di variabili jolly che il risolutore Omega sarà in grado di gestire
inserire. Il valore predefinito è 18.

omega-hash-tabella-dimensioni
La dimensione della tabella hash nel risolutore Omega. Il valore predefinito è 550.

chiavi omega-max
Il numero massimo di chiavi utilizzate dal risolutore Omega. Il valore predefinito è 500.

omega-elimina-vincoli-ridondanti
Quando è impostato su 1, utilizza metodi costosi per eliminare tutti i vincoli ridondanti. Il
il valore predefinito è 0.

vect-max-versione-per-controlli-di-allineamento
Il numero massimo di controlli in fase di esecuzione che possono essere eseguiti durante l'esecuzione del ciclo
versioning per l'allineamento nel vectorizer. Vedi l'opzione ftree-vect-loop-version
per maggiori informazioni.

versione-vect-max-per-controlli-alias
Il numero massimo di controlli in fase di esecuzione che possono essere eseguiti durante l'esecuzione del ciclo
versioning per alias nel vectorizer. Vedere l'opzione ftree-vect-loop-version per
maggiori informazioni.

max-iterazioni-da-tracciare
Il numero massimo di iterazioni di un ciclo l'algoritmo di forza bruta per l'analisi
di # di iterazioni del ciclo tenta di valutare.

hot-bb-count-frazione
Seleziona la frazione del numero massimo di ripetizioni del blocco di base nel programma
dato il blocco di base deve essere considerato caldo.

hot-bb-frazione-frequenza
Seleziona frazione del blocco di ingresso frequenza delle esecuzioni del blocco base in
la funzione data il blocco di base deve essere considerata calda.

iterazioni-max-previste
Il numero massimo di iterazioni del ciclo che prevediamo staticamente. Questo è utile in
casi in cui la funzione contiene un ciclo singolo con limite noto e un altro ciclo con
sconosciuto. Prevediamo correttamente il numero noto di iterazioni, mentre l'incognita
numero medio di iterazioni a circa 10. Ciò significa che il ciclo senza
i limiti apparirebbero artificialmente freddi rispetto all'altro.

allinea-soglia
Seleziona frazione della frequenza massima di esecuzioni del blocco base in funzione
dato blocco di base verrà allineato.

allinea-loop-iterazioni
Un ciclo dovrebbe iterare almeno il numero selezionato di iterazioni
allineato.

tracciante-dinamica-copertura
tracciante-dinamica-copertura-feedback
Questo valore viene utilizzato per limitare la formazione di superblocchi una volta raggiunta la percentuale data di
istruzioni eseguite è coperto. Ciò limita l'espansione della dimensione del codice non necessaria.

I tracciante-dinamica-copertura-feedback viene utilizzato solo quando il feedback del profilo è
a disposizione. I profili reali (al contrario di quelli stimati staticamente) sono molto
meno bilanciato consentendo alla soglia di essere di valore maggiore.

tracciante-max-code-crescita
Interrompi la duplicazione della coda una volta che la crescita del codice ha raggiunto una determinata percentuale. Questo è
argomento piuttosto hokey, poiché la maggior parte dei duplicati verrà eliminata in seguito in cross
saltando, quindi potrebbe essere impostato su valori molto più alti della crescita del codice desiderata.

rapporto-minimo-ramo-tracciante
Arresta la crescita inversa quando la probabilità inversa del vantaggio migliore è inferiore a questa
soglia (in percentuale).

rapporto-minimo-ramo-tracciante
tracer-min-rapporto-rapporto-feedback
Arresta la crescita in avanti se il vantaggio migliore ha una probabilità inferiore a questo
soglia.

Analogamente a tracciante-dinamica-copertura sono presenti due valori, uno per la compilazione
per il feedback del profilo e uno per la compilazione senza. Il valore per la compilazione
con il feedback del profilo deve essere più conservativo (più alto) per rendere
tracciante efficace.

lunghezza-percorso-max-cse
Numero massimo di blocchi di base sul percorso che cse considera. Il valore predefinito è 10.

max-cse-insns
Le istruzioni massime CSE processano prima del flushing. Il valore predefinito è 1000.

ggc-min-espandi
GCC utilizza un garbage collector per gestire la propria allocazione di memoria. Questo parametro
specifica la percentuale minima in base alla quale dovrebbe essere l'heap del raccoglitore di rifiuti
permesso di espandersi tra le collezioni. L'ottimizzazione di questo può migliorare la velocità di compilazione;
non ha alcun effetto sulla generazione del codice.

Il valore predefinito è 30% + 70% * (RAM/1 GB) con un limite superiore del 100% quando RAM >= 1 GB.
Se "getrlimit" è disponibile, la nozione di "RAM" è la più piccola della RAM effettiva e
"RLIMIT_DATA" o "RLIMIT_AS". Se GCC non è in grado di calcolare la RAM su un particolare
piattaforma, viene utilizzato il limite inferiore del 30%. L'impostazione di questo parametro e ggc-min-
enorme a zero fa sì che si verifichi una raccolta completa in ogni occasione. Questo è
estremamente lento, ma può essere utile per il debug.

ggc-min-heapsize
Dimensione minima dell'heap del raccoglitore di rifiuti prima che inizi a preoccuparsi di raccogliere
spazzatura. La prima raccolta si verifica dopo che l'heap si espande di ggc-min-espandi%
al di là di ggc-min-heapsize. Ancora una volta, l'ottimizzazione di questo può migliorare la velocità di compilazione e
non ha alcun effetto sulla generazione del codice.

L'impostazione predefinita è il più piccolo di RAM/8, RLIMIT_RSS o un limite che cerca di garantire
che RLIMIT_DATA o RLIMIT_AS non siano superati, ma con un limite inferiore di 4096
(quattro megabyte) e un limite superiore di 131072 (128 megabyte). Se GCC non è in grado
per calcolare la RAM su una particolare piattaforma, viene utilizzato il limite inferiore. Impostazione di questo
parametro molto grande disabilita efficacemente la raccolta dei rifiuti. Impostazione di questo
parametro e ggc-min-espandi a zero fa sì che si verifichi una raccolta completa ad ogni
opportunità.

max-ricarica-ricerca-insns
Il numero massimo di ricaricamento delle istruzioni dovrebbe guardare indietro per equivalente
Registrati. Valori crescenti significano un'ottimizzazione più aggressiva, rendendo il
il tempo di compilazione aumenta con prestazioni probabilmente leggermente migliori. Il predefinito
il valore è 100.

posizioni-memoria-max-cselib
Il numero massimo di locazioni di memoria che cselib dovrebbe prendere in considerazione.
L'aumento dei valori significa un'ottimizzazione più aggressiva, rendendo il tempo di compilazione
aumentare con prestazioni probabilmente leggermente migliori. Il valore predefinito è 500.

riordina-blocchi-duplica
riordina-blocchi-duplicati-feedback
Utilizzato dal passaggio di riordino dei blocchi di base per decidere se utilizzare il ramo incondizionato
o duplicare il codice sulla sua destinazione. Il codice è duplicato quando è stimato
la dimensione è inferiore a questo valore moltiplicato per la dimensione stimata di incondizionato
saltare nei punti caldi del programma.

I riordina-blocco-duplicato-feedback viene utilizzato solo quando il feedback del profilo è
disponibile e può essere impostato su valori superiori a riordina-blocco-duplicato da
le informazioni sui punti caldi sono più accurate.

max-sched-ready-insns
Il numero massimo di istruzioni pronte per essere emesse dallo scheduler dovrebbe
considerare in qualsiasi momento durante il primo passaggio di programmazione. Valori in aumento
significa ricerche più approfondite, facendo aumentare il tempo di compilazione con probabilmente
piccolo beneficio. Il valore predefinito è 100.

blocchi-regione-max-sched
Il numero massimo di blocchi in una regione da considerare per l'interblocco
programmazione. Il valore predefinito è 10.

blocchi-regione-conduttura-max
Il numero massimo di blocchi in una regione da considerare per il gasdotto nel
schedulatore selettivo. Il valore predefinito è 15.

max-sched-region-insns
Il numero massimo di insns in una regione da considerare per l'interblocco
programmazione. Il valore predefinito è 100.

max-pipeline-regione-insns
Il numero massimo di insns in una regione da considerare per il gasdotto nel
schedulatore selettivo. Il valore predefinito è 200.

min-spec-prob
La probabilità minima (in percentuale) di raggiungere un blocco sorgente per interblocco
programmazione speculativa. Il valore predefinito è 40.

max-sched-extend-regioni-iter
Il numero massimo di iterazioni attraverso CFG per estendere le regioni. 0 - disabilita
estensione della regione, N - esegue al massimo N iterazioni. Il valore predefinito è 0.

ritardo-conflitto-max-sched-insn
Il ritardo massimo di conflitto per un insn da considerare per il movimento speculativo.
Il valore predefinito è 3.

sched-spec-prob-cutoff
La minima probabilità di successo della speculazione (in percentuale), in modo che speculativa
insn sarà programmato. Il valore predefinito è 40.

sched-mem-true-dep-costo
Distanza minima (in cicli della CPU) tra archivio e carico destinati alla stessa memoria
posizioni. Il valore predefinito è 1.

selsched-max-lookahead
La dimensione massima della finestra di previsione della pianificazione selettiva. È una profondità
di ricerca delle istruzioni disponibili. Il valore predefinito è 50.

selsched-max-tempi-programmati
Il numero massimo di volte in cui un'istruzione sarà schedulata durante la selezione
programmazione. Questo è il limite al numero di iterazioni attraverso le quali il
l'istruzione può essere convogliata. Il valore predefinito è 2.

selsched-max-insns-da-rinominare
Il numero massimo di migliori istruzioni nell'elenco pronto che sono considerate per
ridenominazione nello scheduler selettivo. Il valore predefinito è 2.

sms-min-sc
Il valore minimo del conteggio fasi generato dallo scheduler swing modulo. Il
il valore predefinito è 2.

max-ultimo-valore-rtl
La dimensione massima misurata come numero di RTL che possono essere registrati in un'espressione
in combinatore per uno pseudo registro come ultimo valore noto di quel registro. Il
il valore predefinito è 10000.

limite di condivisione intera
Le piccole costanti intere possono utilizzare una struttura dati condivisa, riducendo i compiti del compilatore
utilizzo della memoria e aumentandone la velocità. Questo imposta il valore massimo di un shared
costante intera. Il valore predefinito è 256.

min-mapping-virtuali
Specifica il numero minimo di mappature virtuali nell'aggiornamento SSA incrementale
che dovrebbe essere registrato per attivare l'euristica delle mappature virtuali definita da
rapporto-mapping-virtuale. Il valore predefinito è 100.

rapporto-mapping-virtuale
Se il numero di mappature virtuali è un rapporto di mappature virtuali maggiore del numero
di simboli virtuali da aggiornare, quindi il programma di aggiornamento SSA incrementale passa a a
aggiornamento completo per quei simboli. Il rapporto predefinito è 3.

ssp-dimensione del buffer
La dimensione minima dei buffer (cioè gli array) che riceveranno lo stack smashing
protezione quando -fstack-protezione viene utilizzato.

Questa impostazione predefinita prima di Ubuntu 10.10 era "8". Attualmente è "4", per aumentare il
numero di funzioni protette dalla protezione dello stack.

max-jump-thread-duplicazione-stmts
Numero massimo di istruzioni consentite in un blocco che deve essere duplicato quando
salti di filettatura.

max-fields-per-sensibile ai campi
Numero massimo di campi in una struttura che tratteremo in modo sensibile ai campi
durante l'analisi del puntatore. Il valore predefinito è zero per -O0 e -O1 e 100 per -Os,
-O2 e -O3.

prefetch-latenza
Stima sul numero medio di istruzioni eseguite prima del prefetch
finiture. La distanza che preleviamo in avanti è proporzionale a questa costante.
L'aumento di questo numero può anche portare a un minor numero di flussi precaricati (vedi
prelettura simultanea).

prelettura simultanea
Numero massimo di prelettura che possono essere eseguiti contemporaneamente.

l1-cache-line-size
La dimensione della linea della cache nella cache L1, in byte.

dimensione della cache l1
La dimensione della cache L1, in kilobyte.

dimensione della cache l2
La dimensione della cache L2, in kilobyte.

rapporto min-insn-prefetch
Il rapporto minimo tra il numero di istruzioni e il numero di prefetch
per abilitare il precaricamento in un ciclo.

prefetch-min-insn-to-mem-rapporto
Il rapporto minimo tra il numero di istruzioni e il numero di memoria
riferimenti per abilitare il precaricamento in un ciclo.

uso-tipi-canonici
Se il compilatore deve utilizzare il sistema di tipi "canonico". Per impostazione predefinita, questo
dovrebbe sempre essere 1, che utilizza un meccanismo interno più efficiente per il confronto
tipi in C++ e Objective-C++. Tuttavia, se i bug nel sistema di tipo canonico sono
causando errori di compilazione, impostare questo valore su 0 per disabilitare i tipi canonici.

interruttore-conversione-max-rapporto-diramazione
La conversione dell'inizializzazione dello switch si rifiuterà di creare array più grandi di
interruttore-conversione-max-rapporto-diramazione volte il numero di rami nello switch.

max-parziale-lunghezza-antic
Lunghezza massima dell'insieme antico parziale calcolata durante l'albero parziale
ottimizzazione dell'eliminazione della ridondanza (-ftree-pre) quando si ottimizza a -O3 e al di sopra.
Per alcuni tipi di codice sorgente l'eliminazione della ridondanza parziale avanzata
l'ottimizzazione può scappare, consumando tutta la memoria disponibile sull'host
macchina. Questo parametro imposta un limite alla lunghezza degli insiemi calcolati,
che impedisce il comportamento fuggitivo. L'impostazione di un valore di 0 per questo parametro sarà
consentire una lunghezza fissa illimitata.

dimensione-sccvn-max-scc
Dimensione massima di un componente fortemente connesso (SCC) durante l'elaborazione SCCVN. Se
questo limite viene raggiunto, l'elaborazione SCCVN per l'intera funzione non verrà eseguita e
le ottimizzazioni a seconda di esso saranno disabilitate. La dimensione SCC massima predefinita è
10000

ira-max-numero-loop
L'IRA utilizza l'allocazione del registro regionale per impostazione predefinita. Se una funzione contiene più
loop rispetto al numero dato da questo parametro, solo al massimo il numero dato di
i loop più frequentemente eseguiti formano le regioni per l'allocazione al registro regionale.
Il valore predefinito del parametro è 100.

dimensione-tabella-di-conflitto-ira-max
Sebbene l'IRA utilizzi un sofisticato algoritmo per comprimere la tabella dei conflitti, il
table può ancora richiedere quantità eccessive di memoria per funzioni enormi. Se la
la tabella dei conflitti per una funzione potrebbe essere maggiore della dimensione in MB fornita da questo
parametro, l'allocatore di registro utilizza invece un più veloce, più semplice e più basso
algoritmo di qualità che non richiede la creazione di una tabella dei conflitti di pseudo-registri.
Il valore predefinito del parametro è 2000.

ira-loop-regs riservati
L'IRA può essere utilizzato per valutare una pressione di registro più accurata nei cicli decisionali
per spostare gli invarianti di ciclo (vedi -O3). Il numero di registri disponibili riservati a
qualche altro scopo è dato da questo parametro. Il valore predefinito di
il parametro è 2, che è il numero minimo di registri necessari per il tipico
Istruzioni. Questo valore è il migliore trovato da numerosi esperimenti.

loop-invariante-max-bbs-in-loop
Il movimento invariante del loop può essere molto costoso, sia in fase di compilazione che in
quantità di memoria necessaria in fase di compilazione, con cicli molto grandi. Cicli con più
i blocchi di base di questo parametro non avranno l'ottimizzazione del movimento invariante del ciclo
eseguita su di essi. Il valore predefinito del parametro è 1000 per -O1 e 10000
per -O2 e oltre.

loop-max-datarefs-per-datadeps
La creazione di dipendenze di dati è costosa per loop molto grandi. Questo parametro
limita il numero di riferimenti ai dati nei cicli considerati per i dati
analisi della dipendenza Questi grandi loop non saranno quindi gestiti dal
ottimizzazioni utilizzando le dipendenze dei dati del ciclo. Il valore predefinito è 1000.

dimensione-max-vartrack
Imposta un numero massimo di slot della tabella hash da utilizzare durante il flusso di dati di monitoraggio delle variabili
analisi di qualsiasi funzione. Se questo limite viene superato con l'inseguimento variabile a
assegnazioni abilitate, l'analisi per quella funzione viene ritentata senza di essa, dopo
rimuovendo tutti i messaggi di debug dalla funzione. Se il limite viene superato anche senza
debug insns, l'analisi del tracciamento var è completamente disabilitata per la funzione.
L'impostazione del parametro a zero lo rende illimitato.

max-vartrack-expr-profondità
Imposta un numero massimo di livelli di ricorsione quando si tenta di mappare i nomi delle variabili o
eseguire il debug di temporanei per valutare le espressioni. Questo scambia il tempo di compilazione per altro
informazioni di debug complete. Se è impostato su un valore troppo basso, valuta le espressioni che sono
disponibile e potrebbe essere rappresentato nelle informazioni di debug potrebbe non essere utilizzato;
l'impostazione di questo valore più alto può consentire al compilatore di trovare un debug più complesso
espressioni, ma il tempo di compilazione e l'utilizzo della memoria possono aumentare. Il valore predefinito è 12.

min-nondebug-insn-uid
Usa uid a partire da questo parametro per insns non di debug. L'intervallo al di sotto del
parametro è riservato esclusivamente agli inns di debug creati da
-fvar-tracciamento-assegnazioni, ma debug insns potrebbe ottenere uid (non sovrapposti) sopra
it se l'intervallo riservato è esaurito.

ipa-sra-ptr-fattore-di-crescita
IPA-SRA sostituirà un puntatore a un aggregato con uno o più nuovi parametri
solo quando la loro dimensione cumulativa è inferiore o uguale a ipa-sra-ptr-fattore-di-crescita
volte la dimensione del parametro del puntatore originale.

tm-max-dimensione-aggregata
Quando si effettuano copie di variabili locali del thread in una transazione, questo parametro
specifica la dimensione in byte dopo la quale le variabili verranno salvate con la registrazione
funzioni invece di salvare/ripristinare coppie di sequenze di codice. Solo questa opzione
si applica quando si utilizza -fgnu-tm.

grafite-max-nb-scop-params
Per evitare effetti esponenziali nelle trasformazioni del ciclo Graphite, il numero di
parametri in una parte di controllo statico (SCoP) è limitato. Il valore predefinito è 10
parametri. Una variabile il cui valore è sconosciuto al momento della compilazione e definito
al di fuori di uno SCoP è un parametro dello SCoP.

grafite-max-bbs-per-funzione
Per evitare effetti esponenziali nel rilevamento di SCoP, la dimensione delle funzioni
analizzato da Graphite è limitato. Il valore predefinito è 100 blocchi di base.

loop-block-size-tile-size
Blocco del ciclo o trasformazioni di strip mining, abilitate con -blocco floop or
-flop-strip-mio, elimina ogni loop nel nido di loop di un dato numero di
iterazioni. La lunghezza della striscia può essere modificata utilizzando il loop-block-size-tile-size
parametro. Il valore predefinito è 51 iterazioni.

dimensione-elenco-di-valori-ipa-cp
IPA-CP tenta di tenere traccia di tutti i possibili valori e tipi passati a una funzione
parametro per propagarli ed eseguire la devirtualizzazione. ipa-cp-valore-
dimensione-lista è il numero massimo di valori e tipi che memorizza per un formale
parametro di una funzione.

lto-partizioni
Specificare il numero desiderato di partizioni prodotte durante la compilazione WHOPR. Il
il numero di partizioni deve superare il numero di CPU utilizzate per la compilazione. Il
il valore predefinito è 32.

lto-minpartizione
Dimensione della partizione minima per WHOPR (nelle istruzioni stimate). Questo impedisce
spese per suddividere programmi molto piccoli in troppe partizioni.

cxx-max-namespaces-for-diagnostic-help
Il numero massimo di spazi dei nomi da consultare per suggerimenti durante la ricerca del nome C++
non riesce per un identificatore. Il valore predefinito è 1000.

soglia-frequenza di caduta
La massima frequenza di esecuzione relativa (in percentuale) del blocco di destinazione
relativo al blocco originale di un'istruzione per consentire l'affondamento dell'istruzione di a
dichiarazione. Numeri più grandi comportano un affondamento delle dichiarazioni più aggressivo. Il
il valore predefinito è 75. Viene applicato un piccolo aggiustamento positivo per le dichiarazioni con
gli operandi di memoria in quanto sono ancora più redditizi, quindi affondano.

max-negozi-a-sink
Il numero massimo di coppie di negozi condizionali che possono essere affondate. Imposta a 0 se
o vettorizzazione (-ftree-vettorizzare) o if-conversion (-ftree-loop-se-converti)
è disabilitato. Il valore predefinito è 2.

consenti-carica-dati-corse
Consenti agli ottimizzatori di introdurre nuove corse di dati sui carichi. Impostare su 1 per consentire,
altrimenti a 0. Questa opzione è abilitata per impostazione predefinita a meno che non sia implicitamente impostata dal
-fmemoria-modello= opzione.

consentire-archivio-data-races
Consenti agli ottimizzatori di introdurre nuove corse di dati nei negozi. Impostare su 1 per consentire,
altrimenti a 0. Questa opzione è abilitata per impostazione predefinita a meno che non sia implicitamente impostata dal
-fmemoria-modello= opzione.

consentire-packed-load-data-races
Consenti agli ottimizzatori di introdurre nuove corse di dati su carichi di dati compressi. Imposta da 1 a
allow, altrimenti a 0. Questa opzione è abilitata per impostazione predefinita a meno che non sia impostata implicitamente da
, il -fmemoria-modello= opzione.

consenti-imballato-store-data-races
Consenti agli ottimizzatori di introdurre nuove corse di dati su datastore compressi. Imposta da 1 a
allow, altrimenti a 0. Questa opzione è abilitata per impostazione predefinita a meno che non sia impostata implicitamente da
, il -fmemoria-modello= opzione.

caso-valori-soglia
Il minor numero di valori diversi per i quali è meglio usare una jump-table
invece di un albero di rami condizionali. Se il valore è 0, usa l'impostazione predefinita per
la macchina. Il valore predefinito è 0.

albero-reassoc-width
Imposta il numero massimo di istruzioni eseguite in parallelo nell'albero riassociato.
Questo parametro sovrascrive l'euristica dipendente dalla destinazione utilizzata per impostazione predefinita se non ha
valore zero.

Opzioni Controllo , il preprocessore
Queste opzioni controllano il preprocessore C, che viene eseguito su ogni file sorgente C prima dell'effettivo
compilazione.

Se si utilizza il -E opzione, non viene eseguita alcuna operazione tranne la preelaborazione. Alcune di queste opzioni
ha senso solo insieme a -E perché fanno sì che l'uscita del preprocessore sia
inadatto alla compilazione effettiva.

-Wp,opzione
Puoi usare -Wp,opzione per bypassare il driver del compilatore e passare opzione direttamente attraverso
al preprocessore. Se opzione contiene virgole, è suddiviso in più opzioni in
le virgole. Tuttavia, molte opzioni vengono modificate, tradotte o interpretate dal
driver del compilatore prima di essere passato al preprocessore e -Wp bypassa forzatamente
questa fase. L'interfaccia diretta del preprocessore non è documentata e soggetta a
cambiare, quindi quando possibile dovresti evitare di usare -Wp e lascia che sia l'autista a gestire il
opzioni invece.

-Xpreprocessore opzione
Passare opzione come opzione per il preprocessore. Puoi usarlo per fornire sistema-
specifiche opzioni del preprocessore che GCC non sa riconoscere.

Se vuoi passare un'opzione che accetta un argomento, devi usare -Xpreprocessore
due volte, una volta per l'opzione e una volta per l'argomento.

-D Nome
Predefinire Nome come macro, con definizione 1.

-D Nome=definizione
Il contenuto di definizione vengono tokenizzati ed elaborati come se apparissero durante
traduzione fase tre in a #define direttiva. In particolare, la definizione sarà
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. Insieme a sh ed csh,
-D'Nome(argomenti...)=definizione' .

-D ed -U le opzioni vengono elaborate nell'ordine in cui vengono fornite sulla riga di comando. Tutto
-imacro filetto ed -includere filetto le opzioni vengono elaborate dopo tutto -D ed -U opzioni.

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

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

-I dir
Aggiungi la directory dir all'elenco delle directory in cui cercare i file di intestazione.
Directory nominate da -I vengono cercati prima che il sistema standard includa le directory.
Se la directory dir è una directory di inclusione standard del sistema, l'opzione viene ignorata per
garantire che l'ordine di ricerca predefinito per le directory di sistema e il trattamento speciale
degli header di sistema non vengono eliminati. Se dir inizia con "=", quindi "=" sarà
sostituito dal prefisso sysroot; vedere --sysroot ed -isysroot.

-o filetto
Scrivi output su filetto. Questo è lo stesso che specificare filetto come seconda non opzione
argomento a cpp. gcc ha una diversa interpretazione di un secondo argomento di non opzione,
quindi devi usare -o per specificare il file di output.

-Parete
Attiva tutti gli avvisi facoltativi desiderabili per il codice normale. Al momento questo
is -Wcommento, -Scritte, -Wmulticar e un avviso sulla promozione di interi che causa a
cambio di segno nelle espressioni "#if". Nota che molti degli avvertimenti del preprocessore
sono attivi per impostazione predefinita e non hanno opzioni per controllarli.

-Wcommento
-Wcommenti
Avvisa ogni volta che una sequenza di inizio commento /* appare in a /* commento, o ogni volta che a
backslash-newline appare in a // commento. (Entrambe le forme hanno lo stesso effetto.)

-Scritte
La maggior parte dei trigrammi nei commenti non può influenzare il significato del programma. Tuttavia, a
trigramma che formerebbe una nuova riga con escape (??/ alla fine di una riga) può, da
cambiando dove inizia o finisce il commento. Pertanto, solo trigrammi che si formerebbero
le nuove righe con escape producono avvisi all'interno di un commento.

Questa opzione è implicata da -Parete. Se -Parete non è dato, questa opzione è ancora abilitata
a meno che i trigrafi non siano abilitati. Per ottenere la conversione del trigrafo senza avvisi, ma ottieni
l'altra -Parete avvertenze, uso -trigrafie -Parete -Wno-trigrafie.

-Wtradizionale
Avvisa di alcuni costrutti che si comportano in modo diverso in C tradizionale e ISO. Inoltre
mettere in guardia sui costrutti ISO C che non hanno un equivalente C tradizionale e problematico
costrutti che dovrebbero essere evitati.

-Wundef
Avvisa ogni volta che si incontra un identificatore che non è una macro in un #Se direttiva,
al di fuori di definito. Tali identificatori vengono sostituiti con zero.

-Wunused-macro
Avvisa delle macro definite nel file principale che non sono utilizzate. Una macro è utilizzato se è
ampliato o testato per l'esistenza almeno una volta. Il preprocessore avviserà anche se
la macro non è stata utilizzata nel momento in cui è stata ridefinita o indefinita.

Macro integrate, macro definite sulla riga di comando e macro definite in include
i file non vengono avvisati.

Nota: Se una macro viene effettivamente utilizzata, ma utilizzata solo nei blocchi condizionali ignorati, allora
CPP lo segnalerà come non utilizzato. Per evitare l'avviso in tal caso, potresti migliorare
l'ambito della definizione della macro, ad esempio, spostandola nella prima saltata
bloccare. In alternativa, potresti fornire un uso fittizio con qualcosa come:

#se definito the_macro_causing_the_warning
#endif

-Etichette Wendif
Avvisa ogni volta che #else o un #endif sono seguiti dal testo. Questo di solito accade in
codice del modulo

#se FOO
...
#altro FOO
...
#endif FOO

Il secondo e il terzo "FOO" dovrebbero essere nei commenti, ma spesso non lo sono nei programmi più vecchi.
Questo avviso è attivo per impostazione predefinita.

-Errore
Trasforma tutti gli avvisi in errori reali. Il codice sorgente che attiva gli avvisi sarà
respinto.

-Wsystem-header
Emetti avvisi per il codice nelle intestazioni di sistema. Questi sono normalmente inutili nel trovare
bug nel proprio codice, quindi soppressi. Se sei responsabile del sistema
libreria, potresti volerli vedere.

-w Sopprime tutti gli avvisi, inclusi quelli che GNU CPP emette per impostazione predefinita.

-pedante
Emettere tutte le diagnostiche obbligatorie elencate nello standard C. Alcuni di loro sono rimasti
fuori per impostazione predefinita, poiché si attivano frequentemente su codice innocuo.

-errori-pedanti
Emetti tutte le diagnostiche obbligatorie e trasforma tutte le diagnostiche obbligatorie in errori.
Ciò include la diagnostica obbligatoria che GCC emette senza -pedante ma tratta come
avvertenze.

-M Invece di emettere il risultato della pre-elaborazione, emettere una regola adatta per make
descrivendo le dipendenze del file sorgente principale. Il preprocessore emette uno
make regola contenente il nome del file oggetto per quel file sorgente, i due punti e i nomi
di tutti i file inclusi, compresi quelli provenienti da -includere or -imacro command
opzioni di linea.

Se non specificato esplicitamente (con - MT or -MQ), il nome del file oggetto è costituito da
nome del file sorgente con qualsiasi suffisso sostituito con il suffisso del file oggetto e con qualsiasi
parti di directory principali rimosse. Se ci sono molti file inclusi, la regola è
diviso in più righe usando \-nuova linea. La regola non ha comandi.

Questa opzione non sopprime l'output di debug del preprocessore, come -dM. Evitare
mescolando tale output di debug con le regole di dipendenza dovresti specificare esplicitamente il
file di output delle dipendenze con -MF, o usa una variabile d'ambiente come
DIPENDENZE_OUTPUT. L'output di debug verrà comunque inviato al normale flusso di output come
Normale.

Di passaggio -M al conducente implica -E, e sopprime gli avvisi con un implicito -w.

-MM Come -M ma non menzionare i file di intestazione che si trovano nelle directory di intestazione del sistema,
né file di intestazione che sono inclusi, direttamente o indirettamente, da tale intestazione.

Ciò implica che la scelta delle parentesi angolari o delle virgolette doppie in an #includere
direttiva non determina di per sé se tale intestazione apparirà in -MM
uscita di dipendenza. Questo è un leggero cambiamento nella semantica rispetto alle versioni GCC 3.0 e
in precedenza.

-MF filetto
Se usato con -M or -MM, specifica un file in cui scrivere le dipendenze. se no -MF
switch è dato il preprocessore invia le regole nello stesso posto in cui avrebbe inviato
uscita preelaborata.

Se utilizzato con le opzioni del driver -MD or -MMD, -MF sovrascrive la dipendenza predefinita
file di uscita.

-MG In combinazione con un'opzione come -M richiesta di generazione di dipendenza, -MG assume
i file di intestazione mancanti vengono generati file e li aggiunge all'elenco delle dipendenze senza
sollevando un errore. Il nome del file di dipendenza è preso direttamente da "#include"
direttiva senza anteporre alcun percorso. -MG sopprime anche l'output preelaborato, come a
file di intestazione mancante lo rende inutile.

Questa funzione viene utilizzata nell'aggiornamento automatico dei makefile.

-deputato Questa opzione indica a CPP di aggiungere un target fasullo per ogni dipendenza diversa da
main, facendo in modo che ciascuno di essi non dipenda da nulla. Queste regole fittizie aggirano gli errori
make dà se rimuovi i file di intestazione senza aggiornare il Makefile per abbinare.

Questo è un output tipico:

prova.o: prova.c prova.h

prova.h:

- MT bersaglio
Modificare la destinazione della regola emessa dalla generazione delle dipendenze. Per impostazione predefinita, CPP richiede
il nome del file di input principale, elimina qualsiasi componente della directory e qualsiasi suffisso di file
ad esempio .ce aggiunge il solito suffisso oggetto della piattaforma. Il risultato è l'obiettivo.

An - MT L'opzione imposterà la destinazione in modo che sia esattamente la stringa specificata. Se vuoi
obiettivi multipli, puoi specificarli come un singolo argomento per - MT, o usa più
- MT opzioni.

Per esempio, - MT '$(objpfx)foo.o' potrebbe dare

$(objpfx)foo.o: foo.c

-MQ bersaglio
Uguale a - MT, ma cita tutti i caratteri che sono speciali per Make.
-MQ '$(objpfx)foo.o' dà

$$(objpfx)foo.o: foo.c

Il target predefinito viene quotato automaticamente, come se fosse dato con -MQ.

-MD -MD è equivalente -M -MF filetto, salvo che -E non è implicito. L'autista
determina filetto in base al fatto che an -o l'opzione è data. Se lo è, il conducente usa il suo
argomento ma con suffisso .d, altrimenti prende il nome del file di input,
rimuove qualsiasi componente e suffisso della directory e applica a .d suffisso.

If -MD è usato insieme a -E, qualunque -o switch è inteso per specificare il
file di output delle dipendenze, ma se usato senza -E, Ciascun -o si intende specificare a
file oggetto di destinazione.

Dal -E non è implicito, -MD può essere utilizzato per generare un file di output delle dipendenze come a
effetto collaterale del processo di compilazione.

-MMD
Come -MD tranne menzionare solo i file di intestazione dell'utente, non i file di intestazione del sistema.

-fpch-deps
Quando si utilizzano intestazioni precompilate, questo flag farà sì che i flag di output delle dipendenze vengano
elenca anche i file dalle dipendenze dell'intestazione precompilata. Se non specificato solo
l'intestazione precompilata verrebbe elencata e non i file utilizzati per crearla
perché quei file non vengono consultati quando viene utilizzata un'intestazione precompilata.

-fpch-preelaborazione
Questa opzione consente l'uso di un'intestazione precompilata insieme a -E. Inserisce uno speciale
"#pragma", "#pragma GCC pch_preprocess "nome del file"" in uscita per segnare il posto
dove è stata trovata l'intestazione precompilata, e la sua Nome del file. Quando -fpreelaborato è in
uso, GCC riconosce questo "#pragma" e carica il PCH.

Questa opzione è disattivata per impostazione predefinita, perché l'output preelaborato risultante è solo
veramente adatto come input per GCC. Si accende da -salva-temps.

Non dovresti scrivere questo "#pragma" nel tuo codice, ma è sicuro modificarlo
nome file se il file PCH è disponibile in una posizione diversa. Il nome del file potrebbe essere
assoluto o può essere relativo alla directory corrente di GCC.

-x c
-x c ++
-x obiettivo-c
-x assembler-con-cpp
Specificare la lingua di origine: C, C++, Objective-C o assembly. Questo non ha niente a che fare
con conformità agli standard o estensioni; seleziona semplicemente a quale sintassi di base
aspettarsi. Se non fornisci nessuna di queste opzioni, cpp dedurrà la lingua da
estensione del file sorgente: .c, . Cc, .m, o .S. Alcune altre estensioni comuni per
Vengono riconosciuti anche C++ e assembly. Se cpp non riconosce l'estensione, è
tratterà il file come C; questa è la modalità più generica.

Nota: Versioni precedenti di cpp accettate a -Long opzione che ha selezionato sia il
lingua e il livello di conformità agli standard. Questa opzione è stata rimossa perché
è in conflitto con -l opzione.

-std=Standard
-ansi
Specificare lo standard a cui deve conformarsi il codice. Attualmente CPP conosce C
e standard C++; altri potrebbero essere aggiunti in futuro.

Standard potrebbe essere uno di:

"C90"
"C89"
"iso9899:1990"
Lo standard ISO C del 1990. c90 è la consueta abbreviazione per questa versione di
lo standard.

I -ansi opzione è equivalente a -std=c90.

"iso9899:199409"
Lo standard C del 1990, come modificato nel 1994.

"iso9899:1999"
"C99"
"iso9899:199x"
"c9x"
Lo standard ISO C rivisto, pubblicato nel dicembre 1999. Prima della pubblicazione, questo
era conosciuto come C9X.

"iso9899:2011"
"C11"
"c1x"
Lo standard ISO C rivisto, pubblicato nel dicembre 2011. Prima della pubblicazione, questo
era conosciuto come C1X.

"gnu90"
"gnu89"
Lo standard C del 1990 più le estensioni GNU. Questa è l'impostazione predefinita.

"gnu99"
"gnu9x"
Lo standard C del 1999 più le estensioni GNU.

"gnu11"
"gnu1x"
Lo standard C del 2011 più le estensioni GNU.

"c++98"
Lo standard ISO C++ del 1998 più gli emendamenti.

"gnu++98"
Lo stesso di -std = c ++ 98 più estensioni GNU. Questa è l'impostazione predefinita per il codice C++.

-IO- Dividere il percorso di inclusione. Qualsiasi directory specificata con -I opzioni prima -IO- sono
cercato solo per le intestazioni richieste con "#include"file""; non si cercano
"#includerefile>". Se vengono specificate directory aggiuntive con -I opzioni dopo il
-IO-, quelle directory vengono cercate per tutte #includere direttive.

Inoltre, -IO- inibisce l'uso della directory della directory dei file corrente come
la prima directory di ricerca per "#include"file"". Questa opzione è stata deprecata.

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

-nostdin++
Non cercare i file di intestazione nelle directory standard specifiche di C++, ma fallo comunque
cercare nelle altre directory standard. (Questa opzione viene utilizzata durante la compilazione del C++
biblioteca.)

-includere filetto
Processo filetto come se "#include "file"" apparisse come prima riga della fonte primaria
file. Tuttavia, la prima directory cercata filetto il preprocessore sta funzionando?
elenco invece of la directory contenente il file sorgente principale. Se non trovato
lì, viene cercato nel resto della catena di ricerca "#include "..."" come
Normale.

Se multiplo -includere vengono fornite le opzioni, i file vengono inclusi nell'ordine in cui
appaiono sulla riga di comando.

-imacro filetto
Esattamente come -includere, eccetto che qualsiasi output prodotto dalla scansione filetto viene lanciato
via. Le macro che definisce rimangono definite. Questo ti permette di acquisire tutte le macro
da un'intestazione senza elaborare anche le sue dichiarazioni.

Tutti i file specificati da -imacro vengono elaborati prima di tutti i file specificati da -includere.

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

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

-icon prefisso dir
-icon prefisso prima dir
Aggiungere dir al prefisso specificato in precedenza con -iprefisso, e aggiungi il risultato
directory al percorso di ricerca di inclusione. -icon prefisso prima lo mette nello stesso posto -I
voluto; -icon prefisso lo mette dove -idirafter voluto.

-isysroot dir
Questa opzione è come la --sysroot opzione, ma si applica solo ai file di intestazione (eccetto per
Target Darwin, dove si applica sia ai file di intestazione che alle librerie). Vedi il
--sysroot opzione per ulteriori informazioni.

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

-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 "=", allora "=" sarà sostituito dal prefisso sysroot; vedere --sysroot ed
-isysroot.

-quoto dir
Cerca dir solo per i file di intestazione richiesti con "#include"file""; non sono
cercato "#includefile>", 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.

-fsolo-direttive
Durante la preelaborazione, gestire le direttive, ma non espandere le macro.

Il comportamento dell'opzione dipende da -E ed -fpreelaborato opzioni.

Con -E, la preelaborazione è limitata alla gestione di direttive come "#define",
"#ifdef" e "#errore". Altre operazioni del preprocessore, come espansione macro e
la conversione del trigramma non viene eseguita. Inoltre, il -dd l'opzione è implicitamente
abilitato.

Con -fpreelaborato, la predefinizione della riga di comando e la maggior parte delle macro integrate è
Disabilitato. Vengono gestite macro come "__LINE__", che dipendono dal contesto
normalmente. Ciò consente la compilazione di file precedentemente preelaborati con "-E
-fdirectives-only".

Con entrambi -E ed -fpreelaborato, le regole per -fpreelaborato avere la precedenza. Questo
consente la preelaborazione completa dei file precedentemente preelaborati con "-E
-fdirectives-only".

-fdollari-in-identificatori
Accetta $ negli identificatori.

-identificatori-protesi
Accetta nomi di caratteri universali negli identificatori. Questa opzione è sperimentale; in un
versione futura di GCC, sarà abilitato per impostazione predefinita per C99 e C++.

-fpreelaborato
Indica al preprocessore che il file di input è già stato preelaborato. Questo
sopprime cose come l'espansione macro, la conversione del trigrafo, la giunzione di nuova riga sfuggita,
e l'elaborazione della maggior parte delle direttive. Il preprocessore riconosce e rimuove comunque
commenti, in modo da poter passare un file preelaborato con -C al compilatore senza
i problemi. In questa modalità il preprocessore integrato è poco più di un tokenizzatore
per le estremità anteriori.

-fpreelaborato è implicito se il file di input ha una delle estensioni .i, .ii or .mi.
Queste sono le estensioni che GCC utilizza per i file preelaborati creati da -salva-temps.

-ftabstop=larghezza
Imposta la distanza tra le tabulazioni. Questo aiuta il preprocessore a riportare la colonna corretta
numeri in avvisi o errori, anche se sulla riga vengono visualizzate schede. Se il valore è inferiore
maggiore di 1 o maggiore di 100, l'opzione viene ignorata. Il valore predefinito è 8.

-fdebug-cpp
Questa opzione è utile solo per il debug di GCC. Se utilizzato con -E, scarica il debug
informazioni sulle mappe di posizione. Ogni token nell'output è preceduto dal dump di
la mappa a cui appartiene la sua posizione. Il dump della mappa che contiene la posizione di un token
sarebbe:

{"P": F ;"F":F ;"L": ;"C": ;"S": ;"M": ;"E": ,"loc": }

Se usato senza -E, questa opzione non ha effetto.

-ftrack-macro-espansione[=livello]
Tieni traccia delle posizioni dei token nelle espansioni macro. Ciò consente al compilatore di emettere
diagnostica sullo stack di espansione macro corrente quando si verifica un errore di compilazione in
una macro espansione. L'uso di questa opzione fa consumare al preprocessore e al compilatore
più memoria. Il livello parametro può essere utilizzato per scegliere il livello di precisione del token
rilevamento della posizione, riducendo così il consumo di memoria, se necessario. Valore 0 of
livello disattiva questa opzione come se no -ftrack-macro-espansione era presente il
la riga di comando. Valore 1 tiene traccia delle posizioni dei token in una modalità degradata per motivi di
sovraccarico di memoria minimo. In questa modalità tutti i token risultanti dall'espansione di an
l'argomento di una macro di tipo funzione ha la stessa posizione. Valore 2 tiene traccia dei token
posizioni completamente. Questo valore è il più affamato di memoria. Quando viene data questa opzione
nessun argomento, il valore del parametro predefinito è 2.

-fexec-charset=set di caratteri
Imposta il set di caratteri di esecuzione, utilizzato per stringhe e costanti di caratteri. Il predefinito
è UTF-8. set di caratteri può essere qualsiasi codifica supportata dalla libreria "iconv" del sistema
routine.

-fwide-exec-charset=set di caratteri
Imposta il set di caratteri di esecuzione ampia, utilizzato per stringhe larghe e costanti di caratteri.
Il valore predefinito è UTF-32 o UTF-16, a seconda di quale corrisponde alla larghezza di "wchar_t". Come
con -fexec-set di caratteri, set di caratteri può essere qualsiasi codifica supportata da "iconv" del sistema
routine della biblioteca; tuttavia, avrai problemi con le codifiche che non si adattano
esattamente in "wchar_t".

-finput-charset=set di caratteri
Imposta il set di caratteri di input, utilizzato per la traduzione dal set di caratteri dell'input
file nel set di caratteri sorgente utilizzato da GCC. Se la lingua non specifica, o GCC
non è possibile ottenere queste informazioni dalla locale, l'impostazione predefinita è UTF-8. Questo può essere
sovrascritto dalle impostazioni internazionali o da questa opzione della riga di comando. Attualmente il comando
l'opzione line ha la precedenza in caso di conflitto. set di caratteri può essere qualsiasi codifica
supportato dalla routine della libreria "iconv" del sistema.

-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".

-fno-show-colonna
Non stampare i numeri di colonna nella diagnostica. Questo può essere necessario se la diagnostica è
essere scansionato da un programma che non comprende i numeri di colonna, come
dejagnu.

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

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

-dCARS
CAR è una sequenza di uno o più dei seguenti caratteri e non deve essere
preceduto da uno spazio. Altri caratteri sono interpretati dal compilatore vero e proprio, oppure
riservati per le versioni future di GCC, e quindi vengono ignorati silenziosamente. Se specifichi
personaggi il cui comportamento è in conflitto, il risultato è indefinito.

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

tocca foo.h; cpp -dM foo.h

mostrerà tutte le macro predefinite.

Se si utilizza -dM senza il -E opzione, -dM è interpretato come sinonimo di
-fdump-rtl-mach.

D Come M tranne per due aspetti: lo fa non includere le macro predefinite e
uscite entrambi , il #define direttive e il risultato della preelaborazione. Entrambi i tipi
di output va al file di output standard.

N Come D, ma emettono solo i nomi delle macro, non le loro espansioni.

I Uscita #includere direttive oltre al risultato della preelaborazione.

U Come D tranne che solo le macro che sono espanse o la cui definizione è testata
nelle direttive del preprocessore, vengono emesse; l'uscita viene ritardata fino all'utilizzo o
prova della macro; e #indif le direttive vengono emesse anche per le macro testate ma
indefinito al momento.

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

-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ù a #.

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

-tradizionale-cpp
Cerca di imitare il comportamento dei preprocessori C vecchio stile, al contrario di ISO C
preprocessori.

-trigrafie
Elabora sequenze trigrafiche. Queste sono sequenze di tre caratteri, tutte che iniziano con
??, che sono definiti da ISO C per indicare caratteri singoli. Per esempio, ??/ si
per \, Così '??/n' è un carattere costante per una nuova riga. Per impostazione predefinita, GCC ignora
trigrafi, ma in modalità conformi allo standard li converte. Vedi il -std ed -ansi
opzioni.

I nove trigrafi e le loro sostituzioni sono

Trigramma: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
Sostituzione: [ ] { } # \ ^ | ~

-rimappa
Abilita codice speciale per aggirare i file system che consentono solo file molto brevi
nomi, come MS-DOS.

--Aiuto
--target-aiuto
Stampa il testo che descrive tutte le opzioni della riga di comando invece di preelaborare qualsiasi cosa.

-v Modalità dettagliata. Stampa il numero di versione di GNU CPP all'inizio dell'esecuzione e
riporta la forma finale del percorso di inclusione.

-H Stampa il nome di ogni file di intestazione utilizzato, oltre alle altre normali attività. Ogni
il nome è rientrato per mostrare quanto è profondo il #includere pila è. Intestazione precompilata
vengono stampati anche i file, anche se risultano non validi; un precompilato non valido
il file di intestazione viene stampato con ...X e uno valido con ...! .

-versione
--versione
Stampa il numero di versione di GNU CPP. Con un trattino, procedi normalmente alla preelaborazione.
Con due trattini, esci immediatamente.

Di passaggio Opzioni a , il Assembler
Puoi passare le opzioni all'assemblatore.

-Wa,opzione
Passare opzione come opzione per l'assemblatore. Se opzione contiene virgole, è diviso
in più opzioni in corrispondenza delle virgole.

-Xassemblatore opzione
Passare opzione come opzione per l'assemblatore. Puoi usarlo per fornire specifiche del sistema
opzioni assembler che GCC non sa riconoscere.

Se vuoi passare un'opzione che accetta un argomento, devi usare -Xassemblatore due volte,
una volta per l'opzione e una volta per l'argomento.

Opzioni per Collegamento
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.

nome-file-oggetto
Un nome di file che non termina con uno speciale suffisso riconosciuto è considerato un nome
file oggetto o libreria. (I file oggetto si distinguono dalle librerie dal linker
in base al contenuto del file.) Se il collegamento viene eseguito, questi file oggetto vengono utilizzati come
ingresso al linker.

-c
-S
-E Se viene utilizzata una di queste opzioni, il linker non viene eseguito e i nomi dei file oggetto
non dovrebbero essere usati come argomenti.

-lbiblioteca
-l biblioteca
Cerca nella libreria denominata biblioteca durante il collegamento. (La seconda alternativa con il
la libreria come argomento separato è solo per la conformità POSIX e non è consigliata.)

Fa differenza dove nel comando si scrive questa opzione; il linker cerca
ed elabora librerie e file oggetto nell'ordine in cui sono specificati. Così, foo.o
-lz bar.o cerca nella libreria z dopo il file foo.o ma prima bar.o. Se bar.o si riferisce
funzioni in z, tali funzioni potrebbero non essere caricate.

Il linker cerca un elenco standard di directory per la libreria, che in realtà è
un file chiamato libreria.a. Il linker utilizza quindi questo file come se fosse stato specificato
appunto per nome.

Le directory ricercate includono diverse directory di sistema standard più quelle che tu
specificare con -L.

Normalmente i file trovati in questo modo sono file di libreria --- file di archivio i cui membri sono
file oggetto. Il linker gestisce un file di archivio scansionandolo per i membri
che definiscono i simboli che sono stati finora referenziati ma non definiti. Ma se il
il file che viene trovato è un normale file oggetto, è collegato nel solito modo. Il
unica differenza tra l'uso di an -l opzione e specificare un nome di file è quello -l
circonda biblioteca con lib ed .a e cerca in diverse directory.

-lobc
Hai bisogno di questo caso speciale del -l opzione per collegare un Objective-C o
Programma Objective-C++.

-nostartfiles
Non utilizzare i file di avvio del sistema standard durante il collegamento. Il sistema standard
le librerie sono usate normalmente, a meno che -nostdlib or -nodefaultlibs viene utilizzato.

-nodefaultlibs
Non utilizzare le librerie di sistema standard durante il collegamento. Solo le librerie che specifichi
verrà passato al linker, le opzioni che specificano il collegamento delle librerie di sistema, come
come "-static-libgcc" o "-shared-libgcc", verrà ignorato. I file di avvio standard
sono usati normalmente, a meno che -nostartfiles viene utilizzato. Il compilatore può generare chiamate a
"memcmp", "memset", "memcpy" e "memmove". Queste voci sono generalmente risolte da
voci in libc. Questi punti di ingresso dovrebbero essere forniti attraverso qualche altro meccanismo
quando questa opzione è specificata.

-nostdlib
Non utilizzare i file o le librerie di avvio del sistema standard durante il collegamento. Nessun avvio
file e solo le librerie specificate verranno passate al linker, opzioni
specificando il collegamento delle librerie di sistema, come "-static-libgcc" o
"-shared-libgcc", verrà ignorato. Il compilatore può generare chiamate a "memcmp",
"memset", "memcpy" e "memmove". Queste voci sono generalmente risolte da voci in
libc. Questi punti di ingresso dovrebbero essere forniti attraverso qualche altro meccanismo quando questo
l'opzione è specificata.

Una delle librerie standard bypassate da -nostdlib ed -nodefaultlibs is libgcc.a, un
libreria di sottoprogrammi interni che GCC utilizza per superare le carenze di particolari
macchine o esigenze speciali per alcune lingue.

Nella maggior parte dei casi, è necessario libgcc.a anche quando vuoi evitare altre librerie standard.
In altre parole, quando specifichi -nostdlib or -nodefaultlibs dovresti di solito
specificare -lgcc anche. Ciò garantisce di non avere riferimenti irrisolti a
subroutine interne della libreria GCC. (Per esempio, __principale, utilizzato per garantire C++
saranno chiamati i costruttori.)

-torta
Produrre un eseguibile indipendente dalla posizione sui target che lo supportano. Per prevedibile
risultati, devi anche specificare lo stesso insieme di opzioni che sono state usate per generare il codice
(-fpie, -fPIEo opzioni secondarie del modello) quando si specifica questa opzione.

-rdinamico
Passa la bandiera -export-dinamica al linker ELF, sui target che lo supportano. Questo
indica al linker di aggiungere tutti i simboli, non solo quelli usati, al simbolo dinamico
tavolo. Questa opzione è necessaria per alcuni usi di "dlopen" o per consentire di ottenere
backtraccia dall'interno di un programma.

-s Rimuovere tutte le informazioni sulla tabella dei simboli e sulla rilocazione dall'eseguibile.

-statico
Sui sistemi che supportano il collegamento dinamico, questo impedisce il collegamento con la condivisione
biblioteche. Su altri sistemi, questa opzione non ha effetto.

-condiviso
Produrre un oggetto condiviso che può poi essere collegato con altri oggetti per formare un
eseguibile. Non tutti i sistemi supportano questa opzione. Per risultati prevedibili, devi
specificare anche lo stesso insieme di opzioni che sono state utilizzate per generare il codice (-fpic, -fPIC, o
subopzioni del modello) quando si specifica questa opzione.[1]

-libgcc-condivisa
-static-libgcc
Su sistemi che forniscono libcc come libreria condivisa, queste opzioni forzano l'uso di
rispettivamente la versione condivisa o statica. Se nessuna versione condivisa di libcc Prima
compilato quando il compilatore è stato configurato, queste opzioni non hanno effetto.

Ci sono diverse situazioni in cui un'applicazione dovrebbe usare lo shared libcc
invece della versione statica. Il più comune di questi è quando l'applicazione
desidera lanciare e catturare eccezioni tra diverse librerie condivise. In quel caso,
ciascuna delle librerie e l'applicazione stessa dovrebbero usare shared libcc.

Pertanto, i driver G++ e GCJ si aggiungono automaticamente -libgcc-condivisa ogni volta che costruisci
una libreria condivisa o un eseguibile principale, perché i programmi C++ e Java in genere usano
eccezioni, quindi questa è la cosa giusta da fare.

Se, invece, usi il driver GCC per creare librerie condivise, potresti scoprire che
non sarà sempre collegato alla condivisione libcc. Se GCC trova, alla sua configurazione
volta, che hai un linker non GNU o un linker GNU che non supporta l'opzione
--eh-frame-hdr, collegherà la versione condivisa di libcc nelle biblioteche condivise da
predefinito. Altrimenti, sfrutterà il linker e ottimizzerà via il
collegamento con la versione condivisa di libcc, collegamento con la versione statica di libgcc
per impostazione predefinita. Ciò consente alle eccezioni di propagarsi attraverso tali librerie condivise,
senza incorrere in costi di trasferimento al momento del caricamento della libreria.

Tuttavia, se si suppone che una libreria o un eseguibile principale generi o catturi eccezioni,
deve collegarlo utilizzando il driver G++ o GCJ, a seconda dei linguaggi utilizzati nel
programma o utilizzando l'opzione -libgcc-condivisa, in modo tale da essere collegato con il condiviso
libcc.

-static-libstdc++
Quando il g ++ programma viene utilizzato per collegare un programma C++, normalmente lo farà automaticamente
collegamento contro libstdc++. Se libstdc++ è disponibile come libreria condivisa e il
-statico l'opzione non viene utilizzata, quindi questo si collegherà alla versione condivisa di
libstdc++. Normalmente va bene. Tuttavia, a volte è utile congelare il
versione libstdc++ utilizzato dal programma senza arrivare fino a un livello completamente statico
collegamento. Il -static-libstdc++ l'opzione dirige il g ++ driver da collegare libstdc++
staticamente, senza necessariamente collegare staticamente altre librerie.

-simbolico
Associa i riferimenti ai simboli globali durante la creazione di un oggetto condiviso. Avverti di qualsiasi
riferimenti non risolti (a meno che non vengano sovrascritti dall'opzione dell'editor dei collegamenti -Xlinker -z
-Xlinker def). Solo pochi sistemi supportano questa opzione.

-T copione
Usa il copione come script del linker. Questa opzione è supportata dalla maggior parte dei sistemi che utilizzano il
linker GNU. Su alcuni target, come target bareboard senza un sistema operativo,
, il -T L'opzione può essere richiesta durante il collegamento per evitare riferimenti a simboli non definiti.

-Xlinker opzione
Passare opzione come opzione per il linker. Puoi usarlo per fornire specifiche del sistema
opzioni del linker che GCC non riconosce.

Se vuoi passare un'opzione che accetta un argomento separato, devi usare -Xlinker
due volte, una volta per l'opzione e una volta per l'argomento. Ad esempio, per passare -affermare
definizioni, devi scrivere -Xlinker -affermare -Xlinker definizioni. Non funziona
scrivere -Xlinker "-affermare definizioni", perché questo passa l'intera stringa come a
singolo argomento, che non è quello che si aspetta il linker.

Quando si usa il linker GNU, di solito è più conveniente passare argomenti al linker
opzioni usando il opzione=APPREZZIAMO sintassi che come argomenti separati. Ad esempio, tu
può specificare -Xlinker -Mappa=output.map anziché -Xlinker -Carta geografica -Xlinker uscita.mappa.
Altri linker potrebbero non supportare questa sintassi per le opzioni della riga di comando.

-Wl,opzione
Passare opzione come opzione per il linker. Se opzione contiene virgole, è diviso in
più opzioni alle virgole. Puoi usare questa sintassi per passare un argomento al
opzione. Per esempio, -Wl,-Mappa,output.map Passi -Carta geografica uscita.mappa al linker. quando
usando il linker GNU, puoi anche ottenere lo stesso effetto con -Wl, -Map = output.map.

NOTA: in Ubuntu 8.10 e versioni successive, per LDFLAGS, l'opzione -Wl,-z,relro viene utilizzato.
Per disabilitare, utilizzare -Wl,-z,norelro.

-u simbolo
Fai finta che il simbolo simbolo non è definito, per forzare il collegamento dei moduli della libreria da definire
esso. Puoi usare -u più volte con simboli diversi per forzare il caricamento di
moduli aggiuntivi della libreria.

Opzioni per elenco Cerca
Queste opzioni specificano le directory in cui cercare i file di intestazione, le librerie e le parti
del compilatore:

-Idir
Aggiungi la directory dir all'inizio dell'elenco delle directory da cercare per intestazione
File. Questo può essere usato per sovrascrivere un file di intestazione di sistema, sostituendo il tuo
versione, poiché queste directory vengono cercate prima del file di intestazione del sistema
directory. Tuttavia, non dovresti usare questa opzione per aggiungere directory che contengono
file di intestazione di sistema forniti dal fornitore (usare -isistema per quello). Se ne usi più di uno
-I opzione, le directory vengono scansionate in ordine da sinistra a destra; il sistema standard
le directory vengono dopo.

Se una directory include un sistema standard o una directory specificata con -isistema, è
specificato anche con -I, le -I opzione verrà ignorata. La directory sarà ancora
cercato ma come directory di sistema nella sua posizione normale nella catena di inclusione del sistema.
Questo per garantire che la procedura di GCC per correggere le intestazioni di sistema difettose e l'ordine
per la direttiva include_next non vengono modificati inavvertitamente. Se proprio ne hai bisogno
modificare l'ordine di ricerca per le directory di sistema, utilizzare il tasto -nostdin e / o -isistema
opzioni.

-iplugindir=dir
Imposta la directory per cercare i plugin passati da -fplugin=Nome invece di
-fplugin=sentiero/Nome.così. Questa opzione non è pensata per essere utilizzata dall'utente, ma solo
passato dall'autista.

-quotodir
Aggiungi la directory dir all'inizio dell'elenco delle directory da cercare per intestazione
file solo per il caso di #includere "filetto"; non si cercano #includere <filetto>,
altrimenti proprio come -I.

-Ldir
Aggiungi directory dir all'elenco delle directory da cercare -l.

-Bprefisso
Questa opzione specifica dove trovare gli eseguibili, le librerie, i file di inclusione e
file di dati del compilatore stesso.

Il programma del driver del compilatore esegue uno o più sottoprogrammi cpp, cc1, as ed ld.
ci prova prefisso come prefisso per ogni programma che tenta di eseguire, sia con che senza
macchina/versione/.

Per ogni sottoprogramma da eseguire, il driver del compilatore prova prima il -B prefisso, se presente.
Se quel nome non viene trovato, o se -B non è stato specificato, il driver prova due standard
prefissi, /usr/lib/gcc/ ed /usr/local/lib/gcc/. Se nessuno di questi risultati in a
nome del file trovato, viene cercato il nome del programma non modificato utilizzando il
directory specificate nel tuo PERCORSO variabile d'ambiente.

Il compilatore verificherà se il percorso fornito dal -B si riferisce a una directory,
e se necessario aggiungerà un carattere separatore di directory alla fine del percorso.

-B i prefissi che specificano efficacemente i nomi delle directory si applicano anche alle librerie nel
linker, perché il compilatore traduce queste opzioni in -L opzioni per il linker.
Si applicano anche ai file include nel preprocessore, perché il compilatore traduce
queste opzioni in -isistema opzioni per il preprocessore. In questo caso, il compilatore
aggiunge includere al prefisso.

Il file di supporto runtime libgcc.a può anche essere cercato utilizzando il -B prefisso, se
necessario. Se non viene trovato lì, vengono provati i due prefissi standard sopra e questo
è tutto. Il file viene escluso dal collegamento se non viene trovato con questi mezzi.

Un altro modo per specificare un prefisso molto simile a -B il prefisso è usare l'ambiente
variabile GCC_EXEC_PREFIX.

Come un kludge speciale, se il percorso fornito da -B is [dir/]palcoN/, Dove N è un numero
nell'intervallo da 0 a 9, verrà sostituito da [dir/]includi. Questo è per aiutare con
boot-strapping del compilatore.

-specifiche=filetto
Processo filetto dopo che il compilatore ha letto lo standard occhiali file, per sovrascrivere
le impostazioni predefinite che gcc il programma del driver utilizza per determinare quali interruttori passare
a cc1, cc1plus, as, ld, ecc. Più di uno -specifiche=filetto può essere specificato sul
riga di comando e vengono elaborati in ordine, da sinistra a destra.

--sysroot=dir
Usa il dir come directory radice logica per intestazioni e librerie. Ad esempio, se
il compilatore normalmente cercherà le intestazioni in / usr / include e biblioteche in / Usr / lib,
cercherà invece dir/usr/include ed dir/usr/lib.

Se usi sia questa opzione che il -isysroot opzione, quindi il --sysroot l'opzione sarà
si applicano alle biblioteche, ma il -isysroot l'opzione verrà applicata ai file di intestazione.

Il linker GNU (a partire dalla versione 2.16) ha il supporto necessario per questo
opzione. Se il tuo linker non supporta questa opzione, l'aspetto del file di intestazione di
--sysroot funzionerà ancora, ma l'aspetto della libreria no.

-IO- Questa opzione è stata deprecata. Si prega di utilizzare -quoto invece per -I directory prima
, il -IO- e rimuovere il file -IO-. Qualsiasi directory specificata con -I opzioni prima del
-IO- vengono ricercate solo per il caso di #includere "filetto"; non vengono cercati
per #includere <filetto>.

Se vengono specificate directory aggiuntive con -I opzioni dopo il -IO-, Queste
le directory vengono cercate per tutte #includere direttive. (normalmente contro tutti i -I directory
sono usati in questo modo.)

Inoltre, l' -IO- l'opzione inibisce l'uso della directory corrente (dove il
da cui proviene il file di input corrente) come prima directory di ricerca per #includere "filetto".
Non c'è modo di ignorare questo effetto di -IO-. Con -IO. puoi specificare la ricerca
la directory che era corrente quando è stato richiamato il compilatore. Non è esattamente quello
uguale a quello che fa il preprocessore per impostazione predefinita, ma spesso è soddisfacente.

-IO- non inibisce l'uso delle directory di sistema standard per i file di intestazione.
Così, -IO- ed -nostdin sono indipendenti.

specificando Target Confezionatrici Verticali VFFS ed Compiler Versione
Il modo normale per eseguire GCC è eseguire l'eseguibile chiamato gcc, o macchina-gcc quando cross-
compilazione, o macchina-gcc-versione per eseguire una versione diversa da quella installata
ultimo.

Hardware Modelli ed Configurazioni
Ogni tipo di macchina di destinazione può avere le proprie opzioni speciali, a partire da -m, scegliere
tra vari modelli o configurazioni hardware --- ad esempio, 68010 vs 68020, flottante
coprocessore o nessuno. Una singola versione installata del compilatore può compilare per qualsiasi modello
o configurazione, secondo le opzioni specificate.

Alcune configurazioni del compilatore supportano anche opzioni speciali aggiuntive, solitamente per
compatibilità con altri compilatori sulla stessa piattaforma.

Adatta Epifania Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per Adapteva Epiphany:

-metà-file-reg
Non allocare alcun registro nell'intervallo "r32"..."r63". Ciò consente l'esecuzione del codice
varianti hardware prive di questi registri.

-mprefer-breve-insn-regs
Allocare preferibilmente i registri che consentono la generazione di istruzioni brevi. questo può
comporta un aumento del numero di istruzioni, quindi se questo riduce o aumenta la dimensione del codice
potrebbe variare da caso a caso.

-mbranch-costo=num
Imposta il costo delle filiali a circa num istruzioni "semplici". Questo costo è solo un
euristico e non è garantito che produca risultati coerenti tra le versioni.

-mcsposta
Abilita la generazione di mosse condizionali.

-mnop=num
Emettere num nops prima di ogni altra istruzione generata.

-mno-soft-cmpsf
Per i confronti a virgola mobile a precisione singola, emettere un'istruzione fsub e testare il
bandiere. Questo è più veloce di un confronto software, ma può ottenere risultati errati in
la presenza di NaN, o quando due diversi piccoli numeri vengono confrontati in modo tale che il loro
la differenza è calcolata come zero. L'impostazione predefinita è -msoft-cmpsf, che usa più lento, ma
Conforme a IEEE, confronti di software.

-mstack-offset=num
Imposta l'offset tra la parte superiore dello stack e il puntatore dello stack. Ad esempio, un valore di 8
significa che gli otto byte nell'intervallo sp+0...sp+7 possono essere utilizzati dalle funzioni foglia
senza allocazione dello stack. Valori diversi da 8 or 16 non sono testati ed è improbabile che lo facciano
opera. Nota anche che questa opzione cambia l'ABI, compilando un programma con a
un offset dello stack diverso da quello con cui sono state compilate le librerie generalmente non lo farà
opera. Questa opzione può essere utile se vuoi valutare se un diverso offset dello stack
ti darebbe un codice migliore, ma usare effettivamente un diverso offset dello stack per costruire
programmi funzionanti, si consiglia di configurare la toolchain con l'apposito
--con-stack-offset=num opzione.

-mno-rotondo-più vicino
Fare in modo che l'utilità di pianificazione presupponga che la modalità di arrotondamento sia stata impostata sul troncamento. Il
l'impostazione predefinita è -mround-più vicino.

-mlong-chiamate
Se non diversamente specificato da un attributo, supponi che tutte le chiamate possano essere oltre il
offset delle istruzioni b/bl, e quindi caricare l'indirizzo della funzione in
un registro prima di effettuare una chiamata (altrimenti diretta). Questa è l'impostazione predefinita.

-mshort-call
Se non diversamente specificato da un attributo, supponiamo che tutte le chiamate dirette siano nell'intervallo
delle istruzioni b/bl, quindi utilizzate queste istruzioni per le chiamate dirette. Il predefinito
is -mlong-chiamate.

-mpiccolo16
Si supponga che gli indirizzi possano essere caricati come valori senza segno a 16 bit. Questo non si applica a
indirizzi di funzione per i quali -mlong-chiamate semantica è in vigore.

-modalità-mfp=modo
Imposta la modalità prevalente dell'unità a virgola mobile. Questo determina il galleggiante-
modalità punto fornita e prevista alla chiamata della funzione e all'ora di ritorno. Fabbricazione
questa modalità corrisponde alla modalità di cui hai prevalentemente bisogno all'avvio della funzione può rendere il tuo
programmi più piccoli e veloci evitando cambi di modalità non necessari.

modo può essere impostato su uno dei seguenti valori:

visitatore
Qualsiasi modalità all'immissione della funzione è valida e viene mantenuta o ripristinata quando la funzione
restituisce e quando chiama altre funzioni. Questa modalità è utile per la compilazione
librerie o altre unità di compilazione che potresti voler incorporare in diverse
programmi con diverse modalità FPU prevalenti e la comodità di poterlo
l'uso di un singolo file oggetto supera le dimensioni e la velocità del sovraccarico per qualsiasi modalità aggiuntiva
commutazione che potrebbe essere necessaria, rispetto a quella che sarebbe necessaria con un più
scelta specifica della modalità FPU prevalente.

troncare
Questaèla modalità usata per i calcoli in virgola mobile con troncamento (cioè round
verso lo zero) modalità di arrotondamento. Ciò include la conversione da virgola mobile a
numero intero.

il più vicino
Questa è la modalità utilizzata per i calcoli in virgola mobile con arrotondamento al più vicino o
modalità di arrotondamento uniforme.

int Questa è la modalità utilizzata per eseguire calcoli interi nella FPU, ad esempio intero
moltiplicare o moltiplicare-e-accumulare intero.

L'impostazione predefinita è -mfp-mode=chiamante

-Mnosplit-lohi
-mno-postin
-mno-postmodifica
Modifiche alla generazione del codice che disabilitano, rispettivamente, la suddivisione dei carichi a 32 bit,
generazione di indirizzi post-incremento e generazione di indirizzi post-modifica. Il
le impostazioni predefinite sono mssplit-lohi, -mpost-ince -mpost-modifica.

-mnovect-doppio
Cambia la modalità SIMD preferita in SImode. L'impostazione predefinita è -mvect-doppio, Che utilizza
DImode come modalità SIMD preferita.

-max-vect-align=num
L'allineamento massimo per i tipi di modalità vettoriale SIMD. num può essere 4 o 8. Il valore predefinito è
8. Si noti che questa è una modifica ABI, anche se molte interfacce di funzioni di libreria lo faranno
essere inalterato, se non utilizzano le modalità vettoriali SIMD in luoghi in cui influiscono sulle dimensioni
e/o allineamento delle tipologie rilevanti.

-msplit-vecmove-presto
Il vettore diviso si sposta in singole parole prima di ricaricare. In teoria questo potrebbe dare
migliore allocazione dei registri, ma finora sembra essere generalmente il contrario.

-m1reg-reg
Specificare un registro per mantenere la costante -1, il che rende il caricamento piccolo negativo
costanti e alcune maschere di bit più velocemente. I valori consentiti per reg sono r43 e r63,
che specificano di usare quel registro come registro fisso, e nessuno, il che significa che no
registro è utilizzato per questo scopo. L'impostazione predefinita è -m1reg-nessuno.

AAArch64 Opzioni

Queste opzioni sono definite per le implementazioni di AArch64:

-big endian
Genera codice big-endian. Questa è l'impostazione predefinita quando GCC è configurato per un
aarch64_be-*-* bersaglio.

-mgeneral-regs-only
Genera codice che utilizza solo i registri generali.

-mittle-endian
Genera codice little-endian. Questa è l'impostazione predefinita quando GCC è configurato per un
aarch64-*-* ma non un aarch64_be-*-* bersaglio.

-mcmodel=piccolo
Genera codice per il modello di codice minuscolo. Il programma e i suoi simboli staticamente definiti
devono trovarsi entro 1 GB l'uno dall'altro. I puntatori sono a 64 bit. I programmi possono essere staticamente
o collegati dinamicamente. Questo modello non è completamente implementato e per lo più trattato come
"piccolo".

-mcmodel=piccolo
Genera codice per il modello a codice piccolo. Il programma e la sua definizione statica
i simboli devono trovarsi entro 4 GB l'uno dall'altro. I puntatori sono a 64 bit. I programmi possono essere
collegati staticamente o dinamicamente. Questo è il modello di codice predefinito.

-mcmodel=grande
Genera codice per il modello di codice grande. Questo non fa supposizioni su indirizzi e
dimensioni delle sezioni. I puntatori sono a 64 bit. I programmi possono essere collegati solo staticamente.

-mstrict-align
Non presumere che i riferimenti di memoria non allineati verranno gestiti dal sistema.

-puntatore-cornice-foglia-momit
-mno-omit-leaf-frame pointer
Ometti o mantieni il puntatore a cornice nelle funzioni foglia. Il primo comportamento è il
predefinito.

-mtls-dialetto=desc
Utilizzare i descrittori TLS come meccanismo di archiviazione locale del thread per gli accessi dinamici di TLS
variabili. Questa è l'impostazione predefinita.

-mtls-dialect=tradizionale
Usa TLS tradizionale come meccanismo di archiviazione locale del thread per gli accessi dinamici di TLS
variabili.

-marzo=Nome
Specificare il nome dell'architettura di destinazione, facoltativamente suffisso da uno o più
modificatori di funzionalità. Questa opzione ha la forma -marzo=arco{+[no]caratteristica}*, dove il
solo valore per arco is armv8-a. I possibili valori per caratteristica sono documentati nel
sottosezione sottostante.

Laddove vengono specificati modificatori di funzionalità in conflitto, viene utilizzata la funzionalità più a destra.

GCC usa questo nome per determinare che tipo di istruzioni può emettere durante la generazione
codice montaggio. Questa opzione può essere utilizzata insieme o al posto di -mcpu=
opzione.

-mcpu=Nome
Specificare il nome del processore di destinazione, facoltativamente suffisso da una o più funzionalità
modificatori. Questa opzione ha la forma -mcpu=cpu{+[no]caratteristica}*, dove possibile
valori per cpu sono generico, grandi. I possibili valori per caratteristica sono documentati in
la sottosezione sottostante.

Laddove vengono specificati modificatori di funzionalità in conflitto, viene utilizzata la funzionalità più a destra.

GCC usa questo nome per determinare che tipo di istruzioni può emettere durante la generazione
codice montaggio.

-mtune=Nome
Specificare il nome del processore per cui ottimizzare le prestazioni. Il codice sarà sintonizzato
come se il processore di destinazione fosse del tipo specificato in questa opzione, ma ancora in uso
istruzioni compatibili con il processore di destinazione specificato da a -mcpu= opzione. Questo
l'opzione non può essere suffissata dai modificatori di funzionalità.

-marzo ed -mcpu modificatori di funzionalità

Modificatori di funzionalità utilizzati con -marzo ed -mcpu può essere uno dei seguenti:

crypto
Abilita l'estensione Crypto. Ciò implica che la SIMD avanzata sia abilitata.

fp Abilita le istruzioni in virgola mobile.

sim
Abilita le istruzioni SIMD avanzate. Ciò implica che le istruzioni in virgola mobile siano
abilitato. Questa è l'impostazione predefinita per tutti i valori possibili correnti per le opzioni -marzo ed
-mcpu=.

ARM Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le architetture Advanced RISC Machines (ARM):

-mabi=Nome
Genera codice per l'ABI specificato. I valori ammessi sono: apcs-gnu, atpc, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
aapcs-linux ed iwmmxt.

-mapcs-frame
Genera uno stack frame conforme allo standard ARM Procedure Call per tutti
funzioni, anche se ciò non è strettamente necessario per la corretta esecuzione del codice.
specificando -puntatore-frame-fomit con questa opzione gli stack frame non saranno
generato per le funzioni foglia. L'impostazione predefinita è -mno-aps-frame.

-mapc
Questo è sinonimo di -mapcs-frame.

-mthumb-interazione
Genera codice che supporti la chiamata tra i set di istruzioni ARM e Thumb.
Senza questa opzione, su architetture pre-v5, i due set di istruzioni non possono essere
utilizzato in modo affidabile all'interno di un programma. L'impostazione predefinita è -mno-pollice-interwork, poiché leggermente
codice più grande viene generato quando -mthumb-interazione è specificato. Nelle configurazioni AAPCS
questa opzione non ha senso.

-mno-sched-prolog
Impedire il riordino delle istruzioni nel prologo della funzione, o la fusione di
quelle istruzioni con le istruzioni nel corpo della funzione. Questo significa che tutto
funzioni inizieranno con un insieme riconoscibile di istruzioni (o in effetti uno di a
scelta da un piccolo insieme di diversi prologhi di funzioni), e questa informazione può essere
utilizzato per individuare le funzioni start if all'interno di un pezzo di codice eseguibile. Il predefinito
is -msched-prologo.

-mfloat-abi=Nome
Specifica quale ABI a virgola mobile utilizzare. I valori ammessi sono: morbido, Softfp ed
difficile.

specificando morbido fa sì che GCC generi un output contenente chiamate di libreria per floating-
operazioni puntuali. Softfp consente la generazione di codice utilizzando hardware in virgola mobile
istruzioni, ma utilizza ancora le convenzioni di chiamata soft-float. difficile consente
generazione di istruzioni in virgola mobile e utilizza convenzioni di chiamata specifiche della FPU.

L'impostazione predefinita dipende dalla configurazione di destinazione specifica. Nota che l'hard-float
e gli ABI soft-float non sono compatibili con il collegamento; devi compilare l'intero programma con
lo stesso ABI e collegarsi a un set di librerie compatibile.

-mittle-endian
Genera codice per un processore in esecuzione in modalità little-endian. Questa è l'impostazione predefinita per
tutte le configurazioni standard.

-big endian
Genera codice per un processore in esecuzione in modalità big-endian; l'impostazione predefinita è compilare
codice per un processore little-endian.

-mwords-little-endian
Questa opzione si applica solo durante la generazione di codice per processori big-endian. creare
codice per un ordine di parole little-endian ma un ordine di byte big-endian. Cioè, un byte
ordine della forma 32107654. Nota: questa opzione dovrebbe essere utilizzata solo se necessario
compatibilità con il codice per i processori ARM big-endian generati dalle versioni del
compilatore precedente alla 2.8. Questa opzione è ora deprecata.

-marzo=Nome
Specifica il nome dell'architettura ARM di destinazione. GCC usa questo nome per
determinare il tipo di istruzioni che può emettere durante la generazione del codice assembly. Questo
l'opzione può essere utilizzata insieme o al posto di -mcpu= opzione. ammissibile
i nomi sono: armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5e,
armv5te, armv6, armv6j, armv6t2, armv6z, armv6zk, armv6-m, armv7, armv7-a, armv7-r,
armv7-m, armv7e-m, iwmmxt, iwmmxt2, ep9312.

-marzo=nativo fa sì che il compilatore rilevi automaticamente l'architettura della build
computer. Al momento, questa funzione è supportata solo su Linux e non su tutti
si riconoscono le architetture. Se il rilevamento automatico non ha successo, l'opzione non ha
effetto.

-mtune=Nome
Questa opzione specifica il nome del processore ARM di destinazione per il quale GCC dovrebbe sintonizzarsi
l'esecuzione del codice. Per alcune implementazioni ARM possono essere migliori prestazioni
ottenuto utilizzando questa opzione. I nomi consentiti sono: arm2, arm250, arm3, arm6,
arm60, arm600, arm610, arm620, arm7, braccio7m, braccio7d, braccio7dm, arm7di, arm7dmi, arm70,
arm700, braccio700i, arm710, ARM710C, arm7100, arm720, arm7500, braccio7500fe, arm7tdmi,
arm7tdmi-s, braccio710t, braccio720t, braccio740t, braccio forte, braccio forte110, braccio forte1100,
braccio forte1110, arm8, arm810, arm9, braccio9e, arm920, braccio920t, braccio922t, arm946e-s,
arm966e-s, arm968e-s, arm926ej-s, braccio940t, arm9tdmi, arm10tdmi, braccio1020t, arm1026ej-s,
braccio10e, braccio1020e, braccio1022e, braccio1136j-s, braccio1136jf-s, mpcore, mpcorenovfp, braccio1156t2-s,
braccio1156t2f-s, braccio1176jz-s, braccio1176jzf-s, corteccia-a5, corteccia-a7, corteccia-a8, corteccia-a9,
corteccia-a15, corteccia-r4, corteccia-r4f, corteccia-r5, corteccia-m4, corteccia-m3, corteccia-m1,
corteccia-m0, xscala, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626,
fa726te.

-mtune=generico-arco specifica che GCC dovrebbe ottimizzare le prestazioni per una miscela di
processori all'interno dell'architettura arco. L'obiettivo è generare codice che funzioni bene sul
gli attuali processori più popolari, bilanciando tra le ottimizzazioni che avvantaggiano alcuni
CPU della gamma ed evitando le insidie ​​delle prestazioni di altre CPU. Gli effetti di
questa opzione potrebbe cambiare nelle future versioni di GCC man mano che i modelli di CPU vanno e vengono.

-mtune=nativo fa sì che il compilatore rilevi automaticamente la CPU del computer di compilazione. In
presente, questa funzione è supportata solo su Linux e non tutte le architetture lo sono
riconosciuto. Se il rilevamento automatico non ha successo, l'opzione non ha effetto.

-mcpu=Nome
Specifica il nome del processore ARM di destinazione. GCC usa questo nome per derivare il
nome dell'architettura ARM di destinazione (come se specificato da -marzo) e il processore ARM
tipo per il quale eseguire l'ottimizzazione per le prestazioni (come se specificato da -mtune). Dove questa opzione
è usato insieme a -marzo or -mtune, queste opzioni hanno la precedenza su
parte appropriata di questa opzione.

I nomi consentiti per questa opzione sono gli stessi di quelli per -mtune.

-mcpu=generico-arco è anche ammissibile, ed è equivalente a -marzo=arco
-mtune=generico-arco. Vedere -mtune per maggiori informazioni.

-mcpu=nativo fa sì che il compilatore rilevi automaticamente la CPU del computer di compilazione. In
presente, questa funzione è supportata solo su Linux e non tutte le architetture lo sono
riconosciuto. Se il rilevamento automatico non ha successo, l'opzione non ha effetto.

-mfpu=Nome
-mfpe=numero
-mfp=numero
Questo specifica su quale hardware a virgola mobile (o emulazione hardware) è disponibile
il bersaglio. I nomi consentiti sono: fpa, fpe2, fpe3, maverick, vfp, vfpv3, vfpv3-fp16,
vfpv3-d16, vfpv3-d16-fp16, vfpv3xd, vfpv3xd-fp16, neon, neon-FP16, vfpv4, vfpv4-d16,
fpv4-sp-d16 ed neon-vfpv4. -mfp ed -mfpe sono sinonimi di -mfpu=fpenumero, Per
compatibilità con le versioni precedenti di GCC.

If -msoft-flottante è specificato questo specifica il formato dei valori a virgola mobile.

Se l'hardware in virgola mobile selezionato include l'estensione NEON (ad es -mfpu=neon),
nota che le operazioni in virgola mobile non verranno utilizzate dal pass di vettorizzazione automatica di GCC
salvo che -funsafe-math-ottimizzazioni è anche specificato. Questo perché l'hardware NEON
non implementa completamente lo standard IEEE 754 per l'aritmetica in virgola mobile (in
particolari valori denormali sono trattati come zero), quindi l'uso di istruzioni NEON può
portare a una perdita di precisione.

-mfp16-formato=Nome
Specificare il formato del tipo a virgola mobile a mezza precisione "__fp16". ammissibile
i nomi sono nessuna, ieee alternativa; l'impostazione predefinita è nessuna, nel qual caso il "__fp16"
il tipo non è definito.

-mstruttura-dimensione-confine=n
La dimensione di tutte le strutture e le unioni sarà arrotondata a un multiplo del numero
di bit impostati da questa opzione. I valori consentiti sono 8, 32 e 64. Il valore predefinito
varia per le diverse toolchain. Per la toolchain mirata COFF il valore predefinito è
8. Un valore di 64 è consentito solo se l'ABI sottostante lo supporta.

Specificare il numero maggiore può produrre codice più veloce ed efficiente, ma può anche
aumentare le dimensioni del programma. Valori diversi sono potenzialmente incompatibili.
Il codice compilato con un valore non può necessariamente aspettarsi di funzionare con codice o librerie
compilati con un altro valore, se si scambiano informazioni tramite strutture o sindacati.

-mabort-su-mancato ritorno
Genera una chiamata alla funzione "abort" alla fine di una funzione "noreturn". Lo farà
essere eseguito se la funzione tenta di restituire.

-mlong-chiamate
-mno-chiamate lunghe
Dice al compilatore di eseguire chiamate di funzione caricando prima l'indirizzo del
funzione in un registro e quindi eseguire una chiamata di subroutine su questo registro. Questo
l'interruttore è necessario se la funzione di destinazione si trova al di fuori dell'indirizzamento da 64 megabyte
intervallo della versione basata sull'offset dell'istruzione di chiamata della subroutine.

Anche se questo interruttore è abilitato, non tutte le chiamate di funzione verranno trasformate in chiamate lunghe.
L'euristica è che le funzioni statiche, funzioni che hanno il chiamata breve attributo,
funzioni che rientrano nell'ambito di a #pragma nessuna_chiamata_lunga direttiva e funzioni
le cui definizioni sono già state compilate all'interno dell'unità di compilazione corrente, sarà
non trasformarsi in lunghe chiamate. L'eccezione a questa regola è quella funzione debole
definizioni, funzioni con il lunga chiamata attributo o il pagina attributo, e
funzioni che rientrano nell'ambito di a #pragma lunghe_chiamate direttiva, sarà sempre
trasformato in lunghe chiamate.

Questa funzione non è abilitata per impostazione predefinita. Specificando -mno-chiamate lunghe ripristinerà il
comportamento predefinito, così come il posizionamento delle chiamate di funzione nell'ambito di a #pragma
chiamate_lunghe_off direttiva. Nota che queste opzioni non hanno effetto sul modo in cui il compilatore
genera codice per gestire le chiamate di funzione tramite puntatori a funzione.

-mssingle-pic-base
Tratta il registro utilizzato per l'indirizzamento PIC come di sola lettura, piuttosto che caricarlo nel
prologo per ogni funzione. Il sistema di runtime è responsabile dell'inizializzazione di questo
registrarsi con un valore appropriato prima dell'inizio dell'esecuzione.

-registro-mpic=reg
Specificare il registro da utilizzare per l'indirizzamento PIC. L'impostazione predefinita è R10 a meno che non venga impilato
il controllo è abilitato, quando si usa R9.

-mcirrus-fix-insns-non-validi
Inserire NOP nel flusso di istruzioni per per aggirare i problemi con
combinazioni di istruzioni Maverick non valide. Questa opzione è valida solo se il
-mcpu=ep9312 è stata utilizzata l'opzione per abilitare la generazione di istruzioni per il Cirrus
Coprocessore a virgola mobile Maverick. Questa opzione non è abilitata per impostazione predefinita, poiché
il problema è presente solo nelle vecchie implementazioni di Maverick. L'impostazione predefinita può essere ri-
abilitato dall'uso del -mno-cirrus-fix-insns-non-validi interruttore.

-nome-funzione-mpoke
Scrivi il nome di ogni funzione nella sezione di testo, direttamente prima della funzione
prologo. Il codice generato è simile a questo:

t0
.ascii "arm_poke_function_name", 0
.allineare
t1
.parola 0xff000000 + (t1 - t0)
arm_poke_nome_funzione
movimento ip, sp
stmfd sp!, {fp, ip, lr, pc}
sub fp, IP, #4

Quando si esegue un backtrace dello stack, il codice può ispezionare il valore di "pc" memorizzato in "fp +
0". Se la funzione di traccia guarda quindi alla posizione "pc - 12" e i primi 8 bit sono
set, allora sappiamo che c'è un nome di funzione incorporato immediatamente prima di questo
posizione e ha lunghezza "((pc[-3]) & 0xff000000)".

- pollice
-marma
Seleziona tra la generazione di codice che viene eseguito negli stati ARM e Thumb. L'impostazione predefinita per
la maggior parte delle configurazioni consiste nel generare codice che viene eseguito nello stato ARM, ma l'impostazione predefinita
può essere modificato configurando GCC con il --con-modalità=stato configurare l'opzione.

-mtpcs-telaio
Genera uno stack frame conforme allo standard Thumb Procedure Call per
tutte le funzioni non fogliari. (Una funzione foglia è una che non ne chiama altre
funzioni.) L'impostazione predefinita è -mno-tpcs-frame.

-mtpcs-foglia-frame
Genera uno stack frame conforme allo standard Thumb Procedure Call per
tutte le funzioni fogliari. (Una funzione foglia è una funzione che non chiama altre funzioni.)
L'impostazione predefinita è -mno-apc-cornice-foglia.

-mcallee-super-interazione
Fornisce a tutte le funzioni visibili esternamente nel file in fase di compilazione un'istruzione ARM
set header che passa alla modalità Thumb prima di eseguire il resto della funzione.
Ciò consente di chiamare queste funzioni da codice non interoperativo. Questa opzione è
non valido nelle configurazioni AAPCS perché l'interworking è abilitato per impostazione predefinita.

-mcaller-super-interazione
Consente l'esecuzione corretta delle chiamate tramite puntatori a funzione (incluse le funzioni virtuali)
indipendentemente dal fatto che il codice di destinazione sia stato compilato per l'interazione o meno.
C'è un piccolo sovraccarico nel costo di esecuzione di un puntatore a funzione se questa opzione
è abilitato. Questa opzione non è valida nelle configurazioni AAPCS perché l'interoperabilità è
abilitato per impostazione predefinita.

-mtp=Nome
Specificare il modello di accesso per il puntatore di archiviazione locale del thread. I modelli validi sono
morbido, che genera chiamate a "__aeabi_read_tp", cp15, che recupera il filo
puntatore direttamente da "cp15" (supportato nell'architettura arm6k), e auto, quale
utilizza il miglior metodo disponibile per il processore selezionato. L'impostazione predefinita è
auto.

-mtls-dialetto=dialetto
Specificare il dialetto da utilizzare per accedere all'archiviazione locale del thread. Due dialetti sono
supportato --- gnu ed gnu2. gnu dialetto seleziona lo schema GNU originale per
supportare modelli TLS dinamici locali e globali. Il gnu2 il dialetto seleziona lo GNU
schema descrittore, che fornisce prestazioni migliori per le librerie condivise. Il GNU
schema descrittore è compatibile con lo schema originale, ma richiede nuove
assembler, linker e supporto per librerie. I modelli TLS di esecuzione iniziale e locale sono
non interessati da questa opzione e utilizzare sempre lo schema originale.

-mword-rilocazioni
Genera solo rilocazioni assolute su valori delle dimensioni di una parola (es. R_ARM_ABS32). Questo è
abilitato di default sui target (uClinux, SymbianOS) dove il runtime loader impone
questa restrizione, e quando -fpic or -fPIC è specificato.

-mfix-corteccia-m3-ldrd
Alcuni core Cortex-M3 possono causare la corruzione dei dati quando le istruzioni "ldrd" con
vengono utilizzati registri di destinazione e base sovrapposti. Questa opzione evita di generare
queste istruzioni. Questa opzione è abilitata per impostazione predefinita quando -mcpu=corteccia-m3 is
specificato.

-accesso-munitario
-mno-accesso-non allineato
Abilita (o disabilita) la lettura e la scrittura di valori a 16 e 32 bit da indirizzi
che non sono allineati a 16 o 32 bit. Per impostazione predefinita, l'accesso non allineato è disabilitato per tutti
pre-ARMv6 e tutte le architetture ARMv6-M e abilitato per tutte le altre architetture. Se
l'accesso non allineato non è abilitato, si accederà alle parole nelle strutture di dati compressi
un byte alla volta.

L'attributo ARM "Tag_CPU_unaligned_access" verrà impostato nel file oggetto generato
su true o false, a seconda dell'impostazione di questa opzione. Se non allineato
l'accesso è abilitato, verrà visualizzato anche il simbolo del preprocessore "__ARM_FEATURE_UNALIGNED"
definito.

-mneon-per-64bit
Consente di utilizzare Neon per gestire operazioni scalari a 64 bit. Questa impostazione è disabilitata per impostazione predefinita
poiché il costo per lo spostamento dei dati dai registri principali a Neon è elevato.

AVR Opzioni

-mmcu=MCU
Specificare le architetture del set di istruzioni Atmel AVR (ISA) o il tipo di MCU.

L'impostazione predefinita per questa opzione è@tie{}"avr2".

GCC supporta i seguenti dispositivi AVR e ISA:

"av2"
Dispositivi "classici" con fino a 8@tie{}KiB di memoria di programma. MCU@tie{}= "attiny22",
"attiny26", "at90c8534", "at90s2313", "at90s2323", "at90s2333", "at90s2343",
"at90s4414", "at90s4433", "at90s4434", "at90s8515", "at90s8535".

"av25"
Dispositivi "classici" con fino a 8@tie{}KiB di memoria di programma e con il "MOVW"
istruzioni. MCU@tie{}= "ata6289", "attiny13", "attiny13a", "attiny2313",
"attiny2313a", "attiny24", "attiny24a", "attiny25", "attiny261", "attiny261a",
"attiny43u", "attiny4313", "attiny44", "attiny44a", "attiny45", "attiny461",
"attiny461a", "attiny48", "attiny84", "attiny84a", "attiny85", "attiny861",
"attiny861a", "attiny87", "attiny88", "at86rf401".

"av3"
Dispositivi "classici" con 16@tie{}KiB fino a 64@tie{}KiB di memoria di programma.
MCU@tie{}= "at43usb355", "at76c711".

"av31"
Dispositivi "classici" con 128@tie{}KiB di memoria di programma. MCU@tie{}= "atmega103",
"at43usb320".

"av35"
Dispositivi "classici" con 16@tie{}KiB fino a 64@tie{}KiB di memoria di programma e con
l'istruzione "MOVW". MCU@tie{}= "atmega16u2", "atmega32u2", "atmega8u2",
"attiny167", "at90usb162", "at90usb82".

"av4"
Dispositivi "potenziati" con fino a 8@tie{}KiB di memoria di programma. MCU@cravatta{}=
"atmega48", "atmega48a", "atmega48p", "atmega8", "atmega8hva", "atmega8515",
"atmega8535", "atmega88", "atmega88a", "atmega88p", "atmega88pa", "at90pwm1",
"at90pwm2", "at90pwm2b", "at90pwm3", "at90pwm3b", "at90pwm81".

"av5"
Dispositivi "potenziati" con 16@tie{}KiB fino a 64@tie{}KiB di memoria di programma.
MCU@tie{}= "atmega16", "atmega16a", "atmega16hva", "atmega16hva2", "atmega16hvb",
"atmega16m1", "atmega16u4", "atmega161", "atmega162", "atmega163", "atmega164a",
"atmega164p", "atmega165", "atmega165a", "atmega165p", "atmega168", "atmega168a",
"atmega168p", "atmega169", "atmega169a", "atmega169p", "atmega169pa", "atmega32",
"atmega32c1", "atmega32hvb", "atmega32m1", "atmega32u4", "atmega32u6",
"atmega323", "atmega324a", "atmega324p", "atmega324pa", "atmega325", "atmega325a",
"atmega325p", "atmega3250", "atmega3250a", "atmega3250p", "atmega328",
"atmega328p", "atmega329", "atmega329a", "atmega329p", "atmega329pa",
"atmega3290", "atmega3290a", "atmega3290p", "atmega406", "atmega64", "atmega64c1",
"atmega64hve", "atmega64m1", "atmega640", "atmega644", "atmega644a", "atmega644p",
"atmega644pa", "atmega645", "atmega645a", "atmega645p", "atmega6450",
"atmega6450a", "atmega6450p", "atmega649", "atmega649a", "atmega649p",
"atmega6490", "at90can32", "at90can64", "at90pwm216", "at90pwm316", "at90scr100",
"at90usb646", "at90usb647", "at94k", "m3000".

"av51"
Dispositivi "potenziati" con 128@tie{}KiB di memoria di programma. MCU@tie{}= "atmega128",
"atmega128rfa1", "atmega1280", "atmega1281", "atmega1284p", "at90can128",
"at90usb1286", "at90usb1287".

"av6"
Dispositivi "potenziati" con PC a 3 byte, cioè con più di 128@tie{}KiB di programma
memoria. MCU@tie{}= "atmega2560", "atmega2561".

"avrxmega2"
Dispositivi "XMEGA" con più di 8@tie{}KiB e fino a 64@tie{}KiB di memoria di programma.
MCU@tie{}= "atxmega16a4", "atxmega16d4", "atxmega16x1", "atxmega32a4",
"atxmega32d4", "atxmega32x1".

"avrxmega4"
Dispositivi "XMEGA" con più di 64@tie{}KiB e fino a 128@tie{}KiB di programma
memoria. MCU@tie{}= "atxmega64a3", "atxmega64d3".

"avrxmega5"
Dispositivi "XMEGA" con più di 64@tie{}KiB e fino a 128@tie{}KiB di programma
memoria e più di 64@tie{}KiB di RAM. MCU@tie{}= "atxmega64a1",
"atxmega64a1u".

"avrxmega6"
Dispositivi "XMEGA" con più di 128@tie{}KiB di memoria di programma. MCU@cravatta{}=
"atxmega128a3", "atxmega128d3", "atxmega192a3", "atxmega192d3", "atxmega256a3",
"atxmega256a3b", "atxmega256a3bu", "atxmega256d3".

"avrxmega7"
Dispositivi "XMEGA" con più di 128@tie{}KiB di memoria di programma e più di
64@tie{}KiB di RAM. MCU@tie{}= "atxmega128a1", "atxmega128a1u".

"av1"
Questo ISA è implementato dal core AVR minimale e supportato solo per assembler.
MCU@tie{}= "attiny11", "attiny12", "attiny15", "attiny28", "at90s1200".

-macculate-args
Accumula argomenti della funzione in uscita e acquisisci/rilascia lo spazio dello stack necessario per
argomenti della funzione in uscita una volta nel prologo/epilogo della funzione. Senza questa opzione,
gli argomenti in uscita vengono inviati prima di chiamare una funzione e visualizzati successivamente.

Il pop degli argomenti dopo la chiamata di funzione può essere costoso su AVR, quindi
accumulare lo spazio dello stack potrebbe portare a eseguibili più piccoli perché gli argomenti devono
da non rimuovere dallo stack dopo tale chiamata di funzione.

Questa opzione può ridurre la dimensione del codice per le funzioni che eseguono più chiamate a
funzioni che ottengono i loro argomenti nello stack come le chiamate a funzioni simili a printf.

-mbranch-costo=costo
Imposta i costi del ramo per le istruzioni condizionali del ramo su costo. Valori ragionevoli
per costo sono piccoli numeri interi non negativi. Il costo del ramo predefinito è 0.

-mcall-prologhi
Le funzioni prologhi/epiloghi sono espansi come chiamate a sottoprogrammi appropriati. Codice
la dimensione è più piccola.

-menta8
Supponiamo che "int" sia un intero a 8 bit. Ciò influisce sulle dimensioni di tutti i tipi: un "char" è 1
byte, un "int" è 1 byte, un "long" è 2 byte e "long long" è 4 byte. Per favore
nota che questa opzione non è conforme agli standard C, ma risulta più piccola
dimensione del codice.

-mno-interrupt
Il codice generato non è compatibile con gli interrupt hardware. La dimensione del codice è più piccola.

-rilassati
Prova a sostituire "CALL" risp. Istruzione "JMP" dal più breve "RCALL" risp. "RJMP"
istruzione se applicabile. L'impostazione di "-mrelax" aggiunge semplicemente l'opzione "--relax" al
riga di comando del linker quando viene chiamato il linker.

Il rilassamento del salto viene eseguito dal linker perché gli offset del salto non sono noti prima
codice si trova. Pertanto, il codice assembler generato dal compilatore è lo stesso,
ma le istruzioni nell'eseguibile possono differire dalle istruzioni nell'assemblatore
codice.

Il rilassamento deve essere attivato se sono necessari gli stub del linker, vedere la sezione su "EIND" e
linker stub di seguito.

-mshort-call
Questa opzione è stata deprecata e verrà rimossa in GCC 4.8. Vedi "-mrelax" per a
la sostituzione.

Usa le istruzioni "RCALL"/"RJMP" anche su dispositivi con 16@tie{}KiB o più di programma
memoria, cioè sui dispositivi che hanno le istruzioni "CALL" e "JMP".

-msp8
Tratta il registro del puntatore dello stack come un registro a 8 bit, cioè prendi il byte alto di
il puntatore dello stack è zero. In generale, non è necessario impostare manualmente questa opzione.

Questa opzione viene utilizzata internamente dal compilatore per selezionare e creare multilibs per
architetture "avr2" e "avr25". Queste architetture combinano dispositivi con e senza
"SPH". Per qualsiasi impostazione diversa da "-mmcu=avr2" o "-mmcu=avr25" il driver del compilatore
aggiungerà o rimuoverà questa opzione dalla riga di comando del compilatore propriamente detto, perché
compilatore quindi sa se il dispositivo o l'architettura ha un puntatore allo stack a 8 bit e quindi
nessun registro "SPH" o meno.

-mstrict-X
Utilizzare il registro indirizzi "X" nel modo proposto dall'hardware. Ciò significa che "X" è
utilizzato solo nell'indirizzamento indiretto, post-incremento o pre-decremento.

Senza questa opzione, il registro "X" può essere utilizzato allo stesso modo di "Y" o "Z" che
quindi viene emulato da istruzioni aggiuntive. Ad esempio, caricando un valore con
Indirizzamento "X+const" con un piccolo "const < 64" non negativo a un registro Rn is
eseguito come

adiw r26, cost ; X += cost
ld , X ; = *X
sbiw r26, cost ; X -= cost

-pila piccola
Cambia solo gli 8@tie{}bit inferiori del puntatore dello stack.

"EIND" e dispositivi con più di 128 Ki Byte di Flash

I puntatori nell'implementazione sono larghi 16@tie{}bit. L'indirizzo di una funzione o etichetta
è rappresentato come indirizzo di parola in modo che i salti e le chiamate indiretti possano indirizzare qualsiasi codice
indirizzo nell'intervallo di 64@tie{}parole Ki.

Per facilitare il salto indiretto su dispositivi con più di 128@tie{}Ki byte di
spazio di memoria del programma, c'è un registro di funzione speciale chiamato "EIND" che funge da
parte più significativa dell'indirizzo di destinazione quando le istruzioni "EICALL" o "EIJMP" sono
Usato.

I salti e le chiamate indiretti su questi dispositivi sono gestiti come segue dal compilatore e sono:
soggetto ad alcune limitazioni:

· Il compilatore non imposta mai "EIND".

· Il compilatore usa implicitamente "EIND" nelle istruzioni "EICALL"/"EIJMP" o potrebbe leggere
"EIND" direttamente per emulare un richiamo/salto indiretto tramite un "RET"
istruzioni.

· Il compilatore presuppone che "EIND" non cambi mai durante il codice di avvio o durante il
applicazione. In particolare, "EIND" non viene salvato/ripristinato in funzione o interruzione
prologo/epilogo di routine del servizio.

· Per chiamate indirette a funzioni e goto calcolato, il linker genera stub. mozziconi
a volte vengono anche chiamati jump pad trampolini. Pertanto, la chiamata/salto indiretta passa a
un tale stuzzichino. Lo stub contiene un salto diretto all'indirizzo desiderato.

· Il rilassamento del linker deve essere attivato in modo che il linker generi gli stub
correttamente una situazione tutta. Vedi l'opzione del compilatore "-mrelax" e l'opzione linler
"--relax". Ci sono casi angolari in cui il linker dovrebbe generare stub ma
si interrompe senza relax e senza un messaggio di errore utile.

· Lo script del linker predefinito è predisposto per il codice con "EIND = 0". Se si suppone il codice
per lavorare per una configurazione con "EIND != 0", è necessario utilizzare uno script linker personalizzato nell'ordine
per posizionare le sezioni il cui nome inizia con ".trampolines" nel segmento in cui
"EIND" indica.

· Il codice di avvio di libgcc non imposta mai "EIND". Nota che il codice di avvio è una miscela
di codice da libgcc e AVR-LibC. Per l'impatto di AVR-LibC su "EIND", vedere l'AVR-
LibC manuale utente ("http://nongnu.org/avr-libc/user-manual/").

· È legittimo che il codice di avvio specifico dell'utente configuri "EIND" in anticipo, ad esempio tramite
mezzo di codice di inizializzazione situato nella sezione ".init3". Tale codice viene eseguito prima di
codice di avvio generale che inizializza la RAM e chiama i costruttori, ma dopo il bit of
codice di avvio da AVR-LibC che imposta "EIND" al segmento in cui si trova la tabella vettoriale
trova.

#includere

vuoto statico
__attributo__((sezione(".init3"),nudo,usato,nessuna_funzione_strumento))
init3_set_eind (vuoto)
{
__asm ​​volatile ("ldi r24,pm_hh8(__trampolines_start)\n\t"
"out %i0,r24" :: "n" (&EIND): "r24","memoria");
}

Il simbolo "__trampolines_start" è definito nello script del linker.

· Gli stub sono generati automaticamente dal linker se le seguenti due condizioni sono
con:

-
(Corto per generare stub) così:

LDI r24, lo8(gs( ))
LDI r25, hi8(gs( ))

-
al di fuori il segmento in cui si trovano gli stub.

· Il compilatore emette tali modificatori "gs" per le etichette di codice nelle seguenti situazioni:

-
-
- -mcall-prologhi>
opzione della riga di comando.

-
tabelle è possibile specificare il -fno-salto-tabelle opzione della riga di comando.

-
-
· Passare a indirizzi non simbolici è così non supportati:

int main (vuoto)
{
/* Richiama la funzione all'indirizzo word 0x2 */
return ((int(*)(void)) 0x2)();
}

Occorre invece impostare uno stub, ovvero la funzione deve essere richiamata tramite un simbolo
("func_4" nell'esempio):

int main (vuoto)
{
extern int func_4 (vuoto);

/* Richiama la funzione all'indirizzo byte 0x4 */
return fun_4();
}

e l'applicazione sia collegata con "-Wl,--defsym,func_4=0x4". In alternativa, "func_4"
può essere definito nello script del linker.

Gestione dei registri delle funzioni speciali "RAMPD", "RAMPX", "RAMPY" e "RAMPZ"

Alcuni dispositivi AVR supportano memorie più grandi della gamma di 64@tie{}KiB a cui è possibile accedere
con puntatori a 16 bit. Per accedere a posizioni di memoria al di fuori di questa gamma di 64@tie{}KiB, il
il contenuto di un registro "RAMP" è usato come parte alta dell'indirizzo: La "X", "Y", "Z"
il registro indirizzi è concatenato con la funzione speciale "RAMPX", "RAMPY", "RAMPZ"
registrarsi, rispettivamente, per ottenere un indirizzo ampio. Allo stesso modo, "RAMPD" è usato insieme a
indirizzamento diretto.

· Il codice di avvio inizializza i registri della funzione speciale "RAMP" con zero.

· Se un AVR Detto Indirizzo Spazi, denominati indirizzo spazio diverso da generico o "__flash" è
utilizzato, quindi "RAMPZ" viene impostato come necessario prima dell'operazione.

· Se il dispositivo supporta RAM maggiore di 64@tie{KiB} e il compilatore deve cambiare
"RAMPZ" per eseguire un'operazione, "RAMPZ" viene azzerato dopo l'operazione.

· Se il dispositivo è dotato di un registro "RAMP" specifico, il prologo/epilogo ISR
salva/ripristina quell'SFR e lo inizializza con zero nel caso in cui il codice ISR possa
(implicitamente) usarlo.

· La RAM maggiore di 64@tie{KiB} non è supportata da GCC per i target AVR. Se usi
assemblatore in linea per leggere da posizioni al di fuori dell'intervallo di indirizzi a 16 bit e modificare
uno dei registri "RAMP", è necessario azzerarlo dopo l'accesso.

Macro integrate nell'AVR

GCC definisce diverse macro integrate in modo che il codice utente possa verificare la presenza o
assenza di caratteristiche. Quasi tutte le seguenti macro integrate vengono dedotte dal dispositivo
capacità e quindi attivato dall'opzione della riga di comando "-mmcu=".

Per ulteriori macro integrate specifiche per AVR, vedere AVR Detto Indirizzo Spazi ed AVR Built-in
funzioni.

"__AVR_ARCH__"
Macro incorporata che si risolve in un numero decimale che identifica l'architettura e
dipende da "-mmcu=mcu" opzione. I valori possibili sono:

2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107

per MCU="avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",
rispettivamente "avrxmega2", "avrxmega4", "avrxmega5", "avrxmega6", "avrxmega7". Se MCU
specifica un dispositivo, questa macro incorporata è impostata di conseguenza. Ad esempio, con
"-mmcu=atmega8" la macro sarà definita a 4.

"__AVR_Dispositivo__"
Impostazione "-mmcu=dispositivo" definisce questa macro incorporata che riflette il nome del dispositivo.
Ad esempio, "-mmcu=atmega8" definisce la macro integrata "__AVR_ATmega8__",
"-mmcu=attiny261a" definisce "__AVR_ATtiny261A__", ecc.

I nomi delle macro integrate seguono lo schema "__AVR_Dispositivo__" where Dispositivo Europe è
nome del dispositivo come dal manuale utente dell'AVR. La differenza tra Dispositivo nel built-in
macro e dispositivo in "-mmcu=dispositivo" è che quest'ultimo è sempre minuscolo.

If dispositivo non è un dispositivo ma solo un'architettura di base come "avr51", questa macro lo farà
non essere definito.

"__AVR_XMEGA__"
Il dispositivo/architettura appartiene alla famiglia di dispositivi XMEGA.

"__AVR_HAVE_ELPM__"
Il dispositivo ha l'istruzione "ELPM".

"__AVR_HAVE_ELPMX__"
Il dispositivo ha il "ELPM Rn, Z" e "ELPM Rn,Z+" istruzioni.

"__AVR_HAVE_MOVW__"
Il dispositivo ha l'istruzione "MOVW" per eseguire spostamenti di registro-registro a 16 bit.

"__AVR_HAVE_LPMX__"
Il dispositivo ha il "LPM Rn, Z" e "LPM Rn,Z+" istruzioni.

"__AVR_HAVE_MUL__"
Il dispositivo ha un moltiplicatore hardware.

"__AVR_HAVE_JMP_CALL__"
Il dispositivo ha le istruzioni "JMP" e "CALL". Questo è il caso dei dispositivi con
almeno 16@tie{}KiB di memoria del programma e se "-mshort-calls" non è impostato.

"__AVR_HAVE_EIJMP_EICALL__"
"__AVR_3_BYTE_PC__"
Il dispositivo ha le istruzioni "EIJMP" e "EICALL". Questo è il caso dei dispositivi
con più di 128@tie{}KiB di memoria di programma. Questo significa anche che il programma
contatore (PC) è largo 3@tie{}byte.

"__AVR_2_BYTE_PC__"
Il contatore del programma (PC) è largo 2@tie{}byte. Questo è il caso di dispositivi fino a
128@tie{}KiB di memoria del programma.

"__AVR_HAVE_8BIT_SP__"
"__AVR_HAVE_16BIT_SP__"
Il registro del puntatore dello stack (SP) viene trattato come registro a 8 bit rispettivamente a 16 bit da
il compilatore. La definizione di queste macro è influenzata da "-mtiny-stack".

"__AVR_HAVE_SPH__"
"__AVR_SP8__"
Il dispositivo ha il registro di funzione speciale SPH (high part of stack pointer) o ha
un puntatore allo stack a 8 bit, rispettivamente. La definizione di queste macro è influenzata da
"-mmcu=" e nei casi di "-mmcu=avr2" e "-mmcu=avr25" anche di "-msp8".

"__AVR_HAVE_RAMPD__"
"__AVR_HAVE_RAMPX__"
"__AVR_HAVE_RAMPY__"
"__AVR_HAVE_RAMPZ__"
Il dispositivo ha il registro delle funzioni speciali "RAMPD", "RAMPX", "RAMPY", "RAMPZ",
rispettivamente.

"__NO_INTERRUZIONI__"
Questa macro riflette l'opzione della riga di comando "-mno-interrupts".

"__AVR_ERRATA_SKIP__"
"__AVR_ERRATA_SKIP_JMP_CALL__"
Alcuni dispositivi AVR (AT90S8515, ATmega103) non devono saltare le istruzioni a 32 bit a causa di a
errore hardware. Le istruzioni di salto sono "SBRS", "SBRC", "SBIS", "SBIC" e "CPSE".
La seconda macro è definita solo se è impostato anche "__AVR_HAVE_JMP_CALL__".

"__AVR_SFR_OFFSET__=compensare"
Istruzioni che possono indirizzare direttamente i registri di funzioni speciali di I/O come "IN",
"OUT", "SBI", ecc. possono utilizzare un indirizzo diverso come se fosse indirizzato da un'istruzione a
accedere alla RAM come "LD" o "STS". Questo offset dipende dall'architettura del dispositivo e ha
da sottrarre all'indirizzo RAM per ottenere il rispettivo indirizzo I/O@tie{}.

"__WITH_AVRLIBC__"
Il compilatore è configurato per essere utilizzato insieme ad AVR-Libc. Vedi il
Opzione di configurazione "--with-avrlibc".

Blackfin Opzioni

-mcpu=cpu[-sirevisione]
Specifica il nome del processore Blackfin di destinazione. Attualmente, cpu può essere uno di
bf512, bf514, bf516, bf518, bf522, bf523, bf524, bf525, bf526, bf527, bf531, bf532,
bf533, bf534, bf536, bf537, bf538, bf539, bf542, bf544, bf547, bf548, bf549, bf542m,
bf544m, bf547m, bf548m, bf549m, bf561, bf592. L'opzionale sirevisione specifica il
revisione del silicio del processore Blackfin di destinazione. Eventuali soluzioni alternative disponibili per il
sarà abilitata la revisione mirata del silicio. Se sirevisione is nessuna, non ci sono soluzioni alternative
abilitato. Se sirevisione is in qualsiasi, tutte le soluzioni alternative per il processore di destinazione saranno
abilitato. La macro "__SILICON_REVISION__" è definita da due cifre esadecimali
che rappresentano i numeri maggiori e minori nella revisione del silicio. Se sirevisione is
nessuna, "__SILICON_REVISION__" non è definito. Se sirevisione is in qualsiasi, le
"__SILICON_REVISION__" è definito come 0xffff. Se questo facoltativo sirevisione non è
utilizzato, GCC assume l'ultima revisione nota del silicio del Blackfin mirato
processore.

Supporto per bf561 è incompleto. Per bf561, Viene definita solo la macro del processore.
Senza questa opzione, bf532 viene utilizzato come processore per impostazione predefinita. Il corrispondente
macro del processore predefinite per cpu è da definire. E per bfin-elfo catena degli attrezzi,
questo fa sì che il BSP hardware fornito da libgloss sia collegato in if -msim non è
dato.

-msim
Specifica che il programma verrà eseguito sul simulatore. Questo causa il simulatore
BSP fornito da libgloss da collegare. Questa opzione ha effetto solo per bfin-elfo
catena degli strumenti. Alcune altre opzioni, come -mid-libreria-condivisa ed -mfdpic, implicare
-msim.

-puntatore-cornice-foglia-momit
Non tenere il puntatore a frame in un registro per le funzioni foglia. Questo evita il
istruzioni per salvare, impostare e ripristinare i puntatori dei frame e creare un registro aggiuntivo
disponibile nelle funzioni foglia. L'opzione -puntatore-frame-fomit rimuove il telaio
puntatore per tutte le funzioni, il che potrebbe rendere più difficile il debug.

-mspecld-anomalia
Quando abilitato, il compilatore assicurerà che il codice generato non contenga
carichi speculativi dopo le istruzioni di salto. Se si utilizza questa opzione,
"__WORKAROUND_SPECULATIVE_LOADS" è definito.

-mno-specld-anomalia
Non generare codice aggiuntivo per evitare che si verifichino carichi speculativi.

-mcsync-anomalia
Quando abilitato, il compilatore assicurerà che il codice generato non contenga CSYNC
o istruzioni SSYNC troppo presto dopo i rami condizionali. Se si utilizza questa opzione,
"__WORKAROUND_SPECULATIVE_SYNCS" è definito.

-mno-csync-anomalia
Non generare codice aggiuntivo per evitare che si verifichino anche istruzioni CSYNC o SSYNC
subito dopo un ramo condizionale.

-mbasso-64k
Quando abilitato, il compilatore è libero di sfruttare la consapevolezza che l'intero
programma si inserisce nel basso 64k di memoria.

-mno-basso-64k
Supponiamo che il programma sia arbitrariamente grande. Questa è l'impostazione predefinita.

-mstack-check-l1
Eseguire il controllo dello stack utilizzando le informazioni inserite nella memoria scratchpad L1 da uClinux
kernel.

-mid-libreria-condivisa
Genera codice che supporti le librerie condivise tramite il metodo dell'ID libreria. Questo permette
per eseguire librerie sul posto e condivise in un ambiente senza memoria virtuale
gestione. Questa opzione implica -fPIC. Con un bfin-elfo target, questa opzione implica
-msim.

-mno-id-libreria-condivisa
Genera codice che non presuppone l'utilizzo di librerie condivise basate su ID. Questo è
il predefinito.

-mleaf-id-libreria-condivisa
Genera codice che supporti le librerie condivise tramite il metodo dell'ID libreria, ma presuppone
che questa libreria o eseguibile non si collegherà a nessun'altra libreria condivisa ID.
Ciò consente al compilatore di utilizzare codice più veloce per salti e chiamate.

-mno-leaf-id-libreria-condivisa
Non dare per scontato che il codice in fase di compilazione non si colleghi a nessuna libreria condivisa ID.
Verrà generato un codice più lento per jump e call insns.

-m-id-libreria-condivisa=n
Specificato il numero di identificazione della libreria condivisa basata su ID in fase di compilazione.
Specificare un valore 0 genererà un codice più compatto, specificare altri valori lo farà
forzare l'assegnazione di quel numero alla libreria corrente ma non c'è più spazio oppure
tempo efficiente rispetto all'omissione di questa opzione.

-msep-dati
Genera codice che consente di posizionare il segmento di dati in un'area di memoria diversa
dal segmento di testo. Ciò consente di eseguire sul posto in un ambiente senza
gestione della memoria virtuale eliminando le rilocazioni contro la sezione di testo.

-mno-set-data
Genera codice che presuppone che il segmento di dati segua il segmento di testo. Questo è
il predefinito.

-mlong-chiamate
-mno-chiamate lunghe
Dice al compilatore di eseguire chiamate di funzione caricando prima l'indirizzo del
funzione in un registro e quindi eseguire una chiamata di subroutine su questo registro. Questo
l'interruttore è necessario se la funzione di destinazione si trova al di fuori dell'intervallo di indirizzamento a 24 bit di
la versione basata sull'offset dell'istruzione di chiamata della subroutine.

Questa funzione non è abilitata per impostazione predefinita. Specificando -mno-chiamate lunghe ripristinerà il
comportamento predefinito. Nota che queste opzioni non hanno effetto su come il compilatore genera
codice per gestire le chiamate di funzione tramite puntatori a funzione.

-mfast-fp
Collegamento con la libreria in virgola mobile veloce. Questa libreria rilassa parte dell'IEEE
regole dello standard in virgola mobile per il controllo degli input rispetto a Not-a-Number (NAN), nel
interesse di prestazione.

-minline-plt
Abilita l'inlining delle voci PLT nelle chiamate di funzione a funzioni che non sono note
legarsi localmente. Non ha effetto senza -mfdpic.

-multicore
Crea un'applicazione standalone per il processore Blackfin multicore. File di avvio corretti e
gli script di collegamento verranno utilizzati per supportare il multicore. Questa opzione definisce
"__BFIN_MULTICORE". Può essere utilizzato solo con -mcpu=bf561[-sirevisione]. Può essere usato
con -mcorea or -mcoreb. Se viene utilizzato senza -mcorea or -mcoreb, Singolo
viene utilizzato il modello di programmazione application/dual core. In questo modello, la funzione principale di
Core B dovrebbe essere chiamato come coreb_main. Se è usato con -mcorea or -mcoreb, uno
viene utilizzata l'applicazione per modello di programmazione di base. Se questa opzione non viene utilizzata, single
viene utilizzato il modello di programmazione delle applicazioni di base.

-mcorea
Crea un'applicazione autonoma per Core A di BF561 quando usi un'applicazione per core
modello di programmazione. Verranno utilizzati file di avvio e script di collegamento corretti per supportare Core A.
Questa opzione definisce "__BFIN_COREA". Deve essere usato con -multicore.

-mcoreb
Crea un'applicazione autonoma per Core B di BF561 quando usi un'applicazione per core
modello di programmazione. Verranno utilizzati file di avvio e script di collegamento corretti per supportare Core B.
Questa opzione definisce "__BFIN_COREB". Quando viene utilizzata questa opzione, coreb_main dovrebbe essere
usato al posto di principale. Deve essere usato con -multicore.

-msdram
Crea un'applicazione autonoma per SDRAM. I file di avvio corretti e gli script di collegamento saranno
utilizzato per inserire l'applicazione in SDRAM. Il caricatore dovrebbe inizializzare la SDRAM prima del caricamento
l'applicazione in SDRAM. Questa opzione definisce "__BFIN_SDRAM".

-microfono
Si supponga che gli ICPLB siano abilitati in fase di esecuzione. Questo ha un effetto su alcune anomalie
soluzioni alternative. Per i target Linux, l'impostazione predefinita prevede che gli ICPLB siano abilitati; per
applicazioni autonome l'impostazione predefinita è disattivata.

C6X Opzioni

-marzo=Nome
Specifica il nome dell'architettura di destinazione. GCC usa questo nome per determinare
che tipo di istruzioni può emettere durante la generazione del codice assembly. ammissibile
i nomi sono: c62x, c64x, c64x+, c67x, c67x+, c674x.

-big endian
Genera codice per un target big-endian.

-mittle-endian
Genera codice per un target little-endian. Questa è l'impostazione predefinita.

-msim
Scegli i file di avvio e lo script del linker adatti al simulatore.

-msdata=predefinito
Metti piccoli dati globali e statici nel .nearddata sezione, che è indicata da
registrare "B14". Inserisci piccoli dati globali e statici non inizializzati nel .bss ,
che è adiacente al .nearddata sezione. Inserisci piccoli dati di sola lettura nel .rodata
sezione. Le sezioni corrispondenti usate per grandi pezzi di dati sono .fardati, .far
ed .cost.

-msdata=tutto
Metti tutti i dati, non solo i piccoli oggetti, nelle sezioni riservate ai piccoli dati, e
utilizzare l'indirizzamento relativo al registro "B14" per accedervi.

-msdata=nessuno
Non utilizzare le sezioni riservate ai piccoli dati e utilizzare indirizzi assoluti per
accedere a tutti i dati. Metti tutti i dati globali e statici inizializzati nel .fardati ,
e tutti i dati non inizializzati nel .far sezione. Metti tutti i dati costanti nel .cost
.

CRIS Opzioni

Queste opzioni sono definite specificamente per le porte CRIS.

-marzo=tipo di architettura
-mcpu=tipo di architettura
Genera codice per l'architettura specificata. Le scelte per tipo di architettura sono
v3, v8 ed v10 rispettivamente per ETRAX 4, ETRAX 100 e ETRAX 100 LX. L'impostazione predefinita è v0
ad eccezione di cris-axis-linux-gnu, dove il valore predefinito è v10.

-mtune=tipo di architettura
Sintonizzati su tipo di architettura tutto ciò che riguarda il codice generato, ad eccezione di
l'ABI e l'insieme delle istruzioni disponibili. Le scelte per tipo di architettura sono
lo stesso che per -marzo=tipo di architettura.

-mmax-stack-frame=n
Avvisa quando lo stack frame di una funzione supera n byte.

-metrax4
-metrax100
Le opzioni -metrax4 ed -metrax100 sono sinonimi di -marzo=v3 ed -marzo=v8
rispettivamente.

-mmul-bug-soluzione alternativa
-mno-mul-bug-soluzione
Risolvere un bug nelle istruzioni "mul" e "mulu" per i modelli di CPU in cui
si applica. Questa opzione è attiva per impostazione predefinita.

-mpdebug
Abilitare le informazioni dettagliate relative al debug specifiche di CRIS nel codice assembly. Questo
l'opzione ha anche l'effetto di disattivare il #NO_APP indicatore di codice formattato per il
assembler all'inizio del file assembly.

-mcc-init
Non utilizzare i risultati del codice di condizione dall'istruzione precedente; emetti sempre confronta e
istruzioni di prova prima dell'uso dei codici di condizione.

-mno-effetti collaterali
Non emettere istruzioni con effetti collaterali in modalità di indirizzamento diverse da quelle post-
incremento.

-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
Queste opzioni (nessuna opzione) organizzano (eliminano le disposizioni) per lo stack-frame,
dati individuali e costanti da allineare per la dimensione massima di accesso singolo ai dati
per il modello di CPU scelto. L'impostazione predefinita prevede l'allineamento a 32 bit. ABI
dettagli come il layout della struttura non sono interessati da queste opzioni.

-m32 bit
-m16 bit
-m8 bit
Simile alle opzioni stack-data- e const-align sopra, queste opzioni organizzano
stack frame, dati scrivibili e costanti per essere tutti allineati a 32 bit, 16 bit o 8 bit.
L'impostazione predefinita è l'allineamento a 32 bit.

-mno-prologo-epilogo
-mprologue-epilogo
Con -mno-prologo-epilogo, la normale funzione prologo ed epilogo che istituiscono
lo stack frame viene omesso e non vengono restituite istruzioni o sequenze di ritorno
generato nel codice. Utilizzare questa opzione solo insieme all'ispezione visiva del
codice compilato: non vengono generati avvisi o errori quando i registri salvati in chiamata devono essere
salvato o è necessario allocare lo spazio di archiviazione per la variabile locale.

-mno-gotplt
-Mgotplt
Con -fpic ed -fPIC, non generare (generare) sequenze di istruzioni che si caricano
indirizzi per le funzioni dalla parte PLT del GOT piuttosto che (tradizionale su altro
architetture) chiamate al PLT. L'impostazione predefinita è -Mgotplt.

-melf
Opzione no-op legacy riconosciuta solo con cris-axis-elf e cris-axis-linux-gnu
obiettivi.

-mlinux
Opzione no-op legacy riconosciuta solo con il target cris-axis-linux-gnu.

-sim
Questa opzione, riconosciuta per il cris-axis-elf, fa in modo di collegarsi con input-output
funzioni da una libreria del simulatore. Codice, dati inizializzati e dati inizializzati a zero
sono assegnati consecutivamente.

-sim2
Come -sim, ma passa le opzioni del linker per individuare i dati inizializzati a 0x40000000 e zero-
dati inizializzati a 0x80000000.

CR16 Opzioni

Queste opzioni sono definite specificamente per le porte CR16.

-mmac
Consentire l'uso di istruzioni di accumulo multiplo. Disabilitato per impostazione predefinita.

-mcr16cplus
-mcr16c
Genera codice per l'architettura CR16C o CR16C+. L'architettura CR16C+ è predefinita.

-msim
Collega la libreria libsim.a che è compatibile con simulator. Applicabile all'elfo
solo compilatore.

-menta32
Scegli il tipo intero con larghezza a 32 bit.

-mbit-ops
Genera istruzioni sbit/cbit per la manipolazione dei bit.

-mdata-modello=modello
Scegli un modello di dati. Le scelte per modello sono vicino, lontano or medie. medie è l'impostazione predefinita.
Però, i lontano non è valido quando viene scelta l'opzione -mcr16c in quanto l'architettura CR16C non lo fa
supportare il modello di dati lontano.

Darwin Opzioni

Queste opzioni sono definite per tutte le architetture che eseguono il sistema operativo Darwin.

FSF GCC su Darwin non crea file oggetto "grassi"; creerà un file oggetto per
l'unica architettura per cui è stato costruito. Il GCC di Apple su Darwin crea
file "grassi" se multipli -arco vengono utilizzate le opzioni; lo fa eseguendo il compilatore o
linker più volte e unendo i risultati insieme a lipo.

Il sottotipo del file creato (come ppc7400 or ppc970 or i686) è determinato da
flag che specificano l'ISA che GCC sta prendendo di mira, come -mcpu or -marzo.
-force_cpusubtype_ALL l'opzione può essere utilizzata per sovrascriverlo.

Gli strumenti Darwin variano nel loro comportamento quando vengono presentati con una mancata corrispondenza ISA. Il
assemblatore, as, consentirà solo l'utilizzo di istruzioni valide per il sottotipo di
il file che sta generando, quindi non puoi inserire istruzioni a 64 bit in a ppc750 file oggetto.
Il linker per le librerie condivise, /usr/bin/libtool, fallirà e stamperà un errore se richiesto
per creare una libreria condivisa con un sottotipo meno restrittivo rispetto ai suoi file di input (per
esempio, cercando di mettere a ppc970 file oggetto in a ppc7400 biblioteca). Il linker per
eseguibili, ld, darà silenziosamente all'eseguibile il sottotipo più restrittivo di qualsiasi di
suoi file di input.

-Fdir
Aggiungi la directory del framework dir all'inizio dell'elenco delle directory da cercare
per i file di intestazione. Queste directory sono intercalate con quelle specificate da -I
opzioni e vengono scansionati in ordine da sinistra a destra.

Una directory framework è una directory con i framework al suo interno. Un quadro è un
directory con a "Intestazioni" e / o "Intestazioni private" directory contenuta direttamente in essa
che finisce in ".struttura". Il nome di un framework è il nome di questa directory
escludendo il ".struttura". Le intestazioni associate al framework si trovano in una delle
quelle due directory, con "Intestazioni" essere cercato per primo. Un sottoquadro è un
directory del framework che si trova in un framework "Quadri" directory. Include di
le intestazioni del sottoframework possono apparire solo in un'intestazione di un framework che contiene il
sottoframework o in un'intestazione di sottoframework di pari livello. Due sottoquadri sono fratelli se
si verificano nello stesso quadro. Un sottoframework non dovrebbe avere lo stesso nome di a
framework, verrà emesso un avviso in caso di violazione. Attualmente un sottoquadro
non possono avere sottoquadri, in futuro il meccanismo potrebbe essere esteso a supporto
questo. I framework standard possono essere trovati in "/Sistema/Libreria/Framework" ed
"/Libreria/Framework". Un esempio include sembra "#include ",
where Contesto denota il nome del framework e header.h si trova in
"Intestazioni private" or "Intestazioni" directory.

-iframeworkdir
Come -F tranne che la directory è trattata come una directory di sistema. La differenza principale
tra questo -iframework ed -F è quello con -iframework il compilatore non avvisa
sui costrutti contenuti nei file di intestazione trovati tramite dir. Questa opzione è valida
solo per la famiglia di lingue C.

-gusto
Emetti informazioni di debug per i simboli utilizzati. Per il formato di debug STABS,
questo abilita -feliminare-simboli-debug-inutilizzati. Questo è attivato per impostazione predefinita.

-pieno
Emetti informazioni di debug per tutti i simboli e i tipi.

-mmacosx-versione-min=versione
La prima versione di MacOS X su cui verrà eseguito questo eseguibile è versione. Tipico
valori di versione includere 10.1, 10.2 e 10.3.9.

Se il compilatore è stato creato per utilizzare le intestazioni del sistema per impostazione predefinita, l'impostazione predefinita per
questa opzione è la versione del sistema su cui è in esecuzione il compilatore, altrimenti il
l'impostazione predefinita è fare scelte compatibili con tanti sistemi e basi di codice quanti sono
possibile.

-mkernel
Abilita la modalità di sviluppo del kernel. Il -mkernel set di opzioni -statico, -fno-comune,
-fno-cxa-atexit, -fno-eccezioni, -fno-non-chiamata-eccezioni, -fapple-kext, -fno-debole
ed -fno-rtti ove applicabile. Anche questa modalità imposta -mno-altivoc, -msoft-flottante,
-fno-integrato ed -mlong-ramo per obiettivi PowerPC.

-monete-byte-bool
Sostituisci le impostazioni predefinite per bool affinché dimensionedi(bool)==1. Per impostazione predefinita sizeof (bool) is 4
durante la compilazione per Darwin/PowerPC e 1 durante la compilazione per Darwin/x86, quindi questa opzione
non ha effetto su x86.

Attenzione: I -monete-byte-bool switch fa sì che GCC generi codice non binario
compatibile con il codice generato senza quell'interruttore. L'utilizzo di questo interruttore potrebbe richiedere
ricompilare tutti gli altri moduli in un programma, incluse le librerie di sistema. Usa questo
passare per conformarsi a un modello di dati non predefinito.

-mfix-e-continua
-correggi-e-continua
-findirect-dati
Genera codice adatto per uno sviluppo veloce. Necessario per abilitare gdb a
carica dinamicamente i file ".o" nei programmi già in esecuzione. -findirect-dati ed
-correggi-e-continua sono forniti per compatibilità con le versioni precedenti.

-tutto_carico
Carica tutti i membri delle librerie di archivi statici. vedi uomo ld(1) per maggiori informazioni.

-arch_errors_fatale
Causa gli errori che hanno a che fare con i file che hanno l'architettura sbagliata per essere fatali.

-bind_at_load
Fa in modo che il file di output venga contrassegnato in modo tale che il linker dinamico leghi tutto
riferimenti non definiti quando il file viene caricato o avviato.

-fascio
Produci un file in formato bundle Mach-o. vedi uomo ld(1) per maggiori informazioni.

-caricatore_bundle eseguibile
Questa opzione specifica il eseguibile che caricherà il file di output della build in corso
collegato. vedi uomo ld(1) per maggiori informazioni.

-libreria dinamica
Quando viene passata questa opzione, GCC produrrà una libreria dinamica invece di un eseguibile
durante il collegamento, utilizzando il Darwin libtool comando.

-force_cpusubtype_ALL
Questo fa sì che il file di output di GCC abbia il TUTTO sottotipo, invece di uno controllato da
, il -mcpu or -marzo opzione.

-client_consentito nome del cliente
-nome del cliente
-versione_compatibilità
-Versione corrente
-striscia_morta
-file-di-dipendenza
-dylib_file
-dylinker_nome_installazione
-dinamico
-elenco_simboli_esportati
-elenco file
-spazio dei nomi_piatto
-force_flat_namespace
-headerpad_max_install_names
-base_immagine
-dentro
-nome_installazione
-keep_private_externs
-multi_modulo
-moltiplicare_definito
-moltiplicare_definito_non utilizzato
-noall_load
-no_dead_strip_inits_and_terms
-nofix preassociazione
-nomultidef
-nessun previncolo
-noseglinkedit
-dimensione_paginazero
-prelegare
-prebind_all_twolevel_modules
-Private_Bundle
-read_only_relocas
-settalign
-settooggettisimboli
-perché
-seg1ind
-setta creare
-settooggettisimboli
-settore
-segadr
-segs_read_only_addr
-segs_read_write_addr
-seg_addr_tabella
-seg_addr_nome_file_tabella
-Seglinkedit
-segprot
-segs_read_only_addr
-segs_read_write_addr
-modulo_singolo
-statico
-sub_libreria
-sub_ombrello
-spazio dei nomi a due livelli
-ombrello
-non definito
-lista_simboli_non esportati
-weak_reference_dismatches
-cosa è stato caricato
Queste opzioni vengono passate al linker Darwin. La pagina man del linker Darwin descrive
loro in dettaglio.

Dicembre Alpha Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni DEC Alpha:

-mno-morbido-flottante
-msoft-flottante
Utilizzare (non utilizzare) le istruzioni hardware in virgola mobile per la virgola mobile
operazioni. quando -msoft-flottante è specificato, funziona in libgcc.a sarà abituato
eseguire operazioni in virgola mobile. A meno che non vengano sostituiti da routine che emulano
le operazioni in virgola mobile, o compilato in modo tale da chiamare tali emulazioni
routine, queste routine eseguiranno operazioni a virgola mobile. Se stai compilando
per un Alpha senza operazioni in virgola mobile, devi assicurarti che la libreria sia
costruito per non chiamarli.

Nota che le implementazioni Alpha senza operazioni in virgola mobile devono avere
registri in virgola mobile.

-mfp-reg
-mno-fp-regs
Genera codice che utilizza (non utilizza) il set di registri a virgola mobile. -mno-fp-regs
implica -msoft-flottante. Se il set di registri a virgola mobile non viene utilizzato, a virgola mobile
gli operandi vengono passati nei registri interi come se fossero interi e in virgola mobile
i risultati vengono passati in $0 invece di $f0. Questa è una sequenza di chiamate non standard, quindi
qualsiasi funzione con un argomento in virgola mobile o un valore restituito chiamato dal codice compilato
con -mno-fp-regs deve essere compilato anche con tale opzione.

Un uso tipico di questa opzione è la creazione di un kernel che non utilizza e quindi necessita
non salvare e ripristinare, eventuali registri a virgola mobile.

-mieee
L'architettura Alpha implementa hardware in virgola mobile ottimizzato per il massimo
prestazione. È per lo più conforme allo standard a virgola mobile IEEE. Però,
per la piena conformità, è necessaria l'assistenza del software. Questa opzione genera codice
codice completamente conforme a IEEE con l’esclusione di che l' bandiera-inesatta non viene mantenuto (vedi sotto).
Se questa opzione è attivata, la macro del preprocessore "_IEEE_FP" viene definita durante
compilazione. Il codice risultante è meno efficiente ma è in grado di supportare correttamente
numeri denormalizzati e valori IEEE eccezionali come not-a-number e plus/minus
infinito. Altri compilatori Alpha chiamano questa opzione -ieee_con_no_inesatti.

-mieee-con-inesatto
Questo è come -mieee tranne che il codice generato mantiene anche l'IEEE bandiera-inesatta.
L'attivazione di questa opzione fa sì che il codice generato implementi IEEE completamente conforme
matematica. Oltre a "_IEEE_FP", "_IEEE_FP_EXACT" è definito come macro del preprocessore.
Su alcune implementazioni Alpha, il codice risultante potrebbe essere eseguito significativamente più lentamente di
il codice generato di default. Poiché c'è pochissimo codice che dipende dal
bandiera-inesatta, normalmente non dovresti specificare questa opzione. Altri compilatori Alpha chiamano
questa opzione -ieee_with_inesact.

-mfp-modalità trap=modalità trappola
Questa opzione controlla quali trap correlati a virgola mobile sono abilitati. Altro Alfa
i compilatori chiamano questa opzione -ftm modalità trappola. La modalità trappola può essere impostata su una delle quattro
valori:

n Questa è l'impostazione predefinita (normale). Le uniche trappole abilitate sono le
quelli che non possono essere disabilitati nel software (ad esempio, divisione per zero trap).

u Oltre alle trappole abilitate da n, sono abilitate anche le trappole di underflow.

su Come u, ma le istruzioni sono contrassegnate per essere sicure per il completamento del software (vedi
manuale dell'architettura Alpha per i dettagli).

sui Come su, ma sono abilitati anche i trap inesatti.

-mfp-modalità-arrotondamento=modalità di arrotondamento
Seleziona la modalità di arrotondamento IEEE. Altri compilatori Alpha chiamano questa opzione -fprm
modalità di arrotondamento. modalità di arrotondamento può essere uno di:

n Normale modalità di arrotondamento IEEE. I numeri in virgola mobile sono arrotondati al più vicino
numero macchina o verso il numero macchina pari in caso di parità.

m Arrotonda verso meno infinito.

c Modalità arrotondamento tritato. I numeri in virgola mobile vengono arrotondati allo zero.

d Modalità di arrotondamento dinamico. Un campo nel registro di controllo a virgola mobile (fpcr, Vedere
Manuale di riferimento dell'architettura Alpha) controlla la modalità di arrotondamento in vigore. il C
la libreria inizializza questo registro per l'arrotondamento verso più infinito. Così,
a meno che il tuo programma non modifichi il fpcr, d corrisponde a arrotondare verso il più
infinito.

-mtrap-precisione=trappola di precisione
Nell'architettura Alpha, le trappole a virgola mobile sono imprecise. Questo significa senza
assistenza software è impossibile recuperare da una trappola galleggiante e programma
l'esecuzione normalmente deve essere terminata. GCC può generare codice che può aiutare
gestori di trap del sistema operativo nel determinare la posizione esatta che ha causato un
trappola a virgola mobile. A seconda dei requisiti di un'applicazione, diversi
i livelli di precisione possono essere selezionati:

p Precisione del programma. Questa opzione è l'impostazione predefinita e significa che un gestore di trap può solo
identificare quale programma ha causato un'eccezione in virgola mobile.

f Precisione della funzione. Il gestore trap può determinare la funzione che ha causato un
eccezione in virgola mobile.

i Precisione dell'istruzione. Il gestore della trappola può determinare l'istruzione esatta che
ha causato un'eccezione a virgola mobile.

Altri compilatori Alpha forniscono le opzioni equivalenti chiamate -ambito_sicuro ed
-ripresa_sicura.

-mieee-conforme
Questa opzione contrassegna il codice generato come conforme a IEEE. Non devi usare questa opzione
a meno che non specifichi anche tu -mtrap-precisione=i e nemmeno -mfp-modalità trap=su or
-mfp-trap-mode=sui. Il suo unico effetto è quello di emettere la linea .flag 48 nella funzione
prologo del file assembly generato. Sotto DEC Unix, questo ha l'effetto che
Le routine della libreria matematica conformi a IEEE verranno collegate.

-mbuild-costanti
Normalmente GCC esamina una costante intera a 32 o 64 bit per vedere se può costruirla
da costanti più piccole in due o tre istruzioni. Se non può, emetterà il
costante come letterale e generare codice per caricarlo dal segmento di dati in fase di esecuzione.

Usa questa opzione per richiedere la costruzione di GCC contro tutti i costanti intere usando il codice, anche se
ci vogliono più istruzioni (il massimo è sei).

In genere utilizzeresti questa opzione per creare un caricatore dinamico di librerie condivise. Si
una libreria condivisa, deve riposizionarsi in memoria prima di poter trovare le variabili
e costanti nel proprio segmento di dati.

-malfa-as
-mgas
Seleziona se generare il codice che deve essere assemblato dall'assemblatore fornito dal fornitore
(-malfa-as) o dall'assemblatore GNU -mgas.

-mbwx
-mno-bwx
-mcix
-mno-cix
-mfix
-mno-correzione
-mmax
-mno-max
Indica se GCC deve generare codice per utilizzare BWX, CIX, FIX e MAX opzionali
set di istruzioni. L'impostazione predefinita è utilizzare i set di istruzioni supportati dalla CPU
tipo specificato tramite -mcpu= opzione o quella della CPU su cui è stato costruito GCC se nessuna lo era
specificato.

-mfloat-vax
-mfloat-ieee
Genera codice che usa (non usa) VAX F e G aritmetica a virgola mobile invece
di IEEE a singola e doppia precisione.

-Mexplicit-relocs
-mno-reloc-esplicito
I vecchi assemblatori Alpha non fornivano alcun modo per generare rilocazioni di simboli se non tramite
macro assembler. L'uso di queste macro non consente una pianificazione ottimale delle istruzioni.
GNU binutils dalla versione 2.12 supporta una nuova sintassi che consente al compilatore di
contrassegnare esplicitamente quali trasferimenti dovrebbero applicarsi a quali istruzioni. Questa opzione è
per lo più utile per il debug, poiché GCC rileva le capacità dell'assemblatore quando
è costruito e imposta il valore predefinito di conseguenza.

-msmall-data
-mlarge-dati
Quando -Mexplicit-relocs è in effetti, si accede ai dati statici tramite parente gp
traslochi. quando -msmall-data viene utilizzato, vengono inseriti oggetti di lunghezza pari o inferiore a 8 byte
a piccole dati area (le sezioni ".sdata" e ".sbss") e vi si accede tramite 16 bit
traslochi al di fuori del registro $gp. Ciò limita la dimensione della piccola area dati a
64KB, ma permette di accedere direttamente alle variabili tramite un'unica istruzione.

L'impostazione predefinita è -mlarge-dati. Con questa opzione l'area dati è limitata appena sotto
2GB. I programmi che richiedono più di 2 GB di dati devono utilizzare "malloc" o "mmap" per
allocare i dati nell'heap anziché nel segmento di dati del programma.

Quando si genera codice per librerie condivise, -fpic implica -msmall-data ed -fPIC
implica -mlarge-dati.

-mtesto-piccolo
-mlarge-testo
Quando -mtesto-piccolo viene utilizzato, il compilatore assume che il codice dell'intero programma
(o libreria condivisa) si adatta a 4 MB ed è quindi raggiungibile con un'istruzione branch.
Quando -msmall-data viene utilizzato, il compilatore può assumere che tutti i simboli locali condividano il
stesso valore $gp, e quindi ridurre il numero di istruzioni richieste per una funzione
chiamare dalle 4 alle 1.

L'impostazione predefinita è -mlarge-testo.

-mcpu=tipo_cpu
Impostare il set di istruzioni e i parametri di pianificazione delle istruzioni per il tipo di macchina
tipo_cpu. È possibile specificare sia il EV nome dello stile o il numero del chip corrispondente.
GCC supporta i parametri di pianificazione per la famiglia di processori EV4, EV5 ed EV6 e
sceglierà i valori predefiniti per il set di istruzioni dal processore specificato.
Se non si specifica un tipo di processore, GCC utilizzerà per impostazione predefinita il processore su cui il
compilatore è stato costruito.

Valori supportati per tipo_cpu sono

ev4
ev45
21064
Pianifica come EV4 e non ha estensioni del set di istruzioni.

ev5
21164
Pianifica come EV5 e non ha estensioni del set di istruzioni.

ev56
21164a
Pianifica come EV5 e supporta l'estensione BWX.

pca56
21164pc
21164PC
Pianifica come EV5 e supporta le estensioni BWX e MAX.

ev6
21264
Pianifica come EV6 e supporta le estensioni BWX, FIX e MAX.

ev67
21264a
Pianifica come EV6 e supporta le estensioni BWX, CIX, FIX e MAX.

Anche le toolchain native supportano il valore nativo, che seleziona la migliore architettura
opzione per il processore host. -mcpu=nativo non ha alcun effetto se GCC non riconosce
il processore.

-mtune=tipo_cpu
Imposta solo i parametri di pianificazione delle istruzioni per il tipo di macchina tipo_cpu.
il set di istruzioni non viene modificato.

Anche le toolchain native supportano il valore nativo, che seleziona la migliore architettura
opzione per il processore host. -mtune=nativo non ha alcun effetto se GCC non riconosce
il processore.

-memoria-latenza=tempo
Imposta la latenza che lo scheduler dovrebbe assumere per i riferimenti di memoria tipici visti da
l'applicazione. Questo numero dipende fortemente dai modelli di accesso alla memoria utilizzati
dall'applicazione e dalla dimensione della cache esterna sulla macchina.

Opzioni valide per tempo sono

numero
Un numero decimale che rappresenta i cicli di clock.

L1
L2
L3
principale
Il compilatore contiene stime del numero di cicli di clock per EV4 "tipici" e
Hardware EV5 per le cache di livello 1, 2 e 3 (chiamate anche Dcache, Scache e
Bcache), nonché alla memoria principale. Nota che L3 è valido solo per EV5.

Dicembre Alfa/VMS Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni DEC Alpha/VMS:

-codici-di-ritorno-mvms
Restituisce i codici delle condizioni VMS da main. L'impostazione predefinita è restituire la condizione di stile POSIX
(es. errore) codici.

-mdebug-main=prefisso
Segnala la prima routine il cui nome inizia con prefisso come routine principale per il
eseguire il debug.

-mmalloc64
L'impostazione predefinita è routine di allocazione della memoria a 64 bit.

FR30 Opzioni

Queste opzioni sono definite specificamente per la porta FR30.

-mpiccolo-modello
Utilizzare il modello dello spazio degli indirizzi ridotto. Questo può produrre codice più piccolo, ma presuppone
che tutti i valori e gli indirizzi simbolici rientrino in un intervallo di 20 bit.

-mno-lsim
Supponiamo che sia stato fornito il supporto per il runtime e quindi non è necessario includere il
libreria del simulatore (libsim.a) sulla riga di comando del linker.

VRF Opzioni

-mgpr-32
Utilizzare solo i primi 32 registri generici.

-mgpr-64
Usa tutti i 64 registri generici.

-mfpr-32
Utilizzare solo i primi 32 registri a virgola mobile.

-mfpr-64
Usa tutti i 64 registri a virgola mobile.

-mhard-flottante
Utilizzare le istruzioni hardware per le operazioni in virgola mobile.

-msoft-flottante
Utilizzare le routine di libreria per le operazioni in virgola mobile.

-maloc-cc
Allocare dinamicamente i registri del codice di condizione.

-mfisso-cc
Non provare ad allocare dinamicamente i registri del codice di condizione, usa solo "icc0" e
"fcc0".

-mdparola
Modificare l'ABI per utilizzare la doppia parola insns.

-mno-dword
Non utilizzare istruzioni a doppia parola.

-mdoppio
Utilizzare le doppie istruzioni in virgola mobile.

-mno-doppio
Non utilizzare doppie istruzioni in virgola mobile.

-media
Usa le istruzioni per i media.

-mno-media
Non utilizzare le istruzioni dei supporti.

-mmulad
Usa le istruzioni di moltiplicazione e addizione/sottrazione.

-mno-mulad
Non utilizzare le istruzioni di moltiplicazione e aggiunta/sottrazione.

-mfdpic
Selezionare l'ABI FDPIC, che utilizza i descrittori di funzione per rappresentare i puntatori a
funzioni. Senza alcuna opzione relativa a PIC/PIE, implica -fPIE. Con -fpic or
-fpie, presuppone che le voci GOT e i piccoli dati rientrino in un intervallo di 12 bit dal GOT
indirizzo di base; insieme a -fPIC or -fPIE, gli offset GOT sono calcolati con 32 bit. Con un
bfin-elfo target, questa opzione implica -msim.

-minline-plt
Abilita l'inlining delle voci PLT nelle chiamate di funzione a funzioni che non sono note
legarsi localmente. Non ha effetto senza -mfdpic. È abilitato di default se
l'ottimizzazione per la velocità e la compilazione per le librerie condivise (ad es. -fPIC or -fpic), o
quando un'opzione di ottimizzazione come -O3 o superiore è presente nella riga di comando.

-mTLS
Assumere un segmento TLS di grandi dimensioni durante la generazione di codice locale del thread.

-ml
Non presumere un segmento TLS di grandi dimensioni durante la generazione di codice locale del thread.

-mgprel-ro
Consentire l'uso delle rilocazioni "GPREL" nell'IFPDT ABI per i dati noti per essere in
sezioni di sola lettura. È abilitato per impostazione predefinita, tranne che per -fpic or -fpie: nonostante
può aiutare a ridurre la tabella di offset globale, scambia 1 istruzione per 4. Con
-fPIC or -fPIE, scambia 3 istruzioni per 4, una delle quali può essere condivisa da più
simboli, ed evita la necessità di una voce GOT per il simbolo di riferimento, quindi è
più probabile che sia una vittoria. Se non è, -mno-gprel-ro può essere utilizzato per disabilitarlo.

-multilib-libreria-pic
Collegamento con le librerie di immagini (libreria, non FD). È implicito da -mlibrary-pic, anche
come da -fPIC ed -fpic senza -mfdpic. Non dovresti mai usarlo esplicitamente.

-mlinked-fp
Segui il requisito EABI di creare sempre un puntatore a frame ogni volta che uno stack frame
è assegnato. Questa opzione è abilitata per impostazione predefinita e può essere disabilitata con
-mno-collegato-fp.

-mlong-chiamate
Utilizzare l'indirizzamento indiretto per chiamare funzioni al di fuori dell'unità di compilazione corrente. Questo
consente di posizionare le funzioni ovunque all'interno dello spazio degli indirizzi a 32 bit.

-etichette-maligne
Prova ad allineare le etichette a un limite di 8 byte inserendo nops nel pacchetto precedente.
Questa opzione ha effetto solo quando l'impacchettamento VLIW è abilitato. Non crea nuovo
pacchetti; aggiunge semplicemente no a quelli esistenti.

-mlibrary-pic
Genera codice EABI indipendente dalla posizione.

-mac-4
Utilizzare solo i primi quattro registri dell'accumulatore di supporti.

-mac-8
Utilizzare tutti e otto i registri dell'accumulatore dei supporti.

-mpack
Pack istruzioni VLIW.

-mno-pacchetto
Non imballare le istruzioni VLIW.

-mno-flag
Non contrassegnare gli switch ABI in e_flags.

-mcond-mossa
Abilita l'uso delle istruzioni di spostamento condizionale (impostazione predefinita).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-cond-mossa
Disabilitare l'uso delle istruzioni di spostamento condizionale.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mscc
Abilita l'uso delle istruzioni di set condizionale (impostazione predefinita).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-scc
Disabilitare l'uso delle istruzioni degli insiemi condizionali.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mcond-exec
Abilita l'uso dell'esecuzione condizionale (impostazione predefinita).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-cond-exec
Disabilitare l'uso dell'esecuzione condizionale.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mvliw-ramo
Esegui un passaggio per comprimere i rami nelle istruzioni VLIW (impostazione predefinita).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-vliw-ramo
Non eseguire un passaggio per comprimere i rami nelle istruzioni VLIW.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mmulti-cond-exec
Abilita l'ottimizzazione di "&&" e "||" in esecuzione condizionale (predefinito).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-multi-cond-exec
Disabilita l'ottimizzazione di "&&" e "||" nell'esecuzione condizionale.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mnested-cond-exec
Abilita le ottimizzazioni dell'esecuzione condizionale annidate (impostazione predefinita).

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-mno-nested-cond-exec
Disabilita le ottimizzazioni dell'esecuzione condizionale annidate.

Questa opzione serve principalmente per il debug del compilatore e probabilmente verrà rimossa in a
versione futura.

-moptimize-membar
Questa opzione rimuove le istruzioni "membar" ridondanti dal codice generato dal compilatore.
Si è abilitata di default.

-mno-ottimizzare-membar
Questo interruttore disabilita la rimozione automatica delle istruzioni "membar" ridondanti dal
codice generato.

-mtomcat-statistiche
Fai in modo che il gas stampi le statistiche di Tomcat.

-mcpu=cpu
Seleziona il tipo di processore per cui generare il codice. I valori possibili sono fr, fr550,
micio, fr500, fr450, fr405, fr400, fr300 ed semplice.

GNU / Linux Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per i target GNU/Linux:

-mglibc
Usa la libreria GNU C. Questa è l'impostazione predefinita tranne che su *-*-linux-*uclibc* ed
*-*-linux-*android* obiettivi.

-muclibc
Usa la libreria uClibc C. Questa è l'impostazione predefinita attivata *-*-linux-*uclibc* obiettivi.

-mbionico
Usa la libreria Bionic C. Questa è l'impostazione predefinita attivata *-*-linux-*android* obiettivi.

-mandroide
Compila il codice compatibile con la piattaforma Android. Questa è l'impostazione predefinita attivata
*-*-linux-*android* obiettivi.

Durante la compilazione, questa opzione abilita -mbionico, -fPIC, -fno-eccezioni ed -fno-rtti by
predefinito. Durante il collegamento, questa opzione fa in modo che il driver GCC passi le opzioni specifiche di Android
al linker. Infine, questa opzione fa sì che la macro del preprocessore "__ANDROID__" sia
definito.

-tno-android-cc
Disabilita gli effetti di compilazione di -mandroide, ovvero non abilitare -mbionico, -fPIC,
-fno-eccezioni ed -fno-rtti per impostazione predefinita.

-tno-android-ld
Disabilita gli effetti di collegamento di -mandroide, ovvero passare le opzioni di collegamento standard di Linux al
linker.

H8 / 300 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni H8/300:

-rilassati
Accorciare alcuni riferimenti di indirizzo al momento del collegamento, quando possibile; usa l'opzione del linker
-rilassare.

-mh Genera codice per H8/300H.

-SM Genera codice per H8S.

-min Genera codice per H8S e H8/300H in modalità normale. Questo interruttore deve essere utilizzato
o con -mh or -SM.

-ms2600
Genera codice per H8S/2600. Questo interruttore deve essere utilizzato con -SM.

-menta32
Rendi i dati "int" a 32 bit per impostazione predefinita.

-maligno-300
Sull'H8/300H e sull'H8S, utilizzare le stesse regole di allineamento dell'H8/300. Il predefinito
per H8/300H e H8S è di allineare long e float su limiti di 4 byte.
-maligno-300 li fa allineare su limiti di 2 byte. Questa opzione non ha effetto
sull'H8/300.

HPPA Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per la famiglia di computer HPPA:

-marzo=tipo di architettura
Genera codice per l'architettura specificata. Le scelte per tipo di architettura sono
1.0 per PA 1.0, 1.1 per PA 1.1, e 2.0 per processori PA 2.0. Fare riferimento a
/usr/lib/sched.models su un sistema HP-UX per determinare l'opzione di architettura corretta
per la tua macchina Il codice compilato per architetture con numeri inferiori verrà eseguito su più alto
architetture numerate, ma non viceversa.

-MPA-RISC-1-0
-MPA-RISC-1-1
-MPA-RISC-2-0
Sinonimi per -marzo=1.0, -marzo=1.1e -marzo=2.0 rispettivamente.

-grande-interruttore
Genera codice adatto a grandi tabelle di commutazione. Utilizzare questa opzione solo se il
assembler/linker si lamentano di rami fuori range all'interno di una tabella switch.

-m salto in ritardo
Riempi gli slot di ritardo delle chiamate di funzione con istruzioni di salto incondizionato modificando
il puntatore di ritorno per la chiamata di funzione sia l'obiettivo del salto condizionale.

-mdisable-fpregs
Impedire che i registri a virgola mobile vengano utilizzati in alcun modo. Questo è necessario per
compilazione di kernel che eseguono il cambio di contesto pigro di registri a virgola mobile. Se
si usa questa opzione e si tenta di eseguire operazioni in virgola mobile, il compilatore
abortisce.

-mdisable-indicizzazione
Impedisce al compilatore di utilizzare le modalità di indicizzazione degli indirizzi. Questo evita alcuni piuttosto
problemi oscuri durante la compilazione del codice generato da MIG in MACH.

-mno-spazio-regs
Genera codice che presuppone che il target non abbia registri di spazio. Ciò consente a GCC di
generare chiamate indirette più veloci e utilizzare modalità di indirizzo indice non scalabili.

Tale codice è adatto per sistemi PA e kernel di livello 0.

-mfast-chiamate-indirette
Genera codice che presuppone che le chiamate non superino mai i limiti dello spazio. Ciò consente a GCC di
emetti codice che esegue chiamate indirette più veloci.

Questa opzione non funzionerà in presenza di librerie condivise o funzioni annidate.

-mintervallo-fisso=registro-intervallo
Genera codice trattando l'intervallo di registri specificato come registri fissi. Un registro fisso
è uno che l'allocatore del registro non può utilizzare. Questo è utile quando si compila il kernel
codice. Un intervallo di registri è specificato come due registri separati da un trattino. multiplo
gli intervalli di registro possono essere specificati separati da una virgola.

-mlong-load-store
Genera il caricamento di 3 istruzioni e memorizza le sequenze come talvolta richiesto da HP-UX 10
linker. Questo è equivalente a +k opzione per i compilatori HP.

-portable-runtime
Utilizzare le convenzioni di chiamata portatile proposte da HP per i sistemi ELF.

-mgas
Abilita l'uso delle direttive assembler che solo GAS può comprendere.

-msprogramma=tipo di CPU
Codice di pianificazione in base ai vincoli per il tipo di macchina tipo di CPU. Le scelte
per tipo di CPU sono 700 7100, 7100LC, 7200, 7300 ed 8000. Fare riferimento a
/usr/lib/sched.models su un sistema HP-UX per determinare l'opzione di pianificazione corretta per
la tua macchina. La pianificazione predefinita è 8000.

-mlinker-opz
Abilitare il passaggio di ottimizzazione nel linker HP-UX. Nota che questo rende il debug simbolico
impossibile. Inoltre, attiva un bug nei linker HP-UX 8 e HP-UX 9 in cui essi
dare messaggi di errore fasulli quando si collegano alcuni programmi.

-msoft-flottante
Genera output contenente chiamate di libreria per virgola mobile. Attenzione: il requisito
le librerie non sono disponibili per tutte le destinazioni HPPA. Normalmente le strutture del
vengono usati i normali compilatori C della macchina, ma questo non può essere fatto direttamente in cross-
compilazione. Devi prendere le tue disposizioni per fornire una libreria adatta
funzioni per la compilazione incrociata.

-msoft-flottante cambia la convenzione di chiamata nel file di output; quindi, è solo
utile se compili contro tutti i di un programma con questa opzione. In particolare, è necessario
compilare libgcc.a, la libreria fornita con GCC, con -msoft-flottante in ordine per questo
lavorare.

-msio
Genera la definizione predefinita, "_SIO", per l'IO del server. L'impostazione predefinita è -mwsio. Questo genera
i predefiniti, "__hp9000s700", "__hp9000s700__" e "_WSIO", per workstation IO.
Queste opzioni sono disponibili in HP-UX e HI-UX.

-mgnu-ld
Usa le opzioni specifiche di GNU ld. questo passa -condiviso da leggere quando si costruisce una condivisione
biblioteca. È l'impostazione predefinita quando GCC è configurato, esplicitamente o implicitamente, con il
linker GNU. Questa opzione non ha alcun effetto su quale sia chiamato ld, ma solo
cambia quali parametri vengono passati a quel ld. Il ld chiamato è determinato da
, il --con-ld l'opzione configure, il percorso di ricerca del programma di GCC e infine quello dell'utente
PERCORSO. Il linker utilizzato da GCC può essere stampato utilizzando quale `ccc -print-nome-programma=ld`.
Questa opzione è disponibile solo su HP-UX GCC a 64 bit, cioè configurato con
hppa*64*-*-hpux*.

-mhp-ld
Utilizzare le opzioni specifiche di HP ld. questo passa -b ld durante la creazione di una libreria condivisa e
Passi +Accetta Tipo non corrispondente a ld su tutti i link. È l'impostazione predefinita quando GCC è
configurato, esplicitamente o implicitamente, con il linker HP. Questa opzione non ha
qualsiasi effetto su cui viene chiamato ld, cambia solo quali parametri vengono passati a quello
ld. Ld che viene chiamato è determinato da --con-ld opzione di configurazione, GCC
percorso di ricerca del programma, e infine dall'utente PERCORSO. Il linker utilizzato da GCC può essere
stampato usando quale `ccc -print-nome-programma=ld`. Questa opzione è disponibile solo su
HP-UX GCC a 64 bit, cioè configurato con hppa*64*-*-hpux*.

-mlong-chiamate
Genera codice che utilizza sequenze di chiamate lunghe. Ciò garantisce che una chiamata sia sempre possibile
per raggiungere gli stub generati dal linker. L'impostazione predefinita è generare chiamate lunghe solo quando il
distanza dal sito della chiamata all'inizio della funzione o dell'unità di traduzione, come
caso, supera un limite predefinito fissato dal tipo di filiale utilizzato. Il
i limiti per le chiamate normali sono 7,600,000 e 240,000 byte, rispettivamente per la PA 2.0
e architetture PA 1.X. Le chiamate Sib sono sempre limitate a 240,000 byte.

Le distanze vengono misurate dall'inizio delle funzioni quando si utilizza il
-ffunzioni-sezioni opzione, o quando si utilizza il -mgas ed -mno-runtime-portatile Opzioni
insieme sotto HP-UX con il linker SOM.

Normalmente non è consigliabile utilizzare questa opzione poiché ridurrà le prestazioni.
Tuttavia, può essere utile in applicazioni di grandi dimensioni, in particolare quando il collegamento parziale è
utilizzato per creare l'applicazione.

I tipi di chiamate lunghe utilizzate dipendono dalle capacità dell'assemblatore e del linker,
e il tipo di codice generato. L'impatto sui sistemi che supportano a lungo
le chiamate assolute e le chiamate relative al simbolo della foto lunga o relative al PC dovrebbero essere
relativamente piccolo. Tuttavia, una chiamata indiretta viene utilizzata su sistemi ELF a 32 bit nel codice pic
ed è abbastanza lungo.

-Munix =unix-std
Genera predefiniti del compilatore e seleziona un file di avvio per lo standard UNIX specificato.
Le scelte per unix-std sono 93, 95 ed 98. 93 è supportato su tutte le versioni di HP-UX.
95 è disponibile su HP-UX 10.10 e versioni successive. 98 è disponibile su HP-UX 11.11 e versioni successive.
I valori predefiniti sono 93 per HP-UX 10.00, 95 per HP-UX 10.10 fino alle 11.00 e 98
per HP-UX 11.11 e versioni successive.

-munix=93 fornisce le stesse predefinizioni di GCC 3.3 e 3.4. -munix=95 fornisce
predefinizioni aggiuntive per "XOPEN_UNIX" e "_XOPEN_SOURCE_EXTENDED" e il file di avvio
unix95.o. -munix=98 fornisce ulteriori predefinizioni per "_XOPEN_UNIX",
"_XOPEN_SOURCE_EXTENDED", "_INCLUDE__STDC_A1_SOURCE" e "_INCLUDE_XOPEN_SOURCE_500",
e il file di avvio unix98.o.

È importante da notare che questa opzione cambia le interfacce per varie librerie
routine. Influisce anche sul comportamento operativo della libreria C. Così, estremo
è necessaria cautela nell'uso di questa opzione.

Il codice della libreria destinato a funzionare con più di uno standard UNIX deve testare,
imposta e ripristina la variabile __xpg4_extended_mask come appropriato. La maggior parte dei software GNU
non fornisce questa capacità.

-nolibldl
Sopprimere la generazione di opzioni di collegamento per cercare libdld.sl quando il -statico opzione è
specificato su HP-UX 10 e versioni successive.

-statico
L'implementazione HP-UX di setlocale in libc ha una dipendenza da libdld.sl. Là
non è una versione di archivio di libdld.sl. Così, quando il -statico l'opzione è specificata,
sono necessarie opzioni di collegamento speciali per risolvere questa dipendenza.

Su HP-UX 10 e versioni successive, il driver GCC aggiunge le opzioni necessarie per il collegamento
libdld.sl quando il -statico l'opzione è specificata. Questo fa sì che il binario risultante sia
essere dinamico. Sulla porta a 64 bit, i linker generano binari dinamici per impostazione predefinita in
in ogni caso. Il -nolibldl l'opzione può essere utilizzata per impedire l'aggiunta del driver GCC
queste opzioni di collegamento.

-threads
Aggiungi il supporto per il multithreading con il dc filo libreria sotto HP-UX. Questa opzione
imposta i flag sia per il preprocessore che per il linker.

Intel 386 ed AMD x86-64 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per la famiglia di computer i386 e x86-64:

-mtune=tipo di CPU
Sintonizzati su tipo di CPU tutto ciò che riguarda il codice generato, ad eccezione dell'ABI
e il set di istruzioni disponibili. Le scelte per tipo di CPU siamo:

generico
Produci codice ottimizzato per i più comuni processori IA32/AMD64/EM64T. Se tu
conosci la CPU su cui verrà eseguito il tuo codice, quindi dovresti usare il corrispondente
-mtune opzione al posto di -mtune=generico. Ma, se non sai esattamente quale CPU
avranno gli utenti della tua applicazione, allora dovresti usare questa opzione.

Man mano che sul mercato vengono distribuiti nuovi processori, il comportamento di questa opzione
cambierà. Pertanto, se esegui l'upgrade a una versione più recente di GCC, il codice
l'opzione generata cambierà per riflettere i processori che erano più comuni quando
quella versione di GCC è stata rilasciata.

Non c'è -marzo=generico opzione perché -marzo indica le istruzioni impostate
il compilatore può usare e non esiste un set di istruzioni generico applicabile a tutti
processori. In contrasto, -mtune indica il responsabile (o, in questo caso,
insieme di processori) per cui il codice è ottimizzato.

nativo
Questo seleziona la CPU da sintonizzare al momento della compilazione determinando il processore
tipo di macchina compilatrice. Usando -mtune=nativo produrrà codice ottimizzato
per la macchina locale sotto i vincoli del set di istruzioni selezionato.
utilizzando -marzo=nativo abiliterà tutti i sottoinsiemi di istruzioni supportati dal locale
macchina (quindi il risultato potrebbe non essere eseguito su macchine diverse).

i386
CPU i386 originale di Intel.

i486
CPU Intel i486. (Nessuna pianificazione è implementata per questo chip.)

i586, pentium
CPU Intel Pentium senza supporto MMX.

pentium-mmx
CPU Intel PentiumMMX basata su core Pentium con supporto per set di istruzioni MMX.

pentium
CPU Intel Pentium Pro.

i686
Uguale a "generico", ma se usato come opzione "marcia", set di istruzioni PentiumPro
verrà utilizzato, quindi il codice verrà eseguito su tutti i chip della famiglia i686.

pentium2
CPU Intel Pentium2 basata su core PentiumPro con supporto per set di istruzioni MMX.

pentium3, pentium3m
CPU Intel Pentium3 basata su core PentiumPro con set di istruzioni MMX e SSE
supporto.

pentium-m
Versione a basso consumo della CPU Intel Pentium3 con set di istruzioni MMX, SSE e SSE2
sostegno. Utilizzato dai notebook Centrino.

pentium4, pentium4m
CPU Intel Pentium4 con supporto per set di istruzioni MMX, SSE e SSE2.

Prescott
Versione migliorata della CPU Intel Pentium4 con istruzioni MMX, SSE, SSE2 e SSE3
impostare il supporto.

nocona
Versione migliorata della CPU Intel Pentium4 con estensioni a 64 bit, MMX, SSE, SSE2 e
Supporto del set di istruzioni SSE3.

core2
CPU Intel Core2 con estensioni a 64 bit, istruzioni MMX, SSE, SSE2, SSE3 e SSSE3
impostare il supporto.

corei7
CPU Intel Core i7 con estensioni a 64 bit, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 e
Supporto del set di istruzioni SSE4.2.

corei7-avx
CPU Intel Core i7 con estensioni a 64 bit, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Supporto per set di istruzioni SSE4.2, AVX, AES e PCLMUL.

core-avx-i
CPU Intel Core con estensioni a 64 bit, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Supporto per set di istruzioni SSE4.2, AVX, AES, PCLMUL, FSGSBASE, RDRND e F16C.

atomo
CPU Intel Atom con estensioni a 64 bit, istruzioni MMX, SSE, SSE2, SSE3 e SSSE3
impostare il supporto.

k6 CPU AMD K6 con supporto per set di istruzioni MMX.

k6-2, k6-3
Versioni migliorate della CPU AMD K6 con MMX e 3DNow! supporto del set di istruzioni.

atletica, athlon-tbird
CPU AMD Athlon con MMX, 3dNOW!, 3DNow! e istruzioni di prelettura SSE
supporto.

athlon-4, athlon-xp, athlon-mp
CPU AMD Athlon migliorata con MMX, 3DNow!, 3DNow! e istruzioni SSE complete
impostare il supporto.

k8, ottero, athlon64, Athlon-FX
CPU basate su core AMD K8 con supporto per set di istruzioni x86-64. (Questo sovrascrive MMX,
SSE, SSE2, 3DNow!, 3DNow migliorato! ed estensioni del set di istruzioni a 64 bit.)

k8-sse3, opteron-sse3, athlon64-sse3
Versioni migliorate di k8, opteron e athlon64 con supporto per set di istruzioni SSE3.

amdfam10, Barcellona
CPU basate su core della famiglia AMD 10h con supporto per set di istruzioni x86-64. (Questo
superset MMX, SSE, SSE2, SSE3, SSE4A, 3DNow!, 3DNow! avanzato, ABM e 64 bit
estensioni del set di istruzioni.)

bdver1
CPU basate su core della famiglia AMD 15h con supporto per set di istruzioni x86-64. (Questo
superset FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A,
SSSE3, SSE4.1, SSE4.2, ABM ed estensioni del set di istruzioni a 64 bit.)

bdver2
CPU basate su core della famiglia AMD 15h con supporto per set di istruzioni x86-64. (Questo
superset BMI, TBM, F16C, FMA, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2,
SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM ed estensioni del set di istruzioni a 64 bit.)

btver1
CPU basate su core della famiglia AMD 14h con supporto per set di istruzioni x86-64. (Questo
superset MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM e set di istruzioni a 64 bit
estensioni.)

winchip-c6
CPU IDT Winchip C6, trattata allo stesso modo dell'i486 con un set di istruzioni MMX aggiuntivo
supporto.

verricello2
CPU IDT Winchip2, trattata allo stesso modo dell'i486 con MMX aggiuntivo e 3DNow!
supporto del set di istruzioni.

c3 Tramite CPU C3 con MMX e 3DNow! supporto del set di istruzioni. (Nessuna programmazione è
implementato per questo chip.)

c3-2
Tramite CPU C3-2 con supporto per set di istruzioni MMX e SSE. (Nessuna programmazione è
implementato per questo chip.)

geode
CPU AMD integrata con MMX e 3DNow! supporto del set di istruzioni.

Mentre scegli uno specifico tipo di CPU pianificherà le cose in modo appropriato per questo
particolare chip, il compilatore non genererà alcun codice che non venga eseguito sul
tipo di macchina predefinito senza il -marzo=tipo di CPU opzione in uso. Ad esempio, se
GCC è configurato per i686-pc-linux-gnu quindi -mtune=pentium4 genererà codice che
è sintonizzato per Pentium4 ma continuerà a funzionare su macchine i686.

-marzo=tipo di CPU
Genera istruzioni per il tipo di macchina tipo di CPU. Le scelte per tipo di CPU sono la
come per -mtune. Inoltre, specificando -marzo=tipo di CPU implica -mtune=tipo di CPU.

-mcpu=tipo di CPU
Un sinonimo deprecato di -mtune.

-mfpmth=unità
Genera aritmetica in virgola mobile per l'unità selezionata unità. Le scelte per unità siamo:

387 Utilizzare il coprocessore a virgola mobile 387 standard presente sulla maggior parte dei chip
ed emulato in altro modo. Il codice compilato con questa opzione viene eseguito quasi ovunque.
I risultati temporanei vengono calcolati con una precisione a 80 bit anziché con la precisione
specificato dal tipo, con risultati leggermente diversi rispetto alla maggior parte dei
altri chip. Vedere -float-negozio per una descrizione più dettagliata.

Questa è la scelta predefinita per il compilatore i386.

sse Utilizzare le istruzioni scalari a virgola mobile presenti nel set di istruzioni SSE. Questo
il set di istruzioni è supportato da Pentium3 e dai chip più recenti, nella linea AMD di
Chip Athlon-4, Athlon-xp e Athlon-mp. La versione precedente dell'istruzione SSE
set supporta solo l'aritmetica a precisione singola, quindi il doppio ed esteso-
l'aritmetica di precisione viene ancora eseguita utilizzando 387. Una versione successiva, presente solo in
Pentium4 e i futuri chip AMD x86-64, supportano l'aritmetica a doppia precisione
troppo.

Per il compilatore i386, devi usare -marzo=tipo di CPU, -msse or -msse2 interruttori
per abilitare le estensioni SSE e rendere effettiva questa opzione. Per il compilatore x86-64,
queste estensioni sono abilitate per impostazione predefinita.

Il codice risultante dovrebbe essere notevolmente più veloce nella maggior parte dei casi e
evitare i problemi di instabilità numerica del codice 387, ma potrebbe romperne alcuni esistenti
codice che prevede che i temporanei siano 80 bit.

Questa è la scelta predefinita per il compilatore x86-64.

se, 387
se+387
entrambi
Tentare di utilizzare entrambi i set di istruzioni contemporaneamente. Questo effettivamente raddoppia il
quantità di registri disponibili e su chip con unità di esecuzione separate per 387
e SSE anche le risorse di esecuzione. Usa questa opzione con attenzione, poiché è ancora
sperimentale, perché l'allocatore del registro GCC non modella separatamente
unità funzionali bene con conseguente prestazione instabile.

-masm=dialetto
Emetti istruzioni asm utilizzando selezionato dialetto. Le scelte supportate sono intel or a
(quello predefinito). Darwin non supporta intel.

-mieee-fp
-mno-ieee-fp
Controlla se il compilatore utilizza o meno i confronti a virgola mobile IEEE. Queste
gestire correttamente il caso in cui il risultato di un confronto non è ordinato.

-msoft-flottante
Genera output contenente chiamate di libreria per virgola mobile. Attenzione: il requisito
le librerie non fanno parte di GCC. Normalmente le strutture del solito C . della macchina
vengono utilizzati compilatori, ma ciò non può essere eseguito direttamente nella compilazione incrociata. Devi
fare le proprie disposizioni per fornire funzioni di libreria adeguate per
compilazione.

Su macchine in cui una funzione restituisce risultati in virgola mobile nel registro 80387
stack, alcuni codici operativi in ​​virgola mobile potrebbero essere emessi anche se -msoft-flottante viene utilizzato.

-mno-fp-ret-in-387
Non utilizzare i registri FPU per restituire i valori delle funzioni.

La solita convenzione di chiamata prevede che le funzioni restituiscano valori di tipo "float" e "double"
in un registro FPU, anche se non c'è FPU. L'idea è che il sistema operativo
dovrebbe emulare una FPU.

L'opzione -mno-fp-ret-in-387 fa sì che tali valori vengano restituiti nella CPU ordinaria
registri invece.

-mno-fantasia-matematica-387
Alcuni 387 emulatori non supportano le istruzioni "sin", "cos" e "sqrt" per il
387. Specificare questa opzione per evitare di generare tali istruzioni. Questa opzione è la
predefinito su FreeBSD, OpenBSD e NetBSD. Questa opzione viene ignorata quando -marzo
indica che la CPU di destinazione avrà sempre una FPU e quindi l'istruzione no
bisogno di emulazione. A partire dalla revisione 2.6.1, queste istruzioni non vengono generate a meno che tu
usa anche il -funsafe-math-ottimizzazioni interruttore.

-maligno-doppio
-mno-align-doppio
Controlla se GCC allinea le variabili "double", "long double" e "long long" su a
confine di due parole o un confine di una parola. Allineare variabili "doppie" su due parole
confine produce codice che viene eseguito un po' più velocemente su a Pentium a scapito di più
memoria.

Su x86-64, -maligno-doppio è abilitato per impostazione predefinita.

Attenzione: se usi l'estensione -maligno-doppio switch, strutture contenenti i tipi di cui sopra
sarà allineato in modo diverso rispetto all'interfaccia binaria dell'applicazione pubblicata
specifiche per il 386 e non sarà compatibile binario con le strutture nel codice
compilato senza quell'interruttore.

-m96bit-lungo-doppio
-m128bit-lungo-doppio
Questi interruttori controllano la dimensione del tipo "long double". Il binario dell'applicazione i386
interfaccia specifica la dimensione da 96 bit, quindi -m96bit-lungo-doppio è l'impostazione predefinita in
Modalità a 32 bit.

Le architetture moderne (Pentium e successive) preferiscono "long double" per essere allineate a un 8-
o limite di 16 byte. In array o strutture conformi all'ABI, questo non lo è
possibile. Quindi specificando -m128bit-lungo-doppio allinea "long double" a 16 byte
confine riempiendo il "long double" con un ulteriore zero a 32 bit.

Nel compilatore x86-64, -m128bit-lungo-doppio è la scelta predefinita come ABI
specifica che "long double" deve essere allineato su un limite di 16 byte.

Nota che nessuna di queste opzioni consente una precisione extra rispetto allo standard x87
di 80 bit per un "long double".

Attenzione: se sovrascrivi il valore predefinito per il tuo ABI target, le strutture e
gli array contenenti variabili "long double" cambieranno dimensione e funzione
la convenzione di chiamata per la funzione che richiede "long double" verrà modificata. quindi loro
non sarà compatibile a livello binario con array o strutture nel codice compilato senza quello
interruttore.

-mlarge-data-soglia=numero
Quando -mcmodel=medio è specificato, i dati maggiori di soglia sono posti in grande
sezione dati. Questo valore deve essere lo stesso per tutti gli oggetti collegati nel binario
e il valore predefinito è 65535.

-mrtd
Utilizzare una convenzione di chiamata di funzione diversa, in cui le funzioni che accettano un valore fisso
numero di argomenti restituiti con il "ret" num istruzione, che fa apparire i loro argomenti
durante il ritorno. Ciò consente di risparmiare un'istruzione nel chiamante poiché non è necessario
pop gli argomenti lì.

Puoi specificare che una singola funzione viene chiamata con questa sequenza di chiamata con
l'attributo della funzione stdcall. Puoi anche sovrascrivere il -mrtd opzione utilizzando il
attributo della funzione cdecl.

Attenzione: questa convenzione di chiamata è incompatibile con quella normalmente usata su Unix,
quindi non puoi usarlo se hai bisogno di chiamare librerie compilate con il compilatore Unix.

Inoltre, è necessario fornire prototipi di funzioni per tutte le funzioni che accettano variabili
numero di argomenti (incluso "printf"); altrimenti verrà generato un codice errato
per le chiamate a tali funzioni.

Inoltre, risulterà un codice gravemente errato se si chiama una funzione con troppi
argomenti. (Normalmente, gli argomenti aggiuntivi vengono ignorati in modo innocuo.)

-mregparm=num
Controlla quanti registri vengono utilizzati per passare argomenti interi. Per impostazione predefinita, no
i registri vengono utilizzati per passare argomenti e possono essere utilizzati al massimo 3 registri. Puoi
controllare questo comportamento per una funzione specifica utilizzando l'attributo function regparm.

Attenzione: se usi questo interruttore, e num è diverso da zero, quindi devi compilare tutti i moduli
con lo stesso valore, comprese eventuali librerie. Ciò include le librerie di sistema e
moduli di avvio.

-msseregparm
Utilizzare le convenzioni di passaggio del registro SSE per gli argomenti float e double e i valori restituiti.
Puoi controllare questo comportamento per una funzione specifica usando l'attributo function
sseregparm.

Attenzione: se usi questa opzione, devi creare tutti i moduli con lo stesso valore,
comprese eventuali biblioteche. Ciò include le librerie di sistema e i moduli di avvio.

-mvect8-ret-in-mem
Restituisce vettori a 8 byte in memoria invece dei registri MMX. Questa è l'impostazione predefinita attivata
Solaris@tie{}8 e 9 e VxWorks per abbinare l'ABI dei compilatori Sun Studio fino al
versione 12. Seguono versioni successive del compilatore (a partire da Studio 12 Update@tie{}1)
l'ABI utilizzato da altri target x86, che è l'impostazione predefinita su Solaris@tie{}10 ​​e versioni successive.
Solo usa questa opzione se hai bisogno di rimanere compatibile con il codice esistente prodotto da
quelle versioni precedenti del compilatore o versioni precedenti di GCC.

-mpc32
-mpc64
-mpc80
Imposta la precisione in virgola mobile 80387 su 32, 64 o 80 bit. quando -mpc32 è specificato,
i significandi dei risultati delle operazioni in virgola mobile sono arrotondati a 24 bit
(singola precisione); -mpc64 arrotonda i significandi dei risultati in virgola mobile
operazioni a 53 bit (doppia precisione) e -mpc80 arrotonda i significandi dei risultati
di operazioni in virgola mobile a 64 bit (doppia precisione estesa), che è il
predefinito. Quando viene utilizzata questa opzione, le operazioni in virgola mobile con precisioni più elevate sono
non disponibile per il programmatore senza impostare esplicitamente la parola di controllo FPU.

L'impostazione dell'arrotondamento delle operazioni in virgola mobile su un valore inferiore agli 80 bit predefiniti può
velocizzare alcuni programmi del 2% o più. Nota che alcune librerie matematiche presumono che
le operazioni a virgola mobile a precisione estesa (80 bit) sono abilitate per impostazione predefinita; routine
in tali librerie potrebbe subire una significativa perdita di accuratezza, tipicamente attraverso
chiamata "cancellazione catastrofica", quando questa opzione viene utilizzata per impostare la precisione su
meno di precisione estesa.

-mstackrealign
Riallineare la pila all'ingresso. Su Intel x86, il -mstackrealign l'opzione genererà
un prologo e un epilogo alternativi che riallineano lo stack di runtime se necessario.
Ciò supporta la combinazione di codici legacy che mantengono uno stack allineato a 4 byte con codici moderni
che mantengono uno stack di 16 byte per la compatibilità SSE. Vedi anche l'attributo
"force_align_arg_pointer", applicabile alle singole funzioni.

-preferred-stack-boundary=num
Tentativo di mantenere il confine dello stack allineato a un 2 elevato a num limite di byte. Se
-preferred-stack-boundary non è specificato, il valore predefinito è 4 (16 byte o 128 bit).

Attenzione: Quando si genera codice per l'architettura x86-64 con estensioni SSE
Disabilitato, -preferred-stack-boundary=3 può essere utilizzato per mantenere allineato il confine dello stack
al limite di 8 byte. Devi costruire tutti i moduli con -preferred-stack-boundary=3,
comprese eventuali biblioteche. Ciò include le librerie di sistema e i moduli di avvio.

-confine-stack-minima=num
Supponiamo che lo stack in entrata sia allineato a un 2 elevato a num limite di byte. Se
-confine-stack mincoming non è specificato, quello specificato da
-preferred-stack-boundary verrà utilizzato.

Su Pentium e PentiumPro, i valori "double" e "long double" devono essere allineati a an
Limite di 8 byte (vedi -maligno-doppio) o subiscono prestazioni di runtime significative
sanzioni. Su Pentium III, il tipo di dati Streaming SIMD Extension (SSE) "__m128" può
non funziona correttamente se non è allineato a 16 byte.

Per garantire il corretto allineamento di questi valori sullo stack, il limite dello stack deve essere uguale a
allineato come richiesto da qualsiasi valore memorizzato nello stack. Inoltre, ogni funzione
deve essere generato in modo tale da mantenere lo stack allineato. Chiamando così una funzione
compilato con un limite di stack preferito più alto da una funzione compilata con un limite inferiore
il limite dello stack preferito molto probabilmente disallinea lo stack. Si raccomanda che
le librerie che utilizzano i callback utilizzano sempre l'impostazione predefinita.

Questo allineamento extra consuma spazio aggiuntivo nello stack e generalmente aumenta il codice
dimensione. Codice sensibile all'utilizzo dello spazio dello stack, come sistemi embedded e
kernel del sistema operativo, potrebbe voler ridurre l'allineamento preferito a
-preferred-stack-boundary=2.

-mmmmx
-mno-mmx
-msse
-mno-sse
-msse2
-mno-sse2
-msse3
-mno-sse3
-mssse3
-mno-sse3
-msse4.1
-mno-sse4.1
-msse4.2
-mno-sse4.2
-msse4
-mno-sse4
-max
-mno-avx
-mavx2
-mno-avx2
-maes
-mno-ae
-mpclmul
-mno-pclmul
-mfsgsbase
-mno-fsgsbase
-signorrnd
-mno-rndrnd
-mf16c
-mno-f16c
-mfma
-mno-fma
-msse4a
-mno-sse4a
-mfma4
-mno-fma4
-mxop
-mno-xop
-mlwp
-mno-lwp
-m3dora
-mno-3dora
-mpocnt
-mno-popcnt
-mamm
-mno-abm
-mbmi
-mbmi2
-mno-bmi
-mno-bmi2
-mlzcnt
-mno-lzcnt
-mtbm
-mno-tbm
Questi interruttori abilitano o disabilitano l'uso delle istruzioni in MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP,
LWP, ABM, BMI, BMI2, LZCNT o 3DNow!
set di istruzioni estese. Queste estensioni sono disponibili anche come built-in
funzioni: vedi X86 Built-in funzioni, per il dettaglio delle funzioni abilitate e
disabilitato da questi interruttori.

Per fare in modo che le istruzioni SSE/SSE2 vengano generate automaticamente dal codice a virgola mobile (come
contraria alle istruzioni 387), cfr -mfpmth=sse.

GCC deprime le istruzioni SSEx quando -max viene utilizzato. Invece, genera nuovo AVX
istruzioni o equivalenza AVX per tutte le istruzioni SSEx quando necessario.

Queste opzioni consentiranno a GCC di utilizzare queste istruzioni estese nel codice generato,
anche senza -mfpmth=sse. Le applicazioni che eseguono il rilevamento della CPU in fase di esecuzione devono
compilare file separati per ogni architettura supportata, utilizzando i flag appropriati.
In particolare, il file contenente il codice di rilevamento della CPU deve essere compilato senza
queste opzioni.

-mld
Questa opzione indica a GCC di emettere un'istruzione "cld" nel prologo delle funzioni
che utilizzano istruzioni stringa. Le istruzioni delle stringhe dipendono dal flag DF da selezionare
tra modalità autoincrement o autodecrement. Mentre l'ABI specifica il flag DF su
essere cancellato all'immissione della funzione, alcuni sistemi operativi violano questa specifica non
cancellando il flag DF nei loro dispatcher di eccezioni. Il gestore delle eccezioni può essere
invocato con il flag DF impostato, che porta alla modalità di direzione sbagliata quando string
vengono utilizzate le istruzioni. Questa opzione può essere abilitata per impostazione predefinita su target x32 a 86 bit da
configurare GCC con il -Nable-CLD configurare l'opzione. Generazione di "cld"
le istruzioni possono essere soppresse con il -mno-cld opzione del compilatore in questo caso.

-mvzeroupper
Questa opzione indica a GCC di emettere un'istruzione "vzeroupper" prima di un trasferimento di
controllare il flusso fuori dalla funzione per ridurre al minimo la penalità di transizione da AVX a SSE, nonché
rimuovere gli elementi intrinseci zeroupper non necessari.

-mprefer-avx128
Questa opzione indica a GCC di utilizzare istruzioni AVX a 128 bit invece di AVX a 256 bit
istruzioni nel vettorizzatore automatico.

-mcx16
Questa opzione consentirà a GCC di utilizzare l'istruzione CMPXCHG16B nel codice generato.
CMPXCHG16B consente operazioni atomiche su dati double quadword (o oword) a 128 bit
tipi. Questo è utile per i contatori ad alta risoluzione che potrebbero essere aggiornati da più
processori (o core). Questa istruzione è generata come parte di atomic built-in
funzioni: vedi __sincronizzazione Builtin or __atomico Builtin per i dettagli.

-msaf
Questa opzione consentirà a GCC di utilizzare l'istruzione SAHF nel codice a 64 bit generato. Presto
Le CPU Intel con Intel 64 mancavano di istruzioni LAHF e SAHF supportate da AMD64 fino al
introduzione del passo Pentium 4 G1 nel dicembre 2005. LAHF e SAHF vengono caricati e archiviati
istruzioni, rispettivamente, per determinati flag di stato. In modalità a 64 bit, SAHF
l'istruzione viene utilizzata per ottimizzare le funzioni integrate "fmod", "drem" o "remainder": vedere
Altro Builtin per i dettagli.

-Movbe
Questa opzione consentirà a GCC di utilizzare l'istruzione movbe per implementare "__builtin_bswap32"
e "__builtin_bswap64".

-mcrc32
Questa opzione abilita le funzioni integrate, "__builtin_ia32_crc32qi",
"__builtin_ia32_crc32hi". "__builtin_ia32_crc32si" e "__builtin_ia32_crc32di" per
generare l'istruzione macchina crc32.

-mrecip
Questa opzione consentirà a GCC di utilizzare le istruzioni RCPSS e RSQRTSS (e le loro
varianti vettorizzate RCPPS e RSQRTPS) con un ulteriore passaggio Newton-Raphson per
aumentare la precisione invece di DIVSS e SQRTSS (e delle loro varianti vettorializzate) per
argomenti a virgola mobile a precisione singola. Queste istruzioni vengono generate solo quando
-funsafe-math-ottimizzazioni è abilitato insieme a -solo matematica finita ed
-fno-trapping-matematica. Si noti che mentre il throughput della sequenza è superiore a
throughput dell'istruzione non reciproca, la precisione della sequenza può essere
diminuito fino a 2 ulp (cioè l'inverso di 1.0 è uguale a 0.99999994).

Nota che GCC implementa "1.0f/sqrtf(X)" in termini di RSQRTSS (o RSQRTPS) già con
-fast-matematica (o la combinazione di opzioni sopra) e non è necessario -mrecip.

Si noti inoltre che GCC emette la sequenza di cui sopra con un ulteriore passo di Newton-Raphson per
divisione vettoriale vettorizzata e "sqrtf(X)" già con -fast-matematica
(o la combinazione di opzioni sopra) e non è necessario -mrecip.

-mrecip=optare
Questa opzione permette di controllare quali istruzioni di stima reciproche possono essere utilizzate. optare
è un elenco di opzioni separate da virgole, che può essere preceduto da un "!" invertire il
opzione: "all": abilita tutte le istruzioni di stima, "default": abilita il default
istruzioni, equivalente a -mrecip, "none": disabilita tutte le istruzioni di preventivo,
equivalente -mno-ricetta, "div": abilita l'approssimazione per la divisione scalare,
"vec-div": abilita l'approssimazione per la divisione vettorizzata, "sqrt": abilita l'
approssimazione per radice quadrata scalare, "vec-sqrt": abilitare l'approssimazione per
radice quadrata vettorizzata.

Quindi per esempio, -mrecip=tutti,!sqrt consentirebbe tutte le approssimazioni reciproche,
ad eccezione della radice quadrata.

-mveclibabi=Digitare
Specifica il tipo ABI da utilizzare per vettorizzare gli elementi intrinseci utilizzando una libreria esterna.
I tipi supportati sono "svml" per la libreria di matematica vettoriale breve Intel e "acml" per il
Stile di interfacciamento della libreria di core matematici AMD. GCC attualmente emetterà chiamate a
"vmldExp2", "vmldLn2", "vmldLog102", "vmldLog102", "vmldPow2", "vmldTanh2",
"vmldTan2", "vmldAtan2", "vmldAtanh2", "vmldCbrt2", "vmldSinh2", "vmldSin2",
"vmldAsinh2", "vmldAsin2", "vmldCosh2", "vmldCos2", "vmldAcosh2", "vmldAcos2",
"vmlsExp4", "vmlsLn4", "vmlsLog104", "vmlsLog104", "vmlsPow4", "vmlsTanh4",
"vmlsTan4", "vmlsAtan4", "vmlsAtanh4", "vmlsCbrt4", "vmlsSinh4", "vmlsSin4",
"vmlsAsinh4", "vmlsAsin4", "vmlsCosh4", "vmlsCos4", "vmlsAcosh4" e "vmlsAcos4" per
tipo di funzione corrispondente quando -mveclibabi=svml viene utilizzato e "__vrd2_sin",
"__vrd2_cos", "__vrd2_exp", "__vrd2_log", "__vrd2_log2", "__vrd2_log10",
"__vrs4_sinf", "__vrs4_cosf", "__vrs4_expf", "__vrs4_logf", "__vrs4_log2f",
"__vrs4_log10f" e "__vrs4_powf" per il tipo di funzione corrispondente quando
-mveclibabi=acml viene utilizzato. Entrambi -ftree-vettorizzare ed -funsafe-math-ottimizzazioni avere
essere abilitato. Una libreria compatibile con SVML o ACML ABI dovrà essere specificata al link
tempo.

-mabi=Nome
Genera codice per la convenzione di chiamata specificata. I valori ammessi sono: sysv per
l'ABI utilizzato su GNU/Linux e altri sistemi e ms per Microsoft ABI. Il predefinito
consiste nell'utilizzare Microsoft ABI quando si prende di mira Windows. Su tutti gli altri sistemi, l'impostazione predefinita
è il SYSV ABI. È possibile controllare questo comportamento per una funzione specifica utilizzando il
attributo della funzione ms_abi/sysv_abi.

-mtls-dialetto=Digitare
Genera codice per accedere all'archiviazione locale del thread utilizzando il gnu or gnu2 convegni. gnu
è il default conservativo; gnu2 è più efficiente, ma può aggiungere compilazione ed esecuzione
requisiti di tempo che non possono essere soddisfatti su tutti i sistemi.

-mpush-args
-mno-push-args
Utilizzare le operazioni PUSH per memorizzare i parametri in uscita. Questo metodo è più breve e di solito
altrettanto veloce del metodo che utilizza operazioni SUB/MOV ed è abilitato per impostazione predefinita. In qualche
casi disabilitarlo può migliorare le prestazioni a causa della pianificazione migliorata e ridotta
dipendenze.

-maccumulate-in-uscita-args
Se abilitato, la quantità massima di spazio richiesta per gli argomenti in uscita sarà
calcolato nel prologo della funzione. Questo è più veloce sulla maggior parte delle moderne CPU a causa di
dipendenze ridotte, pianificazione migliorata e utilizzo ridotto dello stack quando lo stack preferito
confine non è uguale a 2. Lo svantaggio è un notevole aumento della dimensione del codice. Questo
interruttore implica -mno-push-args.

-mthread
Supporta la gestione delle eccezioni thread-safe attiva Minw32. Codice che si basa su thread-safe
la gestione delle eccezioni deve compilare e collegare tutto il codice con il -mthread opzione. quando
compilare, -mthread definisce -D_mt; quando si collega, si collega in uno speciale aiutante di thread
biblioteca -lmingwrd che pulisce i dati di gestione delle eccezioni per thread.

-mno-align-stringops
Non allineare la destinazione delle operazioni di stringa inline. Questo interruttore riduce la dimensione del codice
e migliora le prestazioni nel caso in cui la destinazione sia già allineata, ma GCC no
saperlo.

-minline-all-stringops
Per impostazione predefinita, GCC incorpora le operazioni sulle stringhe solo quando si sa che la destinazione è
allineato a un limite di almeno 4 byte. Ciò consente più inline, aumenta la dimensione del codice,
ma può migliorare le prestazioni del codice che dipende da memcpy, strlen e memset veloci per
brevi lunghezze.

-minline-stringops-dinamicamente
Per operazioni su stringhe di dimensioni sconosciute, utilizzare i controlli di runtime con codice in linea per piccoli
blocchi e una libreria richiedono blocchi di grandi dimensioni.

-mstringop-strategia=alg
Sovrascrivi l'euristica delle decisioni interne su un particolare algoritmo nella stringa in linea
operazione con. I valori consentiti sono "rep_byte", "rep_4byte", "rep_8byte" per
espandendo usando il prefisso i386 "rep" della dimensione specificata, "byte_loop", "loop",
"unrolled_loop" per espandere il ciclo in linea, "libcall" per espandere sempre la libreria
chiamata.

-puntatore-cornice-foglia-momit
Non tenere il puntatore a frame in un registro per le funzioni foglia. Questo evita il
istruzioni per salvare, impostare e ripristinare i puntatori dei frame e creare un registro aggiuntivo
disponibile nelle funzioni foglia. L'opzione -puntatore-frame-fomit rimuove il telaio
puntatore per tutte le funzioni, il che potrebbe rendere più difficile il debug.

-mtls-seg-diretta-arbitri
-mno-tls-direct-seg-refs
Controlla se è possibile accedere alle variabili TLS con offset dal segmento TLS
register (%gs per 32 bit, %fs per 64 bit) o ​​se il puntatore di base del thread deve essere
aggiunto. Se questo è legale o meno dipende dal sistema operativo e se lo è
mappa il segmento per coprire l'intera area TLS.

Per i sistemi che utilizzano GNU libc, l'impostazione predefinita è attiva.

-msse2avx
-mno-sse2avx
Specificare che l'assemblatore deve codificare le istruzioni SSE con il prefisso VEX. L'opzione
-max lo attiva per impostazione predefinita.

-mfentry
-mno-fentry
Se la profilazione è attiva -pag metti la controchiamata di profilazione prima del prologo. Nota: attivato
architetture x86 l'attributo "ms_hook_prologue" non è al momento possibile per
-mfentry ed -pag.

-m8bit-idiv
-mno-8bit-idiv
Su alcuni processori, come Intel Atom, il divisore intero senza segno a 8 bit è molto più veloce di
Divisione intera a 32/64 bit. Questa opzione genera un controllo in fase di esecuzione. Se entrambi
dividendo e divisore sono compresi nell'intervallo da 0 a 255, la divisione intera senza segno a 8 bit è
utilizzato al posto della divisione intera a 32/64 bit.

-mavx256-split-carico non allineato
-mavx256-split-negozio-non-allineato
Caricamento e archiviazione non allineati AVX a 32 byte suddivisi.

Strumenti Bowman per analizzare le seguenti finiture: -m gli switch sono supportati in aggiunta a quanto sopra sui processori AMD x86-64 in
Ambienti a 64 bit.

-M32
-M64
-mx32
Genera codice per un ambiente a 32 o 64 bit. Il -M32 l'opzione imposta int, long e
puntatore a 32 bit e genera codice che gira su qualsiasi sistema i386. Il -M64 opzione
imposta int su 32 bit e long e pointer su 64 bit e genera codice per AMD
architettura x86-64. Il -mx32 opzione imposta int, long e pointer a 32 bit e
genera codice per l'architettura x86-64 di AMD. Per Darwin solo il -M64 l'opzione si trasforma
fuori -fno-foto ed -mdynamic-no-pic opzioni.

-mno-zona-rossa
Non utilizzare una cosiddetta zona rossa per il codice x86-64. La zona rossa è ordinata dal
x86-64 ABI, è un'area di 128 byte oltre la posizione del puntatore dello stack che verrà
non può essere modificato da gestori di segnale o interrupt e quindi può essere utilizzato per
dati temporanei senza modificare il puntatore dello stack. La bandiera -mno-zona-rossa disattiva
questa zona rossa

-mcmodel=piccolo
Genera codice per il modello a codice piccolo: il programma e i suoi simboli devono essere collegati in
i 2 GB inferiori dello spazio degli indirizzi. I puntatori sono a 64 bit. I programmi possono essere
collegati staticamente o dinamicamente. Questo è il modello di codice predefinito.

-McModel = kernel
Genera codice per il modello di codice del kernel. Il kernel gira nei 2 GB negativi del
spazio degli indirizzi. Questo modello deve essere utilizzato per il codice del kernel Linux.

-mcmodel=medio
Genera codice per il modello medio: il programma è collegato nei 2 GB inferiori del
spazio degli indirizzi. Ci sono anche piccoli simboli. Simboli con dimensioni maggiori di
-mlarge-data-soglia sono inseriti in grandi sezioni di dati o bss e possono essere localizzati
superiore a 2 GB. I programmi possono essere collegati staticamente o dinamicamente.

-mcmodel=grande
Genera codice per il modello grande: questo modello non fa ipotesi su indirizzi e
dimensioni delle sezioni.

-maddress-mode=lungo
Genera codice per la modalità indirizzo lungo. Questo è supportato solo per 64 bit e x32
ambienti. È la modalità di indirizzo predefinita per gli ambienti a 64 bit.

-maddress-mode=corto
Genera codice per la modalità indirizzo breve. Questo è supportato solo per 32 bit e x32
ambienti. È la modalità di indirizzo predefinita per gli ambienti a 32 bit e x32.

i386 ed x86-64 Windows Opzioni

Queste opzioni aggiuntive sono disponibili per le destinazioni Windows:

-mconsole
Questa opzione è disponibile per i target Cygwin e MinGW. Specifica che una console
l'applicazione deve essere generata, indicando al linker di impostare l'intestazione PE
tipo di sottosistema richiesto per le applicazioni console. Questo è il comportamento predefinito per
Obiettivi Cygwin e MinGW.

-mdll
Questa opzione è disponibile per i target Cygwin e MinGW. Specifica che una DLL - a
libreria di collegamento dinamico - deve essere generata, consentendo la selezione del necessario
oggetto di avvio runtime e punto di ingresso.

-mnop-fun-dllimport
Questa opzione è disponibile per i target Cygwin e MinGW. Specifica che il
dllimport dovrebbe essere ignorato.

-mthread
Questa opzione è disponibile per i target MinGW. Specifica quel thread specifico di MinGW
supporto deve essere utilizzato.

-municodice
Questa opzione è disponibile per i target mingw-w64. Specifica che la macro UNICODE
sta diventando predefinito e che viene scelto il codice di avvio runtime compatibile con Unicode.

-mwin32
Questa opzione è disponibile per i target Cygwin e MinGW. Si specifica che il tipico
Le macro predefinite di Windows devono essere impostate nel preprocessore, ma non influenzano
la scelta della libreria runtime/codice di avvio.

-mfinestre
Questa opzione è disponibile per i target Cygwin e MinGW. Specifica che una GUI
l'applicazione deve essere generata indicando al linker di impostare l'intestazione PE
tipo di sottosistema in modo appropriato.

-fno-set-stack-eseguibile
Questa opzione è disponibile per i target MinGW. Specifica che il flag eseguibile per
lo stack utilizzato dalle funzioni nidificate non è impostato. Questo è necessario per i binari in esecuzione in
modalità kernel di Windows, poiché c'è l'API user32, che viene utilizzata per impostare l'eseguibile
privilegi, non è disponibile.

-mpe-allineato-comuni
Questa opzione è disponibile per i target Cygwin e MinGW. Specifica che GNU
estensione al formato file PE che permette il corretto allineamento delle variabili COMUNI
dovrebbe essere usato durante la generazione del codice. Sarà abilitato per impostazione predefinita se GCC rileva
che l'assemblatore di destinazione trovato durante la configurazione supporta la funzionalità.

Vedi anche sotto i386 ed x86-64 Opzioni per le opzioni standard.

IA-64 Opzioni

Questi sono la -m opzioni definite per l'architettura Intel IA-64.

-big endian
Genera codice per un target big-endian. Questa è l'impostazione predefinita per HP-UX.

-mittle-endian
Genera codice per un target little-endian. Questa è l'impostazione predefinita per AIX5 e GNU/Linux.

-mgnu-as
-mno-gnu-as
Generare (o non farlo) codice per l'assemblatore GNU. Questa è l'impostazione predefinita.

-mgnu-ld
-mno-gnu-ld
Genera (o no) il codice per il linker GNU. Questa è l'impostazione predefinita.

-mno-foto
Genera codice che non utilizza un registro del puntatore globale. Il risultato non è la posizione
codice indipendente e viola la IA-64 ABI.

-mvolatile-asm-stop
-mno-volatile-asm-stop
Genera (o no) un bit di stop immediatamente prima e dopo le istruzioni asm volatili.

-mregister-nomi
-mno-nome-registro
Genera (o no) in, loce su nomi di registro per i registri impilati. Questo
può rendere più leggibile l'output dell'assemblatore.

-mno-sdata
-msdata
Disabilitare (o abilitare) le ottimizzazioni che utilizzano la sezione dei dati piccoli. Questo può essere utile
per aggirare i bug dell'ottimizzatore.

-mcostante-gp
Genera codice che utilizza un singolo valore del puntatore globale costante. Questo è utile quando
compilazione del codice del kernel.

-mauto-pic
Genera codice che è auto-rilocabile. Ciò implica -mcostante-gp. Questo è utile
durante la compilazione del codice del firmware.

-minline-float-divide-min-latenza
Genera codice per divisioni in linea di valori a virgola mobile utilizzando la latenza minima
algoritmo.

-minline-float-divide-max-throughput
Genera codice per divisioni in linea di valori a virgola mobile utilizzando il throughput massimo
algoritmo.

-mno-inline-float-divide
Non generare codice in linea per le divisioni di valori a virgola mobile.

-minline-int-divide-min-latenza
Genera codice per divisioni in linea di valori interi utilizzando la latenza minima
algoritmo.

-minline-int-divide-max-throughput
Genera codice per divisioni in linea di valori interi utilizzando il throughput massimo
algoritmo.

-mno-inline-int-divide
Non generare codice in linea per divisioni di valori interi.

-minline-sqrt-min-latenza
Genera codice per radici quadrate in linea utilizzando l'algoritmo di latenza minima.

-minline-sqrt-max-throughput
Genera codice per radici quadrate in linea utilizzando l'algoritmo di throughput massimo.

-mno-inline-sqrt
Non generare codice in linea per sqrt.

-mfuso-pazzo
-mno-fuso-madd
Non (non) generare codice che utilizza la fusione moltiplica/aggiungi o moltiplica/sottrai
Istruzioni. L'impostazione predefinita prevede l'utilizzo di queste istruzioni.

-mno-nano2-asm
-mdwarf2-asm
Non (o non) generare codice assembler per le informazioni di debug del numero di riga DWARF2. Questo
può essere utile quando non si usa l'assemblatore GNU.

-merda-stop-bit
-mno-early-stop-bit
Consenti ai bit di stop di essere posizionati prima di quanto immediatamente precedente l'istruzione che
attivato il bit di stop. Questo può migliorare la programmazione delle istruzioni, ma non sempre
fare così.

-mintervallo-fisso=registro-intervallo
Genera codice trattando l'intervallo di registri specificato come registri fissi. Un registro fisso
è uno che l'allocatore del registro non può utilizzare. Questo è utile quando si compila il kernel
codice. Un intervallo di registri è specificato come due registri separati da un trattino. multiplo
gli intervalli di registro possono essere specificati separati da una virgola.

-mtls-dimensione=dimensione tls
Specificare la dimensione in bit degli offset TLS immediati. I valori validi sono 14, 22 e 64.

-mtune=tipo di CPU
Ottimizza la pianificazione delle istruzioni per una particolare CPU, i valori validi sono itanium,
itanium1, merced, itanium2 e mckinley.

-milp32
-mlp64
Genera codice per un ambiente a 32 o 64 bit. L'ambiente a 32 bit imposta int,
long e puntatore a 32 bit. L'ambiente a 64 bit imposta int su 32 bit e long e
puntatore a 64 bit. Questi sono flag specifici di HP-UX.

-mno-sched-br-data-spec
-msched-br-data-spec
(Dis/Abilita) la programmazione speculativa dei dati prima della ricarica. Questo risulterà in
generazione delle istruzioni ld.a e delle corrispondenti istruzioni di controllo (ld.c /
chk.a). L'impostazione predefinita è "disabilita".

-msched-ar-data-spec
-mno-sched-ar-data-spec
(Attiva/disattiva) programmazione speculativa dei dati dopo la ricarica. Questo si tradurrà in generazione
delle istruzioni ld.a e delle corrispondenti istruzioni di controllo (ld.c / chk.a). Il
l'impostazione predefinita è "abilita".

-mno-sched-control-spec
-spec-controllo-msched
(Dis/En)able controllo schedulazione speculativa. Questa funzione è disponibile solo durante
programmazione della regione (cioè prima della ricarica). Ciò comporterà la generazione del ld.s
istruzioni e le corrispondenti istruzioni di controllo chk.s . L'impostazione predefinita è
'disattivare'.

-msched-br-in-data-spec
-mno-sched-br-in-data-spec
(En/Dis)able schedulazione speculativa delle istruzioni che dipendono dai dati
carichi speculativi prima della ricarica. Questo è efficace solo con -msched-br-data-spec
abilitato. L'impostazione predefinita è "abilita".

-msched-ar-in-data-spec
-mno-sched-ar-in-data-spec
(En/Dis)able schedulazione speculativa delle istruzioni che dipendono dai dati
carichi speculativi dopo la ricarica. Questo è efficace solo con -msched-ar-data-spec
abilitato. L'impostazione predefinita è "abilita".

-msched-in-control-spec
-mno-sched-in-control-spec
(En/Dis)able schedulazione speculativa delle istruzioni che dipendono dal
controllare i carichi speculativi. Questo è efficace solo con -spec-controllo-msched abilitato.
L'impostazione predefinita è "abilita".

-mno-sched-prefer-non-data-spec-insns
-msched-prefer-non-data-spec-insns
Se abilitato, le istruzioni speculative sui dati verranno scelte per la pianificazione solo se ci
non ci sono altre scelte al momento. Questo farà l'uso della speculazione sui dati
molto più conservativo. L'impostazione predefinita è "disabilita".

-mno-sched-prefer-non-control-spec-insns
-msched-prefer-non-spec-insns
Se abilitato, le istruzioni speculative di controllo verranno scelte per la pianificazione solo se ci
non ci sono altre scelte al momento. Questo renderà l'uso della speculazione di controllo
molto più conservativo. L'impostazione predefinita è "disabilita".

-mno-sched-count-spec-in-critical-path
-msched-count-spec-in-critical-path
Se abilitato, le dipendenze speculative verranno prese in considerazione durante il calcolo del
priorità delle istruzioni. Questo renderà un po' di più l'uso della speculazione
conservatore. L'impostazione predefinita è "disabilita".

-msched-spec-ldc
Usa un semplice controllo di speculazione sui dati. Questa opzione è attiva per impostazione predefinita.

-msched-control-spec-ldc
Utilizzare un semplice assegno per la speculazione di controllo. Questa opzione è attiva per impostazione predefinita.

-msched-stop-bits-dopo-ogni-ciclo
Mettere un bit di stop dopo ogni ciclo durante la pianificazione. Questa opzione è attiva per impostazione predefinita.

-msched-fp-mem-deps-a-costo-zero
Si supponga che gli archivi e i carichi in virgola mobile non causino conflitti quando
inseriti nello stesso gruppo di istruzioni. Questa opzione è disabilitata di default.

-msel-sched-dont-check-control-spec
Genera controlli per la speculazione di controllo nella programmazione selettiva. Questa bandiera è
disabilitato per impostazione predefinita.

-msched-max-memoria-insns=max-insns
Limitare il numero di inserimenti di memoria per gruppo di istruzioni, dando priorità inferiore a
successivi insns di memoria che tentano di schedulare nello stesso gruppo di istruzioni.
Frequentemente utile per prevenire conflitti di banca cache. Il valore predefinito è 1.

-msched-max-memory-insns-hard-limit
Non consentire più di "msched-max-memory-insns" nel gruppo di istruzioni. Altrimenti, limita
è `soft' nel senso che preferiremmo operazioni non di memoria quando viene raggiunto il limite ma
può ancora programmare le operazioni di memoria.

IA-64/VMS Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni IA-64/VMS:

-codici-di-ritorno-mvms
Restituisce i codici delle condizioni VMS da main. L'impostazione predefinita è restituire la condizione di stile POSIX
(es. errore) codici.

-mdebug-main=prefisso
Segnala la prima routine il cui nome inizia con prefisso come routine principale per il
eseguire il debug.

-mmalloc64
L'impostazione predefinita è routine di allocazione della memoria a 64 bit.

LM32 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per l'architettura Lattice Mico32:

-mbarrel-shift-abilitato
Abilita le istruzioni di spostamento del barile.

-mdivide abilitato
Abilita le istruzioni di divisione e modulo.

-mmultiply-abilitato
Abilita le istruzioni di moltiplicazione.

-msign-extend-abilitato
Abilita le istruzioni di estensione del segno.

-abilitato per l'utente
Abilita istruzioni definite dall'utente.

M32C Opzioni

-mcpu=Nome
Seleziona la CPU per la quale viene generato il codice. Nome potrebbe essere uno di r8c per R8C/Tiny
serie, M16C per la serie M16C (fino a /60), m32cm per la serie M16C/80, oppure M32C
per la serie M32C/80.

-msim
Specifica che il programma verrà eseguito sul simulatore. Questo provoca un'alternativa
libreria runtime da collegare in cui supporta, ad esempio, file I/O. Non devi
utilizzare questa opzione durante la generazione di programmi che verranno eseguiti su hardware reale; devi
fornire la propria libreria di runtime per qualsiasi funzione di I/O necessaria.

-memreg=numero
Specifica il numero di pseudo-registri basati sulla memoria che GCC utilizzerà durante il codice
generazione. Questi pseudo-registri verranno utilizzati come veri e propri registri, quindi c'è un
compromesso tra la capacità di GCC di adattare il codice ai registri disponibili e il
penalizzazione delle prestazioni nell'uso della memoria invece dei registri. Nota che tutti i moduli in a
programma deve essere compilato con lo stesso valore per questa opzione. Per questo, tu
non deve usare questa opzione con le librerie di runtime predefinite build gcc.

M32R/D Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le architetture Renesas M32R/D:

-m32r2
Genera codice per M32R/2.

-m32rx
Genera codice per M32R/X.

-m32r
Genera codice per M32R. Questa è l'impostazione predefinita.

-mmodel=piccolo
Supponiamo che tutti gli oggetti vivano nei 16 MB inferiori di memoria (in modo che i loro indirizzi possano essere
caricato con l'istruzione "ld24") e supponiamo che tutte le subroutine siano raggiungibili con l'istruzione
istruzione "bl". Questa è l'impostazione predefinita.

L'indirizzabilità di un particolare oggetto può essere impostata con l'attributo "model".

-mmodel=medio
Supponiamo che gli oggetti possano trovarsi ovunque nello spazio degli indirizzi a 32 bit (il compilatore genererà
istruzioni "seth/add3" per caricare i loro indirizzi) e presupporre che tutte le subroutine siano
raggiungibile con l'istruzione "bl".

-mmodel=grande
Supponiamo che gli oggetti possano trovarsi ovunque nello spazio degli indirizzi a 32 bit (il compilatore genererà
istruzioni "seth/add3" per caricare i loro indirizzi) e supporre che le subroutine potrebbero non essere
raggiungibile con l'istruzione "bl" (il compilatore genererà il file molto più lento
sequenza di istruzioni "seth/add3/jl").

-msdata=nessuno
Disabilitare l'uso dell'area dati piccola. Le variabili verranno messe in una di .data, bss, o
.rodata (a meno che non sia stato specificato l'attributo "sezione"). Questa è l'impostazione predefinita.

La piccola area dati è composta da sezioni .sdata ed .sss. Gli oggetti possono essere esplicitamente
inserire nella piccola area dati con l'attributo "section" utilizzando una di queste sezioni.

-msdata=datis
Metti piccoli dati globali e statici nell'area dati piccola, ma non generare speciali
codice per referenziarli.

-msdata=usa
Metti piccoli dati globali e statici nell'area dati piccola e genera speciali
istruzioni per farvi riferimento.

-G num
Metti oggetti globali e statici minori o uguali a num byte nei piccoli dati o
sezioni bss invece delle normali sezioni dati o bss. Il valore predefinito di num is
8. il -msdata l'opzione deve essere impostata su uno di dati or uso per questa opzione di avere qualsiasi
effetto.

Tutti i moduli dovrebbero essere compilati con lo stesso -G num valore. Compilando con diversi
valori di num può o non può funzionare; se non lo fa il linker darà un errore
messaggio --- il codice errato non verrà generato.

-mdebug
Fa in modo che il codice specifico dell'M32R nel compilatore mostri alcune statistiche che potrebbero aiutare
nei programmi di debug.

-maligno-loop
Allinea tutti i loop a un limite di 32 byte.

-mno-align-loop
Non imporre un allineamento a 32 byte per i loop. Questa è l'impostazione predefinita.

-tasso di emissione=numero
Problema numero istruzioni per ciclo. numero può essere solo 1 o 2.

-mbranch-costo=numero
numero può essere solo 1 o 2. Se è 1, i rami saranno preferiti a
codice condizionale, se è 2, verrà applicato il contrario.

-mflush-trappola=numero
Specifica il numero di trap da utilizzare per svuotare la cache. Il valore predefinito è 12. Valido
i numeri sono compresi tra 0 e 15 inclusi.

-mno-trappola-incasso
Specifica che la cache non può essere svuotata utilizzando un trap.

-mflush-funzione=Nome
Specifica il nome della funzione del sistema operativo da chiamare per svuotare la cache. Il
l'impostazione predefinita è _svuota_cache, ma una chiamata di funzione verrà utilizzata solo se una trap non lo è
a disposizione.

-mno-flush-funzione
Indica che non è disponibile alcuna funzione del sistema operativo per lo svuotamento della cache.

M680x0 Opzioni

Questi sono la -m opzioni definite per i processori M680x0 e ColdFire. Le impostazioni predefinite
dipendono da quale architettura è stata selezionata durante la configurazione del compilatore; le impostazioni predefinite
per le scelte più comuni sono riportate di seguito.

-marzo=arco
Genera codice per un'architettura specifica del set di istruzioni M680x0 o ColdFire.
Valori ammessi di arco per le architetture M680x0 sono: 68000, 68010, 68020, 68030,
68040, 68060 ed cpu32. Le architetture ColdFire sono selezionate secondo i criteri di Freescale
La classificazione ISA e i valori ammissibili sono: isaa, isaaplus, isab ed Isaac.

gcc definisce una macro __mcfarco__ ogni volta che genera codice per un target ColdFire.
I arco in questa macro è uno dei -marzo argomentazioni sopra riportate.

Se usati insieme, -marzo ed -mtune seleziona il codice che gira su una famiglia di simili
processori ma che è ottimizzato per una particolare microarchitettura.

-mcpu=cpu
Genera codice per un processore M680x0 o ColdFire specifico. L'M680x0 cpusono:
68000, 68010, 68020, 68030, 68040, 68060, 68302, 68332 ed cpu32. Il ColdFire cpus
sono dati dalla tabella sottostante, che classifica anche le CPU in famiglie:

Famiglia : -mcpu argomenti
51 : 51 51ac 51cn 51em 51 qe
5206 : 5202 5204 5206
5206e : 5206e
5208 : 5207 5208
5211a : 5210a 5211a
5213 : 5211 5212 5213
5216 : 5214 5216
52235 : 52230 52231 52232 52233 52234 52235
5225 : 5224 5225
52259 : 52252 52254 52255 52256 52258 52259
5235 : 5232 5233 5234 5235 523x
5249 : 5249
5250 : 5250
5271 : 5270 5271
5272 : 5272
5275 : 5274 5275
5282 : 5280 5281 5282 528x
53017 : 53011 53012 53013 53014 53015 53016 53017
5307 : 5307
5329 : 5327 5328 5329 532x
5373 : 5372 5373 537x
5407 : 5407
5475 : 5470 5471 5472 5473 5474 5475 547x 5480 5481 5482 5483 5484 5485

-mcpu=cpu sostituisce -marzo=arco if arco è compatibile con cpu. Altre combinazioni di
-mcpu ed -marzo sono rifiutati.

gcc definisce la macro __mcf_cpu_cpu quando target ColdFire cpu è selezionato. È anche
definisce __mcf_famiglia_famiglia, dove il valore di famiglia è data dalla tabella sopra.

-mtune=sintonizzare
Sintonizzare il codice per una particolare microarchitettura, entro i vincoli fissati da -marzo
ed -mcpu. Le microarchitetture M680x0 sono: 68000, 68010, 68020, 68030, 68040,
68060 ed cpu32. Le microarchitetture ColdFire sono: cfv1, cfv2, cfv3, cfv4 ed
cfv4e.

È inoltre possibile utilizzare -mtune=68020-40 per il codice che deve funzionare relativamente bene su 68020,
68030 e 68040 obiettivi. -mtune=68020-60 è simile ma include 68060 obiettivi come
bene. Queste due opzioni selezionano le stesse decisioni di sintonizzazione di -m68020-40 ed -m68020-60
rispettivamente.

gcc definisce le macro __mcarco ed __mcarco__ durante l'ottimizzazione per l'architettura 680x0
arco. Definisce anche mcarco a meno che neanche -ansi o un non GNU -std viene utilizzata l'opzione.
Se gcc sta sintonizzando per una gamma di architetture, come selezionato da -mtune=68020-40 or
-mtune=68020-60, definisce le macro per ogni architettura della gamma.

gcc definisce anche la macro __Mpresto__ durante la messa a punto per la microarchitettura ColdFire
presto, Dove presto è uno degli argomenti sopra citati.

-M68000
-mc68000
Genera output per un 68000. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68000. È equivalente a -marzo=68000.

Utilizzare questa opzione per i microcontrollori con un core 68000 o EC000, incluso il 68008,
68302, 68306, 68307, 68322, 68328 e 68356.

-M68010
Genera output per un 68010. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68010. È equivalente a -marzo=68010.

-M68020
-mc68020
Genera output per un 68020. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68020. È equivalente a -marzo=68020.

-M68030
Genera output per un 68030. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68030. È equivalente a -marzo=68030.

-M68040
Genera output per un 68040. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68040. È equivalente a -marzo=68040.

Questa opzione inibisce l'uso delle istruzioni 68881/68882 che devono essere emulate da
software sul 68040. Utilizzare questa opzione se il 68040 non ha codice da emulare
quelle istruzioni.

-M68060
Genera output per un 68060. Questa è l'impostazione predefinita quando il compilatore è configurato per
sistemi basati su 68060. È equivalente a -marzo=68060.

Questa opzione inibisce l'uso delle istruzioni 68020 e 68881/68882 che devono essere
emulato dal software sul 68060. Usa questa opzione se il tuo 68060 non ha codice
per emulare quelle istruzioni.

-mcpu32
Genera output per una CPU32. Questa è l'impostazione predefinita quando il compilatore è configurato per
Sistemi basati su CPU32. È equivalente a -marzo=cpu32.

Utilizzare questa opzione per i microcontrollori con un core CPU32 o CPU32+, incluso il 68330,
68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 e 68360.

-M5200
Genera output per una CPU ColdFire 520X. Questa è l'impostazione predefinita quando il compilatore è
configurato per sistemi basati su 520X. È equivalente a -MCPU = 5206, ed è adesso
deprecato a favore di tale opzione.

Utilizzare questa opzione per microcontrollori con un core 5200, inclusi MCF5202, MCF5203,
MCF5204 e MCF5206.

-m5206e
Genera output per una CPU ColdFire 5206e. L'opzione è ora deprecata a favore di
l'equivalente -mcpu=5206e.

-m528x
Genera output per un membro della famiglia ColdFire 528X. L'opzione è ora
deprecato a favore dell'equivalente -mcpu=528x.

-M5307
Genera output per una CPU ColdFire 5307. L'opzione è ora deprecata a favore del
equivalente -MCPU = 5307.

-M5407
Genera output per una CPU ColdFire 5407. L'opzione è ora deprecata a favore del
equivalente -MCPU = 5407.

-mcfv4e
Genera output per una CPU della famiglia ColdFire V4e (es. 547x/548x). Ciò include l'uso di
istruzioni hardware in virgola mobile. L'opzione è equivalente a -mcpu=547x, ed è
ora deprecato a favore di tale opzione.

-m68020-40
Genera l'output per un 68040, senza utilizzare nessuna delle nuove istruzioni. Questo risulta
in codice che può essere eseguito in modo relativamente efficiente su un 68020/68881 o un 68030 o a
68040. Il codice generato utilizza le istruzioni 68881 emulate sul
68040

L'opzione è equivalente a -marzo=68020 -mtune=68020-40.

-m68020-60
Genera l'output per un 68060, senza utilizzare nessuna delle nuove istruzioni. Questo risulta
in codice che può essere eseguito in modo relativamente efficiente su un 68020/68881 o un 68030 o a
68040. Il codice generato utilizza le istruzioni 68881 emulate sul
68060

L'opzione è equivalente a -marzo=68020 -mtune=68020-60.

-mhard-flottante
-M68881
Genera istruzioni in virgola mobile. Questa è l'impostazione predefinita per 68020 e versioni successive e
per i dispositivi ColdFire dotati di FPU. Definisce la macro __HAVE_68881__ su M680x0
obiettivi e __mcffpu__ su obiettivi ColdFire.

-msoft-flottante
Non generare istruzioni in virgola mobile; utilizzare invece le chiamate di libreria. Questo è il
predefinito per le destinazioni 68000, 68010 e 68832. È anche l'impostazione predefinita per ColdFire
dispositivi privi di FPU.

-div
-mno-div
Generare (non generare) istruzioni per la divisione e il resto dell'hardware ColdFire. Se
-marzo viene utilizzato senza -mcpu, l'impostazione predefinita è "on" per le architetture ColdFire e "off"
per architetture M680x0. Altrimenti, il valore predefinito viene preso dalla CPU di destinazione (o
la CPU predefinita, o quella specificata da -mcpu). Ad esempio, l'impostazione predefinita è "disattivato"
per -MCPU = 5206 e "acceso" per -mcpu=5206e.

gcc definisce la macro __mcfhwdiv__ quando questa opzione è abilitata.

-mbreve
Considera il tipo "int" largo 16 bit, come "short int". Inoltre, i parametri
passati sullo stack sono anche allineati a un limite di 16 bit anche su obiettivi la cui API
impone la promozione a 32 bit.

-mno-corto
Non considerare il tipo "int" largo 16 bit. Questa è l'impostazione predefinita.

-mnobitfield
-mno-campo di bit
Non utilizzare le istruzioni del campo di bit. Il -M68000, -mcpu32 ed -M5200 le opzioni implicano
-mnobitfield.

-mbitfield
Usa le istruzioni del campo di bit. Il -M68020 opzione implica -mbitfield. Questo è
l'impostazione predefinita se si utilizza una configurazione progettata per un 68020.

-mrtd
Utilizzare una convenzione di chiamata di funzione diversa, in cui le funzioni che accettano un valore fisso
numero di argomenti restituiti con l'istruzione "rtd", che fa apparire i loro argomenti
durante il ritorno. Ciò consente di risparmiare un'istruzione nel chiamante poiché non è necessario
pop gli argomenti lì.

Questa convenzione di chiamata è incompatibile con quella normalmente utilizzata su Unix, quindi
non può usarlo se devi chiamare librerie compilate con il compilatore Unix.

Inoltre, è necessario fornire prototipi di funzioni per tutte le funzioni che accettano variabili
numero di argomenti (incluso "printf"); altrimenti verrà generato un codice errato
per le chiamate a tali funzioni.

Inoltre, risulterà un codice gravemente errato se si chiama una funzione con troppi
argomenti. (Normalmente, gli argomenti aggiuntivi vengono ignorati in modo innocuo.)

L'istruzione "rtd" è supportata da 68010, 68020, 68030, 68040, 68060 e CPU32
processori, ma non dal 68000 o dal 5200.

-mno-rtd
Non utilizzare le convenzioni di chiamata selezionate da -mrtd. Questa è l'impostazione predefinita.

-maligno-int
-mno-align-int
Controlla se GCC allinea "int", "long", "long long", "float", "double" e "long
double" variabili su un limite a 32 bit (-maligno-int) o un limite a 16 bit
(-mno-align-int). L'allineamento delle variabili su limiti a 32 bit produce codice che viene eseguito
un po' più veloce sui processori con bus a 32 bit a scapito di più memoria.

Attenzione: se usi l'estensione -maligno-int switch, GCC allineerà le strutture che contengono il
sopra i tipi in modo diverso rispetto alla maggior parte dell'interfaccia binaria dell'applicazione pubblicata
specifiche per l'm68k.

-mpcrel
Usa direttamente la modalità di indirizzamento relativo al PC del 68000, invece di usare un globale
tabella di compensazione. Al momento, questa opzione implica -fpic, consentendo al massimo un offset di 16 bit
per l'indirizzamento relativo al PC. -fPIC non è attualmente supportato con -mpcrel, sebbene
questo potrebbe essere supportato per processori 68020 e superiori.

-mno-strict-align
-mstrict-align
Non (fare) presumere che i riferimenti di memoria non allineati verranno gestiti dal sistema.

-msep-dati
Genera codice che consente di posizionare il segmento di dati in un'area di memoria diversa
dal segmento di testo. Ciò consente di eseguire sul posto in un ambiente senza
gestione della memoria virtuale. Questa opzione implica -fPIC.

-mno-set-data
Genera codice che presuppone che il segmento di dati segua il segmento di testo. Questo è
il predefinito.

-mid-libreria-condivisa
Genera codice che supporti le librerie condivise tramite il metodo dell'ID libreria. Questo permette
per eseguire librerie sul posto e condivise in un ambiente senza memoria virtuale
gestione. Questa opzione implica -fPIC.

-mno-id-libreria-condivisa
Genera codice che non presuppone l'utilizzo di librerie condivise basate su ID. Questo è
il predefinito.

-m-id-libreria-condivisa=n
Specificato il numero di identificazione della libreria condivisa basata su ID in fase di compilazione.
Specificare un valore 0 genererà un codice più compatto, specificare altri valori lo farà
forzare l'assegnazione di quel numero alla libreria corrente ma non c'è più spazio oppure
tempo efficiente rispetto all'omissione di questa opzione.

-Mxgot
-mno-xgot
Quando si genera codice indipendente dalla posizione per ColdFire, generare codice che funzioni se
il GOT ha più di 8192 voci. Questo codice è più grande e più lento del codice
generato senza questa opzione. Sui processori M680x0, questa opzione non è necessaria; -fPIC
basta.

GCC normalmente usa una singola istruzione per caricare i valori dal GOT. Mentre questo è
relativamente efficiente, funziona solo se il GOT è inferiore a circa 64k. Nulla
più grande fa sì che il linker riporti un errore come:

trasferimento troncato per adattarsi: R_68K_GOT16O foobar

Se ciò accade, dovresti ricompilare il tuo codice con -Mxgot. Dovrebbe quindi funzionare con
GOT molto grandi. Tuttavia, codice generato con -Mxgot è meno efficiente, poiché
richiede 4 istruzioni per recuperare il valore di un simbolo globale.

Nota che alcuni linker, incluse le versioni più recenti del linker GNU, possono creare
più GOT e ordina le voci GOT. Se hai un linker del genere, dovresti solo aver bisogno
usare -Mxgot quando si compila un singolo file oggetto che accede a più di 8192 GOT
inserimenti. Pochissimi lo fanno.

Queste opzioni non hanno effetto a meno che GCC non generi codice indipendente dalla posizione.

MCore Opzioni

Questi sono la -m opzioni definite per i processori Motorola M*Core.

-illuminato
-mno-illuminato
Costanti in linea nel flusso di codice se può essere eseguito in due istruzioni o meno.

-div
-mno-div
Usa l'istruzione di divisione. (Abilitato per impostazione predefinita).

-mrelax-immediato
-mno-relax-immediato
Consenti immediati di dimensioni arbitrarie nelle operazioni sui bit.

-mwide-bitfield
-mno-bitfields
Tratta sempre i campi di bit come interi.

-m4byte-funzioni
-mno-4byte-funzioni
Forza l'allineamento di tutte le funzioni a un limite di 4 byte.

-mcallgraph-dati
-mno-callgraph-dati
Emetti informazioni callgraph.

-mslow-byte
-mno-lento-byte
Preferisci l'accesso alla parola durante la lettura di quantità di byte.

-mittle-endian
-big endian
Genera codice per un target little-endian.

-M210
-M340
Genera codice per il processore 210.

-mno-lsim
Supponiamo che sia stato fornito il supporto per il runtime e quindi ometti la libreria del simulatore
(libsim.a) dalla riga di comando del linker.

-mstack-incremento=Taglia
Imposta l'importo massimo per una singola operazione di incremento dello stack. Grandi valori possono
aumentare la velocità dei programmi che contengono funzioni che richiedono una grande quantità di
spazio dello stack, ma possono anche attivare un errore di segmentazione se lo stack è esteso
troppo. Il valore predefinito è 0x1000.

MeP Opzioni

-mabsdiff
Abilita l'istruzione "abs", che è la differenza assoluta tra due registri.

-centro commerciale
Abilita tutte le istruzioni opzionali: media, moltiplicazione, divisione, operazioni sui bit,
zero iniziale, differenza assoluta, min/max, clip e saturazione.

-la media
Abilita l'istruzione "ave", che calcola la media di due registri.

-mbasato=n
Variabili di dimensione n byte o meno verranno inseriti nella sezione ".based" da
predefinito. Le variabili basate usano il registro $tp come registro di base e c'è un
Limite di 128 byte alla sezione ".based".

-mbitop
Abilita le istruzioni per il funzionamento dei bit: bit test ("btstm"), set ("bsetm"), clear
("bclrm"), invert ("bnotm") e test-and-set ("tas").

-mc=Nome
Seleziona in quale sezione verranno inseriti i dati costanti. Nome può essere "piccolo", "vicino", o
"lontano".

-mclip
Abilita l'istruzione "clip". Nota che "-mclip" non è utile a meno che anche tu
fornire "-mminmax".

-mconfig=Nome
Seleziona una delle configurazioni principali integrate. Ogni chip MeP ne ha uno o più
moduli in esso; ogni modulo ha una CPU principale e una varietà di coprocessori, opzionali
istruzioni e periferiche. Lo strumento "MeP-Integrator", che non fa parte di GCC, fornisce
queste configurazioni tramite questa opzione; l'utilizzo di questa opzione equivale all'utilizzo di all
le corrispondenti opzioni della riga di comando. La configurazione predefinita è "predefinita".

-mcp
Abilita le istruzioni del coprocessore. Per impostazione predefinita, questo è un coprocessore a 32 bit. Nota
che il coprocessore è normalmente abilitato tramite l'opzione "-mconfig=".

-mcop32
Abilita le istruzioni del coprocessore a 32 bit.

-mcop64
Abilita le istruzioni del coprocessore a 64 bit.

-mivc2
Abilita la pianificazione IVC2. IVC2 è un coprocessore VLIW a 64 bit.

-mcc
Fa sì che le variabili costanti vengano posizionate nella sezione ".near".

-div
Abilita le istruzioni "div" e "divu".

-meb
Genera codice big-endian.

-mel
Genera codice little-endian.

-mio-volatile
Dice al compilatore che qualsiasi variabile contrassegnata con l'attributo "io" deve essere
considerato volatile.

-ml Fa sì che le variabili vengano assegnate alla sezione ".far" per impostazione predefinita.

-mleadz
Abilita l'istruzione "leadz" (zero iniziale).

-mm Fa in modo che le variabili vengano assegnate alla sezione ".near" per impostazione predefinita.

-minmax
Abilita le istruzioni "min" e "max".

-multiplo
Abilita la moltiplicazione e le istruzioni di moltiplicazione-accumula.

-mno-opt
Disabilita tutte le istruzioni opzionali abilitate da "-mall-opts".

-ripetere
Abilita le istruzioni "repeat" e "repeat", utilizzate per il looping low-overhead.

-SM Fa sì che tutte le variabili vengano impostate per impostazione predefinita sulla sezione ".tiny". Nota che c'è un
Limite di 65536 byte per questa sezione. Gli accessi a queste variabili usano la base %gp
registro.

-msatur
Abilita le istruzioni di saturazione. Nota che il compilatore attualmente non lo fa
generarli da soli, ma questa opzione è inclusa per compatibilità con altri strumenti,
come "come".

-msdram
Collega il runtime basato su SDRAM invece del runtime predefinito basato su ROM.

-msim
Collega le librerie di runtime del simulatore.

-msimnovec
Collega le librerie runtime del simulatore, escludendo il supporto integrato per il ripristino e
vettori e tabelle di eccezione.

-mtf
Fa sì che tutte le funzioni vengano impostate per impostazione predefinita sulla sezione ".far". Senza questa opzione, le funzioni
l'impostazione predefinita è la sezione ".near".

-minuscolo=n
Variabili che sono n byte o meno verranno assegnati alla sezione ".tiny". Queste
le variabili usano il registro di base $gp. Il valore predefinito per questa opzione è 4, ma tieni presente che
c'è un limite di 65536 byte alla sezione ".tiny".

Microfiamma Opzioni

-msoft-flottante
Usa l'emulazione software per la virgola mobile (impostazione predefinita).

-mhard-flottante
Utilizzare le istruzioni hardware in virgola mobile.

-Mmmpy
Non ottimizzare i movimenti dei blocchi, usa "memcpy".

-mno-clearbss
Questa opzione è deprecata. Utilizzo -fno-zero-inizializzato-in-bss anziché.

-mcpu=tipo di CPU
Utilizzare le funzionalità e programmare il codice per una determinata CPU. I valori supportati sono nel formato
vX.YY.Z, Dove X è una versione principale, YY è la versione minore, e Z è la compatibilità
codice. I valori di esempio sono v3.00.a, v4.00.b, v5.00.a, v5.00.b, v5.00.b, v6.00.a.

-mxl-morbido-mul
Usa l'emulazione di moltiplicazione software (impostazione predefinita).

-mxl-soft-div
Usa l'emulazione software per le divisioni (impostazione predefinita).

-mxl-barile-shift
Usa il cambio a barilotto hardware.

-mxl-pattern-confronta
Usa le istruzioni per il confronto dei modelli.

-msmall-divide
Utilizzare l'ottimizzazione della ricerca nella tabella per le divisioni intere con segno piccole.

-mxl-stack-check
Questa opzione è deprecata. Usa invece -fstack-check.

-mxl-gp-opz
Utilizzare le sezioni sdata/sbss relative a GP.

-mxl-moltiplica-alto
Utilizzare le istruzioni di moltiplicazione alta per la parte alta della moltiplicazione 32x32.

-mxl-float-convert
Utilizzare le istruzioni di conversione hardware in virgola mobile.

-mxl-float-sqrt
Utilizzare l'istruzione radice quadrata hardware in virgola mobile.

-modalità-mxl-modello di app
Seleziona il modello di applicazione modello di app. I modelli validi sono

eseguibile
eseguibile normale (predefinito), utilizza il codice di avvio crt0.o.

xmdstub
da utilizzare con il debug intrusivo del software basato su Xilinx Microprocessor Debugger (XMD)
agente chiamato xmdstub. Questo usa il file di avvio crt1.o e imposta l'indirizzo iniziale di
il programma deve essere 0x800.

bootstrap
per le applicazioni che vengono caricate utilizzando un bootloader. Questo modello utilizza il file di avvio
crt2.o che non contiene un gestore del vettore di ripristino del processore. Questo è adatto
per trasferire il controllo su un reset del processore al bootloader piuttosto che al
applicazione.

romanzieri
per applicazioni che non richiedono nessuno dei vettori MicroBlaze. Questa opzione
può essere utile per le applicazioni in esecuzione all'interno di un'applicazione di monitoraggio. Questo modello
usa crt3.o come file di avvio.

Opzione -modo-xl-modello di app è un alias deprecato per -modalità-mxl-modello di app.

MIPS Opzioni

-EB Genera codice big-endian.

-IL Genera codice little-endian. Questa è l'impostazione predefinita per mips*el-*-* configurazioni.

-marzo=arco
Genera codice che verrà eseguito su arco, che può essere il nome di un generico MIPS ISA, oppure
il nome di un particolare processore. I nomi ISA sono: mips1, mips2, mips3, mips4,
mips32, mips32r2, mips64 ed mips64r2. I nomi dei processori sono: 4kc, 4km, 4kp, 4ksc,
4kec, 4kem, 4conservo, 4ksd, 5kc, 5 kf, 20kc, 24kc, 24kf2_1, 24kf1_1, 24kec, 24kef2_1,
24kef1_1, 34kc, 34kf2_1, 34kf1_1, 74kc, 74kf2_1, 74kf1_1, 74kf3_2, 1004kc, 1004kf2_1,
1004kf1_1, longson2e, longson2f, longson3a, m4k, otteo, ottoone+, otteo2, Orion,
r2000, r3000, r3900, r4000, r4400, r4600, r4650, r6000, r8000, rm7000, rm9000, r10000,
r12000, r14000, r16000, sb1, sr71000, vr4100, vr4111, vr4120, vr4130, vr4300, vr5000,
vr5400, vr5500 ed xlr. Il valore speciale da-abi seleziona il più compatibile
architettura per l'ABI selezionato (ovvero, mips1 per ABI a 32 bit e mips3 per 64 bit
ABI).

Anche le toolchain native Linux/GNU e IRIX supportano il valore nativo, che seleziona il
migliore opzione di architettura per il processore host. -marzo=nativo non ha effetto se GCC
non riconosce il processore.

Nei nomi dei processori, un finale 000 può essere abbreviato come k (per esempio, -marzo=r2k).
I prefissi sono facoltativi e vr può essere scritto r.

Nomi del modulo nf2_1 fare riferimento a processori con FPU con clock a metà della velocità del
nucleo, nomi della forma nf1_1 fare riferimento a processori con FPU con clock alla stessa velocità
come nucleo, e nomi della forma nf3_2 fare riferimento a processori con FPU con un rapporto di clock
di 3:2 rispetto al nucleo. Per motivi di compatibilità, nf è accettato come a
sinonimo di nf2_1 while nx ed bfx sono accettati come sinonimi di nf1_1.

GCC definisce due macro in base al valore di questa opzione. Il primo è _MIPS_ARCH,
che dà il nome dell'architettura di destinazione, come una stringa. Il secondo ha la forma
_MIPS_ARCH_foo, Dove foo è il valore capitalizzato di _MIPS_ARCH. Per esempio,
-marzo=r2000 sarà impostato _MIPS_ARCH a "R2000" e definire la macro _MIPS_ARCH_R2000.

Notare quello _MIPS_ARCH macro utilizza i nomi dei processori indicati sopra. In altre parole,
avrà il prefisso completo e non sarà abbreviato 000 as k. In caso di a partire dal-
abi, la macro nomina l'architettura risolta (o "mips1" or "mips3"). Si nomina
l'architettura predefinita quando no -marzo l'opzione è data.

-mtune=arco
Ottimizza per arco. Tra le altre cose, questa opzione controlla il modo in cui sono le istruzioni
programmato e il costo percepito delle operazioni aritmetiche. L'elenco di arco valori
è lo stesso di -marzo.

Quando questa opzione non viene utilizzata, GCC ottimizzerà per il processore specificato da -marzo.
Utilizzando -marzo ed -mtune insieme, è possibile generare codice che verrà eseguito su
una famiglia di processori, ma ottimizza il codice per un membro particolare di quello
famiglia.

-mtune definisce le macro _MIPS_TUNE ed _MIPS_TUNE_foo, che funzionano allo stesso modo di
, il -marzo quelli sopra descritti.

-mips1
Equivalente a -marzo=mips1.

-mips2
Equivalente a -marzo=mips2.

-mips3
Equivalente a -marzo=mips3.

-mips4
Equivalente a -marzo=mips4.

-mips32
Equivalente a -marzo=mips32.

-mips32r2
Equivalente a -marzo=mips32r2.

-mips64
Equivalente a -marzo=mips64.

-mips64r2
Equivalente a -marzo=mips64r2.

-mips16
-mno-mips16
Genera (non generare) codice MIPS16. Se GCC sta prendendo di mira un MIPS32 o MIPS64
architettura, utilizzerà l'ASE MIPS16e.

La generazione del codice MIPS16 può anche essere controllata in base alla funzione mediante
Attributi "mips16" e "nomips16".

-mflip-mips16
Genera codice MIPS16 su funzioni alternate. Questa opzione è fornita per la regressione
test di generazione di codice misto MIPS16/non MIPS16 e non è inteso per l'ordinario
utilizzare nella compilazione del codice utente.

-minterlink-mips16
-mno-interlink-mips16
Richiedere (non richiedere) che il codice non MIPS16 sia compatibile con il codice MIPS16.

Ad esempio, il codice non MIPS16 non può passare direttamente al codice MIPS16; deve usare a
chiamata o un salto indiretto. -minterlink-mips16 quindi disabilita i salti diretti a meno che
GCC sa che l'obiettivo del salto non è MIPS16.

-mabi=32
-mabi=o64
-mabi=n32
-mabi=64
-mabi=eabi
Genera codice per l'ABI specificato.

Si noti che l'EABI ha una variante a 32 bit e una a 64 bit. GCC normalmente genera 64 bit
codice quando si seleziona un'architettura a 64 bit, ma è possibile utilizzare -mgp32 per ottenere il codice a 32 bit
anziché.

Per informazioni sull'ABI O64, vederehttp://gcc.gnu.org/projects/mipso64-abi.html>.

GCC supporta una variante dell'ABI o32 in cui i registri a virgola mobile sono invece 64
di larghezza superiore a 32 bit. Puoi selezionare questa combinazione con -mabi=32 -mfp64. Questo ABI
si affida a mtc1 ed mfhc1 istruzioni ed è quindi supportato solo per
Processori MIPS32R2.

Le assegnazioni di registro per argomenti e valori restituiti rimangono le stesse, ma ciascuna
il valore scalare viene passato in un singolo registro a 64 bit anziché in una coppia di 32 bit
registri. Ad esempio, i valori scalari a virgola mobile vengono restituiti in $f0 solo, non un
$f0/$f1 coppia. Anche l'insieme dei registri salvati in chiamata rimane lo stesso, ma tutti a 64 bit
sono salvati.

-mabicalls
-mno-abicali
Generare (non generare) codice adatto per oggetti dinamici in stile SVR4.
-mabicalls è l'impostazione predefinita per i sistemi basati su SVR4.

-mcondiviso
-mno-condiviso
Generare (non generare) codice completamente indipendente dalla posizione e che può
quindi essere collegati in librerie condivise. Questa opzione ha effetto solo -mabicalls.

Tutti -mabicalls il codice è stato tradizionalmente indipendente dalla posizione, indipendentemente dalle opzioni
piace -fPIC ed -fpic. Tuttavia, come estensione, la toolchain GNU consente gli eseguibili
utilizzare accessi assoluti per simboli vincolanti localmente. Può anche usare GP più brevi
sequenze di inizializzazione e generare chiamate dirette a funzioni definite localmente. Questo
la modalità è selezionata da -mno-condiviso.

-mno-condiviso dipende da binutils 2.16 o superiore e genera oggetti che possono essere solo
collegato dal linker GNU. L'opzione non incide però sull'ABI della finale
eseguibile; interessa solo l'ABI degli oggetti rilocabili. Usando -mno-condiviso volere
generalmente rendono gli eseguibili sia più piccoli che più veloci.

-mcondiviso è l'impostazione predefinita.

-plt
-mno-plt
Supponiamo (non dare per scontato) che i linker statici e dinamici supportino i PLT e la copia
traslochi. Questa opzione ha effetto solo -mno-condiviso -mabicalls. Per l'ABI n64, questo
l'opzione non ha effetto senza -msim32.

È possibile effettuare -plt l'impostazione predefinita configurando GCC con --con-mips-plt. Il predefinito
is -mno-plt altrimenti.

-Mxgot
-mno-xgot
Sollevare (non sollevare) le solite restrizioni sulla dimensione della tabella di offset globale.

GCC normalmente usa una singola istruzione per caricare i valori dal GOT. Mentre questo è
relativamente efficiente, funzionerà solo se il GOT è inferiore a circa 64k.
Qualsiasi cosa più grande farà sì che il linker riporti un errore come:

trasferimento troncato per adattarsi: R_MIPS_GOT16 foobar

Se ciò accade, dovresti ricompilare il tuo codice con -Mxgot. Dovrebbe quindi funzionare con
GOT molto grandi, anche se sarà anche meno efficiente, poiché ne serviranno tre
istruzioni per recuperare il valore di un simbolo globale.

Nota che alcuni linker possono creare più GOT. Se hai un linker del genere,
dovrebbe solo aver bisogno di usare -Mxgot quando un singolo file oggetto accede a più di 64k
valore delle voci GOT. Pochissimi lo fanno.

Queste opzioni non hanno effetto a meno che GCC non generi codice indipendente dalla posizione.

-mgp32
Supponiamo che i registri generici siano larghi 32 bit.

-mgp64
Supponiamo che i registri generici siano larghi 64 bit.

-mfp32
Supponiamo che i registri a virgola mobile siano larghi 32 bit.

-mfp64
Supponiamo che i registri a virgola mobile siano larghi 64 bit.

-mhard-flottante
Utilizzare le istruzioni del coprocessore in virgola mobile.

-msoft-flottante
Non utilizzare istruzioni del coprocessore in virgola mobile. Implementa la virgola mobile
calcoli utilizzando invece le chiamate di libreria.

-msingle-flottante
Si supponga che il coprocessore a virgola mobile supporti solo operazioni a precisione singola.

-mdouble-flottante
Si supponga che il coprocessore a virgola mobile supporti le operazioni a precisione doppia. Questo
è l'impostazione predefinita.

-mlsc
-mno-llsc
Usa (non usare) ll, sce sync istruzioni per implementare la memoria atomica integrata
funzioni. Quando nessuna delle due opzioni è specificata, GCC utilizzerà le istruzioni se il
l'architettura di destinazione li supporta.

-mlsc è utile se l'ambiente di runtime può emulare le istruzioni e -mno-llsc
può essere utile quando si compila per ISA non standard. Puoi rendere entrambe le opzioni il
predefinito configurando GCC con --con-llsc ed --senza-llsc rispettivamente.
--con-llsc è l'impostazione predefinita per alcune configurazioni; vedere la documentazione di installazione
per i dettagli.

-mdsp
-mno-dsp
Utilizzare (non utilizzare) la revisione 1 di MIPS DSP ASE.
Questa opzione definisce la macro del preprocessore __mips_dsp. Definisce anche
__mips_dsp_rev a 1.

-mdspr2
-mno-dspr2
Utilizzare (non utilizzare) la revisione 2 di MIPS DSP ASE.
Questa opzione definisce le macro del preprocessore __mips_dsp ed __mips_dspr2. Inoltre
definisce __mips_dsp_rev a 2.

-msmartmips
-mno-smartmips
Utilizzare (non utilizzare) MIPS SmartMIPS ASE.

-single-deteriorato
-mno-singolo-accoppiato
Utilizzare (non utilizzare) istruzioni a virgola mobile accoppiate singole.
Questa opzione richiede l'abilitazione del supporto hardware in virgola mobile.

-mdmx
-mno-mdmx
Utilizzare (non utilizzare) le istruzioni MIPS Digital Media Extension. Questa opzione può essere solo
utilizzato durante la generazione di codice a 64 bit e richiede il supporto hardware in virgola mobile per essere
abilitato.

-mips3d
-mno-mips3d
Utilizzare (non utilizzare) MIPS-3D ASE. L'opzione -mips3d implica -single-deteriorato.

-mm
-mno-mt
Utilizzare (non utilizzare) le istruzioni MT Multithreading.

-mlungo64
Forza i tipi "lunghi" ad essere larghi 64 bit. Vedere -mlungo32 per una spiegazione del default
e il modo in cui viene determinata la dimensione del puntatore.

-mlungo32
Forza i tipi "long", "int" e puntatore a una larghezza di 32 bit.

La dimensione predefinita di "int", "long" e puntatori dipende dall'ABI. Tutti i
gli ABI supportati utilizzano "int" a 32 bit. L'ABI n64 utilizza "long" a 64 bit, così come il 64 bit
EABI; gli altri usano "long" a 32 bit. I puntatori hanno le stesse dimensioni dei "lunghi" o dei
stessa dimensione dei registri interi, qualunque sia il più piccolo.

-msim32
-mno-sim32
Supponiamo (non dare per scontato) che tutti i simboli abbiano valori a 32 bit, indipendentemente dal selezionato
ABI. Questa opzione è utile in combinazione con -mabi=64 ed -mno-abicali perché
consente a GCC di generare riferimenti più brevi e veloci a indirizzi simbolici.

-G num
Metti le definizioni dei dati visibili esternamente in una piccola sezione di dati se quei dati non sono
più grande di num byte. GCC può quindi accedere ai dati in modo più efficiente; vedere -mgpopt per
dettagli.

Il predefinito -G l'opzione dipende dalla configurazione.

-mlocal-sdata
-mno-local-sdata
Estendere (non estendere) il -G comportamento anche ai dati locali, ad esempio alle variabili statiche
in c. -mlocal-sdata è l'impostazione predefinita per tutte le configurazioni.

Se il linker si lamenta che un'applicazione sta usando troppi piccoli dati, potresti
voglio provare a ricostruire le parti meno critiche per le prestazioni con -mno-local-sdata. È
potrebbe anche voler creare grandi librerie con -mno-local-sdata, in modo che le biblioteche
lasciare più spazio per il programma principale.

-mextern-sdata
-mno-extern-sdata
Si supponga (non si presuma) che i dati definiti esternamente si trovino in una piccola sezione di dati se
che i dati sono all'interno del -G limite. -mextern-sdata è l'impostazione predefinita per tutti
configurazioni.

Se compili un modulo Modo con -mextern-sdata -G num -mgpopte Modo riferimenti a
variabile Var che non è più grande di num byte, devi assicurarti che Var è posto
in una piccola sezione di dati. Se Var è definito da un altro modulo, devi compilare
quel modulo con un abbastanza alto -G impostare o allegare un attributo "sezione" a Var's
definizione. Se Var è comune, è necessario collegare l'applicazione con un livello abbastanza alto -G
impostazione.

Il modo più semplice per soddisfare queste restrizioni è compilare e collegare ogni modulo
con la stessa -G opzione. Tuttavia, potresti voler creare una libreria che supporti
diversi piccoli limiti di dati. Puoi farlo compilando la libreria con
il più alto supportato -G impostazione e inoltre utilizzando -mno-extern-sdata per fermare il
libreria dal fare ipotesi su dati definiti esternamente.

-mgpopt
-mno-gpopt
Utilizzare (non utilizzare) gli accessi relativi al GP per i simboli che sono noti per essere in un piccolo dato
sezione; vedere -G, -mlocal-sdata ed -mextern-sdata. -mgpopt è l'impostazione predefinita per tutti
configurazioni.

-mno-gpopt è utile nei casi in cui il registro $gp potrebbe non contenere il valore di
"_gp". Ad esempio, se il codice fa parte di una libreria che potrebbe essere utilizzata in un avvio
monitor, i programmi che chiamano le routine del monitor di avvio passeranno un valore sconosciuto in $gp.
(In tali situazioni, il monitor di avvio stesso verrebbe solitamente compilato con -G0.)

-mno-gpopt implica -mno-local-sdata ed -mno-extern-sdata.

-dati-membri
-mno-dati-incorporati
Assegnare le variabili prima alla sezione dati di sola lettura se possibile, quindi successivamente nel
piccola sezione di dati se possibile, altrimenti nei dati. Questo dà un codice leggermente più lento
rispetto all'impostazione predefinita, ma riduce la quantità di RAM richiesta durante l'esecuzione e quindi potrebbe
essere preferito per alcuni sistemi embedded.

-muninit-const-in-rodata
-mno-uninit-const-in-rodata
Inserisci le variabili "const" non inizializzate nella sezione dati di sola lettura. Questa opzione è
significativo solo in combinazione con -dati-membri.

-mcode-leggibile=regolazione
Specifica se GCC può generare codice che legge da sezioni eseguibili. Ci sono
tre possibili impostazioni:

-mcode-readable=sì
Le istruzioni possono accedere liberamente alle sezioni eseguibili. Questa è l'impostazione predefinita.

-mcode-leggibile=pcrel
Le istruzioni di caricamento relative al PC MIPS16 possono accedere alle sezioni eseguibili, ma altro
le istruzioni non devono farlo. Questa opzione è utile sui processori 4KSc e 4KSd
quando i TLB di codice hanno impostato il bit di inibizione della lettura. È utile anche sui processori
che può essere configurato per avere una doppia interfaccia SRAM istruzione/dati e che,
come l'M4K, reindirizza automaticamente i carichi relativi al PC alla RAM delle istruzioni.

-mcode-leggibile=n
Le istruzioni non devono accedere alle sezioni eseguibili. Questa opzione può essere utile su
target che sono configurati per avere una doppia interfaccia SRAM istruzione/dati ma
che (a differenza dell'M4K) non reindirizza automaticamente i carichi relativi al PC al
RAM di istruzioni.

-msplit-indirizzi
-mno-split-indirizzi
Abilita (disabilita) l'uso degli operatori di rilocazione assembler "%hi()" e "%lo()". Questo
l'opzione è stata sostituita da -Mexplicit-relocs ma viene trattenuto all'indietro
la compatibilità.

-Mexplicit-relocs
-mno-reloc-esplicito
Utilizzare (non utilizzare) operatori di rilocazione assembler quando si tratta di indirizzi simbolici.
L'alternativa, selezionata da -mno-reloc-esplicito, è invece di usare le macro assembler.

-Mexplicit-relocs è l'impostazione predefinita se GCC è stato configurato per utilizzare un assembler che
supporta gli operatori di trasloco.

-mcheck-divisione-zero
-mno-check-zero-divisione
Intrappolare (non intrappolare) su una divisione intera per zero.

L'impostazione predefinita è -mcheck-divisione-zero.

-mdivide-trappole
-mdivide-interruzioni
I sistemi MIPS controllano la divisione per zero generando una trappola condizionale o a
istruzione di pausa. L'uso di trap produce un codice più piccolo, ma è supportato solo su MIPS
II e successivi. Inoltre, alcune versioni del kernel Linux hanno un bug che impedisce trap
dalla generazione del segnale appropriato ("SIGFPE"). Utilizzo -mdivide-trappole permettere il condizionale
trappole sulle architetture che le supportano e -mdivide-interruzioni forzare l'uso di
pause.

L'impostazione predefinita è di solito -mdivide-trappole, ma questo può essere sovrascritto al momento della configurazione
utilizzando --with-divide=interruzioni. I controlli di divisione per zero possono essere completamente disabilitati utilizzando
-mno-check-zero-divisione.

-Mmmpy
-mno-memcpy
Forza (non forzare) l'uso di "memcpy()" per movimenti di blocco non banali. Il predefinito
is -mno-memcpy, che consente a GCC di incorporare la maggior parte delle copie di dimensioni costanti.

-mlong-chiamate
-mno-chiamate lunghe
Disabilitare (non disabilitare) l'uso dell'istruzione "jal". Chiamare le funzioni usando "jal"
è più efficiente ma richiede che il chiamante e il chiamato si trovino nello stesso 256 megabyte
segmento.

Questa opzione non ha effetto sul codice abicalls. L'impostazione predefinita è -mno-chiamate lunghe.

-mamma
-mno-pazzo
Abilitare (disabilitare) l'uso delle istruzioni "mad", "madu" e "mul", come previsto dal
R4650 IS.

-mfuso-pazzo
-mno-fuso-madd
Abilitare (disabilitare) l'uso delle istruzioni di moltiplicazione-accumulazione in virgola mobile, quando esse
sono disponibili. L'impostazione predefinita è -mfuso-pazzo.

Quando si utilizzano istruzioni di accumulo multiplo, viene calcolato il prodotto intermedio
con precisione infinita e non è soggetto al bit FCSR Flush to Zero. Può essere
indesiderabile in alcune circostanze.

-nocpp
Dire all'assemblatore MIPS di non eseguire il suo preprocessore sui file assembler utente (con a
.s suffisso) durante il montaggio.

-mfix-24k
-mno-fix-24k
Risolvere l'errata 24K E48 (dati persi sui negozi durante la ricarica). Le soluzioni alternative
sono implementati dall'assemblatore piuttosto che da GCC.

-mfix-r4000
-mno-fix-r4000
Risolvere alcuni errata della CPU R4000:

- Una doppia parola o uno spostamento variabile può dare un risultato errato se eseguito
subito dopo aver iniziato una divisione intera.

- Una doppia parola o uno spostamento variabile può dare un risultato errato se eseguito mentre
è in corso una moltiplicazione intera.

- Una divisione intera può dare un risultato errato se iniziata in uno slot di ritardo di a
preso ramo o un salto.

-mfix-r4400
-mno-fix-r4400
Risolvere alcuni errata della CPU R4400:

- Una doppia parola o uno spostamento variabile può dare un risultato errato se eseguito
subito dopo aver iniziato una divisione intera.

-mfix-r10000
-mno-fix-r10000
Risolvi alcuni errata R10000:

- Le sequenze "ll"/"sc" potrebbero non comportarsi in modo atomico su revisioni precedenti alla 3.0. potrebbero
deadlock sulle revisioni 2.6 e precedenti.

Questa opzione può essere utilizzata solo se l'architettura di destinazione supporta branch-probabilmente
istruzioni. -mfix-r10000 è l'impostazione predefinita quando -marzo=r10000 si usa; -mno-fix-r10000
è l'impostazione predefinita altrimenti.

-mfix-vr4120
-mno-fix-vr4120
Risolvere alcuni errata VR4120:

- "dmultu" non sempre produce il risultato corretto.

- "div" e "ddiv" non producono sempre il risultato corretto se uno degli operandi
è negativo.

Le soluzioni alternative per gli errata di divisione si basano su funzioni speciali in libgcc.a. A
presente, queste funzioni sono fornite solo dalle configurazioni "mips64vr*-elf".

Altre errata VR4120 richiedono l'inserimento di un nop tra determinate coppie di
Istruzioni. Questi errata sono gestiti dall'assemblatore, non dallo stesso GCC.

-mfix-vr4130
Risolvere l'errata "mflo"/"mfhi" del VR4130. Le soluzioni alternative sono implementate dal
assembler piuttosto che da GCC, anche se GCC eviterà di usare "mflo" e "mfhi" se il
Sono invece disponibili le istruzioni VR4130 "macc", "macchi", "dmacc" e "dmacchi".

-mfix-sb1
-mno-correzione-sb1
Risolvere alcuni errata del core della CPU SB-1. (Questo flag attualmente funziona intorno all'SB-1
revisione 2 Errata in virgola mobile "F1" e "F2".)

-mr10k-cache-barriera=regolazione
Specificare se GCC deve inserire barriere di cache per evitare gli effetti collaterali di
speculazioni sui processori R10K.

In comune con molti processori, l'R10K cerca di prevedere l'esito di un condizionale
branch ed esegue in modo speculativo le istruzioni dal ramo "preso". E dopo
interrompe queste istruzioni se il risultato previsto era sbagliato. Tuttavia, sull'R10K,
anche le istruzioni interrotte possono avere effetti collaterali.

Questo problema riguarda solo gli archivi del kernel e, a seconda del sistema, i carichi del kernel.
Ad esempio, un archivio eseguito in modo speculativo può caricare la memoria di destinazione nella cache
e contrassegna la riga della cache come sporca, anche se il negozio stesso viene successivamente interrotto. Se un DMA
operazione scrive nella stessa area di memoria prima che la riga "sporca" venga svuotata, il
i dati memorizzati nella cache sovrascriveranno i dati DMA-ed. Vedere il manuale del processore R10K per un completo
descrizione, inclusi altri potenziali problemi.

Una soluzione alternativa consiste nell'inserire le istruzioni della barriera della cache prima di ogni accesso alla memoria che
potrebbe essere eseguito in modo speculativo e ciò potrebbe avere effetti collaterali anche se abortito.
-mr10k-cache-barriera=regolazione controlla l'implementazione di questa soluzione da parte di GCC. Esso
presuppone che gli accessi interrotti a qualsiasi byte nelle seguenti regioni non avranno side
effetti:

1. la memoria occupata dallo stack frame della funzione corrente;

2. la memoria occupata da un argomento dello stack in ingresso;

3. la memoria occupata da un oggetto con indirizzo a tempo di collegamento costante.

È responsabilità del kernel garantire che gli accessi speculativi a queste regioni
sono davvero al sicuro.

Se il programma di input contiene una dichiarazione di funzione come:

void foo (vuoto);

quindi l'implementazione di "foo" deve consentire l'esecuzione di "j foo" e "jal foo"
speculativamente. GCC rispetta questa restrizione per le funzioni che compila da solo. Esso
si aspetta che le funzioni non GCC (come il codice assembly scritto a mano) facciano lo stesso.

L'opzione ha tre forme:

-mr10k-cache-barrier=carica-archivio
Inserisci una barriera di cache prima di un caricamento o di un archivio che potrebbe essere eseguito in modo speculativo
e questo potrebbe avere effetti collaterali anche se abortito.

-mr10k-cache-barrier=negozio
Inserisci una barriera di cache prima di un negozio che potrebbe essere eseguito in modo speculativo e
che potrebbe avere effetti collaterali anche se abortito.

-mr10k-cache-barrier=nessuno
Disabilita l'inserimento delle barriere cache. Questa è l'impostazione predefinita.

-mflush-funzione=func
-mno-flush-funzione
Specifica la funzione da chiamare per svuotare le cache I e D o per non chiamarne nessuna
funzione. Se chiamata, la funzione deve prendere gli stessi argomenti del common
"_flush_func()", ovvero l'indirizzo dell'intervallo di memoria per il quale è in corso la cache
svuotato, la dimensione dell'intervallo di memoria e il numero 3 (per svuotare entrambe le cache). Il
l'impostazione predefinita dipende dal GCC di destinazione per cui è stato configurato, ma comunemente è uno dei due
_flush_funz or __cpu_flush.

costo-mbranch=num
Imposta il costo delle filiali a circa num istruzioni "semplici". Questo costo è solo un
euristico e non è garantito che produca risultati coerenti tra le versioni. uno zero
costo seleziona in modo ridondante l'impostazione predefinita, che si basa sul -mtune impostazione.

-mbranch-probabile
-mno-ramo-probabile
Abilitare o disabilitare l'uso delle istruzioni Branch Likely, indipendentemente dall'impostazione predefinita per il
architettura selezionata. Per impostazione predefinita, le istruzioni di probabilità di diramazione possono essere generate se
sono supportati dall'architettura selezionata. Un'eccezione è per MIPS32 e
Architetture e processori MIPS64 che implementano tali architetture; per quelli,
Le istruzioni Branch Likely non verranno generate per impostazione predefinita perché MIPS32 e
Le architetture MIPS64 deprecano specificamente il loro uso.

-eccezioni-mfp
-mno-fp-eccezioni
Specifica se le eccezioni FP sono abilitate. Ciò influisce sul modo in cui programmiamo il FP
istruzioni per alcuni processori. L'impostazione predefinita è che le eccezioni FP siano abilitate.

Ad esempio, sull'SB-1, se le eccezioni FP sono disabilitate e stiamo emettendo 64 bit
codice, quindi possiamo usare entrambe le pipe FP. Altrimenti, possiamo usare solo un tubo FP.

-mvr4130-align
-mno-vr4130-align
La pipeline VR4130 è superscalare a due vie, ma può emettere solo due istruzioni
insieme se il primo è allineato a 8 byte. Quando questa opzione è abilitata, GCC lo farà
allinea le coppie di istruzioni che ritiene debbano essere eseguite in parallelo.

Questa opzione ha effetto solo durante l'ottimizzazione per il VR4130. Normalmente fa il codice
più veloce, ma a scapito di renderlo più grande. È abilitato per impostazione predefinita su
livello di ottimizzazione -O3.

-msynci
-mno-synci
Abilita (disabilita) la generazione di istruzioni "synci" sulle architetture che la supportano.
Le istruzioni "synci" (se abilitate) verranno generate quando
"__builtin___clear_cache()" è compilato.

Questa opzione predefinita è "-mno-synci", ma l'impostazione predefinita può essere sovrascritta configurando
con "--con-synci".

Quando si compila codice per sistemi a processore singolo, è generalmente sicuro utilizzare "synci".
Tuttavia, su molti sistemi multi-core (SMP), non invaliderà l'istruzione
cache su tutti i core e può portare a comportamenti indefiniti.

-mrelax-pic-chiamate
-mno-relax-pic-chiamate
Prova a trasformare le chiamate PIC che normalmente vengono inviate tramite il registro $ 25 in chiamate dirette.
Questo è possibile solo se il linker può risolvere la destinazione al momento del collegamento e se
la destinazione è nel raggio di una chiamata diretta.

-mrelax-pic-chiamate è l'impostazione predefinita se GCC è stato configurato per utilizzare un assembler e a
linker che supporta la direttiva assembly ".reloc" e "-mexplicit-relocs" è in
effetto. Con "-mno-explicit-relocs", questa ottimizzazione può essere eseguita dal
assembler e il linker da soli senza l'aiuto del compilatore.

-mmcount-ra-indirizzo
-mno-mcount-ra-indirizzo
Emetti (non emetti) il codice che consente a "_mcount" di modificare il ritorno della funzione chiamante
indirizzo. Quando abilitata, questa opzione estende la solita interfaccia "_mcount" con una nuova
ra-indirizzo parametro, che ha tipo "intptr_t *" e viene passato nel registro $12.
"_mcount" può quindi modificare l'indirizzo di ritorno effettuando entrambe le seguenti operazioni:

· Restituzione del nuovo indirizzo nel registro $ 31.

· Memorizzazione del nuovo indirizzo in "*ra-indirizzo", Se ra-indirizzo è non nullo.

L'impostazione predefinita è -mno-mcount-ra-indirizzo.

MMIX Opzioni

Queste opzioni sono definite per MMIX:

-mlibfuncs
-mno-libfuncs
Specificare che le funzioni della libreria intrinseca vengono compilate, passando tutti i valori in
registri, indipendentemente dalle dimensioni.

-mepsilon
-mno-epsilon
Genera istruzioni di confronto in virgola mobile che confrontano rispetto a "rE"
registro epsilon.

-mabi=mixware
-mabi = gnu
Genera codice che passi parametri di funzione e restituisca valori che (nella chiamata
funzione) sono visti come registri da $0 in su, al contrario di GNU ABI che usa global
registra $ 231 e oltre.

-mzero-estendere
-mno-zero-estendere
Quando si leggono dati dalla memoria di dimensioni inferiori a 64 bit, utilizzare (non utilizzare) zero-
estendendo le istruzioni di caricamento per impostazione predefinita, piuttosto che quelle che estendono il segno.

-mknuthdiv
-mno-knuthdiv
Fai in modo che il risultato di una divisione che produce un resto abbia lo stesso segno del divisore.
Con l'impostazione predefinita, -mno-knuthdiv, il segno del resto segue il segno della
dividendo. Entrambi i metodi sono aritmeticamente validi, essendo quest'ultimo quasi esclusivamente
Usato.

-mtoplevel-simboli
-mno-toplevel-simboli
Anteporre (non anteporre) a : a tutti i simboli globali, quindi è possibile utilizzare il codice assembly
con la direttiva assembly "PREFIX".

-melf
Genera un eseguibile nel formato ELF, piuttosto che in quello predefinito mmo formato usato da
, il mescolare simulatore.

-mbranch-prevedere
-mno-ramo-previsione
Utilizzare (non utilizzare) le istruzioni del probabile ramo, quando la previsione del ramo statico
indica un probabile ramo.

-indirizzi-base
-mno-indirizzi-base
Genera (non generare) codice che utilizza base indirizzi. Utilizzo di un indirizzo di base
genera automaticamente una richiesta (gestita dall'assemblatore e dal linker) per a
costante da impostare in un registro globale. Il registro è utilizzato per una o più basi
indirizzare le richieste nell'intervallo da 0 a 255 dal valore contenuto nel registro. Il
generalmente porta a un codice breve e veloce, ma il numero di diversi elementi di dati che
può essere affrontato è limitato. Ciò significa che un programma che utilizza molti dati statici
può richiedere -mno-indirizzi-base.

-msuscita singola
-mno-uscita singola
Forza (non forzare) il codice generato per avere un singolo punto di uscita in ogni funzione.

MN10300 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le architetture Matsushita MN10300:

-Mult-bug
Genera codice per evitare bug nelle istruzioni di moltiplicazione per i processori MN10300.
Questo è l'impostazione predefinita.

-mno-multi-bug
Non generare codice per evitare bug nelle istruzioni di moltiplicazione per MN10300
processori.

-mam33
Genera codice utilizzando funzionalità specifiche del processore AM33.

-Mno-Am33
Non generare codice utilizzando funzionalità specifiche del processore AM33. Questo è il
predefinito.

-mam33-2
Genera codice utilizzando funzionalità specifiche del processore AM33/2.0.

-mam34
Genera codice utilizzando funzionalità specifiche del processore AM34.

-mtune=tipo di CPU
Utilizzare le caratteristiche di temporizzazione del tipo di CPU indicato durante la pianificazione delle istruzioni.
Ciò non modifica il tipo di processore di destinazione. Il tipo di CPU deve essere uno di
mn10300, am33, am33-2 or am34.

-mpuntatore-di-ritorno-su-d0
Quando si genera una funzione che restituisce un puntatore, restituire il puntatore sia in "a0" che in
"d0". Altrimenti, il puntatore viene restituito solo in a0 e tenta di chiamare tale
funzioni senza un prototipo comporterebbe errori. Nota che questa opzione è attiva da
predefinito; utilizzo -mno-puntatore-ritorno-su-d0 per disabilitarlo.

-mno-crt0
Non collegare nel file oggetto di inizializzazione di runtime C.

-rilassati
Indica al linker che deve eseguire un passaggio di ottimizzazione del rilassamento a
accorciare rami, chiamate e indirizzi di memoria assoluta. Questa opzione ha solo effetto
quando utilizzato sulla riga di comando per il passaggio finale del collegamento.

Questa opzione rende impossibile il debug simbolico.

-miw
Consenti al compilatore di generare Lunghi Istruzione Word istruzioni se l'obiettivo è il
AM33 o più tardi. Questa è l'impostazione predefinita. Questa opzione definisce la macro del preprocessore
__LIW__.

-Mnoliw
Non consentire al compilatore di generare Lunghi Istruzione Word Istruzioni. Questa opzione
definisce la macro del preprocessore __NO_LIW__.

-msetlb
Consenti al compilatore di generare il SETLB ed Lcc istruzioni se l'obiettivo è il
AM33 o più tardi. Questa è l'impostazione predefinita. Questa opzione definisce la macro del preprocessore
__SETLB__.

-mnosetlb
Non consentire al compilatore di generare SETLB or Lcc Istruzioni. Questa opzione definisce
la macro del preprocessore __NO_SETLB__.

PDP-11 Opzioni

Queste opzioni sono definite per il PDP-11:

-mfpu
Usa hardware FPP in virgola mobile. Questa è l'impostazione predefinita. (virgola mobile FIS sul
PDP-11/40 non è supportato.)

-msoft-flottante
Non utilizzare hardware in virgola mobile.

-mac0
Restituisce i risultati in virgola mobile in ac0 (fr0 nella sintassi dell'assemblatore Unix).

-mno-ac0
Restituisce i risultati in virgola mobile in memoria. Questa è l'impostazione predefinita.

-M40
Genera codice per un PDP-11/40.

-M45
Genera codice per un PDP-11/45. Questa è l'impostazione predefinita.

-M10
Genera codice per un PDP-11/10.

-mbcopy-integrato
Usa modelli "movmemhi" in linea per copiare la memoria. Questa è l'impostazione predefinita.

-mbcopia
Non utilizzare modelli "movmemhi" in linea per copiare la memoria.

-menta16
-mno-int32
Usa "int" a 16 bit. Questa è l'impostazione predefinita.

-menta32
-mno-int16
Usa "int" a 32 bit.

-mfloat64
-mno-flottante32
Usa "float" a 64 bit. Questa è l'impostazione predefinita.

-mfloat32
-mno-flottante64
Usa "float" a 32 bit.

-mabshi
Usa il modello "abshi2". Questa è l'impostazione predefinita.

-mno-abshi
Non utilizzare il modello "abshi2".

-mbranch-costoso
Fai finta che le filiali siano costose. Questo è per sperimentare con la generazione del codice
solo.

-mbranch-economico
Non fingere che i rami siano costosi. Questa è l'impostazione predefinita.

-munix-asm
Usa la sintassi dell'assemblatore Unix. Questa è l'impostazione predefinita quando è configurata per pdp11-*-bsd.

-mdec-asm
Usa la sintassi dell'assemblatore DEC. Questa è l'impostazione predefinita quando è configurata per qualsiasi target PDP-11
diverso pdp11-*-bsd.

picoChip Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni picoChip:

-mae=ae_type
Impostare il set di istruzioni, il set di registri e i parametri di pianificazione delle istruzioni per l'array
tipo di elemento ae_type. Valori supportati per ae_type sono QUALSIASI, MULe MAC.

-mae=QUALSIASI seleziona un tipo di AE completamente generico. Il codice generato con questa opzione sarà
eseguito su uno qualsiasi degli altri tipi di AE. Il codice non sarà efficiente come lo sarebbe se
compilato per uno specifico tipo di AE e alcuni tipi di operazioni (ad es. moltiplicazione)
non funzionerà correttamente su tutti i tipi di AE.

-mae=MUL seleziona un tipo MUL AE. Questo è il tipo AE più utile per il codice compilato,
ed è l'impostazione predefinita.

-mae=MAC seleziona un MAC AE in stile DSP. Il codice compilato con questa opzione potrebbe risentirne
scarse prestazioni di manipolazione di byte (char), poiché DSP AE non fornisce
supporto hardware per caricamento/archiviazione di byte.

-msimbolo-come-indirizzo
Consenti al compilatore di utilizzare direttamente un nome di simbolo come indirizzo in un carico/negozio
istruzione, senza prima caricarla in un registro. In genere, l'uso di questo
l'opzione genererà programmi più grandi, che vengono eseguiti più velocemente rispetto a quando l'opzione non lo è
Usato. Tuttavia, i risultati variano da programma a programma, quindi viene lasciato come utente
opzione, invece di essere permanentemente abilitato.

-mno-inefficiente-avvisi
Disabilita gli avvisi sulla generazione di codice inefficiente. Questi avvertimenti possono essere
generato, ad esempio, durante la compilazione di codice che esegue operazioni di memoria a livello di byte
sul tipo MAC AE. Il MAC AE non ha supporto hardware per la memoria a livello di byte
operazioni, quindi tutti i byte load/store devono essere sintetizzati dalla parola load/store
operazioni. Questo è inefficiente e verrà generato un avviso che indica al
programmatore che dovrebbero riscrivere il codice per evitare operazioni sui byte o per mirare a
Tipo AE che dispone del supporto hardware necessario. Questa opzione abilita l'avviso a
essere spento.

PowerPC Opzioni

Questi sono elencati sotto

RL78 Opzioni

-msim
Collegamenti in librerie di destinazione aggiuntive per supportare il funzionamento all'interno di un simulatore.

-mmul=nessuno
-mmul=g13
-mmul=rl78
Specifica il tipo di supporto per la moltiplicazione hardware da utilizzare. L'impostazione predefinita è
"none", che utilizza funzioni di moltiplicazione software. L'opzione "g13" è per il
hardware moltiplica/dividi periferica solo sui target RL78/G13. L'opzione "rl78"
è per la moltiplicazione hardware standard definita nel manuale del software RL78.

IBM RS/6000 ed PowerPC Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per IBM RS/6000 e PowerPC:

-potenza
-mno-potenza
-mpower2
-mno-potere2
-mpowerpc
-mno-powerpc
-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mpowerpc64
-mno-powerpc64
-mmfcrf
-mno-mfcrf
-mpocntb
-mno-popcntb
-mpocntd
-mno-popcntd
-mfprnd
-mno-fprnd
-mcmpb
-mno-cmpb
-mmfpgpr
-mno-mfpgpr
-mhard-dfp
-mno-hard-dfp
GCC supporta due architetture di set di istruzioni correlate per RS/6000 e PowerPC.
I POTENZA set di istruzioni sono quelle istruzioni supportate dal rios chipset usato
nei sistemi originali RS/6000 e nel PowerPC il set di istruzioni è l'architettura di
i microprocessori Freescale MPC5xx, MPC6xx, MPC8xx e IBM 4xx, 6xx e
microprocessori successivi.

Nessuna delle due architetture è un sottoinsieme dell'altra. Tuttavia c'è un grande sottoinsieme comune
di istruzioni supportate da entrambi. Un registro MQ è incluso nei processori
supportare l'architettura POWER.

Utilizzi queste opzioni per specificare quali istruzioni sono disponibili sul processore che desideri
stiamo usando. Il valore predefinito di queste opzioni è determinato durante la configurazione di GCC.
Specificando il -mcpu=tipo_cpu sovrascrive la specifica di queste opzioni. Noi
ti consiglio di usare il -mcpu=tipo_cpu opzione anziché le opzioni elencate sopra.

I -potenza l'opzione consente a GCC di generare istruzioni che si trovano solo nel
architettura POWER e di utilizzare il registro MQ. Specificando -mpower2 implica -Power ed
consente inoltre a GCC di generare istruzioni presenti nell'architettura POWER2
ma non l'architettura POWER originale.

I -mpowerpc l'opzione consente a GCC di generare istruzioni che si trovano solo nel
Sottoinsieme a 32 bit dell'architettura PowerPC. Specificando -mpowerpc-gpopt implica
-mpowerpc e consente inoltre a GCC di utilizzare le istruzioni opzionali dell'architettura PowerPC in
il gruppo General Purpose, inclusa la radice quadrata a virgola mobile. Specificando
-mpowerpc-gfxopt implica -mpowerpc e consente anche a GCC di utilizzare il PowerPC opzionale
istruzioni sull'architettura nel gruppo Grafica, inclusa la selezione a virgola mobile.

I -mmfcrf l'opzione consente a GCC di generare lo spostamento dal campo del registro delle condizioni
istruzione implementata sul processore POWER4 e altri processori che supportano il
Architettura PowerPC V2.01. Il -mpocntb l'opzione consente a GCC di generare il popcount
e istruzione di stima reciproca FP a doppia precisione implementata su POWER5
processore e altri processori che supportano l'architettura PowerPC V2.02. Il
-mpocntd l'opzione consente a GCC di generare l'istruzione popcount implementata sul
Processore POWER7 e altri processori che supportano l'architettura PowerPC V2.06.
I -mfprnd l'opzione consente a GCC di generare le istruzioni FP round to integer
implementato sul processore POWER5+ e altri processori che supportano il PowerPC
Architettura V2.03. Il -mcmpb l'opzione consente a GCC di generare i byte di confronto
istruzione implementata sul processore POWER6 e altri processori che supportano il
Architettura PowerPC V2.05. Il -mmfpgpr l'opzione consente a GCC di generare la mossa FP
da/verso le istruzioni del registro di uso generale implementate sul processore POWER6X e
altri processori che supportano l'architettura estesa PowerPC V2.05. Il -mhard-dfp
l'opzione consente a GCC di generare le istruzioni decimali in virgola mobile implementate su
alcuni processori POWER.

I -mpowerpc64 l'opzione consente a GCC di generare le istruzioni aggiuntive a 64 bit che
si trovano nell'architettura PowerPC64 completa e trattano i GPR come 64 bit, doubleword
le quantità. L'impostazione predefinita di GCC è -mno-powerpc64.

Se specifichi entrambi -mno-potenza ed -mno-powerpc, GCC utilizzerà solo le istruzioni in
il sottoinsieme comune di entrambe le architetture più alcune chiamate di modo comune AIX speciali e
non utilizzerà il registro MQ. Specificando entrambi -potenza ed -mpowerpc consente a GCC di
utilizzare qualsiasi istruzione di entrambe le architetture e consentire l'uso del registro MQ;
specificarlo per il Motorola MPC601.

-mnew-mnemonici
-mnemonico-stampo
Seleziona quale mnemonico utilizzare nel codice assembler generato. Insieme a -mnew-mnemonici,
GCC utilizza i mnemonici assembler definiti per l'architettura PowerPC. Insieme a
-mnemonico-stampo utilizza i mnemonici assembler definiti per l'architettura POWER.
Le istruzioni definite in una sola architettura hanno un solo mnemonico; GCC lo usa
mnemonico indipendentemente da quale di queste opzioni è specificata.

GCC utilizza per impostazione predefinita i mnemonici appropriati per l'architettura in uso. Specificando
-mcpu=tipo_cpu a volte sovrascrive il valore di queste opzioni. A meno che tu non stia costruendo
un cross-compilatore, normalmente non dovresti specificare neanche -mnew-mnemonici or
-mnemonico-stampo, ma dovrebbe invece accettare il valore predefinito.

-mcpu=tipo_cpu
Imposta il tipo di architettura, l'utilizzo del registro, la scelta dei mnemonici e la pianificazione delle istruzioni
parametri per il tipo di macchina tipo_cpu. Valori supportati per tipo_cpu sono 401, 403,
405, 405fp, 440, 440fp, 464, 464fp, 476, 476fp, 505, 601, 602, 603, 603e, 604, 604e,
620, 630, 740, 7400, 7450, 750, 801, 821, 823, 860, 970, 8540, a2, e300c2, e300c3,
e500mc, e500mc64, ec603e, G3, G4, G5, titano, energia, power2, power3, power4, power5,
potenza5+, power6, potenza6x, power7, comune, pc di potenza, powerpc64, rios, fiumi1, fiumi2, rsc,
ed rs64.

-mcpu=comune seleziona un processore completamente generico. Codice generato con questa opzione
funzionerà su qualsiasi processore POWER o PowerPC. GCC utilizzerà solo le istruzioni nel
sottoinsieme comune di entrambe le architetture e non utilizzerà il registro MQ. GCC assume a
modello di processore generico per scopi di pianificazione.

-mcpu=potenza, -mcpu=potenza2, -mcpu=potenzapce -mcpu=powerpc64 specificare POTENZA generica,
POWER2, ​​architettura PowerPC pura a 32 bit (ovvero non MPC601) e PowerPC a 64 bit
tipi di macchina, con un modello di processore generico appropriato assunto per la pianificazione
scopi.

Le altre opzioni specificano un processore specifico. Codice generato in queste opzioni
funzionerà meglio su quel processore e potrebbe non funzionare affatto su altri.

I -mcpu opzioni abilitano o disabilitano automaticamente le seguenti opzioni:

-maltivec -mfprnd -mhard-flottante -mmfcrf -mmultiplo -mnew-mnemonici -mpocntb
-mpocntd -potenza -mpower2 -mpowerpc64 -mpowerpc-gpopt -mpowerpc-gfxopt
-msingle-flottante -mdouble-flottante -msemplice-fpu -mstringa -mmhw -mdlmzb -mmfpgpr -mvsx

Le opzioni particolari impostate per ogni particolare CPU varieranno tra le versioni del compilatore,
a seconda di quale impostazione sembra produrre codice ottimale per quella CPU; non lo fa
riflettono necessariamente le reali capacità dell'hardware. Se desideri impostare un
singola opzione a un valore particolare, è possibile specificarlo dopo il -mcpu opzione,
piace -MCPU = 970 -mno-altivoc.

Su AIX, il -maltivec ed -mpowerpc64 le opzioni non sono abilitate o disabilitate dal -mcpu
opzione al momento perché AIX non dispone del supporto completo per queste opzioni. Potresti
ancora abilitali o disabilitali individualmente se sei sicuro che funzionerà nel tuo
ambiente.

-mtune=tipo_cpu
Impostare i parametri di pianificazione delle istruzioni per il tipo di macchina tipo_cpu, ma non impostare
il tipo di architettura, l'utilizzo del registro o la scelta dei mnemonici, come -mcpu=tipo_cpu
voluto. Gli stessi valori per tipo_cpu sono usati per -mtune quanto a -mcpu. Se entrambi sono
specificato, il codice generato utilizzerà l'architettura, i registri e il set mnemonico
by -mcpu, ma i parametri di schedulazione impostati da -mtune.

-mcmodel=piccolo
Genera codice PowerPC64 per il modello piccolo: il TOC è limitato a 64k.

-mcmodel=medio
Genera codice PowerPC64 per il modello medio: il TOC e altri dati statici potrebbero essere aumentati
a un totale di 4G di dimensione.

-mcmodel=grande
Genera codice PowerPC64 per il modello grande: il TOC può avere dimensioni fino a 4G. Altro
dati e codice sono limitati solo dallo spazio degli indirizzi a 64 bit.

-maltivec
-mno-altivoc
Genera codice che utilizza (non utilizza) le istruzioni AltiVec e abilita anche l'uso
di funzioni integrate che consentono un accesso più diretto al set di istruzioni AltiVec.
Potrebbe anche essere necessario impostare -mabi=altivo per regolare l'attuale ABI con AltiVec ABI
miglioramenti.

-mvrsave
-mno-vrsave
Genera istruzioni VRSAVE durante la generazione del codice AltiVec.

-mgen-cell-microcodice
Genera istruzioni per il microcodice cellulare

-mwarn-cell-microcodice
Avvertimento quando un'istruzione del microcodice Cell sta per essere emessa. Un esempio di cella
l'istruzione del microcodice è uno spostamento variabile.

-msecure-plt
Genera codice che consente a ld e ld.so di creare eseguibili e librerie condivise con
sezioni non-exec .plt e .got. Questa è un'opzione PowerPC SYSV ABI a 32 bit.

-mbss-plt
Genera codice che utilizza una sezione BSS .plt che ld.so compila e richiede .plt e
.got sezioni scrivibili ed eseguibili. Questo è un SYSV PowerPC a 32 bit
Opzione ABI.

-Misel
-mno-isel
Questo interruttore abilita o disabilita la generazione di istruzioni ISEL.

-misl=si No
Questa opzione è stata deprecata. Utilizzo -Misel ed -mno-isel anziché.

-mspe
-mno-spe
Questo interruttore abilita o disabilita la generazione di istruzioni SPE simd.

- deteriorato
-mno-accoppiato
Questo interruttore abilita o disabilita la generazione di istruzioni simd PAIRED.

-mspe=si No
Questa opzione è stata deprecata. Utilizzo -mspe ed -mno-spe anziché.

-mvsx
-mno-vsx
Genera codice che utilizza (non usa) istruzioni vettoriali/scalari (VSX) e anche
abilitare l'uso di funzioni integrate che consentono un accesso più diretto al VSX
set di istruzioni.

-mfloat-gprs=si/singolo/doppio/no
-mfloat-gprs
Questo interruttore abilita o disabilita la generazione di operazioni in virgola mobile sul
registri generici per le architetture che lo supportano.

L'argomento sì or singolo consente l'uso della virgola mobile a precisione singola
operazioni.

L'argomento doppio consente l'uso di virgola mobile a precisione singola e doppia
operazioni.

L'argomento no disabilita le operazioni in virgola mobile sui registri generici.

Questa opzione è attualmente disponibile solo su MPC854x.

-M32
-M64
Genera codice per ambienti a 32 o 64 bit di target Darwin e SVR4 (incluso
GNU/Linux). L'ambiente a 32 bit imposta int, long e pointer a 32 bit e
genera codice che gira su qualsiasi variante di PowerPC. L'ambiente a 64 bit imposta int su
32 bit e lungo e puntatore a 64 bit e genera codice per PowerPC64, come per
-mpowerpc64.

-mfull-toc
-mno-fp-in-toc
-mno-somma-in-toc
-minimal-toc
Modifica la generazione del TOC (Table Of Contents), che viene creato per ogni
file eseguibile. Il -mfull-toc l'opzione è selezionata per impostazione predefinita. In tal caso, GCC
assegnerà almeno una voce TOC per ogni riferimento variabile non automatico univoco
nel tuo programma. GCC posizionerà anche le costanti in virgola mobile nel sommario. Però,
solo 16,384 voci sono disponibili nel sommario.

Se ricevi un messaggio di errore del linker che dice che hai traboccato la disponibilità
Spazio TOC, è possibile ridurre la quantità di spazio TOC utilizzato con il -mno-fp-in-toc ed
-mno-somma-in-toc opzioni. -mno-fp-in-toc impedisce a GCC di inserire la virgola mobile
costanti nel TOC e -mno-somma-in-toc forza GCC a generare codice per calcolare il
somma di un indirizzo e una costante in fase di esecuzione invece di inserire tale somma nel sommario.
Puoi specificare una o entrambe queste opzioni. Ciascuno fa sì che GCC produca molto
codice leggermente più lento e più grande a scapito della conservazione dello spazio del sommario.

Se si esaurisce ancora lo spazio nel sommario anche quando si specificano entrambe queste opzioni,
specificare -minimal-toc Invece. Questa opzione fa sì che GCC crei una sola voce di sommario per
ogni file. Quando specifichi questa opzione, GCC produrrà codice più lento e
più grande ma che utilizza pochissimo spazio TOC. Potresti voler usare questa opzione
solo su file che contengono codice eseguito meno frequentemente.

-maix64
-maix32
Abilita ABI AIX a 64 bit e convenzione di chiamata: puntatori a 64 bit, tipo "lungo" a 64 bit e
le infrastrutture necessarie per sostenerli. Specificando -maix64 implica -mpowerpc64 ed
-mpowerpc mentre la lavorazione del prodotto finito avviene negli stabilimenti del nostro partner -maix32 disabilita l'ABI a 64 bit e implica -mno-powerpc64. CCG
il valore predefinito è -maix32.

-mxl-comp
-mno-xl-comp
Produce codice più conforme alla semantica del compilatore IBM XL quando si utilizza AIX-
compatibile ABI. Passa argomenti in virgola mobile a funzioni prototipate oltre a
registra l'area di salvataggio (RSA) sullo stack oltre agli argomenti FPR. Non assumere
che il valore double più significativo in un valore double lungo a 128 bit viene arrotondato correttamente quando
confrontare i valori e convertirli in double. Usa i nomi dei simboli XL per il doppio lungo
routine di supporto.

La convenzione di chiamata AIX è stata estesa ma inizialmente non documentata per gestire un
oscuro K&R C caso di chiamata di una funzione che prende l'indirizzo dei suoi argomenti con
meno argomenti di quelli dichiarati. I compilatori IBM XL accedono ad argomenti in virgola mobile che
non si adattano alla RSA dallo stack quando una subroutine viene compilata senza
ottimizzazione. Perché memorizzare sempre argomenti in virgola mobile nello stack è
inefficiente e raramente necessaria, questa opzione non è abilitata per impostazione predefinita ed è solo
necessario quando si chiamano subroutine compilate dai compilatori IBM XL senza ottimizzazione.

-mpe
Assistenza IBM RS/6000 SP Parallel Ambiente (PE). Collega un'applicazione scritta per l'uso
passaggio di messaggi con codice di avvio speciale per consentire l'esecuzione dell'applicazione. Il
il sistema deve avere PE installato nella posizione standard (/usr/lpp/ppe.poe/), o il
occhiali il file deve essere sovrascritto con il -specifiche= opzione per specificare l'appropriato
posizione della directory. L'ambiente parallelo non supporta i thread, quindi il -mpe
opzione e il -pthread opzione sono incompatibili.

-maligno-naturale
-potere-maligno
Su AIX, Darwin a 32 bit e PowerPC a 64 bit GNU/Linux, l'opzione -maligno-naturale
sovrascrive l'allineamento definito dall'ABI di tipi più grandi, come double a virgola mobile,
sul loro confine naturale basato sulla dimensione. L'opzione -potere-maligno istruisce GCC a
seguire le regole di allineamento specificate dall'ABI. GCC utilizza l'allineamento standard per impostazione predefinita
definito nell'ABI.

Su Darwin a 64 bit, l'allineamento naturale è l'impostazione predefinita e -potere-maligno non è
supportato.

-msoft-flottante
-mhard-flottante
Genera codice che non usa (usa) il set di registri a virgola mobile. Software
l'emulazione in virgola mobile viene fornita se si utilizza il -msoft-flottante opzione e passare il
opzione a GCC durante il collegamento.

-msingle-flottante
-mdouble-flottante
Genera codice per operazioni a virgola mobile a precisione singola o doppia.
-mdouble-flottante implica -msingle-flottante.

-msemplice-fpu
Non generare istruzioni sqrt e div per unità hardware a virgola mobile.

-mfpu
Specificare il tipo di unità a virgola mobile. I valori validi sono sp_lite (equivalente a
-msingle-float -msimple-fpu), dp_lite (equivalente a -mdouble-float -msimple-fpu),
sp_pieno (equivalente a -mssingle-float), e dp_pieno (equivalente a -mdouble-float).

-mxilinx-fpu
Eseguire ottimizzazioni per l'unità in virgola mobile su Xilinx PPC 405/440.

-mmultiplo
-mno-multiplo
Genera codice che utilizza (non utilizza) le istruzioni di caricamento di più parole e il
memorizzare più istruzioni di parole. Queste istruzioni sono generate di default su
sistemi POWER, e non generati su sistemi PowerPC. Non usare -mmultiplo su poco-
sistemi endian PowerPC, poiché queste istruzioni non funzionano quando il processore è in
modalità little-endian. Le eccezioni sono PPC740 e PPC750 che le consentono
istruzioni in modalità little endian.

-mstringa
-mno-stringa
Genera codice che utilizza (non usa) le istruzioni della stringa di caricamento e il negozio
istruzioni stringa di parole per salvare più registri ed eseguire piccoli movimenti di blocco. Queste
le istruzioni sono generate di default sui sistemi POWER e non generate su PowerPC
sistemi. Non usare -mstringa su sistemi little-endian PowerPC, poiché quelli
le istruzioni non funzionano quando il processore è in modalità little-endian. Le eccezioni
sono PPC740 e PPC750 che consentono queste istruzioni in modalità little-endian.

-aggiornamento
-mno-aggiornamento
Genera codice che utilizza (non utilizza) il caricamento o memorizza le istruzioni che aggiornano il
registro di base all'indirizzo della posizione di memoria calcolata. Queste istruzioni
vengono generati per impostazione predefinita. Se usi -mno-aggiornamento, c'è una piccola finestra tra i
volta che il puntatore dello stack viene aggiornato e l'indirizzo del frame precedente è
memorizzato, il che significa che il codice che percorre lo stack frame attraverso interruzioni o segnali può
ottenere dati corrotti.

-mavoid-indirizzi-indicizzati
-mno-evita-indirizzi-indicizzati
Genera codice che cerca di evitare (non evitare) l'uso di carichi indicizzati o negozi
Istruzioni. Queste istruzioni possono comportare una riduzione delle prestazioni sui processori Power6
in determinate situazioni, come quando si passa attraverso grandi array che attraversano un 16M
confine. Questa opzione è abilitata per impostazione predefinita quando si prende di mira Power6 e disabilitata
altrimenti.

-mfuso-pazzo
-mno-fuso-madd
Genera codice che utilizza (non utilizza) la moltiplicazione e l'accumulo in virgola mobile
Istruzioni. Queste istruzioni vengono generate per impostazione predefinita se hardware in virgola mobile
viene utilizzato. Il dipendente dalla macchina -mfuso-pazzo l'opzione è ora mappata sulla macchina-
studente indipendente -ffp-contratto=veloce opzione e -mno-fuso-madd è mappato a
-ffp-contratto=off.

-mmhw
-mno-mulhw
Genera codice che usa (non usa) la mezza parola moltiplica e moltiplica-accumula
istruzioni sui processori IBM 405, 440, 464 e 476. Queste istruzioni sono
generato per impostazione predefinita quando si prendono di mira quei processori.

-mdlmzb
-mno-dlmzb
Genera codice che usa (non usa) la ricerca di stringhe dlmzb istruzioni sull'IBM
processori 405, 440, 464 e 476. Questa istruzione viene generata di default quando
mirare a quei processori.

-mno-bit-align
-mbit-align
Su System V.4 e i sistemi PowerPC embedded non forzano le strutture e le unioni
che contengono campi di bit da allineare al tipo di base del campo di bit.

Ad esempio, per impostazione predefinita una struttura contenente nient'altro che 8 campi di bit "non firmati" di
la lunghezza 1 è allineata a un limite di 4 byte e ha una dimensione di 4 byte. Usando
-mno-bit-align, la struttura è allineata a un limite di 1 byte e ha una dimensione di 1 byte.

-mno-strict-align
-mstrict-align
Su System V.4 e sui sistemi PowerPC embedded non presumere (do) che la memoria non allineata
i riferimenti saranno gestiti dal sistema.

-mrilocabile
-mno-rilocabile
Genera codice che consente (non consente) di riposizionare un eseguibile statico in a
indirizzo diverso in fase di esecuzione. Un semplice caricatore di sistema integrato PowerPC dovrebbe
riposizionare l'intero contenuto di ".got2" e le posizioni a 4 byte elencate in ".fixup"
sezione, una tabella di indirizzi a 32 bit generati da questa opzione. Perché funzioni, tutti
gli oggetti collegati tra loro devono essere compilati con -mrilocabile or -mrelocatable-lib.
-mrilocabile il codice allinea lo stack a un limite di 8 byte.

-mrelocatable-lib
-mno-relocatable-lib
Come -mrilocabile, -mrelocatable-lib genera una sezione ".fixup" per consentire l'elettricità statica
eseguibili da riposizionare in fase di esecuzione, ma -mrelocatable-lib non usa il
allineamento dello stack più piccolo di -mrilocabile. Oggetti compilati con -mrelocatable-lib può
essere collegato con oggetti compilati con qualsiasi combinazione di -mrilocabile opzioni.

-mno-toc
-toc
Su System V.4 e sui sistemi PowerPC embedded non presumere (do) che il registro 2 contenga
un puntatore a un'area globale che punta agli indirizzi utilizzati nel programma.

-poco
-mittle-endian
Su System V.4 e sui sistemi PowerPC embedded compila il codice per il processore in poco
modalità endiana. Il -mittle-endian l'opzione è la stessa di -poco.

-grande
-big endian
Su System V.4 e sistemi embedded PowerPC compilare il codice per il processore in grandi
modalità endiana. Il -big endian l'opzione è la stessa di -grande.

-mdynamic-no-pic
Sui sistemi Darwin e Mac OS X, compila il codice in modo che non sia riposizionabile, ma questo
i suoi riferimenti esterni sono rilocabili. Il codice risultante è adatto per
applicazioni, ma non librerie condivise.

-mssingle-pic-base
Tratta il registro utilizzato per l'indirizzamento PIC come di sola lettura, piuttosto che caricarlo nel
prologo per ogni funzione. Il sistema di runtime è responsabile dell'inizializzazione di questo
registrarsi con un valore appropriato prima dell'inizio dell'esecuzione.

-prioritize-restricted-insns=priorità
Questa opzione controlla la priorità assegnata allo slot di spedizione limitato
istruzioni durante il secondo passaggio di programmazione. L'argomento priorità prende il valore
0/1/2 assegnare no/più alto/secondo più alto priorità allo slot di spedizione limitato
istruzioni.

-msched-costoso-dep=dipendenza_tipo
Questa opzione controlla quali dipendenze sono considerate costose dal target durante
programmazione delle istruzioni. L'argomento dipendenza_tipo prende uno dei seguenti
valori: no: nessuna dipendenza è costosa, contro tutti i: tutte le dipendenze sono costose,
true_store_to_load: una vera dipendenza dal magazzino al carico è costosa, memorizzare_per_caricare: qualunque
la dipendenza dal negozio al carico è costosa, numero: qualsiasi dipendenza per cui latenza >=
numero è costoso.

-minsert-sched-nops=schema
Questa opzione controlla quale schema di inserimento nop verrà utilizzato durante il secondo
passaggio di programmazione. L'argomento schema assume uno dei seguenti valori: no: Non farlo
inserire no. sentiero: Pad con nops qualsiasi gruppo di spedizione che ha slot di problema vacanti,
secondo il raggruppamento dello scheduler. raggruppare_esatto: Inserisci nops per forzare costoso
inns dipendenti in gruppi separati. Inserisci esattamente tutti i nop necessari per forzare
un insn a un nuovo gruppo, secondo il raggruppamento stimato del processore. numero: Inserisci
nops per forzare gli insns dipendenti costosi in gruppi separati. Inserire numero no a
forzare un insn a un nuovo gruppo.

-mcall-sysv
Su System V.4 e sui sistemi PowerPC embedded compila il codice usando convenzioni di chiamata che
aderisce alla bozza di marzo 1995 dell'interfaccia binaria dell'applicazione System V, PowerPC
supplemento del processore. Questa è l'impostazione predefinita a meno che tu non abbia configurato GCC usando
powerpc-*-eabiaix.

-mcall-sysv-eabi
-mcall-eabi
Specificare entrambi -mcall-sysv ed -meabi opzioni.

-mcall-sysv-noeabi
Specificare entrambi -mcall-sysv ed -mno-eabi opzioni.

-mcall-aixdesc
Sul sistema V.4 e sui sistemi PowerPC incorporati compilare il codice per il sistema operativo AIX.

-mcall-linux
Su System V.4 e sistemi PowerPC embedded compila il codice per GNU . basato su Linux
.

-mcall-freebsd
Sul sistema V.4 e sui sistemi PowerPC embedded compila il codice per il funzionamento di FreeBSD
.

-mcall-netbsd
Sul sistema V.4 e sui sistemi PowerPC embedded compila il codice per il funzionamento di NetBSD
.

-mcall-openbsd
Su System V.4 e sistemi PowerPC embedded compila il codice per il funzionamento di OpenBSD
.

-maix-struct-ritorno
Restituisce tutte le strutture in memoria (come specificato da AIX ABI).

-msvr4-struct-ritorno
Restituire strutture inferiori a 8 byte nei registri (come specificato dall'SVR4 ABI).

-mabi=abi-tipo
Estendere l'ABI corrente con una particolare estensione o rimuovere tale estensione. Valido
i valori sono altivec, no-altivec, spe, no spe, ibmlongdouble, ieeelongdouble.

-mabi=spe
Estendi l'attuale ABI con le estensioni SPE ABI. Questo non cambia l'ABI predefinito,
invece aggiunge le estensioni SPE ABI all'attuale ABI.

-mabi=no-spe
Disabilita le estensioni ABI di Booke SPE per l'ABI corrente.

-mabi=ibmlongdoppio
Modificare l'ABI corrente per utilizzare il doppio lungo a precisione estesa IBM. Questo è un PowerPC
Opzione SYSV ABI a 32 bit.

-mabi=ieeelongdoppio
Modificare l'ABI corrente per utilizzare long double IEEE a precisione estesa. Questo è un PowerPC
Opzione ABI Linux a 32 bit.

-mprototipo
-mno-prototipo
Su System V.4 e sistemi PowerPC embedded presuppongono che tutte le chiamate all'argomento variabile
funzioni sono correttamente prototipate. In caso contrario, il compilatore deve inserire un'istruzione
prima di ogni chiamata non prototipo per impostare o cancellare il bit 6 del registro del codice di condizione
(CR) per indicare se i valori in virgola mobile sono stati passati nella virgola mobile
registri nel caso in cui la funzione accetti argomenti variabili. Insieme a -mprototipo, solo chiamate
alle funzioni di argomento variabile prototipate imposterà o cancellerà il bit.

-msim
Sui sistemi PowerPC embedded, supponiamo che sia chiamato il modulo di avvio sim-crt0.o ed
che le librerie C standard sono libsim.a ed libc.a. Questa è l'impostazione predefinita per
powerpc-*-eabisim configurazioni.

-MMvme
Sui sistemi PowerPC embedded, supponiamo che sia chiamato il modulo di avvio crt0.o e la
le librerie C standard sono libmvme.a ed libc.a.

-pazzi
Sui sistemi PowerPC embedded, supponiamo che sia chiamato il modulo di avvio crt0.o e la
le librerie C standard sono libads.a ed libc.a.

- coltello giallo
Sui sistemi PowerPC embedded, supponiamo che sia chiamato il modulo di avvio crt0.o e la
le librerie C standard sono libiaka.a ed libc.a.

-mvxworks
Su System V.4 e sistemi PowerPC embedded, specificare che si sta compilando per a
Sistema VxWorks.

-membro
Sui sistemi PowerPC embedded, impostare il PPC_EMB bit nell'intestazione dei flag ELF per indicare
che eabi vengono utilizzati trasferimenti estesi.

-meabi
-mno-eabi
Su System V.4 e i sistemi PowerPC embedded non aderiscono (non) a Embedded
Interfaccia binaria delle applicazioni (eabi) che è un insieme di modifiche al sistema V.4
specifiche. Selezione -meabi significa che lo stack è allineato a un 8 byte
confine, viene chiamata una funzione "__eabi" da "main" per impostare l'ambiente eabi,
e la -msdata l'opzione può utilizzare sia "r2" che "r13" per puntare a due piccoli dati separati
le zone. Selezione -mno-eabi significa che lo stack è allineato a un limite di 16 byte, do
non chiamare una funzione di inizializzazione da "main", e il -msdata l'opzione utilizzerà solo
"r13" per puntare a una singola piccola area dati. Il -meabi l'opzione è attiva per impostazione predefinita se tu
configurato GCC utilizzando uno dei powerpc*-*-eabi* opzioni.

-msdata=eabi
Sul sistema V.4 e sui sistemi PowerPC integrati, inserire un piccolo "const" inizializzato globale e
dati statici nel .sdata2 sezione, a cui punta il registro "r2". Metti piccolo
dati globali e statici non "const" inizializzati nel .sdata sezione, che è appuntita
al registro "r13". Inserisci piccoli dati globali e statici non inizializzati nel .sss
sezione, che è adiacente al .sdata sezione. Il -msdata=eabi opzione è
incompatibile con il -mrilocabile opzione. Il -msdata=eabi opzione imposta anche il
-membro opzione.

-msdata=sysv
Su System V.4 e sistemi PowerPC embedded, inserire piccoli dati globali e statici nel
.sdata sezione, a cui punta il registro "r13". Metti piccolo globale non inizializzato
e dati statici nel .sss sezione, che è adiacente al .sdata sezione. Il
-msdata=sysv l'opzione non è compatibile con -mrilocabile opzione.

-msdata=predefinito
-msdata
Su System V.4 e sistemi PowerPC embedded, se -meabi viene utilizzato, compilare il codice lo stesso
as -msdata=eabi, altrimenti compila il codice come -msdata=sysv.

-msdata=dati
Su System V.4 e sistemi PowerPC embedded, inserire piccoli dati globali nel .sdata
sezione. Inserisci piccoli dati globali non inizializzati nel .sss sezione. Non usare
registrare "r13" per indirizzare comunque piccoli dati. Questo è il comportamento predefinito a meno che
Altro -msdata vengono utilizzate le opzioni.

-msdata=nessuno
-mno-sdata
Sui sistemi PowerPC embedded, inserire tutti i dati globali e statici inizializzati nel .data
sezione, e tutti i dati non inizializzati nel .bss .

-mblock-move-inline-limit=num
Inline tutti i movimenti di blocco (come chiamate a "memcpy" o copie di strutture) inferiori a o
uguale a num byte. Il valore minimo per num è 32 byte su destinazioni a 32 bit e 64
byte su destinazioni a 64 bit. Il valore predefinito è specifico della destinazione.

-G num
Sui sistemi PowerPC embedded, inserire elementi globali e statici inferiori o uguali a num
byte nelle sezioni small data o bss invece della normale sezione data o bss.
Per impostazione predefinita, num è 8. Il -G num switch viene passato anche al linker. Tutti i moduli
dovrebbe essere compilato con lo stesso -G num valore.

-mregnami
-mno-regnami
Su System V.4 e sistemi PowerPC embedded non emettono (non) nomi di registro nel
output in linguaggio assembly utilizzando forme simboliche.

-mlongcall
-mno-lunga chiamata
Per impostazione predefinita, presupponiamo che tutte le chiamate siano lontane, in modo che una chiamata più lunga sia più costosa
sequenza è necessaria. Questo è necessario per le chiamate superiori a 32 megabyte
(33,554,432 byte) dalla posizione corrente. Verrà generata una breve chiamata se il
il compilatore sa che la chiamata non può essere così lontana. Questa impostazione può essere sovrascritta da
l'attributo della funzione "shortcall", o da "#pragma lunga chiamata(0)".

Alcuni linker sono in grado di rilevare chiamate fuori range e generare codice colla su
La mosca. Su questi sistemi, le chiamate lunghe non sono necessarie e generano codice più lento. Come
di questo scritto, il linker AIX può farlo, così come il linker GNU per PowerPC/64. Esso
è prevista l'aggiunta di questa funzionalità al linker GNU anche per i sistemi PowerPC a 32 bit.

Sui sistemi Darwin/PPC, "#pragma longcall" genererà "jbsr callee, L42", più un
"isola ramificata" (codice colla). I due indirizzi di destinazione rappresentano il chiamato e il
"isola ramificata". Il linker Darwin/PPC preferirà il primo indirizzo e genererà a
"bl chiamato" se l'istruzione PPC "bl" raggiunge direttamente il chiamato; altrimenti, il
il linker genererà "bl L42" per chiamare la "branch island". L'"isola del ramo" è
aggiunto al corpo della funzione chiamante; calcola l'indirizzo completo a 32 bit di
il chiamato e salta su di esso.

Sui sistemi Mach-O (Darwin), questa opzione indirizza il compilatore emit alla colla per
ogni chiamata diretta e il linker Darwin decide se utilizzarla o scartarla.

In futuro, potremmo far sì che GCC ignori tutte le specifiche longcall quando il linker
è noto per generare colla.

-mtls-marcatori
-mno-tls-marcatori
Contrassegna (non contrassegnare) le chiamate a "__tls_get_addr" con una rilocazione che specifica la funzione
discussione. Il trasferimento consente a ld di associare in modo affidabile la chiamata di funzione all'argomento
istruzioni di configurazione per l'ottimizzazione TLS, che a sua volta consente a gcc di pianificare meglio
la sequenza.

-pthread
Aggiunge il supporto per il multithreading con il pthread biblioteca. Questa opzione imposta i flag per
sia il preprocessore che il linker.

-mrecip
-mno-ricetta
Questa opzione consentirà a GCC di utilizzare la stima reciproca e la radice quadrata reciproca
istruzioni di stima con ulteriori passaggi di Newton-Raphson per aumentare la precisione
invece di eseguire una divisione o una radice quadrata e dividere per argomenti in virgola mobile. Voi
dovrebbe usare il -fast-matematica opzione quando si utilizza -mrecip (o quantomeno
-funsafe-math-ottimizzazioni, -solo matematica finita, - matematica-freciproca ed
-fno-trapping-matematica). Si noti che mentre il throughput della sequenza è generalmente
superiore al rendimento dell'istruzione non reciproca, la precisione del
la sequenza può essere diminuita fino a 2 ulp (cioè l'inverso di 1.0 è uguale a 0.99999994)
per radici quadrate reciproche.

-mrecip=optare
Questa opzione permette di controllare quali istruzioni di stima reciproche possono essere utilizzate. optare
è un elenco di opzioni separate da virgole, che può essere preceduto da un "!" invertire il
opzione: "all": abilita tutte le istruzioni di stima, "default": abilita il default
istruzioni, equivalente a -mrecip, "none": disabilita tutte le istruzioni di preventivo,
equivalente -mno-ricetta; "div": abilita le istruzioni di approssimazione reciproca per
sia singola che doppia precisione; "divf": abilita il reciproco a precisione singola
istruzioni di approssimazione; "divd": abilita il reciproco a doppia precisione
istruzioni di approssimazione; "rsqrt": abilita l'approssimazione della radice quadrata reciproca
istruzioni sia per singola che per doppia precisione; "rsqrtf": abilita il single-
istruzioni di approssimazione di radice quadrata reciproca di precisione; "rsqrtd": abilita il
istruzioni di approssimazione con radice quadrata reciproca a doppia precisione;

Quindi per esempio, -mrecip=tutto,!rsqrtd consentirebbe il tutto della stima reciproca
istruzioni, ad eccezione delle istruzioni "FRSQRTE", "XSRSQRTEDP" e "XVRSQRTEDP"
che gestiscono i calcoli della radice quadrata reciproca a precisione doppia.

-mrecip-precisione
-mno-recip-precisione
Assumiamo (non presupponiamo) che le istruzioni di stima reciproche forniscano maggiori
stime di precisione rispetto a quanto richiesto dall'ABI PowerPC. Selezione -mcpu=potenza6 or
-mcpu=potenza7 seleziona automaticamente -mrecip-precisione. La squadra a doppia precisione
le istruzioni di stima radice non vengono generate per impostazione predefinita su macchine a bassa precisione,
poiché non forniscono una stima che converge dopo tre passaggi.

-mveclibabi=Digitare
Specifica il tipo ABI da utilizzare per vettorizzare gli elementi intrinseci utilizzando una libreria esterna.
L'unico tipo attualmente supportato è "mass", che specifica di utilizzare IBM
Librerie Mathematical Acceleration Subsystem (MASS) per vettorizzare gli intrinseci usando
librerie esterne. GCC attualmente emetterà chiamate a "acosd2", "acosf4", "acoshd2",
"acoshf4", "asind2", "asinf4", "asinhd2", "asinhf4", "atan2d2", "atan2f4", "atand2",
"atanf4", "atanhd2", "atanhf4", "cbrtd2", "cbrtf4", "cosd2", "cosf4", "coshd2",
"coshf4", "erfcd2", "erfcf4", "erfd2", "erff4", "exp2d2", "exp2f4", "expd2", "expf4",
"expm1d2", "expm1f4", "hypotd2", "hypotf4", "lgammad2", "lgammaf4", "log10d2",
"log10f4", "log1pd2", "log1pf4", "log2d2", "log2f4", "logd2", "logf4", "powd2",
"powf4", "sind2", "sinf4", "sinhd2", "sinhf4", "sqrtd2", "sqrtf4", "tand2", "tanf4",
"tanhd2" e "tanhf4" durante la generazione del codice per power7. Entrambi -ftree-vettorizzare ed
-funsafe-math-ottimizzazioni devono essere abilitati. Le biblioteche MASS dovranno essere
specificato al momento del collegamento.

-mfriz
-mno-friz
Genera (non generare) l'istruzione "friz" quando il -funsafe-math-ottimizzazioni
l'opzione viene utilizzata per ottimizzare l'arrotondamento dei valori in virgola mobile a un numero intero a 64 bit e
torna in virgola mobile. L'istruzione "friz" non restituisce lo stesso valore se il
il numero in virgola mobile è troppo grande per essere contenuto in un numero intero.

-punti-di-funzioni-annidate
-mno-puntatori-a-funzioni-annidate
Generare (non generare) codice per caricare il registro della catena statica (r11) quando
chiamata tramite un puntatore su sistemi AIX e Linux a 64 bit in cui un puntatore a funzione
punta a un descrittore di 3 parole che fornisce l'indirizzo della funzione, il valore TOC da caricare
registro r2, e il valore della catena statica da caricare nel registro r11.
-punti-di-funzioni-annidate è attivo per impostazione predefinita. Non potrai chiamare tramite
puntatori a funzioni annidate o puntatori a funzioni compilate in altri linguaggi che
usa la catena statica se usi il -mno-puntatori-a-funzioni-annidate.

-msave-toc-indiretto
-mno-salva-toc-indiretto
Genera (non generare) codice per salvare il valore TOC nella posizione dello stack riservata
nel prologo della funzione se la funzione chiama tramite un puntatore su AIX e 64 bit
Sistemi Linux. Se il valore TOC non viene salvato nel prologo, viene salvato appena prima
la chiamata tramite il puntatore. Il -mno-salva-toc-indiretto l'opzione è l'impostazione predefinita.

RX Opzioni

Queste opzioni della riga di comando sono definite per i target RX:

-m64bit-raddoppia
-m32bit-raddoppia
Rendi il tipo di dati "doppio" a 64 bit (-m64bit-raddoppia) o 32 bit (-m32bit-raddoppia)
in misura. L'impostazione predefinita è -m32bit-raddoppia. Note: Funziona solo l'hardware in virgola mobile RX
su valori a 32 bit, motivo per cui l'impostazione predefinita è -m32bit-raddoppia.

-fpu
-nofpu
Consente (-fpu) o disabilita (-nofpu) l'uso di hardware in virgola mobile RX. Il
l'impostazione predefinita è abilitata per il RX600 serie e disabili per il RX200 serie.

Le istruzioni in virgola mobile verranno generate solo per valori in virgola mobile a 32 bit
tuttavia, quindi se il -m64bit-raddoppia l'opzione è in uso, l'hardware della FPU non lo sarà
usato per il doppio.

Note: Se l' -fpu l'opzione è abilitata allora -funsafe-math-ottimizzazioni è anche abilitato
automaticamente. Questo perché le istruzioni RX FPU sono di per sé pericolose.

-mcpu=Nome
Seleziona il tipo di CPU RX da prendere di mira. Attualmente sono supportati tre tipi, il
generico RX600 ed RX200 hardware di serie e lo specifico RX610 PROCESSORE. L'impostazione predefinita è
RX600.

L'unica differenza tra RX600 ed RX610 è che l' RX610 non supporta il
Istruzione "MVTIPL".

I RX200 serie non ha un'unità hardware in virgola mobile e quindi -nofpu è abilitato
per impostazione predefinita quando questo tipo è selezionato.

-bbig-endian-data
-mlittle-endian-dati
Memorizza i dati (ma non il codice) nel formato big-endian. L'impostazione predefinita è
-mlittle-endian-dati, ovvero per memorizzare i dati nel formato little-endian.

-mlimite-dati-piccolo=N
Specifica la dimensione massima in byte delle variabili globali e statiche che possono essere posizionate
nella piccola area dati. L'utilizzo della piccola area dati può portare a dimensioni più piccole e più veloci
codice, ma la dimensione dell'area è limitata e spetta al programmatore assicurarsi che
l'area non trabocca. Anche quando viene utilizzata la piccola area dati uno degli RX
registri (di solito "r13") è riservato per l'uso che punta a quest'area, quindi è no
più disponibile per l'uso da parte del compilatore. Ciò potrebbe risultare più lento e/o più grande
codice se le variabili che una volta avrebbero potuto essere mantenute nel registro riservato sono ora
spinto sulla pila.

Nota, le variabili comuni (variabili che non sono state inizializzate) e le costanti sono
non inseriti nell'area dati piccola in quanto sono assegnati ad altre sezioni nel
eseguibile in uscita.

Il valore predefinito è zero, che disabilita questa funzione. Nota, questa funzione non lo è
abilitato di default con livelli di ottimizzazione più alti (-O2 ecc) a causa del
effetti potenzialmente dannosi della prenotazione di un registro. Sta al programmatore
per sperimentare e scoprire se questa funzione è vantaggiosa per il loro programma. Vedere
la descrizione del -pid opzione per una descrizione di come l'effettivo registro per
tieni premuto il puntatore dell'area dati piccola.

-msim
-mno-sim
Usa il runtime del simulatore. L'impostazione predefinita prevede l'utilizzo del runtime specifico della scheda libgloss.

-mas100-sintassi
-mno-as100-syntassi
Quando si genera l'output dell'assemblatore, utilizzare una sintassi compatibile con AS100 . di Renesas
assemblatore. Questa sintassi può essere gestita anche dall'assemblatore GAS ma ne ha alcune
restrizioni quindi generarlo non è l'opzione predefinita.

-mmax-dimensione-costante=N
Specifica la dimensione massima, in byte, di una costante che può essere utilizzata come operando in
un'istruzione RX. Sebbene il set di istruzioni RX consenta costanti fino a 4
byte di lunghezza da utilizzare nelle istruzioni, un valore più lungo equivale a un più lungo
istruzione. Pertanto, in alcune circostanze può essere utile limitare la dimensione di
costanti utilizzate nelle istruzioni. Le costanti troppo grandi lo sono invece
inserito in un pool costante e referenziato tramite l'indiretto di registro.

Il valore N può essere compreso tra 0 e 4. Un valore 0 (predefinito) o 4 significa che
sono consentite costanti di qualsiasi dimensione.

-rilassati
Abilita il rilassamento del linker. Il rilassamento del linker è un processo per cui il linker lo farà
tentare di ridurre le dimensioni di un programma trovando versioni più brevi di vari
Istruzioni. Disabilitato per impostazione predefinita.

-registro-menta=N
Specificare il numero di registri da riservare per le funzioni di gestione degli interrupt veloci. Il
APPREZZIAMO N può essere compreso tra 0 e 4. Un valore di 1 significa che il registro "r13" sarà
riservato all'uso esclusivo di gestori di interruzioni veloci. Un valore di 2 riserve
"r13" e "r12". Un valore di 3 riserve "r13", "r12" e "r11", e un valore di 4
riserva da "r13" a "r10". Un valore di 0, il valore predefinito, non ne riserva nessuno
registri.

-msave-acc-in-interrupt
Specifica che le funzioni del gestore di interrupt devono preservare il registro dell'accumulatore.
Questo è necessario solo se il codice normale potrebbe utilizzare il registro dell'accumulatore, ad esempio
perché esegue moltiplicazioni a 64 bit. L'impostazione predefinita è ignorare l'accumulatore
poiché ciò rende i gestori di interrupt più veloci.

-pid
-mno-pid
Consente la generazione di dati indipendenti dalla posizione. Quando abilitato qualsiasi accesso a
i dati costanti verranno eseguiti tramite un offset da un indirizzo di base tenuto in un registro. Questo
consente di determinare la posizione dei dati costanti in fase di esecuzione senza richiedere
l'eseguibile da riposizionare, che è un vantaggio per le applicazioni embedded con stretto
vincoli di memoria. I dati che possono essere modificati non sono interessati da questa opzione.

Nota, l'utilizzo di questa funzione riserva un registro, solitamente "r13", per i dati costanti
indirizzo di base. Ciò può comportare un codice più lento e/o più grande, specialmente in complicati
funzioni.

Il registro effettivo scelto per contenere l'indirizzo del database costante dipende dal fatto che
, il -mlimite-dati-piccoli e / o -registro-zecca le opzioni della riga di comando sono abilitate.
Partendo dal registro "r13" e procedendo verso il basso, i registri vengono assegnati per primi
per soddisfare i requisiti di -registro-zecca, poi -pid e infine
-mlimite-dati-piccoli. Quindi è possibile che il registro dell'area dati piccola sia "r8"
se entrambi -registro-zecca=4 ed -pid sono specificati nella riga di comando.

Per impostazione predefinita questa funzione non è abilitata. L'impostazione predefinita può essere ripristinata tramite il -mno-pid
opzione della riga di comando.

Nota: L'opzione generica della riga di comando di GCC -fissa-reg ha un significato speciale per l'RX
port quando utilizzato con l'attributo della funzione "interrupt". Questo attributo indica a
funzione destinata a elaborare gli interrupt veloci. GCC farà in modo che utilizzi solo il
registri "r10", "r11", "r12" e/o "r13" e solo a condizione che il normale utilizzo del
i registri corrispondenti sono stati ristretti tramite il -fissa-reg or -registro-zecca
opzioni della riga di comando.

S / 390 ed zSerie Opzioni

Questi sono la -m opzioni definite per l'architettura S/390 e zSeries.

-mhard-flottante
-msoft-flottante
Utilizzare (non utilizzare) le istruzioni e i registri hardware in virgola mobile per
operazioni puntuali. quando -msoft-flottante è specificato, funziona in libgcc.a sarà usato
per eseguire operazioni in virgola mobile. quando -mhard-flottante è specificato, il compilatore
genera istruzioni in virgola mobile IEEE. Questa è l'impostazione predefinita.

-mhard-dfp
-mno-hard-dfp
Utilizzare (non utilizzare) le istruzioni hardware a virgola mobile decimale per
operazioni in virgola mobile. quando -mno-hard-dfp è specificato, funziona in libgcc.a
verrà utilizzato per eseguire operazioni in virgola mobile decimale. quando -mhard-dfp is
specificato, il compilatore genera istruzioni hardware in virgola mobile decimale. Questo
è l'impostazione predefinita per -marzo=z9-ec o superiore.

-mlong-doppio-64
-mlong-doppio-128
Questi interruttori controllano la dimensione del tipo "long double". Una dimensione di 64 bit rende il
tipo "long double" equivalente al tipo "double". Questa è l'impostazione predefinita.

-mbackchain
-mno-backchain
Memorizzare (non memorizzare) l'indirizzo del frame del chiamante come puntatore backchain nel
stack frame del chiamato. Potrebbe essere necessaria una backchain per consentire il debug utilizzando strumenti che
non capiscono le informazioni sul frame di chiamata DWARF-2. quando -pila-mno-imballata è in
effetto, il puntatore backchain viene memorizzato nella parte inferiore dello stack frame; quando
-packed-stack è in effetti, il backchain è posizionato nella parola più in alto del
Area di salvataggio del registro da 96/160 byte.

In generale, codice compilato con -mbackchain è compatibile con le chiamate con il codice compilato con
-mmo-backchain; tuttavia, l'uso della backchain per scopi di debug di solito richiede
con cui è costruito l'intero binario -mbackchain. Si noti che la combinazione di
-mbackchain, -packed-stack ed -mhard-flottante non è supportato. Per costruire un
uso del kernel linux -msoft-flottante.

L'impostazione predefinita è non mantenere il backchain.

-packed-stack
-pila-mno-imballata
Utilizzare (non utilizzare) il layout della pila imballata. quando -pila-mno-imballata è specificato, il
compilatore utilizza tutti i campi dell'area di salvataggio del registro a 96/160 byte solo per i propri
scopo predefinito; i campi inutilizzati occupano ancora spazio nello stack. quando -packed-stack is
specificato, gli slot di salvataggio del registro sono densamente compressi nella parte superiore del salvataggio del registro
la zona; lo spazio inutilizzato viene riutilizzato per altri scopi, consentendo un uso più efficiente di
lo spazio disponibile della pila. Tuttavia, quando -mbackchain è anche in effetti, il più alto
la parola dell'area di salvataggio viene sempre utilizzata per memorizzare la backchain e l'indirizzo di ritorno
register viene sempre salvato due parole sotto la backchain.

Finché non viene utilizzata la backchain dello stack frame, il codice generato con -packed-stack
è compatibile con la chiamata con il codice generato con -pila-mno-imballata. Nota che alcuni non FSF
versioni di GCC 2.95 per codice generato da S/390 o zSeries che utilizza lo stack frame
backchain in fase di esecuzione, non solo per scopi di debug. Tale codice non è chiamato-
compatibile con il codice compilato con -packed-stack. Si noti inoltre che la combinazione di
-mbackchain, -packed-stack ed -mhard-flottante non è supportato. Per costruire un
uso del kernel linux -msoft-flottante.

L'impostazione predefinita è non utilizzare il layout stack compresso.

-msmall-exec
-mno-piccolo-exec
Generare (o non generare) codice utilizzando l'istruzione "reggiseni" per eseguire la subroutine
chiamate. Funziona in modo affidabile solo se la dimensione totale dell'eseguibile non supera i 64k.
L'impostazione predefinita è invece utilizzare l'istruzione "basr", che non ha questo
limitazione.

-M64
-M31
Quando -M31 è specificato, genera codice conforme a GNU/Linux per S/390 ABI. quando
-M64 è specificato, genera codice conforme a GNU/Linux per zSeries ABI. Questo
consente in particolare a GCC di generare istruzioni a 64 bit. Per il s390 obiettivi, i
l'impostazione predefinita è -M31, Mentre l' s390x obiettivi predefiniti su -M64.

-mzarca
-mesa
Quando -mzarca è specificato, generare il codice utilizzando le istruzioni disponibili su
z/Architettura. quando -mesa è specificato, generare il codice utilizzando le istruzioni
disponibile su ESA/390. Notare che -mesa non è possibile con -M64. Quando si genera
codice conforme a GNU/Linux per S/390 ABI, il valore predefinito è -mesa. Quando si genera
codice conforme a GNU/Linux per zSeries ABI, l'impostazione predefinita è -mzarca.

-mmvcle
-mno-mvcle
Generare (o non generare) codice utilizzando l'istruzione "mvcle" per eseguire il blocco
si sposta. quando -mno-mvcle è specificato, utilizzare invece un ciclo "mvc". Questa è l'impostazione predefinita
a meno che non si ottimizzi per le dimensioni.

-mdebug
-mno-debug
Stampa (o non stampa) ulteriori informazioni di debug durante la compilazione. L'impostazione predefinita è
per non stampare le informazioni di debug.

-marzo=tipo di CPU
Genera codice che verrà eseguito su tipo di CPU, che è il nome di un sistema che rappresenta a
determinato tipo di processore. Valori possibili per tipo di CPU sono g5, g6, z900, z990, z9-109,
Z9-EC ed z10. Quando si genera codice utilizzando le istruzioni disponibili su
z/Architettura, l'impostazione predefinita è -marzo=z900. In caso contrario, l'impostazione predefinita è -marzo=g5.

-mtune=tipo di CPU
Sintonizzati su tipo di CPU tutto ciò che riguarda il codice generato, ad eccezione dell'ABI
e il set di istruzioni disponibili. L'elenco di tipo di CPU i valori sono gli stessi di per
-marzo. Il valore predefinito è il valore utilizzato per -marzo.

-mtpf-traccia
-mno-tpf-traccia
Genera codice che aggiunge (non aggiunge) nei rami specifici del sistema operativo TPF per tracciare le routine
nel sistema operativo. Questa opzione è disattivata per impostazione predefinita, anche durante la compilazione per il
Sistema operativo TPF.

-mfuso-pazzo
-mno-fuso-madd
Genera codice che utilizza (non utilizza) la moltiplicazione e l'accumulo in virgola mobile
Istruzioni. Queste istruzioni vengono generate per impostazione predefinita se hardware in virgola mobile
viene utilizzato.

-mwarn-dimensione-frame=dimensione della cornice
Emette un avviso se la funzione corrente supera la dimensione del frame data. Perché questo è
un controllo in fase di compilazione non deve essere un vero problema quando il programma viene eseguito. Esso
ha lo scopo di identificare le funzioni che molto probabilmente causano un overflow dello stack. è
utile per essere utilizzato in un ambiente con dimensioni dello stack limitate, ad esempio il kernel linux.

-mwarn-stack dinamico
Emette un avviso se la funzione chiama alloca o utilizza array di dimensioni dinamiche. Questo è
generalmente una cattiva idea con una dimensione dello stack limitata.

-mstack-guard=guardia-pila
-mstack-dimensione=dimensione dello stack
Se vengono fornite queste opzioni, il back-end s390 emette istruzioni aggiuntive nel
prologo della funzione che attiva una trappola se la dimensione dello stack è guardia-pila byte sopra
, il dimensione dello stack (ricorda che lo stack su s390 cresce verso il basso). Se la guardia-pila
opzione viene omessa la potenza minima di 2 maggiore della dimensione del fotogramma del compilato
viene scelta la funzione. Queste opzioni sono destinate ad essere utilizzate per aiutare a eseguire il debug dello stack
problemi di trabocco. Il codice emesso in aggiunta causa solo un piccolo sovraccarico e
quindi può essere utilizzato anche in produzione come sistemi senza maggiori prestazioni
degradazione. I valori dati devono essere potenze esatte di 2 e dimensione dello stack deve essere
più grande di guardia-pila senza superare i 64k. Per essere efficiente l'extra
il codice presuppone che lo stack inizi a un indirizzo allineato al valore
dato da dimensione dello stack. guardia-pila l'opzione può essere utilizzata solo in combinazione con
dimensione dello stack.

Risultato Opzioni

Queste opzioni sono definite per le implementazioni di Score:

-meb
Compila il codice per la modalità big-endian. Questa è l'impostazione predefinita.

-mel
Compila il codice per la modalità little-endian.

-mnhwloop
Disabilita la generazione dell'istruzione bcnz.

-mul
Abilita generare un carico non allineato e memorizzare l'istruzione.

-mmac
Consentire l'uso di istruzioni di accumulo multiplo. Disabilitato per impostazione predefinita.

-punteggio 5
Specificare SCORE5 come architettura di destinazione.

-mscore5u
Specificare lo SCORE5U dell'architettura di destinazione.

-punteggio 7
Specificare SCORE7 come architettura di destinazione. Questa è l'impostazione predefinita.

-mscore7d
Specificare SCORE7D come architettura di destinazione.

SH Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni SH:

-M1 Genera codice per SH1.

-M2 Genera codice per SH2.

-m2e
Genera codice per SH2e.

-m2a-nofpu
Genera codice per SH2a senza FPU o per SH2a-FPU in modo tale che il
l'unità a virgola mobile non viene utilizzata.

-m2a-solo-singolo
Genera codice per SH2a-FPU, in modo tale che non ci sia virgola mobile a doppia precisione
si utilizzano le operazioni.

-m2a-singolo
Genera codice per SH2a-FPU supponendo che l'unità a virgola mobile sia in precisione singola
modalità predefinita.

-m2a
Genera codice per SH2a-FPU assumendo che l'unità a virgola mobile sia in doppia precisione
modalità predefinita.

-M3 Genera codice per SH3.

-m3e
Genera codice per SH3e.

-m4-nofpu
Genera codice per SH4 senza un'unità a virgola mobile.

-m4-solo-singolo
Genera codice per SH4 con un'unità a virgola mobile che supporta solo
aritmetica di precisione.

-m4-singolo
Genera codice per SH4 supponendo che l'unità a virgola mobile sia in modalità a precisione singola
per impostazione predefinita.

-M4 Genera codice per SH4.

-m4a-nofpu
Genera codice per SH4al-dsp, o per SH4a in modo tale che la virgola mobile
l'unità non viene utilizzata.

-m4a-solo-singolo
Genera codice per SH4a, in modo tale che non ci sia virgola mobile a doppia precisione
si utilizzano le operazioni.

-m4a-singolo
Genera codice per SH4a assumendo che l'unità a virgola mobile sia in precisione singola
modalità predefinita.

-m4a
Genera codice per SH4a.

-m4al
Uguale a -m4a-nofpu, tranne che passa implicitamente -dsp all'assemblatore. GCC
al momento non genera alcuna istruzione DSP.

-mb Compila il codice per il processore in modalità big-endian.

-ml Compila il codice per il processore in modalità little-endian.

-mdalign
Allinea i doppi ai limiti di 64 bit. Nota che questo cambia le convenzioni di chiamata,
e quindi alcune funzioni della libreria C standard non funzioneranno a meno che non si ricompilino
prima con -mdalign.

-rilassati
Accorciare alcuni riferimenti di indirizzo al momento del collegamento, quando possibile; usa l'opzione del linker
-rilassare.

-migtable
Utilizzare offset a 32 bit nelle tabelle "switch". L'impostazione predefinita prevede l'utilizzo di offset a 16 bit.

-mbitop
Abilitare l'uso delle istruzioni di manipolazione dei bit su SH2A.

-mfmovd
Abilitare l'uso dell'istruzione "fmovd". Dai un'occhiata -mdalign per i vincoli di allineamento.

-mitachi
Rispettare le convenzioni di chiamata definite da Renesas.

-mrenesa
Rispettare le convenzioni di chiamata definite da Renesas.

-mno-renesas
Rispettare le convenzioni di chiamata definite per GCC prima delle convenzioni Renesas
erano disponibili. Questa opzione è l'impostazione predefinita per tutti i target della toolchain SH.

-mnomac salva
Contrassegna il registro "MAC" come bloccato, anche se -mitachi viene data.

-mieee
-mno-ieee
Controlla la conformità IEEE dei confronti in virgola mobile, che influisce sulla gestione
dei casi in cui il risultato di un confronto non è ordinato. Per impostazione predefinita -mieee is
implicitamente abilitato. Se -finite-math-only è abilitato -mno-ieee è implicitamente impostato,
che si traduce in confronti più uguali e meno uguali in virgola mobile più veloci. Il
le impostazioni implicite possono essere sovrascritte specificando sia -mieee or -mno-ieee.

-minline-ic_invalidate
Codice in linea per invalidare le voci della cache delle istruzioni dopo aver impostato la funzione nidificata
trampolini. Questa opzione non ha effetto se -musermode è attivo e l'opzione selezionata
l'opzione di generazione del codice (es. -m4) non consente l'uso dell'istruzione icbi. Se
l'opzione di generazione del codice selezionata non consente l'uso dell'istruzione icbi,
e -musermode non è attivo, il codice inline manipolerà l'istruzione
array di indirizzi cache direttamente con una scrittura associativa. Questo non solo richiede
modalità privilegiata, ma fallirà anche se la linea della cache è stata mappata tramite TLB
ed è diventato non mappato.

-dimensione
Scarica la dimensione e la posizione dell'istruzione nel codice dell'assembly.

-mpdstruct
Questa opzione è deprecata. Imbottisce le strutture a multipli di 4 byte, che è
incompatibile con la SH ABI.

-msoft-atomico
Genera sequenze atomiche del software gUSA compatibile con GNU/Linux per l'integrato atomico
funzioni. Le sequenze atomiche generate richiedono il supporto dell'interrupt /
codice di gestione delle eccezioni del sistema e sono adatti solo per sistemi single-core.
Non funzioneranno correttamente su sistemi multi-core. Questa opzione è abilitata da
default quando il target è "sh-*-linux*". Per i dettagli sul built-in atomico
funzioni vedi __atomico Builtin.

-mspazio
Ottimizza per lo spazio invece che per la velocità. Implicito da -Voi.

-prefergot
Quando si genera codice indipendente dalla posizione, emettere chiamate di funzione utilizzando l'offset globale
Tabella invece della Tabella di collegamento delle procedure.

-modalità utente
Non generare codice solo in modalità privilegiata; implica -mno-inline-ic_invalidate se il
il codice inline non funzionerebbe in modalità utente. Questa è l'impostazione predefinita quando l'obiettivo è
"sh-*-linux*".

-multicosto=numero
Imposta il costo da assumere per una moltiplicazione insn.

-mdiv=strategia
Imposta la strategia di divisione da utilizzare per le operazioni di divisione di interi. Per SHmedia
strategia può essere uno di:

fp Esegue l'operazione in virgola mobile. Questo ha una latenza molto alta, ma necessita
solo poche istruzioni, quindi potrebbe essere una buona scelta se il tuo codice ne ha abbastanza
ILP facilmente sfruttabile per consentire al compilatore di schedulare la virgola mobile
istruzioni insieme ad altre istruzioni. La divisione per zero causa a
eccezione in virgola mobile.

inv Utilizza operazioni intere per calcolare l'inverso del divisore, quindi
moltiplica il dividendo per l'inverso. Questa strategia consente CSE e sollevamento
del calcolo inverso. La divisione per zero calcola un risultato non specificato,
ma non intrappola.

inv:minlat
Una variante di inv dove, se non sono state trovate opportunità di CSE o di sollevamento, o se
l'intera operazione è stata issata nello stesso luogo, le ultime fasi del
calcolo inverso si intrecciano con la moltiplicazione finale per ridurre il totale
latenza, a scapito dell'utilizzo di qualche istruzione in più e quindi dell'offerta di meno
opportunità di pianificazione con altro codice.

chiamata
Chiama una funzione di libreria che di solito implementa il inv:minlat strategia. Questo
fornisce un'elevata densità di codice per le compilazioni "m5-*media-nofpu".

call2
Utilizza un punto di ingresso diverso della stessa funzione di libreria, dove assume che a
il puntatore a una tabella di ricerca è già stato impostato, che espone il caricamento del puntatore
alle ottimizzazioni di CSE e di sollevamento del codice.

inv:chiamare
inv:chiama2
inv:fp
Usa il inv algoritmo per la generazione iniziale del codice, ma se il codice rimane
non ottimizzato, tornare al chiamata, call2, o fp strategie, rispettivamente. Notare che
l'effetto collaterale potenzialmente intrappolante della divisione per zero è portato da un separato
istruzione, quindi è possibile che tutte le istruzioni intere vengano tirate fuori,
ma l'indicatore dell'effetto collaterale rimane dov'è. Una ricombinazione per
operazioni in virgola mobile o una chiamata non sono possibili in questo caso.

inv20u
inv20l
Varianti di inv:minlat strategia. Nel caso in cui il calcolo inverso sia
non separati dalla moltiplicazione, accelerano la divisione dove sta il dividendo
in 20 bit (segno più dove applicabile) inserendo un test per saltare un numero di
operazioni in questo caso; questo test rallenta il caso di dividendi maggiori.
inv20u assume che il caso di un dividendo così piccolo sia improbabile, e inv20l
presume che sia probabile.

Per target diversi da SHmedia strategia può essere uno di:

Call-div1
Chiama una funzione di libreria che utilizza l'istruzione di divisione a passo singolo "div1" per
eseguire l'operazione. La divisione per zero calcola un risultato non specificato e lo fa
non trappola. Questa è l'impostazione predefinita ad eccezione di SH4, SH2A e SHcompact.

chiamata-fp
Chiama una funzione di libreria che esegue l'operazione in doppia precisione floating
punto. La divisione per zero causa un'eccezione a virgola mobile. Questa è l'impostazione predefinita
per SHcompact con FPU. Specificandolo per i target che non hanno un double
FPU di precisione verrà impostato su "call-div1".

chiamata-tabella
Chiama una funzione di libreria che utilizza una tabella di ricerca per piccoli divisori e il
Istruzione "div1" con distinzione tra maiuscole e minuscole per divisori più grandi. Divisione per zero
calcola un risultato non specificato e non esegue il trap. Questa è l'impostazione predefinita per SH4.
Specificare questo per i bersagli che non hanno istruzioni di cambio dinamico lo farà
l'impostazione predefinita è "call-div1".

Quando non è stata specificata una strategia di divisione, verrà selezionata la strategia predefinita
in base all'obiettivo attuale. Per SH2A la strategia predefinita è utilizzare i "div" e
Istruzioni "divu" invece delle chiamate alle funzioni di libreria.

-maccumulate-in-uscita-args
Riserva spazio una volta per gli argomenti in uscita nel prologo della funzione piuttosto che in giro
ogni chiamata. Generalmente vantaggioso per prestazioni e dimensioni. Necessario anche per rilassarsi
per evitare di modificare lo stack frame attorno al codice condizionale.

-mdivsi3_libfunc=Nome
Imposta il nome della funzione di libreria utilizzata per la divisione con segno a 32 bit su Nome. Questo
interessano solo il nome utilizzato nelle strategie di divisione call e inv:call, e il
il compilatore si aspetterà ancora gli stessi insiemi di registri input/output/clobbed come se
questa opzione non era presente.

-mintervallo-fisso=registro-intervallo
Genera codice trattando l'intervallo di registri specificato come registri fissi. Un registro fisso
è uno che l'allocatore del registro non può utilizzare. Questo è utile quando si compila il kernel
codice. Un intervallo di registri è specificato come due registri separati da un trattino. multiplo
gli intervalli di registro possono essere specificati separati da una virgola.

-adattare-srotolare
Accelerare lo srotolamento per evitare di battere i registri di destinazione. Questa opzione ha solo un
effetto se la base di codice gcc supporta l'hook di destinazione TARGET_ADJUST_UNROLL_MAX.

-indirizzamento mirato
Abilitare l'uso della modalità di indirizzamento indicizzato per SHmedia32/SHcompact. Questo è solo
sicuro se l'hardware e/o il sistema operativo implementano la semantica avvolgente a 32 bit per l'indicizzato
modalità di indirizzamento. L'architettura consente l'implementazione di processori con 64 bit
MMU, che il sistema operativo potrebbe utilizzare per ottenere l'indirizzamento a 32 bit, ma poiché nessun hardware attuale
l'implementazione supporta questo o qualsiasi altro modo per rendere sicura la modalità di indirizzamento indicizzata
da utilizzare nell'ABI a 32 bit, l'impostazione predefinita è -mno-indirizzamento-indicizzato.

-mgettrcosto=numero
Imposta il costo assunto per l'istruzione gettr su numero. Il valore predefinito è 2 se
-mpt-fisso è in vigore, 100 altrimenti.

-mpt-fisso
Supponiamo che le istruzioni pt* non vengano trap. Questo genererà generalmente una migliore pianificazione
codice, ma non è sicuro sull'hardware corrente. L'attuale definizione dell'architettura dice
che ptabs e ptrel intrappolano quando l'obiettivo anded con 3 è 3. Questo ha il
effetto involontario di rendere non sicuro la pianificazione di ptab / ptrel prima di un ramo, o
sollevarlo da un anello. Ad esempio, __do_global_ctors, una parte di libgcc che viene eseguita
costruttori all'avvio del programma, chiama le funzioni in un elenco delimitato da -1.
Con l'opzione -mpt-fixed, i ptab verranno eseguiti prima del test con -1. Quella
significa che tutti i costruttori verranno eseguiti un po' più velocemente, ma quando arriva il ciclo
alla fine dell'elenco, il programma si arresta in modo anomalo perché ptabs carica -1 in un target
Registrati. Poiché questa opzione non è sicura per qualsiasi hardware che implementa l'attuale
specifica dell'architettura, l'impostazione predefinita è -mno-pt-fixed. A meno che l'utente non specifichi a
costo specifico con -mgttrcosto, -mno-pt-fixed implica anche -mgettrcosto=100; Questo
scoraggia l'allocazione dei registri utilizzando i registri di destinazione per la memorizzazione di numeri interi ordinari.

-minvalid-simboli
Si supponga che i simboli potrebbero non essere validi. Simboli di funzioni ordinarie generati dal compilatore
sarà sempre valido per caricare con movi/shori/ptabs o movi/shori/ptrel, ma con
trucchi assembler e/o linker è possibile generare simboli che causeranno
ptabs / ptrel per intrappolare. Questa opzione è significativa solo quando -mno-pt-fisso è in
effetto. Preverrà quindi il blocco di base incrociato, il sollevamento e la maggior parte delle programmazioni di
carichi di simboli. L'impostazione predefinita è -mno-simboli-non-validi.

-mbranch-costo=num
Assumere num essere il costo per un'istruzione di ramo. I numeri più alti faranno il
il compilatore cerca di generare più codice senza branch, se possibile. Se non specificato il
viene selezionato in base al tipo di processore per cui viene compilato.

-mcbranchdi
Abilita il modello di istruzione "cbranchdi4".

-mcpeqdi
Emetti il ​​modello di istruzione "cmpeqdi_t" anche quando -mcbranchdi è in vigore.

-mfuso-pazzo
Consentire l'uso dell'istruzione "fmac" (moltiplicazione-accumulazione in virgola mobile) se
il tipo di processore lo supporta. L'abilitazione di questa opzione potrebbe generare codice che produce
risultati numerici in virgola mobile diversi rispetto alla rigida aritmetica IEEE 754.

-pretendere-cmove
Preferisci i rami condizionali a spostamento zero per l'istruzione di movimento condizionale
modelli. Ciò può comportare un codice più veloce sul processore SH4.

Solaris 2 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate su Solaris 2:

-testo-impuro
-testo-impuro, utilizzato in aggiunta a -condiviso, dice al compilatore di non passare -z testo a
il linker quando si collega un oggetto condiviso. Usando questa opzione, puoi collegare la posizione-
codice dipendente in un oggetto condiviso.

-testo-impuro sopprime il "rimangono traslochi contro allocabili ma non scrivibili"
messaggio di errore del linker di sezioni". Tuttavia, i riposizionamenti necessari attiveranno la copia-
in scrittura e l'oggetto condiviso non è effettivamente condiviso tra i processi. Invece di
utilizzando -testo-impuro, dovresti compilare tutto il codice sorgente con -fpic or -fPIC.

Questi switch sono supportati in aggiunta a quanto sopra su Solaris 2:

-pthread
Aggiungi il supporto per il multithreading utilizzando la libreria di thread POSIX. Questa opzione imposta
flag sia per il preprocessore che per il linker. Questa opzione non influisce sul thread
sicurezza del codice oggetto prodotto dal compilatore o quello delle librerie fornite con esso.

-pthread
Questo è sinonimo di -pthread.

SPARC Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate su SPARC:

-mno-app-regs
-mapp-regs
Specificare -mapp-regs per generare output utilizzando i registri globali da 2 a 4, che
lo SPARC SVR4 ABI si riserva per le applicazioni. Come il registro globale 1, ogni globale
il registro da 2 a 4 viene quindi trattato come un registro allocabile che viene bloccato da
chiamate di funzione. Questa è l'impostazione predefinita.

Per essere completamente conforme a SVR4 ABI al costo di una perdita di prestazioni, specificare
-mno-app-regs. Dovresti compilare librerie e software di sistema con questa opzione.

-mpiatto
-mno-piatto
Con -mpiatto, il compilatore non genera istruzioni di salvataggio/ripristino e usa a
modello di finestra "piatta" o a registro singolo. Questo modello è compatibile con il normale
registro modello finestra. I registri locali e i registri di ingresso (0--5) sono fermi
trattati come registri "chiamati salvati" e verranno salvati nello stack secondo necessità.

Con -mno-piatto (l'impostazione predefinita), il compilatore genera istruzioni di salvataggio/ripristino (tranne
per le funzioni foglia). Questa è la modalità operativa normale.

-mfpu
-mhard-flottante
Genera un output contenente istruzioni in virgola mobile. Questa è l'impostazione predefinita.

-mno-fpu
-msoft-flottante
Genera output contenente chiamate di libreria per virgola mobile. Attenzione: il requisito
le librerie non sono disponibili per tutti i target SPARC. Normalmente le strutture del
vengono usati i normali compilatori C della macchina, ma questo non può essere fatto direttamente in cross-
compilazione. Devi prendere le tue disposizioni per fornire una libreria adatta
funzioni per la compilazione incrociata. Gli obiettivi incorporati sparc-*-aout ed spaclite-*-*
fornire supporto software in virgola mobile.

-msoft-flottante cambia la convenzione di chiamata nel file di output; quindi, è solo
utile se compili contro tutti i di un programma con questa opzione. In particolare, è necessario
compilare libgcc.a, la libreria fornita con GCC, con -msoft-flottante in ordine per questo
lavorare.

-mhard-quad-flottante
Genera un output contenente istruzioni a virgola mobile quad-word (long double).

-msoft-quad-float
Genera output contenente chiamate di libreria per quad-word (long double) in virgola mobile
Istruzioni. Le funzioni richiamate sono quelle specificate nell'ABI SPARC. Questo è il
predefinito.

Al momento della stesura di questo documento, non ci sono implementazioni SPARC con supporto hardware per
le istruzioni a virgola mobile di quattro parole. Invocano tutti un gestore di trap per uno di
queste istruzioni, quindi il gestore trap emula l'effetto dell'istruzione.
A causa del sovraccarico del gestore trap, questo è molto più lento della chiamata alla libreria ABI
routine. Così il -msoft-quad-float l'opzione è l'impostazione predefinita.

-mno-non-allineato-doppio
-munaligned-doppi
Supponiamo che i doppi abbiano un allineamento a 8 byte. Questa è l'impostazione predefinita.

Con -munaligned-doppi, GCC presuppone che i doppi abbiano un allineamento a 8 byte solo se
sono contenuti in un altro tipo, o se hanno un indirizzo assoluto. Altrimenti, è
presuppone che abbiano un allineamento a 4 byte. Specificando questa opzione si evitano alcune rare
problemi di compatibilità con codice generato da altri compilatori. Non è l'impostazione predefinita
perché comporta una perdita di prestazioni, soprattutto per il codice a virgola mobile.

-mno-strutture-più veloci
-mfaster-struct
Con -mfaster-struct, il compilatore presuppone che le strutture debbano avere 8 byte
allineamento. Ciò consente l'uso di coppie di istruzioni "ldd" e "std" per le copie
nell'assegnazione della struttura, al posto del doppio delle coppie "ld" e "st". in ogni caso, il
l'uso di questo allineamento modificato viola direttamente l'ABI SPARC. Quindi, è inteso
solo per l'uso su obiettivi in ​​cui lo sviluppatore riconosce che il loro codice risultante
non sarà direttamente in linea con le regole dell'ABI.

-mcpu=tipo_cpu
Impostare il set di istruzioni, il set di registri e i parametri di pianificazione delle istruzioni per
tipo di macchina tipo_cpu. Valori supportati per tipo_cpu sono v7, cipresso, v8, supersparcato,
ipersparato, leon, spaclite, f930, f934, spaclite86x, scintillio, TSC701, v9,
ultrasparta, ultrasparco3, Niagara, niagara2, niagara3e niagara4.

Anche le toolchain native Solaris e GNU/Linux supportano il valore nativo, che seleziona
la migliore opzione di architettura per il processore host. -mcpu=nativo non ha effetto se
GCC non riconosce il processore.

I parametri di programmazione delle istruzioni di default vengono utilizzati per i valori che selezionano un
architettura e non un'implementazione. Questi sono v7, v8, spaclite, scintillio, v9.

Di seguito è riportato un elenco di ciascuna architettura supportata e delle relative implementazioni supportate.

v7 cipresso

v8 supersparc, ipersparc, leon

spaclite
f930, f934, spaclite86x

scintillio
TSC701

v9 ultrasparc, ultrasparc3, ​​niagara, niagara2, niagara3, niagara4

Per impostazione predefinita (se non diversamente configurato), GCC genera il codice per la variante V7 del
Architettura SPARC. Insieme a -mcpu=cipresso, il compilatore lo ottimizza inoltre per
il chip Cypress CY7C602, come utilizzato nella serie SPARCStation/SPARCServer 3xx. Questo è
adatto anche per la vecchia SPARCStation 1, 2, IPX ecc.

Con -mcpu=v8, GCC genera il codice per la variante V8 dell'architettura SPARC. Il
l'unica differenza rispetto al codice V7 è che il compilatore emette la moltiplicazione intera e
istruzioni di divisione intera che esistono in SPARC-V8 ma non in SPARC-V7. Insieme a
-mcpu=supersparc, il compilatore lo ottimizza ulteriormente per il chip SuperSPARC, come
utilizzato nelle serie SPARCStation 10, 1000 e 2000.

Con -mcpu=spartilite, GCC genera il codice per la variante SPARClite dello SPARC
architettura. Questo aggiunge il moltiplicatore intero, il passo di divisione intero e la scansione ("ffs")
istruzioni che esistono in SPARClite ma non in SPARC-V7. Insieme a -mcpu=f930, le
il compilatore lo ottimizza inoltre per il chip Fujitsu MB86930, che è l'originale
SPARClite, senza FPU. Insieme a -mcpu=f934, il compilatore lo ottimizza inoltre per
il chip Fujitsu MB86934, che è il più recente SPARClite con FPU.

Con -mcpu=particella, GCC genera il codice per la variante SPARClet di SPARC
architettura. Questo aggiunge l'intero moltiplicare, moltiplicare/accumulare, dividere intero
istruzioni step and scan ("ffs") che esistono in SPARClet ma non in SPARC-V7. Insieme a
-mcpu=tsc701, il compilatore lo ottimizza ulteriormente per il chip TEMIC SPARClet.

Con -mcpu=v9, GCC genera il codice per la variante V9 dell'architettura SPARC. Questo
aggiunge interi a 64 bit e istruzioni di spostamento in virgola mobile, 3 ulteriori in virgola mobile
registri del codice di condizione e istruzioni di spostamento condizionale. Insieme a -mcpu=ultrasparco,
il compilatore lo ottimizza inoltre per i chip Sun UltraSPARC I/II/IIi. Insieme a
-mcpu=ultrasparc3, il compilatore lo ottimizza ulteriormente per Sun UltraSPARC
Chip III/III+/IIIi/IIIi+/IV/IV+. Insieme a -mcpu=niagara, il compilatore inoltre
lo ottimizza per i chip Sun UltraSPARC T1. Insieme a -Mcpu = niagara2, il compilatore
lo ottimizza inoltre per i chip Sun UltraSPARC T2. Insieme a -Mcpu = niagara3, le
Il compilatore lo ottimizza inoltre per i chip Sun UltraSPARC T3. Insieme a -Mcpu = niagara4,
il compilatore lo ottimizza inoltre per i chip Sun UltraSPARC T4.

-mtune=tipo_cpu
Impostare i parametri di pianificazione delle istruzioni per il tipo di macchina tipo_cpu, ma non impostare
il set di istruzioni o il set di registri che l'opzione -mcpu=tipo_cpu voluto.

Gli stessi valori per -mcpu=tipo_cpu può essere utilizzato per -mtune=tipo_cpu, ma l'unico
i valori utili sono quelli che selezionano una particolare implementazione della CPU. Quelli sono
cipresso, supersparcato, ipersparato, leon, f930, f934, spaclite86x, TSC701, ultrasparta,
ultrasparco3, Niagara, niagara2, niagara3 ed niagara4. Con Solaris nativo e
Toolchain GNU/Linux, nativo può anche essere usato.

-mv8plus
-mno-v8plus
Con -mv8plus, GCC genera il codice per SPARC-V8+ ABI. La differenza dal V8
ABI è che i registri globali e out sono considerati larghi 64 bit. Questo è abilitato
per impostazione predefinita su Solaris in modalità a 32 bit per tutti i processori SPARC-V9.

-mvis
-mno-vis
Con -mvis, GCC genera codice che sfrutta UltraSPARC Visual
Estensioni del set di istruzioni. L'impostazione predefinita è -mno-vis.

-mvis2
-mno-vis2
Con -mvis2, GCC genera codice che sfrutta la versione 2.0 di UltraSPARC
Estensioni del set di istruzioni visive. L'impostazione predefinita è -mvis2 quando si prende di mira una CPU che
supporta tali istruzioni, come UltraSPARC-III e versioni successive. Collocamento -mvis2 anche
set -mvis.

-mvis3
-mno-vis3
Con -mvis3, GCC genera codice che sfrutta la versione 3.0 di UltraSPARC
Estensioni del set di istruzioni visive. L'impostazione predefinita è -mvis3 quando si prende di mira una CPU che
supporta tali istruzioni, come niagara-3 e versioni successive. Collocamento -mvis3 imposta anche
-mvis2 ed -mvis.

-mpocc
-mno-popc
Con -mpocc, GCC genera codice che sfrutta la popolazione UltraSPARC
istruzione di conteggio. L'impostazione predefinita è -mpocc quando si prende di mira una CPU che supporta tale
istruzioni, come Niagara-2 e successive.

-mfmf
-mno-fmaf
Con -mfmf, GCC genera un codice che sfrutta l'UltraSPARC Fused Multiply-
Aggiungi estensioni in virgola mobile. L'impostazione predefinita è -mfmf quando si prende di mira una CPU che
supporta tali istruzioni, come Niagara-3 e versioni successive.

-mfix-at697f
Abilita la soluzione documentata per il singolo erratum del processore Atmel AT697F
(che corrisponde all'erratum #13 del processore AT697E).

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate in aggiunta a quanto sopra sui processori SPARC-V9 a 64 bit
ambienti:

-M32
-M64
Genera codice per un ambiente a 32 o 64 bit. L'ambiente a 32 bit imposta int,
long e puntatore a 32 bit. L'ambiente a 64 bit imposta int su 32 bit e long e
puntatore a 64 bit.

-mcmodello=quale
Imposta il modello di codice su uno di

medio
Il modello di codice medio/basso: indirizzi a 64 bit, i programmi devono essere collegati nel basso 32
bit di memoria. I programmi possono essere collegati staticamente o dinamicamente.

medio
Il modello di codice medio/medio: indirizzi a 64 bit, i programmi devono essere collegati in basso
44 bit di memoria, i segmenti di testo e dati devono avere una dimensione inferiore a 2 GB e
il segmento di dati deve trovarsi entro 2 GB dal segmento di testo.

medaglione
Il modello di codice Medium/Anywhere: indirizzi a 64 bit, i programmi possono essere collegati ovunque
in memoria, i segmenti di testo e dati devono avere una dimensione inferiore a 2 GB e i dati
Il segmento deve trovarsi entro 2 GB dal segmento di testo.

Emmedany
Il modello di codice Medium/Anywhere per i sistemi embedded: indirizzi a 64 bit, il testo
e i segmenti di dati devono avere una dimensione inferiore a 2 GB, entrambi a partire da qualsiasi punto della memoria
(determinato al momento del collegamento). Il registro globale %g4 punta alla base dei dati
segmento. I programmi sono collegati staticamente e il PIC non è supportato.

-memory-model=mem-modello
Imposta il modello di memoria in vigore sul processore su uno di

difetto
Il modello di memoria predefinito per il processore e il sistema operativo.

rm Ordine di memoria rilassato

pso Ordine parziale del negozio

tso Ordine totale del negozio

sc Consistenza sequenziale

Questi modelli di memoria sono formalmente definiti nell'Appendice D dell'architettura Sparc V9
manuale, come impostato nel campo "PSTATE.MM" del processore.

-mstack-bias
-mno-stack-bias
Con -mstack-bias, GCC presuppone che il puntatore dello stack e il puntatore del frame se presenti,
sono sfalsati di -2047 che devono essere aggiunti di nuovo quando si effettuano i riferimenti di stack frame. Questo
è l'impostazione predefinita in modalità a 64 bit. In caso contrario, si supponga che tale offset non sia presente.

SPU Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate sulla SPU:

-mwarn-reloc
-errore-reloc
Il caricatore per SPU non gestisce i trasferimenti dinamici. Per impostazione predefinita, GCC darà un
errore quando genera codice che richiede un riposizionamento dinamico. -mno-errore-reloc
disabilita l'errore, -mwarn-reloc genererà invece un avviso.

-msafe-dma
-munsafe-dma
Le istruzioni che avviano o testano il completamento di DMA non devono essere riordinate con
rispetto ai carichi e agli archivi della memoria a cui si accede. Gli utenti in genere
affrontare questo problema utilizzando la parola chiave volatile, ma ciò può portare a un codice inefficiente
in luoghi dove si sa che la memoria non cambia. Piuttosto che contrassegnare il ricordo come
volatile trattiamo le istruzioni DMA come potenzialmente in grado di influenzare tutta la memoria. Insieme a
-munsafe-dma gli utenti devono utilizzare la parola chiave volatile per proteggere gli accessi alla memoria.

-mbranch-suggerimenti
Per impostazione predefinita, GCC genererà un'istruzione di suggerimento di diramazione per evitare stalli della pipeline per
sempre preso o probabilmente preso rami. Un suggerimento non verrà generato più vicino di 8
istruzioni lontano dal suo ramo. Ci sono pochi motivi per disabilitarli, tranne che per
scopi di debugging o per rendere un oggetto un po' più piccolo.

-mpiccolo-mem
-mgrande-mem
Per impostazione predefinita, GCC genera codice assumendo che gli indirizzi non siano mai più grandi di 18 bit.
Con -mgrande-mem viene generato un codice che presuppone un indirizzo completo a 32 bit.

-mstdmain
Per impostazione predefinita, GCC si collega al codice di avvio che assume la funzione principale in stile SPU
interfaccia (che ha un elenco di parametri non convenzionale). Insieme a -mstdmain, GCC collegherà
il tuo programma contro il codice di avvio che assume un'interfaccia in stile C99 su "principale",
inclusa una copia locale delle stringhe "argv".

-mintervallo-fisso=registro-intervallo
Genera codice trattando l'intervallo di registri specificato come registri fissi. Un registro fisso
è uno che l'allocatore del registro non può utilizzare. Questo è utile quando si compila il kernel
codice. Un intervallo di registri è specificato come due registri separati da un trattino. multiplo
gli intervalli di registro possono essere specificati separati da una virgola.

-mea32
-mea64
Compila il codice assumendo che i puntatori allo spazio degli indirizzi PPU a cui si accede tramite "__ea"
il qualificatore dello spazio degli indirizzi denominato sono larghi 32 o 64 bit. L'impostazione predefinita è 32 bit.
Poiché si tratta di un'opzione di modifica ABI, tutto il codice oggetto in un eseguibile deve essere compilato
con la stessa impostazione.

-conversione-spazio-indirizzo
-conversione-spazio-indirizzo-mno
Consentire/non consentire di trattare lo spazio degli indirizzi "__ea" come un sovrainsieme dell'indirizzo generico
spazio. Ciò consente cast espliciti di tipo tra "__ea" e puntatore generico, nonché
conversioni implicite di puntatori generici in puntatori "__ea". L'impostazione predefinita è consentire
conversioni del puntatore dello spazio di indirizzamento.

-dimensione-mcache=dimensione della cache
Questa opzione controlla la versione di libgcc che il compilatore collega a un eseguibile
e seleziona una cache gestita dal software per accedere alle variabili nell'indirizzo "__ea"
spazio con una particolare dimensione della cache. Possibili opzioni per dimensione della cache sono 8, 16, 32, 64
ed 128. La dimensione della cache predefinita è 64 KB.

-aggiornamenti-matomic
-aggiornamenti mno-atomici
Questa opzione controlla la versione di libgcc che il compilatore collega a un eseguibile
e seleziona se gli aggiornamenti atomici alla cache gestita dal software delle variabili lato PPU
sono utilizzati. Se usi gli aggiornamenti atomici, cambia in una variabile PPU dal codice SPU usando
il qualificatore di spazio indirizzo denominato "__ea" non interferirà con le modifiche ad altre PPU
variabili che risiedono nella stessa linea di cache dal codice PPU. Se non usi l'atomo
aggiornamenti, tale interferenza può verificarsi; tuttavia, riscrivere le righe della cache sarà più
efficiente. Il comportamento predefinito consiste nell'utilizzare gli aggiornamenti atomici.

-mdual-nops
-mdual-nops =n
Per impostazione predefinita, GCC inserirà nops per aumentare il doppio problema quando si aspetta che aumenti
e le prestazioni. n può essere un valore compreso tra 0 e 10. Un più piccolo n inserirà meno nops. 10
è l'impostazione predefinita, 0 è uguale a -mno-doppio-nops. Disabilitato con -Voi.

-mint-max-nops=n
Numero massimo di nop da inserire per un suggerimento di ramo. Un suggerimento di ramo deve essere almeno 8
istruzioni lontano dalla filiale che sta effettuando. GCC inserirà fino a n no a
applicarlo, altrimenti non genererà il suggerimento del ramo.

-mint-max-distanza=n
La codifica dell'istruzione del suggerimento di diramazione limita il suggerimento a essere entro 256
istruzioni della filiale che sta effettuando. Per impostazione predefinita, GCC si assicura che sia all'interno
125

-msafe-suggerimenti
Risolvere un bug hardware che causa lo stallo indefinito della SPU. Per impostazione predefinita, GCC
inserirà l'istruzione "hbrp" per assicurarsi che questo stallo non si verifichi.

Opzioni per Sistema V

Queste opzioni aggiuntive sono disponibili su System V Release 4 per compatibilità con altri
compilatori su quei sistemi:

-G Crea un oggetto condiviso. Si raccomanda che -simbolico or -condiviso essere usato invece.

-Qy Identificare le versioni di ogni strumento utilizzato dal compilatore, in un assembler ".ident"
direttiva in uscita.

-Qn Evita di aggiungere direttive ".ident" al file di output (questa è l'impostazione predefinita).

-SI,dirs
Cerca nelle directory dirs, e nessun altro, per le librerie specificate con -l.

-Ym,dir
Guarda nella directory dir per trovare il preprocessore M4. L'assemblatore usa questo
opzione.

TILE-Gx Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate su TILE-Gx:

-mcpu=Nome
Seleziona il tipo di CPU da prendere di mira. Attualmente l'unico tipo supportato è tilex.

-M32
-M64
Genera codice per un ambiente a 32 o 64 bit. L'ambiente a 32 bit imposta int,
long e puntatore a 32 bit. L'ambiente a 64 bit imposta int su 32 bit e long e
puntatore a 64 bit.

TILEPro Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono supportate su TILEPro:

-mcpu=Nome
Seleziona il tipo di CPU da prendere di mira. Attualmente l'unico tipo supportato è tilepro.

-M32
Genera codice per un ambiente a 32 bit, che imposta int, long e pointer a 32 bit.
Questo è l'unico comportamento supportato, quindi il flag viene sostanzialmente ignorato.

V850 Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per le implementazioni V850:

-mlong-chiamate
-mno-chiamate lunghe
Tratta tutte le chiamate come se fossero lontane (vicine). Se si presume che le chiamate siano lontane, il
il compilatore caricherà sempre l'indirizzo delle funzioni in un registro e chiamerà indirettamente
attraverso il puntatore.

-mno-ep
-mep
Non ottimizzare (ottimizzare) i blocchi di base che utilizzano lo stesso puntatore indice 4 o più
volte per copiare il puntatore nel registro "ep" e utilizzare i più brevi "sld" e "sst"
Istruzioni. Il -mep l'opzione è attiva per impostazione predefinita se ottimizzi.

-mno-prolog-funzione
-funzione-mprolog
Non utilizzare (usare) funzioni esterne per salvare e ripristinare i registri al prologo
ed epilogo di una funzione. Le funzioni esterne sono più lente, ma utilizzano meno codice
spazio se più di una funzione salva lo stesso numero di registri. Il
-funzione-mprolog l'opzione è attiva per impostazione predefinita se ottimizzi.

-mspazio
Cerca di rendere il codice il più piccolo possibile. Al momento, questo accende solo il -mep
ed -funzione-mprolog opzioni.

-mtda=n
Metti variabili statiche o globali la cui dimensione è n byte o meno nella piccola area dati
a cui punta il registro "ep". La minuscola area dati può contenere fino a 256 byte in totale
(128 byte per i riferimenti di byte).

-msda=n
Metti variabili statiche o globali la cui dimensione è n byte o meno nella piccola area dati
a cui punta il registro "gp". La piccola area dati può contenere fino a 64 kilobyte.

-mzda=n
Metti variabili statiche o globali la cui dimensione è n byte o meno nei primi 32
kilobyte di memoria.

-mv850
Specificare che il processore di destinazione è il V850.

-grande-interruttore
Genera codice adatto a grandi tabelle di commutazione. Utilizzare questa opzione solo se il
assembler/linker si lamentano di rami fuori range all'interno di una tabella switch.

-mapp-regs
Questa opzione farà in modo che r2 e r5 vengano utilizzati nel codice generato dal compilatore.
Questa impostazione è l'impostazione predefinita.

-mno-app-regs
Questa opzione farà in modo che r2 e r5 vengano trattati come registri fissi.

-mv850e2v3
Specificare che il processore di destinazione è il V850E2V3. Le costanti del preprocessore
__v850e2v3__ sarà definito se viene utilizzata questa opzione.

-mv850e2
Specificare che il processore di destinazione è il V850E2. Le costanti del preprocessore
__v850e2__ sarà definito se viene utilizzata questa opzione.

-mv850e1
Specificare che il processore di destinazione è il V850E1. Le costanti del preprocessore
__v850e1__ ed __v850e__ sarà definito se viene utilizzata questa opzione.

-mv850es
Specificare che il processore di destinazione è il V850ES. Questo è un alias per il -mv850e1
opzione.

-mv850e
Specificare che il processore di destinazione è il V850E. La costante del preprocessore __v850e__
sarà definito se viene utilizzata questa opzione.

Se nessuno dei due -mv850 né -mv850e né -mv850e1 né -mv850e2 né -mv850e2v3 Sono definiti
quindi verrà scelto un processore di destinazione predefinito e il relativo __v850*__ preprocessore
costante sarà definita.

Le costanti del preprocessore __v850 ed __v851__ sono sempre definiti, indipendentemente da quale
la variante del processore è l'obiettivo.

-mdisable-chiamata
Questa opzione sopprimerà la generazione dell'istruzione CALLT per v850e, v850e1,
Versioni v850e2 e v850e2v3 dell'architettura v850. L'impostazione predefinita è
-mno-disabilita-callt che consente di utilizzare l'istruzione CALLT.

VAX Opzioni

Strumenti Bowman per analizzare le seguenti finiture: -m le opzioni sono definite per il VAX:

-munix
Non emettere determinate istruzioni di salto ("aobleq" e così via) che l'assemblatore Unix
per il VAX non può gestire su lunghe distanze.

-mgnu
Emetti quelle istruzioni di salto, partendo dal presupposto che assemblerai con il
assemblatore GNU.

-mg Codice di output per i numeri a virgola mobile in formato G invece del formato D.

VxWorks Opzioni

Le opzioni in questa sezione sono definite per tutti i target VxWorks. Opzioni specifiche per il
l'hardware di destinazione è elencato con le altre opzioni per tale destinazione.

-mrtp
GCC può generare codice sia per i kernel VxWorks che per i processi in tempo reale (RTP). Questo
opzione passa dalla prima alla seconda. Definisce anche la macro del preprocessore
"__RTP__".

-non statico
Collega un eseguibile RTP a librerie condivise anziché a librerie statiche. Il
Opzioni -statico ed -condiviso può essere utilizzato anche per RTP; -statico è l'impostazione predefinita.

-Bstatico
-Bdinamica
Queste opzioni vengono passate al linker. Sono definiti per compatibilità con
diab.

-Xbind-pigro
Abilita il lazy binding delle chiamate di funzione. Questa opzione è equivalente a -Wl,-z, adesso ed è
definito per compatibilità con Diab.

-Xbind-ora
Disabilita l'associazione pigra delle chiamate di funzione. Questa opzione è l'impostazione predefinita ed è definita per
compatibilità con Diab.

x86-64 Opzioni

Questi sono elencati sotto

Xstormy16 Opzioni

Queste opzioni sono definite per Xstormy16:

-msim
Scegli i file di avvio e lo script del linker adatti al simulatore.

Xtensa Opzioni

Queste opzioni sono supportate per i target Xtensa:

-mconst16
-mno-const16
Abilitare o disabilitare l'uso delle istruzioni "CONST16" per il caricamento di valori costanti. Il
L'istruzione "CONST16" non è attualmente un'opzione standard di Tensilica. quando
abilitate, le istruzioni "CONST16" vengono sempre utilizzate al posto dello standard "L32R"
Istruzioni. L'uso di "CONST16" è abilitato di default solo se il "L32R"
l'istruzione non è disponibile.

-mfuso-pazzo
-mno-fuso-madd
Abilitare o disabilitare l'uso delle istruzioni di moltiplicazione/aggiunta e moltiplicazione/sottrazione fuse nel
opzione in virgola mobile. Questo non ha effetto se non lo è anche l'opzione a virgola mobile
abilitato. La disabilitazione delle istruzioni di moltiplicazione/aggiunta e moltiplicazione/sottrazione fuse forza il
compilatore per utilizzare istruzioni separate per le operazioni di moltiplicazione e addizione/sottrazione.
Ciò può essere auspicabile in alcuni casi in cui i risultati rigorosi conformi a IEEE 754 sono
richiesto: le istruzioni di addizione/sottrazione di moltiplicazione fuse non arrotondano l'intermedio
risultato, producendo così risultati con Scopri di più bit di precisione rispetto a quanto specificato dal
Norma IEEE. La disabilitazione delle istruzioni di aggiunta/sottrazione di moltiplicazione fuse assicura anche che
l'output del programma non è sensibile alla capacità del compilatore di combinare moltiplicare e
operazioni di addizione/sottrazione.

-mserializzare-volatile
-mno-serializza-volatile
Quando questa opzione è abilitata, GCC inserisce le istruzioni "MEMW" prima della memoria "volatile"
riferimenti per garantire la coerenza sequenziale. L'impostazione predefinita è -mserializzare-volatile.
Usa il -mno-serializza-volatile per omettere le istruzioni "MEMW".

-mforce-nessuna-immagine
Per obiettivi, come GNU/Linux, dove tutto il codice Xtensa in modalità utente deve essere posizionato
codice indipendente (PIC), questa opzione disabilita il PIC per la compilazione del codice del kernel.

-mtext-sezione-letterali
-mno-testo-sezione-letterali
Controllare il trattamento dei pool letterali. L'impostazione predefinita è -mno-testo-sezione-letterali,
che posiziona i letterali in una sezione separata nel file di output. Questo permette al
pool letterale da inserire in una RAM/ROM di dati e consente anche al linker di combinare
pool letterali da file oggetto separati per rimuovere letterali ridondanti e migliorare il codice
dimensione. Insieme a -mtext-sezione-letterali, i letterali sono intercalati nella sezione di testo
per tenerli il più vicino possibile ai loro riferimenti. Questo potrebbe essere necessario
per file di assiemi di grandi dimensioni.

-mtarget-align
-mno-target-align
Quando questa opzione è abilitata, GCC ordina all'assemblatore di allinearsi automaticamente
istruzioni per ridurre le sanzioni per le filiali a scapito di una certa densità di codice. Il
assemblatore tenta di ampliare le istruzioni di densità per allineare gli obiettivi del ramo e il
istruzioni seguendo le istruzioni di chiamata. Se non ci sono abbastanza precedenti sicuri
istruzioni di densità per allineare un target, non verrà eseguito alcun allargamento. L'impostazione predefinita è
-mtarget-align. Queste opzioni non influiscono sul trattamento dell'auto-allineato
istruzioni come "LOOP", che l'assemblatore allineerà sempre, sia allargando
istruzioni sulla densità o inserendo istruzioni di non intervento.

-chiamate lunghe
-mno-chiamate lunghe
Quando questa opzione è abilitata, GCC indica all'assemblatore di tradurre le chiamate dirette a
chiamate indirette a meno che non riesca a determinare che l'obiettivo di una chiamata diretta è nel
intervallo consentito dall'istruzione di chiamata. Questa traduzione si verifica in genere per le chiamate a
funzioni in altri file sorgente. In particolare, l'assemblatore traduce un direct
Istruzione "CALL" in un "L32R" seguito da un'istruzione "CALLX". L'impostazione predefinita è
-mno-chiamate lunghe. Questa opzione dovrebbe essere utilizzata nei programmi in cui il destinatario della chiamata può
essere potenzialmente fuori portata. Questa opzione è implementata nell'assemblatore, non nel
compilatore, quindi il codice assembly generato da GCC mostrerà ancora la chiamata diretta
istruzioni---guardare il codice oggetto disassemblato per vedere le istruzioni effettive.
Nota che l'assemblatore utilizzerà una chiamata indiretta per ogni chiamata tra file, non solo
quelli che davvero saranno fuori portata.

zSerie Opzioni

Questi sono elencati sotto

Opzioni per Code Generazione 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.

-fbounds-check
Per i front-end che lo supportano, genera codice aggiuntivo per verificare che gli indici utilizzati per
gli array di accesso rientrano nell'intervallo dichiarato. Questo è attualmente supportato solo da
Front-end Java e Fortran, dove questa opzione è impostata per impostazione predefinita su true e false
rispettivamente.

-ftrapv
Questa opzione genera trap per overflow con segno su addizione, sottrazione,
operazioni di moltiplicazione.

-fwrapv
Questa opzione indica al compilatore di assumere che l'overflow aritmetico con segno di
addizione, sottrazione e moltiplicazione si avvolgono usando il complemento a due
rappresentazione. Questo flag abilita alcune ottimizzazioni e ne disabilita altre. Questo
l'opzione è abilitata per impostazione predefinita per il front-end Java, come richiesto dal linguaggio Java
specificazione.

-feccezioni
Abilita la gestione delle eccezioni. Genera codice aggiuntivo necessario per propagare le eccezioni. Per
alcuni obiettivi, questo implica che GCC genererà informazioni di srotolamento dei frame per tutti
funzioni, che possono produrre un sovraccarico di dimensioni significative dei dati, sebbene non lo faccia
influenzare l'esecuzione. Se non specifichi questa opzione, GCC la abiliterà per impostazione predefinita
per linguaggi come il C++ che normalmente richiedono la gestione delle eccezioni e disabilitarlo per
linguaggi come il C che normalmente non lo richiedono. Tuttavia, potrebbe essere necessario abilitare
questa opzione durante la compilazione di codice C che deve interagire correttamente con eccezioni
gestori scritti in C++. Potresti anche voler disabilitare questa opzione se lo sei
compilare programmi C++ meno recenti che non utilizzano la gestione delle eccezioni.

-fnon-chiamata-eccezioni
Genera codice che consente alle istruzioni di trapping di generare eccezioni. Nota che questo
richiede un supporto runtime specifico della piattaforma che non esiste ovunque. Inoltre,
permette solo intrappolando istruzioni per lanciare eccezioni, ad esempio riferimenti alla memoria o
istruzioni in virgola mobile. Non consente di generare eccezioni da arbitrari
gestori di segnale come "SIGALRM".

-funwind-tavoli
Simile a -feccezioni, tranne per il fatto che genererà solo i dati statici necessari, ma
non influenzerà in nessun altro modo il codice generato. Normalmente non abiliti
questa opzione; invece, un processore linguistico che necessita di questa gestione lo abiliterebbe su
in tua vece.

-tabelle-svolgimento-fasincrono
Genera tabella di svolgimento in formato dwarf2, se supportato dalla macchina di destinazione. Il tavolo è
esatto in corrispondenza di ogni confine di istruzione, quindi può essere utilizzato per lo srotolamento della pila da
eventi asincroni (come debugger o Garbage Collector).

-fpcc-struct-ritorno
Restituisce i valori "short" "struct" e "union" in memoria come quelli più lunghi, anziché in
registri. Questa convenzione è meno efficiente, ma ha il vantaggio di consentire
intercalabilità tra file compilati con GCC e file compilati con altri compilatori,
in particolare il compilatore C portatile (pcc).

La convenzione precisa per restituire le strutture in memoria dipende dal target
macro di configurazione.

Le strutture corte e le unioni sono quelle la cui dimensione e allineamento corrispondono a quelle di alcuni
tipo intero.

Attenzione: codice compilato con il -fpcc-struct-ritorno l'interruttore non è compatibile con il binario
con codice compilato con il -freg-struct-ritorno interruttore. Usalo per conformarti a un non-
interfaccia binaria dell'applicazione predefinita.

-freg-struct-ritorno
Restituire i valori "struct" e "union" nei registri quando possibile. Questo è più efficiente
per piccole strutture di -fpcc-struct-ritorno.

Se non specifichi nessuno dei due -fpcc-struct-ritorno né -freg-struct-ritorno, il valore predefinito di GCC è
qualunque sia la convenzione standard per il target. Se non esiste una convenzione standard,
L'impostazione predefinita di GCC è -fpcc-struct-ritorno, ad eccezione di obiettivi in ​​cui GCC è il principale
compilatore. In questi casi, possiamo scegliere lo standard e abbiamo scelto il più efficiente
registro restituzione alternativa.

Attenzione: codice compilato con il -freg-struct-ritorno l'interruttore non è compatibile con il binario
con codice compilato con il -fpcc-struct-ritorno interruttore. Usalo per conformarti a un non-
interfaccia binaria dell'applicazione predefinita.

-fshort-enum
Assegna a un tipo "enum" solo il numero di byte necessario per l'intervallo dichiarato di
valori possibili. Nello specifico, il tipo "enum" sarà equivalente al più piccolo
tipo intero con spazio sufficiente.

Attenzione: , il -fshort-enum switch fa sì che GCC generi codice non binario
compatibile con il codice generato senza quell'interruttore. Usalo per conformarti a un non-
interfaccia binaria dell'applicazione predefinita.

-fshort-doppio
Usa la stessa dimensione per "doppio" e per "float".

Attenzione: , il -fshort-doppio switch fa sì che GCC generi codice non binario
compatibile con il codice generato senza quell'interruttore. Usalo per conformarti a un non-
interfaccia binaria dell'applicazione predefinita.

-fshort-wchar
Sostituisci il tipo sottostante per wchar_t essere corto unsigned int invece del
predefinito per la destinazione. Questa opzione è utile per creare programmi da eseguire sotto
VINO.

Attenzione: , il -fshort-wchar switch fa sì che GCC generi codice non binario
compatibile con il codice generato senza quell'interruttore. Usalo per conformarti a un non-
interfaccia binaria dell'applicazione predefinita.

-fno-comune
Nel codice C, controlla il posizionamento delle variabili globali non inizializzate. Compilatori C Unix
hanno tradizionalmente consentito definizioni multiple di tali variabili in differenti
unità di compilazione inserendo le variabili in un blocco comune. Questo è il comportamento
specificato da -fcomune, ed è l'impostazione predefinita per GCC sulla maggior parte dei target. D'altra parte,
questo comportamento non è richiesto da ISO C, e su alcuni obiettivi può portare una velocità o un codice
penalità dimensionale su referenze variabili. Il -fno-comune opzione specifica che il
il compilatore dovrebbe posizionare variabili globali non inizializzate nella sezione dati dell'oggetto
file, piuttosto che generarli come blocchi comuni. Questo ha l'effetto che se il
stessa variabile è dichiarata (senza "extern") in due diverse compilazioni, lo farai
ottieni un errore di definizione multipla quando li colleghi. In questo caso, devi compilare
con -fcomune Invece. Compilando con -fno-comune è utile su obiettivi per i quali è
fornisce prestazioni migliori, o se si desidera verificare che il programma funzioni su
altri sistemi che trattano sempre in questo modo le dichiarazioni di variabili non inizializzate.

-fno-identificatore
Ignora il #identificazione Direttiva.

-direttiva-dimensione-finhibit
Non emettere una direttiva assembler ".size" o qualsiasi altra cosa che possa causare problemi
se la funzione è divisa a metà e le due metà sono posizionate in posizioni lontane
a parte nella memoria. Questa opzione viene utilizzata durante la compilazione crtstuff.c; non dovresti aver bisogno
usarlo per qualsiasi altra cosa.

-fverboso-asm
Inserisci ulteriori informazioni di commento nel codice di assemblaggio generato per renderlo di più
leggibile. Questa opzione è generalmente utile solo a coloro che hanno effettivamente bisogno di leggere il
codice assembly generato (forse durante il debug del compilatore stesso).

-fno-verboso-asm, l'impostazione predefinita, fa sì che le informazioni aggiuntive vengano omesse ed è
utile quando si confrontano due file assembler.

-interruttori frecord-gcc
Questa opzione fa sì che la riga di comando utilizzata per richiamare il compilatore sia
registrato nel file oggetto che si sta creando. Questo interruttore è implementato solo
su alcuni target e il formato esatto della registrazione è target e formato file binario
dipendente, ma di solito assume la forma di una sezione contenente testo ASCII. Questo
l'interruttore è legato al -fverboso-asm interruttore, ma quell'interruttore registra solo
informazioni nel file di output dell'assemblatore come commenti, quindi non raggiunge mai l'oggetto
file. Guarda anche -grecord-gcc-switch per un altro modo di memorizzare le opzioni del compilatore in
il file oggetto.

-fpic
Genera codice indipendente dalla posizione (PIC) adatto per l'uso in una libreria condivisa, se
supportato per la macchina di destinazione. Tale codice accede a tutti gli indirizzi costanti tramite a
tabella di offset globale (GOT). Il caricatore dinamico risolve le voci GOT quando il
si avvia il programma (il caricatore dinamico non fa parte di GCC; fa parte del programma operativo
sistema). Se la dimensione GOT per l'eseguibile collegato supera un massimo specifico per la macchina
size, ricevi un messaggio di errore dal linker che indica che -fpic non funziona; in
quel caso, ricompila con -fPIC Invece. (Questi massimi sono 8k su SPARC e 32k
su m68k e RS/6000. Il 386 non ha tale limite.)

Il codice indipendente dalla posizione richiede un supporto speciale e quindi funziona solo su
determinate macchine. Per il 386, GCC supporta PIC per System V ma non per Sun
386i. Il codice generato per IBM RS/6000 è sempre indipendente dalla posizione.

Quando questo flag è impostato, le macro "__pic__" e "__PIC__" sono definite a 1.

-fPIC
Se supportato per la macchina di destinazione, emette codice indipendente dalla posizione, adatto per
collegamento dinamico ed evitando qualsiasi limite alla dimensione della tabella di offset globale. Questo
fa la differenza su m68k, PowerPC e SPARC.

Il codice indipendente dalla posizione richiede un supporto speciale e quindi funziona solo su
determinate macchine.

Quando questo flag è impostato, le macro "__pic__" e "__PIC__" sono definite a 2.

-fpie
-fPIE
Queste opzioni sono simili a -fpic ed -fPIC, ma ha generato un codice indipendente dalla posizione
può essere collegato solo in eseguibili. Di solito queste opzioni vengono utilizzate quando -torta GCC
l'opzione verrà utilizzata durante il collegamento.

-fpie ed -fPIE entrambi definiscono le macro "__pie__" e "__PIE__". Le macro hanno il
valore 1 per -fpie e 2 per -fPIE.

-fno-salto-tabelle
Non utilizzare le tabelle di salto per le istruzioni switch anche dove sarebbe più efficiente
rispetto ad altre strategie di generazione del codice. Questa opzione è utile in combinazione con
-fpic or -fPIC per il codice di costruzione che fa parte di un linker dinamico e non può
fare riferimento all'indirizzo di una tabella di salto. Su alcuni bersagli, le tabelle di salto non richiedono a
GOT e questa opzione non è necessaria.

-fissa-reg
Trattare il registro denominato reg come registro fisso; il codice generato non dovrebbe mai fare riferimento a
it (tranne forse come puntatore stack, puntatore frame o in qualche altro ruolo fisso).

reg deve essere il nome di un registro. I nomi dei registri accettati sono specifici della macchina
e sono definiti nella macro "REGISTER_NAMES" nel file macro di descrizione della macchina.

Questo flag non ha una forma negativa, perché specifica una scelta a tre vie.

-fcall-usato-reg
Trattare il registro denominato reg come un registro allocabile che è bloccato dalla funzione
chiamate. Può essere assegnato per temporanei o variabili che non vivono attraverso a
chiamata. Le funzioni compilate in questo modo non salveranno e ripristineranno il registro reg.

È un errore utilizzare questo flag con il puntatore a frame o con il puntatore allo stack. Uso di questo
flag per altri registri che hanno ruoli pervasivi fissi nell'esecuzione della macchina
modello produrrà risultati disastrosi.

Questo flag non ha una forma negativa, perché specifica una scelta a tre vie.

-fcall-salvato-reg
Trattare il registro denominato reg come registro allocabile salvato dalle funzioni. Può essere
allocato anche per temporanei o variabili che vivono attraverso una chiamata. Funzioni
compilato in questo modo salverà e ripristinerà il registro reg se lo usano.

È un errore utilizzare questo flag con il puntatore a frame o con il puntatore allo stack. Uso di questo
flag per altri registri che hanno ruoli pervasivi fissi nell'esecuzione della macchina
modello produrrà risultati disastrosi.

Un diverso tipo di disastro risulterà dall'uso di questo flag per un registro in
quali valori di funzione possono essere restituiti.

Questo flag non ha una forma negativa, perché specifica una scelta a tre vie.

-fpack-struttura[=n]
Senza un valore specificato, compattare insieme tutti i membri della struttura senza fori. Quando un
viene specificato il valore (che deve essere una piccola potenza di due), i membri della struttura del pacchetto
secondo questo valore, che rappresenta il massimo allineamento (cioè oggetti con
i requisiti di allineamento predefiniti maggiori di questo verranno emessi potenzialmente non allineati
nella posizione di montaggio successiva.

Attenzione: , il -fpack-struttura switch fa sì che GCC generi codice non binario
compatibile con il codice generato senza quell'interruttore. Inoltre, rende il codice
subottimale. Usalo per conformarti a un'interfaccia binaria dell'applicazione non predefinita.

-funzioni-strumento
Genera chiamate di strumentazione per l'ingresso e l'uscita dalle funzioni. Subito dopo la funzione
entry e appena prima dell'uscita dalla funzione, verranno chiamate le seguenti funzioni di profilazione
con l'indirizzo della funzione corrente e il suo sito di chiamata. (Su alcune piattaforme,
"__builtin_return_address" non funziona oltre la funzione corrente, quindi il sito di chiamata
altrimenti le informazioni potrebbero non essere disponibili per le funzioni di profilazione.)

void __cyg_profile_func_enter (void *this_fn,
void *chiama_sito);
void __cyg_profile_func_exit (void *this_fn,
void *chiama_sito);

Il primo argomento è l'indirizzo di inizio della funzione corrente, che può essere
cercato esattamente nella tabella dei simboli.

Questa strumentazione viene eseguita anche per le funzioni espanse in linea in altre funzioni.
Le chiamate di profilazione indicheranno dove, concettualmente, viene inserita la funzione inline
e uscito. Ciò significa che devono essere disponibili versioni indirizzabili di tali funzioni.
Se tutti i tuoi usi di una funzione sono espansi in linea, questo potrebbe significare un'ulteriore
espansione della dimensione del codice. Se usi esterno inline nel tuo codice C, un indirizzabile
deve essere fornita la versione di tali funzioni. (Questo è normalmente il caso comunque, ma
se sei fortunato e l'ottimizzatore espande sempre le funzioni in linea, potresti avere
ottenuto via senza fornire copie statiche.)

A una funzione può essere assegnato l'attributo "no_instrument_function", nel qual caso questo
la strumentazione non verrà eseguita. Questo può essere utilizzato, ad esempio, per la profilazione
funzioni elencate sopra, routine di interrupt ad alta priorità e qualsiasi funzione da cui
le funzioni di profilazione non possono essere chiamate con sicurezza (forse gestori di segnale, se il
le routine di profilazione generano output o allocano memoria).

-funzioni-strumento-escludi-elenco-file=filetto,filetto, ...
Imposta la lista delle funzioni escluse dalla strumentazione (vedi descrizione
di "-funzioni-strumento"). Se il file che contiene una definizione di funzione corrisponde
con uno di filetto, allora quella funzione non è strumentata. La partita è finita
sottostringhe: se il filetto parametro è una sottostringa del nome del file, è considerato
essere una partita.

Per esempio:

-finstrument-functions-exclude-file-list=/bits/stl,include/sys

escluderà qualsiasi funzione in linea definita nei file i cui nomi di percorso contengono "/bits/stl"
o "include/sys".

Se, per qualche motivo, vuoi includere la lettera ',' in uno dei sym, Scrivi ','. Per
esempio, "-finstrument-functions-exclude-file-list=',,tmp'" (notare la singola virgoletta
che circonda l'opzione).

-funzioni-strumento-exclude-function-list=sym,sym, ...
È simile a "-finstrument-functions-exclude-file-list", ma questa opzione imposta
l'elenco dei nomi delle funzioni da escludere dalla strumentazione. Il nome della funzione per
essere abbinato è il suo nome visibile all'utente, come "vettore bla (vettore costante &)",
non il nome alterato interno (ad esempio, "_Z4blahRSt6vectorIiSaIiEE"). La partita è fatta
sulle sottostringhe: se il sym parametro è una sottostringa del nome della funzione, è
considerata una partita. Per gli identificatori estesi C99 e C++, il nome della funzione
deve essere fornito in UTF-8, non utilizzando nomi di caratteri universali.

-fstack-controllo
Genera codice per verificare di non oltrepassare il limite dello stack. Voi
dovrebbe specificare questo flag se si esegue in un ambiente con più thread,
ma solo raramente è necessario specificarlo in un ambiente a thread singolo poiché stack
l'overflow viene rilevato automaticamente su quasi tutti i sistemi se è presente un solo stack.

Si noti che questa opzione non provoca effettivamente l'esecuzione del controllo; l'operativo
il sistema o il runtime del linguaggio devono farlo. L'interruttore fa sì che la generazione del codice
assicurarsi che vedano lo stack in fase di estensione.

È inoltre possibile specificare un parametro stringa: "no" significa nessun controllo, "generico"
significa forzare l'uso del controllo vecchio stile, "specifico" significa utilizzare il controllo migliore
metodo ed è equivalente a bare -fstack-controllo.

Il controllo vecchio stile è un meccanismo generico che non richiede un supporto specifico per il target in
il compilatore ma presenta i seguenti inconvenienti:

1. Strategia di allocazione modificata per oggetti di grandi dimensioni: saranno sempre allocati
dinamicamente se la loro dimensione supera una soglia fissa.

2. Limite fisso alla dimensione della cornice statica delle funzioni: quando è sormontata da a
funzione particolare, il controllo dello stack non è affidabile e viene emesso un avviso dal
compilatore.

3. Inefficienza: a causa sia della strategia di allocazione modificata che del generico
implementazione, le prestazioni del codice sono ostacolate.

Nota che il controllo dello stack vecchio stile è anche il metodo di fallback per "specifico" se no
il supporto per il target è stato aggiunto nel compilatore.

-fstack-limite-register=reg
-fstack-limit-simbolo=sym
-fno-stack-limite
Genera codice per assicurarti che lo stack non cresca oltre un certo valore
il valore di un registro o l'indirizzo di un simbolo. Se lo stack crescesse oltre
il valore, viene generato un segnale. Per la maggior parte dei bersagli, il segnale viene alzato prima del
lo stack supera il confine, quindi è possibile catturare il segnale senza prendere
precauzioni speciali.

Ad esempio, se lo stack inizia all'indirizzo assoluto 0x80000000 e cresce verso il basso,
puoi usare le bandiere -fstack-limit-symbol=__limite_stack ed
-Wl, --defsym,__stack_limit=0x7ffe0000 per imporre un limite di stack di 128 KB. Notare che
questo può funzionare solo con il linker GNU.

-fsplit-stack
Genera codice per dividere automaticamente lo stack prima che trabocchi. Il risultato
il programma ha uno stack discontinuo che può traboccare solo se il programma non è in grado di farlo
allocare altra memoria. Questo è molto utile quando si eseguono programmi con thread, in quanto
non è più necessario calcolare una buona dimensione dello stack da utilizzare per ogni thread. Questo è
attualmente implementato solo per i backend i386 e x86_64 che eseguono GNU/Linux.

Quando il codice viene compilato con -fsplit-stack chiama il codice compilato senza -fsplit-stack, Là
potrebbe non esserci molto spazio nello stack disponibile per l'esecuzione di quest'ultimo codice. Se stai compilando tutto
codice, compreso il codice della libreria, con -fsplit-stack non è un'opzione, quindi il linker può
correggere queste chiamate in modo che il codice venga compilato senza -fsplit-stack ha sempre un grande
pila. Il supporto per questo è implementato nel gold linker nella versione GNU binutils
2.21 e successive.

-sottolineatura-sottolineatura
Questa opzione e la sua controparte, -fno-leader-underscore, cambia forzatamente il modo C
i simboli sono rappresentati nel file oggetto. Un uso è quello di aiutare il collegamento con l'eredità
codice montaggio.

Attenzione: , il -sottolineatura-sottolineatura switch fa sì che GCC generi codice che non lo è
binario compatibile con il codice generato senza quell'interruttore. Usalo per conformarsi a a
interfaccia binaria dell'applicazione non predefinita. Non tutti i target forniscono un supporto completo
per questo interruttore.

-ftls-modello=modello
Modificare il modello di archiviazione locale del thread da utilizzare. Il modello l'argomento dovrebbe essere uno dei
"global-dynamic", "local-dynamic", "initial-exec" o "local-exec".

L'impostazione predefinita senza -fpic è "initial-exec"; insieme a -fpic l'impostazione predefinita è
"globale-dinamica".

-fvisibilità=predefinito|interno|nascosto|protetto
Imposta la visibilità del simbolo dell'immagine ELF predefinita sull'opzione specificata --- tutti i simboli lo faranno
essere contrassegnato con questo a meno che non venga sovrascritto all'interno del codice. L'uso di questa funzione può molto
migliorare sostanzialmente il collegamento e i tempi di caricamento delle librerie di oggetti condivisi, produrre di più
codice ottimizzato, fornisce un'esportazione API quasi perfetta e previene i conflitti di simboli. è
fortemente consiglia di utilizzarlo in tutti gli oggetti condivisi che distribuisci.

Nonostante la nomenclatura, "default" significa sempre pubblico; cioè, disponibile per essere collegato
contro dall'esterno dell'oggetto condiviso. "protetto" e "interno" sono abbastanza inutili
nell'uso reale, quindi l'unica altra opzione comunemente usata sarà "nascosta". Il
predefinito se -fvisibilità non è specificato è "predefinito", cioè crea ogni simbolo
public---questo provoca lo stesso comportamento delle versioni precedenti di GCC.

Una buona spiegazione dei vantaggi offerti dall'assicurare che i simboli ELF abbiano il corretto
visibilità è data da "How To Write Shared Libraries" di Ulrich Drepper (che può essere
Trovato ahttp://people.redhat.com/~drepper/>)---comunque una soluzione superiore fatta
possibile con questa opzione contrassegnare le cose nascoste quando l'impostazione predefinita è public è make
l'impostazione predefinita nascosta e contrassegna le cose come pubbliche. Questa è la norma con le DLL su Windows e
con -fvisibilità=nascosto e "__attribute__ ((visibility("default")))" invece di
"__declspec(dllexport)" ottieni una semantica quasi identica con una sintassi identica.
Questo è un grande vantaggio per coloro che lavorano con progetti multipiattaforma.

Per coloro che aggiungono il supporto per la visibilità al codice esistente, potresti trovare #pragma GCC
visibilità d'uso. Funziona racchiudendo le dichiarazioni che desideri impostare
visibilità per con (ad esempio) #pragma GCC visibilità spingere (nascosto) ed #pragma GCC
visibilità pop. Tieni presente che la visibilità del simbolo dovrebbe essere visualizzata as parte of , il
API interfaccia contratto e quindi tutto il nuovo codice dovrebbe sempre specificare la visibilità quando
non è l'impostazione predefinita; vale a dire, le dichiarazioni solo per l'uso all'interno del DSO locale dovrebbero sempre
essere contrassegnato esplicitamente come nascosto in modo da evitare spese generali per l'indiretto PLT --- rendendolo
abbondantemente chiaro aiuta anche la leggibilità e l'autodocumentazione del codice. Notare che
a causa dei requisiti delle specifiche ISO C++, l'operatore nuovo e l'operatore cancella devono
essere sempre di visibilità predefinita.

Tieni presente che le intestazioni esterne al tuo progetto, in particolare le intestazioni di sistema e
intestazioni da qualsiasi altra libreria che usi, potresti non aspettarti di essere compilato con
visibilità diversa da quella predefinita. Potrebbe essere necessario dire esplicitamente #pragma GCC
visibilità premere (predefinito) prima di includere tali intestazioni.

esterno le dichiarazioni non sono influenzate da -fvisibilità, quindi un sacco di codice può essere
ricompilato con -fvisibilità=nascosto senza modifiche. Tuttavia, questo significa che
chiama a esterno le funzioni senza visibilità esplicita utilizzeranno il PLT, quindi è più
efficace da usare __attributo ((visibilità)) e / o #pragma GCC visibilità per dire a
compilatore che esterno le dichiarazioni devono essere trattate come nascoste.

Si noti che -fvisibilità influisce sulle entità di collegamento vago C++. Ciò significa che, per
esempio, una classe di eccezione che verrà generata tra DSO deve essere esplicitamente
contrassegnato con visibilità predefinita in modo che il tipo_info i nodi saranno unificati tra i
DSO.

Una panoramica di queste tecniche, dei loro vantaggi e di come usarli è su
<http://gcc.gnu.org/wiki/Visibility>.

-fstrict-bitfield-volatili
Questa opzione dovrebbe essere usata se si accede a campi di bit volatili (o altre strutture
campi, sebbene il compilatore di solito onori comunque quei tipi) dovrebbe usare un singolo
accesso della larghezza del tipo di campo, se possibile allineato ad un allineamento naturale.
Ad esempio, i target con registri periferici mappati in memoria potrebbero richiedere tutto questo
gli accessi devono essere larghi 16 bit; con questo flag l'utente può dichiarare tutte le periferiche bit-
campi come "unsigned short" (supponendo che short sia di 16 bit su questi target) per forzare GCC
utilizzare accessi a 16 bit invece di, forse, un accesso più efficiente a 32 bit.

Se questa opzione è disabilitata, il compilatore utilizzerà l'istruzione più efficiente. In
l'esempio precedente, potrebbe essere un'istruzione di caricamento a 32 bit, anche se lo farà
byte di accesso che non contengono alcuna parte del campo di bit o mappati in memoria
registri estranei a quello in corso di aggiornamento.

Se il target richiede un allineamento rigoroso e onorare il tipo di campo richiederebbe
violando questo allineamento, viene emesso un avviso. Se il campo ha l'attributo "imballato",
l'accesso avviene senza rispettare il tipo di campo. Se il campo non ha
attributo "packed", l'accesso avviene rispettando il tipo di campo. In entrambi i casi, GCC
presuppone che l'utente sappia qualcosa sull'hardware di destinazione di cui non è a conoscenza.

Il valore predefinito di questa opzione è determinato dall'interfaccia binaria dell'applicazione per
il processore di destinazione.

AMBIENTE

Questa sezione descrive diverse variabili d'ambiente che influenzano il funzionamento di GCC. Alcuni
di questi funzionano specificando directory o prefissi da utilizzare durante la ricerca di vari tipi
di file. Alcuni vengono utilizzati per specificare altri aspetti dell'ambiente di compilazione.

Nota che puoi anche specificare i luoghi in cui cercare usando opzioni come -B, -I ed -L.
Questi hanno la precedenza sui luoghi specificati utilizzando le variabili di ambiente, che a loro volta
hanno la precedenza su quelli specificati dalla configurazione di GCC.

LUNGO
LC_CTYPE
LC_MESSAGGI
LC_TUTTI
Queste variabili di ambiente controllano il modo in cui GCC utilizza le informazioni di localizzazione
che consente a GCC di lavorare con diverse convenzioni nazionali. GCC ispeziona il locale
categoria LC_CTYPE ed LC_MESSAGGI se è stato configurato per farlo. Questi locali
le categorie possono essere impostate su qualsiasi valore supportato dall'installazione. Un valore tipico è
it_IT.UTF-8 per l'inglese nel Regno Unito codificato in UTF-8.

I LC_CTYPE la variabile d'ambiente specifica la classificazione dei caratteri. GCC lo usa per
determinare i limiti dei caratteri in una stringa; questo è necessario per alcuni multibyte
codifiche che contengono virgolette e caratteri di escape che altrimenti verrebbero interpretati
come fine stringa o escape.

I LC_MESSAGGI la variabile di ambiente specifica la lingua da utilizzare nella diagnostica
messaggi.

Se l' LC_TUTTI la variabile d'ambiente è impostata, sovrascrive il valore di LC_CTYPE ed
LC_MESSAGGI; altrimenti, LC_CTYPE ed LC_MESSAGGI predefinito al valore di LUNGO
variabile d'ambiente. Se nessuna di queste variabili è impostata, il valore predefinito di GCC è tradizionale
C comportamento inglese.

TMPDIR
If TMPDIR è impostato, specifica la directory da utilizzare per i file temporanei. GCC utilizza
file temporanei per contenere l'output di una fase della compilazione che deve essere utilizzato come
input alla fase successiva: ad esempio, l'output del preprocessore, che è il
input al compilatore vero e proprio.

GCC_COMPARE_DEBUG
Configurazione GCC_COMPARE_DEBUG è quasi equivalente a passare -fcompare-debug Vai all’email
driver del compilatore. Vedere la documentazione di questa opzione per maggiori dettagli.

GCC_EXEC_PREFIX
If GCC_EXEC_PREFIX è impostato, specifica un prefisso da usare nei nomi dei
sottoprogrammi eseguiti dal compilatore. Non viene aggiunta alcuna barra quando questo prefisso viene combinato
con il nome di un sottoprogramma, ma puoi specificare un prefisso che termini con una barra se
lo si desidera.

If GCC_EXEC_PREFIX non è impostato, GCC tenterà di trovare un prefisso appropriato per
use in base al percorso con cui è stato invocato.

Se GCC non riesce a trovare il sottoprogramma utilizzando il prefisso specificato, prova a cercare nel
posti abituali per il sottoprogramma.

Il valore predefinito di GCC_EXEC_PREFIX is prefisso/lib/gcc/ where prefisso è il prefisso per
il compilatore installato. In molti casi prefisso è il valore di "prefisso" quando hai eseguito il
configure script.

Altri prefissi specificati con -B avere la precedenza su questo prefisso.

Questo prefisso viene utilizzato anche per trovare file come crt0.o che servono per il collegamento.

Inoltre, il prefisso viene utilizzato in modo insolito nel trovare le directory da cercare
per i file di intestazione. Per ciascuna delle directory standard il cui nome inizia normalmente
con /usr/local/lib/gcc (più precisamente, con il valore di GCC_INCLUDE_DIR), GCC ci prova
sostituendo quell'inizio con il prefisso specificato per produrre una directory alternativa
nome. Così, con -Bpippo/, GCC cercherà foo/bar dove normalmente cercherebbe
/usr/local/lib/bar. Queste directory alternative vengono cercate per prime; lo standard
le directory vengono dopo. Se una directory standard inizia con il configurato prefisso poi
il valore di prefisso è sostituito da GCC_EXEC_PREFIX quando si cercano file di intestazione.

COMPILATORE_PERCORSO
Il valore di COMPILATORE_PERCORSO è un elenco di directory separate da due punti, molto simile a PERCORSO.
GCC prova le directory così specificate durante la ricerca di sottoprogrammi, se non può
trova i sottoprogrammi usando GCC_EXEC_PREFIX.

LIBRERIA_PERCORSO
Il valore di LIBRERIA_PERCORSO è un elenco di directory separate da due punti, molto simile a PERCORSO.
Quando è configurato come compilatore nativo, GCC prova le directory così specificate quando
ricerca di file linker speciali, se non riesce a trovarli utilizzando GCC_EXEC_PREFIX.
Il collegamento tramite GCC utilizza anche queste directory durante la ricerca di librerie ordinarie
per l' -l opzione (ma le directory specificate con -L vieni prima).

LUNGO
Questa variabile viene utilizzata per passare le informazioni sulla localizzazione al compilatore. Un modo in cui
questa informazione viene utilizzata per determinare il set di caratteri da utilizzare quando carattere
letterali, letterali stringa e commenti vengono analizzati in C e C++. Quando il compilatore è
configurato per consentire caratteri multibyte, i seguenti valori per LUNGO sono
riconosciuto:

C-JIS
Riconosci i caratteri JIS.

C-SJIS
Riconosci i caratteri SJIS.

C-EUCGP
Riconosci i caratteri EUCJP.

If LUNGO non è definito, o se ha qualche altro valore, il compilatore utilizzerà
mblen e mbtowc come definito dalle impostazioni internazionali predefinite per riconoscere e tradurre multibyte
caratteri.

Alcune variabili di ambiente aggiuntive influiscono sul comportamento del preprocessore.

CPATH
C_include_path
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
Il valore di ogni variabile è un elenco di directory separate da un carattere speciale, molto
piace PERCORSO, in cui cercare i file di intestazione. Il carattere speciale,
"PATH_SEPARATOR", è dipendente dal target e determinato al momento della compilazione di GCC. Per Microsoft
Target basati su Windows è un punto e virgola e per quasi tutti gli altri target è un
colon.

CPATH specifica un elenco di directory in cui eseguire la ricerca come se specificato con -I, ma
dopo ogni percorso dato con -I opzioni sulla riga di comando. Questa variabile d'ambiente
viene utilizzato indipendentemente dalla lingua preelaborata.

Le restanti variabili di ambiente si applicano solo durante la preelaborazione del particolare
lingua indicata. Ciascuno specifica un elenco di directory in cui eseguire la ricerca come se
specificato con -isistema, ma dopo ogni percorso dato con -isistema opzioni sul
riga di comando.

In tutte queste variabili, un elemento vuoto indica al compilatore di cercare la sua corrente
directory di lavoro. Gli elementi vuoti possono apparire all'inizio o alla fine di un percorso. Per
esempio, se il valore di CPATH è ":/special/include", che ha lo stesso effetto di
-IO. -Io/speciale/includo.

DIPENDENZE_OUTPUT
Se questa variabile è impostata, il suo valore specifica come generare le dipendenze per Make based
sui file di intestazione non di sistema elaborati dal compilatore. I file di intestazione di sistema sono
ignorato nell'output della dipendenza.

Il valore di DIPENDENZE_OUTPUT può essere solo un nome di file, nel qual caso le regole Make
vengono scritti su quel file, indovinando il nome di destinazione dal nome del file di origine. O il
il valore può avere la forma filetto bersaglio, nel qual caso le regole vengono scritte su file filetto
utilizzando bersaglio come nome di destinazione.

In altre parole, questa variabile d'ambiente equivale a combinare le opzioni -MM
ed -MF, con un optional - MT anche l'interruttore.

SUNPRO_DEPENDENZE
Questa variabile è la stessa di DIPENDENZE_OUTPUT (vedi sopra), eccetto quel sistema
i file di intestazione non vengono ignorati, quindi implica -M anziché -MM. Tuttavia, l'
la dipendenza dal file di input principale viene omessa.

Usa g++-4.7 online utilizzando i servizi onworks.net