EnglezăFrancezăSpaniolă

Rulați servere | Ubuntu > | Fedora > |


Favicon OnWorks

g++-4.9 - Online în cloud

Rulați g++-4.9 în furnizorul de găzduire gratuit OnWorks prin Ubuntu Online, Fedora Online, emulator online Windows sau emulator online MAC OS

Aceasta este comanda g++-4.9 care poate fi rulată în furnizorul de găzduire gratuit OnWorks folosind una dintre multiplele noastre stații de lucru online gratuite, cum ar fi Ubuntu Online, Fedora Online, emulator online Windows sau emulator online MAC OS

PROGRAM:

NUME


gcc - compilator pentru proiectul GNU C și C++

REZUMAT


gcc [-c|-S|-E] [-std=standard]
[-g] [-pag] [-Onivel]
[-Wavertiza...] [-Wpedant]
[-Idir...] [-Ldir...]
[-Dmacro[=defn]...] [-Umacro]
[-fopțiune...] [-mmașină-opțiune...]
[-o outfile] [@fişier] infile...

Aici sunt enumerate doar cele mai utile opțiuni; vezi mai jos pentru restul. g ++ acceptă
în mare parte aceleași opțiuni ca gcc.

DESCRIERE


Când invocați GCC, de obicei face preprocesare, compilare, asamblare și legare.
„Opțiunile generale” vă permit să opriți acest proces într-o etapă intermediară. Pentru
de exemplu, -c opțiunea spune să nu rulați linkerul. Apoi ieșirea constă din obiect
fișierele scoase de către asamblator.

Alte opțiuni sunt trecute într-o etapă de procesare. Unele opțiuni controlează
preprocesor și alții compilatorul însuși. Totuși, alte opțiuni controlează asamblatorul și
linker; cele mai multe dintre acestea nu sunt documentate aici, deoarece rareori trebuie să utilizați oricare dintre ele.

Majoritatea opțiunilor de linie de comandă pe care le puteți utiliza cu GCC sunt utile pentru programele C; cand
o opțiune este utilă doar cu un alt limbaj (de obicei C++), așa spune explicația
explicit. Dacă descrierea unei anumite opțiuni nu menționează o sursă
limba, puteți utiliza această opțiune cu toate limbile acceptate.

gcc programul acceptă opțiuni și nume de fișiere ca operanzi. Multe opțiuni au mai multe
nume de litere; prin urmare, mai multe opțiuni cu o singură literă pot nu fi grupate: -dv este foarte
diferit de -d -v.

Puteți amesteca opțiuni și alte argumente. În cea mai mare parte, comanda pe care o utilizați nu
materie. Ordinea contează atunci când utilizați mai multe opțiuni de același fel; de exemplu, dacă
specifici tu -L de mai multe ori, directoarele sunt căutate în ordinea specificată. De asemenea,
plasarea -l opțiunea este semnificativă.

Multe opțiuni au nume lungi, începând cu -f sau cu -W---de exemplu,
-fmove-loop-invariants, -Wformat si asa mai departe. Cele mai multe dintre acestea au atât pozitive, cât și negative
forme; forma negativă a -ffoo is -fno-foo. Acest manual documentează doar unul dintre acestea
două forme, oricare dintre acestea nu este implicită.

OPŢIUNI


Opțiune Rezumat
Iată un rezumat al tuturor opțiunilor, grupate după tip. Explicațiile sunt în cele ce urmează
secțiuni.

Salopete Opţiuni
-c -S -E -o fişier -fără-prefixe-canonice -teava -coduri de trecere-ieșire -x limbă -v
-### --Ajutor[=clasă[, ...]] --ţintă-ajutor --versiune -invelis @fişier -fplugin=fişier
-fplugin-arg-nume=arg -fdump-ada-spec[-subţire] -fada-spec-parent=unitate
-fdump-go-spec=fişier

C Limba Opţiuni
-ansi -std=standard -fgnu89-inline -aux-info nume de fișier
-funcții-variadice-fără-parametri -fno-asm -fno-builtin -fno-builtin-funcţie
-fhosted - de sine stătător -fopenmp -fopenmp-simd -fms-extensii -fplan9-extensii
-trigrafe -tradiţional -traditional-cpp -intars-singura-precizie -fcond-nepotrivire
-conversii-vectorale-in -fsigned-bitfields -fsigned-char -funsigned-bitfields
-funsigned-char

C ++ Limba Opţiuni
-fabi-version=n -fno-control-acces -fcheck-new -fconstexpr-depth=n
-ffriend-injectie -fno-elide-constructori -fno-enforce-eh-specs -ffor-sfera
-fno-pentru-sfera -fno-gnu-cuvinte cheie -fno-implicite-şabloane
-fno-implicit-inline-templates -fno-implementare-inline -fms-extensii
-fno-nonansi-builtins -fnothrow-opt -fno-operator-names -fno-optional-diags
-fpermisiv -fno-pretty-şabloane -frepo -fno-rtti -fstats
-ftemplate-backtrace-limit=n -ftemplate-depth=n -fno-threadsafe-statics
-fuzibil-cxa-atexit -fno-slab -nostdinc++ -fvizibility-inline-hidden
-fvtable-verify=std|preinit|niciuna -fvtv-contează -fvtv-debug -fvizibility-ms-compat
-fext-numerice-literale - Wabi -Wconversion-null -Wctor-dtor-privacy
-Wdelete-non-virtual-dtor -Wliteral-sufix -Îngustare - Nu, cu excepția -Wnon-virtual-dtor
-Wreorder -Weffc++ -Wstrict-null-sentinel -Wno-non-template-prieten -Distribuie în stil Wold
-Woverloaded-virtual -Wno-pmf-conversii -Wsign-promoție

Obiectiv-C și Obiectiv-C++ Limba Opţiuni
-fconstant-string-class=numele clasei -fgnu-runtime -fnext-runtime -fno-nil-receptoare
-fobjc-abi-version=n -fobjc-call-cxx-cdtors -fobjc-direct-dispecer -fobjc-excepții
-fobjc-gc -fobjc-nilcheck -fobjc-std=objc1 -freplace-objc-clasele -fzero-link
-gen-decls -Wassign-intercept -Wno-protocol -Wselector -Wstrict-selector-potrivire
-Wundeclared-selector

Limba Independent Opţiuni
-fmessage-length=n -fdiagnostics-show-location=[dată|fiecare-linie]
-fdiagnostics-color =[Auto|nu|mereu] -fno-diagnostics-show-option
-fno-diagnostic-show-caret

avertizare Opţiuni
-doar fsyntax -fmax-erori=n -Wpedant -pedant-erori -w -Wextra -Perete
-Waddress -Waggregate-retur -Wagresive-bucle-optimizări - Limite de război
-Wno-atribute -Wno-builtin-macro-redefinit -Wc++-compat -Wc++11-compat -Wcast-align
-Wcast-qual -Wchar-indice -Wclobbered -Wcomentează -Asistență condiționată
-Wconversie -Wacoperire-nepotrivire -Wdata-ora -Wdelete-incomplet -Wno-cpp
-Wno-depreciat -Wno-depreciate-declarations -Wdisabled-optimizare -Wno-div-by-zero
-Wdubla-promovare -Corpul umed -Wenum-compara -Wno-endif-etichete -Eroare -Werror=*
-Wfatale-erori -Wfloat-egal -Wformat -Wformat=2 -Wno-formatul-contine-nul
-Wno-format-extra-args -Wformat-nonliteral -Wformat-securitate -Wformat-y2k
-Wframe-mai mare-decat=len -Wno-free-nonheap-obiect -Wjump-doar-init
-Wignored-calificative -Wimplicit -Wimplicit-funcție-declarație -Wimplicit-int
- Winit-self -Winline -Wpoate-neinițializat -Wno-int-to-pointer-cast
-Wno-invalid-offsetof -Winvalid-pch -Mai mare decât=len -Wunsafe-loop-optimizations
-Wlogic-op -Lung-lung -Wmain -Wpoate-neinițializat -Wmemset-transpus-args
- Acolade lipsă -Inițializatoare-câmp lipsesc -Fără-include-dir-uri -Wno-multichar
-Wnonnull -Wno-overflow -Wopenmp-simd -Woverlungime-şiruri -Ambalat
-Wpacked-bitfield-compat -Wcaptusit - Paranteze -Wpedantic-ms-format
-Format-wno-pedant-ms -Wpointer-arith -Wno-pointer-to-int-cast -Wredundant-decls
-Wno-return-local-adr -de tip Wreturn -Wsecvența-punct -Wshadow -Wsign-compara
-Wsign-conversie -Wfloat-conversie -Wsizeof-pointer-memaccess -Wstack-protector
-Wstack-usage=len -Wstrict-aliasing -Wstrict-aliasing=n -Wstrict-debordare
-Wstrict-overflow=n -Wsuggest-atribut=[pur|CONST|fără întoarcere|format]
-Atribut-format-lipsă - Întrerupător -Wswitch-implicit -Wswitch-enum -Wsync-nand
-Wsystem-anteturi -Wtrambuline - Trigrafii -Wtip-limite -Wundef -Winitializat
-Wuncunoscut-pragmas -Wno-pragmas -Wunsufixed-float-constante -Wunused
-Wunused-funcție -Wunused-etichetă -Wunused-local-typedefs -Wunused-parametru
-Wno-neutilizat-rezultat -Valoare-neutilizată -Wunused-variabilă -Wunused-dar-setat-parametru
-Wunused-dar-set-variable -Wuseless-distribuie -Wvariadic-macro
-Wvector-operare-performanță -Wvla -Wvolatile-registru-var -Scrie-șiruri
-Wzero-ca-pointer-null-constant

C și Numai obiectivul C avertizare Opţiuni
-Wbad-funcție-cast - Declarații lipsă -Wmissing-parametru-tip
- Lipsă-prototipuri -Wned-externs -Declarație în stil Wold -Wold-stil-definiție
-Wstrict-prototipuri - Tradițional -Wtradițional-conversie
-Wdeclarație-după-declarație -Wpointer-semn

Depanarea Opţiuni
-dlitere -specii de gunoi -basculantă -versiunea de gunoi -fsanitize=stil -fdbg-cnt-list
-fdbg-cnt=contra-lista-valoare -fdisable-ipa-pass_name -fdisable-rtl-pass_name
-fdisable-rtl-nume de trecere=listă-gamă -fdisable-tree-pass_name -fdisable-tree-trece-
nume=listă-gamă -fdump-noaddr -fdump-nenumerotat -fdump-linkuri-nenumerotate
-fdump-unitate-traducere[-n] -fdump-clasă-ierarhie[-n] -fdump-ipa-toate
-fdump-ipa-cgraph -fdump-ipa-inline -fdump-trece -fdump-statistici -fdump-tree-toate
-fdump-tree-original[-n] -fdump-tree-optimizat[-n] -fdump-tree-cfg -fdump-tree-alias
-fdump-tree-ch -fdump-tree-ssa[-n] -fdump-tree-pre[-n] -fdump-tree-ccp[-n]
-fdump-tree-dce[-n] -fdump-tree-gimple[-brut] -fdump-tree-dom[-n] -fdump-tree-dse[-n]
-fdump-tree-phiprop[-n] -fdump-tree-phiopt[-n] -fdump-tree-forwprop[-n]
-fdump-tree-copyrename[-n] -fdump-tree-nrv -fdump-tree-vect -fdump-tree-chiuvetă
-fdump-tree-sra[-n] -fdump-tree-forwprop[-n] -fdump-tree-fre[-n]
-fdump-tree-vtable-verify -fdump-tree-vrp[-n] -fdump-tree-storeccp[-n]
-fdump-final-insns=fişier -fcompare-debug[=optează] -fcompare-debug-second
-feliminate-dwarf2-dups -fno-elimină-tipurile-de-depanare-neutilizate
-elimină-neutilizate-debug-simboluri -femit-class-debug-intotdeauna -fenabil-natură-trece
-fenabil-natură-trece=listă-gamă -fdebug-types-section -fmem-report-wpa -fmem-report
-fpre-ipa-mem-report -fpost-ipa-mem-report -fprofil-arcuri -fopt-info
-fopt-info-Opțiuni[=fişier] -frandom-seed=şir -fsched-verbose=n -fsel-sched-verbose
-fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -fstack-usage -ftest-acoperire
-ftime-raport -fvar-urmărire -fvar-tracking-assignments
-fvar-tracking-assignments-toggle -g -gnivel -gtoggle -gcoff -pitic-versiune -ggdb
-grecord-gcc-switch-uri -gno-record-gcc-switch-uri -gstabs -gstabs+ -gstrict-pitic
-gno-strict-pitic -gvms -gxcoff -gxcoff+ -fno-merge-debug-strings
-fno-dwarf2-cfi-asm -fdebug-prefix-map=vechi=nou -femit-struct-debug-baseonly
-femit-struct-debug-reduced -femit-struct-debug-detailed[=lista de specificații] -p -pag
-print-file-name=bibliotecă -print-libgcc-file-name -print-multi-director
-print-multi-lib -print-multi-os-director -print-prog-name=program
-print-search-dirs -Q -print-sysroot -print-sysroot-headers-sufix -save-temps
-save-temps=cwd -save-temps=obj -timp[=fişier]

Optimizare Opţiuni
-optimizări-agresive-buclă -funcții-falign[=n] -falign-salt[=n]
-falign-labels[=n] -falign-loops[=n] -asociativ-matematică -fauto-inc-dec
-fbranch-probabilităţi -fbranch-target-load-optimize -fbranch-target-load-optimize2
-fbtr-bb-exclusiv -fcaller-salvează -fcheck-data-deps -fcombine-stiva-ajustări
-fconserve-stack -fcompare-elim -fcprop-registre -fcrossjumping -fcse-urmare-sărituri
-fcse-skip-blocks -fcx-fortran-rules -fcx-rază-limitată -fdata-secțiuni -fdce
-framură-întârziată -fdelete-null-pointer-checks -fdevirtualizați
-fdevirtualizare-speculativ -fdse -înspăimântător -fipa-sra
-optimizări scumpe -ffat-lto-obiecte -ffast-matematică -finit-doar matematică
-float-magazin -exces-precizie=stil -înainte-propagă -ffp-contract=stil
-secţiuni-funcţii -fgcse -fgcse-după-reîncărcare -fgcse-las -fgcse-lm
-fgrafit-identitate -fgcse-sm -fhoist-încărcături-adiacente -cinci-conversie -cinci-conversie2
-findirect-inlining -funcții-finline -funcții-finline-numite-o dată -finline-limit=n
-finline-funcții-mici -fipa-cp -fipa-cp-clona -fipa-pta -fipa-profil
-fipa-pură-const -fipa-referință -fira-algoritm=Algoritmul -fira-region=regiune
-fira-pala-presiune -fira-bucla-presiune -fno-ira-share-save-slots
-fno-ira-share-spill-slots -fira-verbose=n -fizolare-cai-eronate-dereferinta
-fisolate-errone-paths-attribute -fivopt -fkeep-inline-functions
-fkeep-static-const -flive-gamă-contracție -floop-bloc -floop-interchange
-floop-strip-mina -floop-nest-optimize -floop-paraleliza-toate -flto
-flto-nivel-compresie -flato-partition=ALG -flto-raport -flato-report-wpa
-fmerge-toate-constantele -fmerge-constante -fmodulo-sched -fmodulo-sched-allow-regmoves
-fmove-loop-invariants -fno-ramură-număr-reg -fno-defer-pop -fno-funcție-cse
-fno-ghici-ramură-probabilitate -fno-inline -fno-matematică-errno -fno-vizor -fno-vizor2
-fno-sched-interbloc -fno-sched-spec -fno-semnat-zerouri -fno-toplevel-reorder
-fno-capcană-matematică -fno-zero-inițializat-în-bss -fomit-cadru-pointer
-foptimize-frate-apeluri -fpartial-inlining -fpeel-bucle -fpredictiv-comuning
-fprefetch-loop-arrays -fprofil-raport -fprofile-corectie -fprofile-dir=cale
-fprofile-generate -fprofile-generate=cale -fprofile-use -fprofile-use=cale
-fprofile-values -fprofile-reordonare-funcții -freciprocal-matematică -gratuit
-frename-registre -blocuri-freorder -freorder-blocuri-și-partiție -funcții-freorder
-frerun-cse-după-buclă -freschedule-modulo-scheduled-loops -întemeierea-matematică
-fsched2-use-superblocuri -fsched-presiune -fsched-spec-load
-fsched-spec-load-dangerous -fsched-stalled-insns-dep[=n] -fsched-stalled-insns[=n]
-fsched-group-euristic -fsched-critical-path-euristic -fsched-spec-insn-euristic
-fsched-rank-euristic -fsched-last-insn-euristic -fsched-dep-count-euristic
-fschedule-insns -fschedule-insns2 -fsectiune-ancore -fselectiv-programare
-fselectiv-scheduling2 -fsel-sched-pipelining -fsel-sched-pipelining-bucle-exterioare
-fshrink-wrap -fsignaling-nans -fsingura-precizie-constant -fsplit-ivs-in-unroller
-fsplit-wide-types -festack-protector -fstack-protector-all -fstack-protector-puternic
-fstrict-aliasing -fstrict-overflow -fthread-sărituri -ftracer -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -fttree-ch -ftree-coalesce-inline-vars
-fttree-coalesce-vars -ftree-copie-prop -fttree-copyrename -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-loop-dacă-conversie
-ftree-loop-if-convert-magazine -fttree-loop-im -fttree-phiprop -ftree-loop-distribution
-ftree-loop-distribute-patterns -ftree-loop-ivcanon -ftree-loop-liniar
-ftree-loop-optimize -ftree-loop-vectorize -fttree-paraleliza-bucle=n -fttree-pre
-fttree-partial-pre -fttree-pta -fttree-reassoc -ftree-chiuvetă -ftree-slsr -ftree-sra
-ftree-switch-conversie -fttree-tail-merge -ftree-ter -fttree-vectoriza -ftree-vrp
-funit-la-o dată -funroll-toate-buclele -bucle-funroll -optimizări-funsafe-loop
-optimizări-funsafe-matematice -funswitch-bucle -fexpansiune-variabilă-în-unroler
-modelul-cost-fvect -fvpt -fweb -întregul-program -fwpa -fuzibil-ld=Link-uri
-fuse-linker-plugin --param nume=valoare -O -O0 -O1 -O2 -O3 -Os -De repede -Og

Preprocesor Opţiuni
-Aîntrebare=răspunde -A-întrebare[=răspunde] -C -dD -dI -dM -dN -Dmacro[=defn] -E -H
-idirafter dir -include fişier -imacros fişier -iprefix fişier -icuprefix dir
-iwithprefixbefore dir -isistem dir -imultilib dir -isysroot dir -M -MM -MF -MG
-MP -MQ -MT -nostdinc -P -fdebug-cpp -ftrack-macro-expansiune -fworking-director
-remapa -trigrafe -undef -Umacro -Wp,opțiune -Xpreprocesor opțiune -fără-integrat-cpp

Montator Opțiune
-Wa,opțiune -Xassembler opțiune

linker Opţiuni
nume-fișier-obiect -lbibliotecă -nostartfiles -nodefaultlibs -nostdlib -plăcintă -rdinamic -s
-static -static-libgcc -static-libstdc++ -static-libasan -static-libtsan
-static-liblsan -static-libubsan -impartit -shared-libgcc -simbolic -T scenariu
-Wl,opțiune -Xlinker opțiune -u simbol

director Opţiuni
-Bprefix -Idir -iplugindir=dir -citezdir -Ldir -specificații=fişier -eu- --sysroot=dir
--fără-sysroot-sufix

Mașină Dependent Opţiuni
AAArch64 Opţiuni -mabi=nume -mbig-endian -mlittle-endian -mgeneral-regs-only
-mcmodel=minuscul -mcmodel=mic -mcmodel=mare -mstrict-align -momit-leaf-frame-pointer
-mno-omite-leaf-frame-pointer -mtls-dialect=desc -mtls-dialect=tradițional
-mfix-cortex-a53-835769 -mno-fix-cortex-a53-835769 -mfix-cortex-a53-843419
-mno-fix-cortex-a53-843419 -martie=nume -mcpu=nume -mtune=nume

Adapteva Bobotează Opţiuni -mhalf-reg-file -mprefer-short-insn-regs -mbranch-cost=o
-mcmove -mnops=o -msoft-cmpsf -msplit-lohi -mpost-inc -mpost-modify
-mstack-offset=o -mround-cea mai apropiată -mlong-apeluri -mshort-calls -msmall16 -mfp-mode=mod
-mvect-dublu -max-vect-align=o -msplit-vecmove-devreme -m1reg-reg

ARC Opţiuni -barrel-shifter -mcpu=cpu -mA6 -mARC600 -mA7 -mARC700 -mdpfp
-mdpfp-compact -mdpfp-rapid -mno-dpfp-lrsr -mea -mno-mpy -mmul32x16 -mmul64 -norma
-mspfp -mspfp-compact -mspfp-rapid -msimd -msoft-float -mswap -mcrc -mdsp-packa -mdvbf
-mlock -mmac-d16 -mmac-24 -mrtsc -mswape -mtelefonie -mxy - misize -manotate-aliniere
-marclinux -marclinux_prof -mepilog-cfi -mlong-apeluri -medium-apeluri -msdata
-mucb-mcount -mvolatile-cache -malign-call -mauto-modify-reg -mbbit-vizor -mno-brcc
-mcase-vector-pcrel -mcompact-casesi -mno-cond-exec -mearly-cbranchsi -mexpand-adddi
-încărcări-mindexate -mlra -mlra-prioritate-niciuna -mlra-prioritate-compact mlra-prioritate-
necompact -mno-millicode -cod mixt -mq-clasa -mRcq -mRcw -msize-level=nivel
-mtune=cpu -mmultcost=o -munalign-prob-threshold=probabilitate

ARM Opţiuni -mapcs-cadru -mno-apcs-frame -mabi=nume -mapcs-stack-check
-mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reintrant
-mno-apcs-reentrant -msched-prolog -mno-sched-prolog -mlittle-endian -mbig-endian
-mwords-little-endian -mfloat-abi=nume -mfp16-format=nume -mthub-interwork
-mno-degetul mare-interwork -mcpu=nume -martie=nume -mfpu=nume -mstructure-size-boundary=n
-avort-la-noreturn -mlong-apeluri -mno-lung-apeluri -msingle-pic-base
-mno-single-pic-base -mpic-registru=reg -mnop-fun-dllimport -mpoke-nume-funcție
-degetul mare -marm -mtpcs-cadru -mtpcs-leaf-frame -mcaller-super-interfuncționare
-mcallee-super-interfuncționare -mtp=nume -mtls-dialect=dialect -mword-relocari
-mfix-cortex-m3-ldrd -munaligned-acces -mneon-pentru-64 de biți -mslow-flash-data
-mrestrict-o

AVR Opţiuni -mmcu=mcu -maccumulate-args -mbranch-cost=costa -mcall-proloage -mentă8
-mno-întreruperi -mrelaxează-te -mstrict-X -mtiny-stack -Waddr-conversie-spațiu

Negru Opţiuni -mcpu=cpu[-sirevision] -msim -momit-leaf-frame-pointer
-mno-omite-leaf-frame-pointer -mspecld-anomalie -mno-specld-anomalie -mcsync-anomalie
-mno-csync-anomalie -mlow-64k -mno-low64k -mstack-check-l1 -mid-shared-bibliotecă
-mno-id-biblioteca partajată -mshared-library-id=n -mleaf-id-biblioteca partajată
-mno-leaf-id-shared-library -msep-data -mno-sep-data -mlong-apeluri -mno-lung-apeluri
-mfast-fp -minline-plt -multicore -mcorea -mcoreb -msdram -micplb

C6X Opţiuni -mbig-endian -mlittle-endian -martie=cpu -msim -msdata=sdata-type

CRIS Opţiuni -mcpu=cpu -martie=cpu -mtune=cpu -mmax-stack-frame=n
-melinux-stacksize=n -metrax4 -metrax100 -mpdebug -mcc-init -mno-efecte secundare
-mstack-align -mdata-align -mconst-align -m32-bit -m16-bit -m8-bit
-mno-prolog-epilog -mno-gotplt -melf -maout -melinux -mlinux -sim -sim2
-mmul-bug-soluție -mno-mul-bug-workaround

CR16 Opţiuni - mmac -mcr16cplus -mcr16c -msim -mentă32 -mbit-ops -mdata-model=model

Darwin Opţiuni -toate_încărcare -client_permis -arc -arch_errors_fatal -arch_only
-bind_at_load -pachet -bundle_loader -numele clientului -compatibility_version
-Versiune curentă -dead_strip -fisier-dependenta -dylib_file -dylinker_install_name
-dinamic -dinamiclib -lista_simbolurilor_exportate -filelist -flat_namespace
-force_cpusubtype_ALL -force_flat_namespace -headerpad_max_install_names -icadru
-bază_imagine -init -nume_instalare -ţine_privaţi_externi -multi_module
-multiplicat_definite -multiply_defined_unused -noall_load
-no_dead_strip_inits_and_terms -nofixprebinding -nomultidefs -nuprelegare
-noseglinkedit -pagezero_size -prelegare -prebind_all_twolevel_modules -private_bundle
-read_only_relocs -sectalign -sectoobiecte simboluri -de ce încărcătură -seg1addr -sectcreate
-sectoobiecte simboluri -sector -segaddr -segs_read_only_addr -segs_read_write_addr
-seg_adr_table -seg_addr_table_filename -seglinkedit -segprot -segs_read_only_addr
-segs_read_write_addr -modul_unic -static -sub_bibliotecă -sub_umbrelă
-spațiu de nume_două_niveluri -umbrelă -nedefinit -listă_simboluri_neexportate
-nepotriviri_de_referințe_slabe -ce încărcat -F - a presupus -gfull -mmacosx-version-min=versiune
-mkernel -mone-byte-bool

Decembrie Alfa Opţiuni -mno-fp-regs -msoft-float -mieee -mieee-cu-inexacte
-mieee-conform -mfp-trap-mode=mod -mfp-rounding-mode=mod -mtrap-precision=mod
-mbuild-constante -mcpu=tip CPU -mtune=tip CPU -mbwx -mmax -mfix -mcix
-mfloat-vax -mfloat-ieee -mexplicit-relocs -msmall-data -mlarge-data -msmall-text
-mlarg-text -memorie-latenta=timp

FR30 Opţiuni -msmall-model -mno-lsim

FRV Opţiuni -mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64 -mhard-float -msoft-float
-malloc-cc -mfixed-cc -mdword -mno-dword -mdublu -mno-dublu -mmedia -mno-media
-mmuladd -mno-muladd -mfdpic -minline-plt -mgprel-ro -multilib-library-pic
-mlinked-fp -mlong-apeluri -etichete-maligne -mlibrary-pic -macc-4 -macc-8 -mpack
-mno-pack -mno-eflaguri -mcond-move -mno-cond-move -moptimize-membar
-mno-optimize-membar -mscc -mno-scc -mcond-exec -mno-cond-exec -mvliw-ramură
-mno-vliw-ramură -mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-imbricat-cond-exec -mtomcat-stats -mTLS -mtls -mcpu=cpu

GNU / Linux Opţiuni -mglibc -muclibc -mbionic -mandroid -tno-android-cc -tno-android-ld

H8 / 300 Opţiuni -mrelaxează-te -mh -Domnișoară -mn -mexr -mno-exr -mentă32 -malign-300

HPPA Opţiuni -martie=de tip arhitectură -mdisable-fpregs -mdisable-indexing
-mfast-indirect-calls -mgas -mgnu-ld -mhp-ld -mfixed-range=registru-gamă
-mjump-in-delay -mlinker-opt -mlong-apeluri -mlong-load-store -mno-disable-fpregs
-mno-disable-indexing -mno-apeluri-rapide-indirecte -mno-gaz -mno-sarit-în-întârziere
-mno-long-load-store -mno-portable-runtime -mno-soft-float -mno-spațiu-regs
-msoft-float -mpa-risc-1-0 -mpa-risc-1-1 -mpa-risc-2-0 -portable-runtime
-mschedule=tip CPU -mspace-regs -msio -mwsio -munix=unix-std -nolibdld -static
- fire

i386 și x86-64 Opţiuni -mtune=tip CPU -martie=tip CPU -mtune-ctrl=listă de caracteristici
-mdump-tune-caracteristici -mno-implicit -mfpmath=unitate -masm=dialect -mno-fancy-math-387
-mno-fp-ret-in-387 -msoft-float -mno-wide-multiplicare -mrtd -malign-dublu
-mpreferred-stack-boundary=o -mincoming-stack-boundary=o -mcld -mcx16 -msahf
-mmovbe -mcrc32 -mrecip -mrecip=opta -mvzeroupper -mprefer-avx128 -mmmx -msse -msse2
-msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx -mavx2 -mavx512f -mavx512pf -mavx512er
-mavx512cd -msha -maes -mpclmul -mfsgsbase -mrdrnd -mf16c -mfma -mprefetchwt1 -msse4a
-m3dnow -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop -mlzcnt -mbmi2 -mfxsr -mxsave
-mxsaveopt -mrtm -mlwp -mthreads -mno-align-stringops -minline-all-stringops
-minline-stringops-dinamic -mstringop-strategy=ALG -mmemcpy-strategy=strategie
-mmemset-strategy=strategie -mpush-args -maccumulate-outgoing-args
-m128bit-long-dublu -m96bit-long-dublu -mlong-dublu-64 -mlong-dublu-80
-mlong-dublu-128 -mregparm=o -msseregparm -mveclibabi=tip -mvect8-ret-in-mem
-mpc32 -mpc64 -mpc80 -mstackrealign -momit-leaf-frame-pointer -mno-zona-rosie
-mno-tls-direct-seg-refs -mcmmodel=cod-model -mabi=nume -maddress-mode=mod -m32 -m64
-mx32 -m16 -mlarge-data-threshold=o -msse2avx -mfentry -m8bit-idiv
-mavx256-split-unaligned-load -mavx256-split-unaligned-store
-mstack-protector-guard=pază

i386 și x86-64 ferestre din Opţiuni -mconsole -mcygwin -mno-cygwin -mdll
-mnop-fun-dllimport -mthread -municode -mwin32 -mwindows -fno-set-stack-executable

IA-64 Opţiuni -mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic
-mvolatile-asm-stop -mregister-names -msdata -mno-sdata -mconstant-gp -mauto-pic
-mfused-madd -minline-float-divide-min-latency -minline-float-divide-max-throughput
-mno-inline-float-divide -minline-int-divide-min-latency
-minline-int-divide-max-throughput -mno-inline-int-divide -minline-sqrt-min-latency
-minline-sqrt-max-throughput -mno-inline-sqrt -mdwarf2-asm -biți-stop-meriți
-mfixed-range=registru-gamă -mtls-size=dimensiunea tls -mtune=tip CPU -milp32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -msched-control-spec -msched-br-in-data-spec
-msched-ar-in-data-spec -msched-in-control-spec -msched-spec-ldc
-msched-spec-control-ldc -msched-prefer-non-data-spec-insns
-msched-prefer-non-control-spec-insns -msched-stop-bits-după-fiecare-ciclu
-msched-count-spec-in-critical-path -msel-sched-dont-check-control-spec
-msched-fp-mem-deps-zero-cost -msched-max-memory-insns-hard-limit
-msched-max-memory-insns=max-insns

LM32 Opţiuni -barrel-shift-activat -mdivide-activat -multiplicare-activat
-msign-extend-activat -activat pentru muzică

M32R/D Opţiuni -m32r2 -m32rx -m32r -mdebug -bucle-maligne -mno-align-loops
-rata-eșec=număr -mbranch-cost=număr -mmodel=cod-dimensiune-tip-model -msdata=sdata-
tip -mno-flush-func -mflush-func=nume -mno-flush-trap -mflush-trap=număr -G o

M32C Opţiuni -mcpu=cpu -msim -memregs=număr

M680x0 Opţiuni -martie=arc -mcpu=cpu -mtune=ton -m68000 -m68020 -m68020-40
-m68020-60 -m68030 -m68040 -m68060 -mcpu32 -m5200 -m5206e -m528x -m5307 -m5407
-mcfv4e -mbitfield -mno-câmp de biți -mc68000 -mc68020 -mnobitfield -mrtd -mno-rtd
-mdiv -mno-div -mscurt -mno-scurt -mhard-float -m68881 -msoft-float -mpcrel
-malign-int -mstrict-align -msep-data -mno-sep-data -mshared-library-id=n
-mid-shared-bibliotecă -mno-id-biblioteca partajată -mxgot -mno-xgot

MCore Opţiuni -mhardlit -mno-luminat greu -mdiv -mno-div -mrelax-imediat
-mno-relax-imediat -mwide-bitfields -mno-wide-bitfields -m4byte-funcții
-mno-4byte-funcții -mcallgraph-date -mno-callgraph-date -mslow-bytes
-mno-slow-bytes -mno-lsim -mlittle-endian -mbig-endian -m210 -m340
-mstack-increment

MeP Opţiuni -mabsdiff -mall-opts -maverage -mbased=n -mbitops -mc=n -mclip
-mconfig=nume -mcop -mcop32 -mcop64 -mivc2 -mdc -mdiv -meb -mel -mio-volatil -ml
-mleadz -mm -mminmax -mult -mno-opts -mrepeat -Domnișoară -msatur -msdram -msim -msimnovec
-mtf -mtiny=n

MicroBlaze Opţiuni -msoft-float -mhard-float -msmall-divides -mcpu=cpu -mmemcpy
-mxl-soft-mul -mxl-soft-div -mxl-baril-shift -mxl-pattern-compara -mxl-stack-check
-mxl-gp-opt -mno-clearbss -mxl-multiplicare-mare -mxl-float-convertire -mxl-float-sqrt
-mbig-endian -mlittle-endian -mxl-reordonare -mxl-mode-modelul aplicației

MIPS Opţiuni -CE -EB -martie=arc -mtune=arc -mips1 -mips2 -mips3 -mips4
-mips32 -mips32r2 -mips64 -mips64r2 -mips16 -mno-mips16 -mflip-mips16
-minterlink-comprimat -mno-interlink-comprimat -minterlink-mips16
-mno-interlink-mips16 -mabi=abi -mabicals -mno-abicalls -mshared -mno-shared
-mplt -mno-plt -mxgot -mno-xgot -mgp32 -mgp64 -mfp32 -mfp64 -mhard-float
-msoft-float -mno-float -msingle-float -mdouble-float -mabs=mod -mnan=codare
-mdsp -mno-dsp -mdspr2 -mno-dspr2 -mmcu -mmno-mcu -meva -mno-eva -mvirt -mno-virt
-micromips -mno-micromips -mfpu=de tip fpu -msmartmips -mno-smartmips -persoană-singure
-mno-pereche-singure -mdmx -mno-mdmx -mips3d -mno-mips3d -mmt -mno-mt -mllsc
-mno-llsc -mlong64 -mlong32 -msym32 -mno-sym32 -Go -mlocal-sdata
-mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt -date-membrate
-mno-date-încorporate -muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable=instalare -msplit-adrese -mno-split-adrese -mexplicit-relocs
-mno-explicite-relocs -mcheck-zero-diviziune -mno-verificare-zero-diviziune -mdivide-capcane
-mdivide-pauze -mmemcpy -mno-memcpy -mlong-apeluri -mno-lung-apeluri -mmad -mno-nebun
-mimadd -mno-imadd -mfused-madd -mno-fuzionat-madd -nocpp -mfix-24k -mno-fix-24k
-mfix-r4000 -mno-fix-r4000 -mfix-r4400 -mno-fix-r4400 -mfix-r10000 -mno-fix-r10000
-mfix-rm7000 -mno-fix-rm7000 -mfix-vr4120 -mno-fix-vr4120 -mfix-vr4130
-mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1 -mflush-func=FUNC -mno-flush-func
-mbranch-cost=o -branch-probabil -mno-ramură-probabilă -mfp-excepții
-mno-fp-excepții -mvr4130-align -mno-vr4130-align -msynci -mno-synci
-mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-adresă

MMIX Opţiuni -mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi=gnu
-mabi=mmixware -mzero-extinde -mknuthdiv -mtoplevel-simboluri -melf -mbranch-predic
-mno-ramură-predic -base-adrese -adrese-mno-bază -msingle-exit
-mno-single-exit

MN10300 Opţiuni -mult-bug -mno-mult-bug -mno-am33 -mam33 -mam33-2 -mam34 -mtune=CPU-
tip -mreturn-pointer-on-d0 -mno-crt0 -mrelaxează-te -mliw -msetlb

Moxie Opţiuni -meb -mel -mno-crt0

MSP430 Opţiuni -msim -masm-hex -mmcu= -mcpu= -m mare -mmic -mrelaxează-te -mhwmult= -minrt

NDS32 Opţiuni -mbig-endian -mlittle-endian -mreducere-reg -mfull-regs -mcmov -mno-cmov
-mperf-ext -mno-perf-ext -mv3push -mno-v3push -m16bit -mno-16 biți -mgp-direct
-mno-gp-direct -misr-vector-size=o -mcache-block-size=o -martie=arc
-mforce-fp-as-gp -mforbid-fp-as-gp -mex9 -mctor-dtor -mrelaxează-te

NIOS II Opţiuni -G o -mgpopt -mno-gpopt -mel -meb -mno-bypass-cache -mbypass-cache
-mno-cache-volatil -mcache-volatil -mno-rapid-sw-div -mfast-sw-div -mhw-mul
-mno-hw-mul -mhw-mulx -mno-hw-mulx -mno-hw-div -mhw-div -mpersonalizat-insn=N
-mno-personalizat-insn -mcustom-fpu-cfg=nume -mhal -msmallc -msys-crt0=nume -msys-lib=nume

PDP-11 Opţiuni -mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10 -mbcopy
-mbcopy-builtin -mentă32 -mno-int16 -mentă16 -mno-int32 -mfloat32 -mno-float64
-mfloat64 -mno-float32 -mabshi -mno-abshi -branch-scump -branch-ieftin
-munix-asm -mdec-asm

picoChip Opţiuni -mae=ae_type -mvliw-lookahead=N -msymbol-ca-adresă
-mno-ineficiente-avertismente

PowerPC Opţiuni Consultați Opțiuni RS/6000 și PowerPC.

RL78 Opţiuni -msim -mmul=niciuna -mmul=g13 -mmul=rl78

RS / 6000 și PowerPC Opţiuni -mcpu=tip CPU -mtune=tip CPU -mcmmodel=cod-model
-mpowerpc64 -maltivec -mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt -mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb
-mpopcntd -mno-popcntd -mfprnd -mno-fprnd -mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr
-mhard-dfp -mno-hard-dfp -mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc
-m64 -m32 -mxl-compat -mno-xl-compat -mpe -putere-malignă -malign-natural
-msoft-float -mhard-float -multiplu -mno-multiplu -msingle-float -mdouble-float
-msimple-fpu -mstring -mno-string -actualizare -mno-update -adrese-mavoid-indexate
-mno-evitati-adresele-indexate -mfused-madd -mno-fuzionat-madd -mbit-align
-mno-bit-align -mstrict-align -mno-strict-align -mrelocabil -mno-relocabil
-mrelocatable-lib -mno-relocabil-lib -mtoc -mno-toc - putin -mlittle-endian
-mbig -mbig-endian -mdynamic-no-pic -maltivec -mswdiv -msingle-pic-base
-mprioritize-restricted-insns=prioritate -msched-costly-dep=tip_dependență
-minsert-sched-nops=schemă -mcall-sysv -mcall-netbsd -maix-struct-return
-msvr4-struct-return -mabi=abi-tip -msecure-plt -mbss-plt
-mblock-move-inline-limit=o -misel -mno-isel -misel=da -misel=nu -mspe -mno-spe
-mspe=da -mspe=nu -compare -mgen-celula-microcod -mwarn-celula-microcod -mvrsave
-mno-vrsave -mmulhw -mno-mulhw -mdlmzb -mno-dlmzb -mfloat-gprs=da -mfloat-gprs=nu
-mfloat-gprs=single -mfloat-gprs=dublu -mprototip -mno-prototip -msim -mmvme
-nebunii -cuțit galben -memb -msdata -msdata=opta -mvxworks -G o -pthread -mrecip
-mrecip=opta -mno-recip -mrecip-precizie -mno-recip-precizie -mveclibabi=tip -mfriz
-mno-friz -mpointers-to-imbricate-funcții -mno-pointere-la-funcții-imbricate
-msave-toc-indirect -mno-save-toc-indirect -mpower8-fusion -mno-mpower8-fusion
-mpower8-vector -mno-power8-vector -mcrypto -mno-cripto -mdirect-mutare -mno-direct-mutare
-mquad-memory -mno-quad-memorie -mquad-memory-atomic -mno-quad-memorie-atomic
-mcompat-align-parm -mno-compat-align-parm

RX Opţiuni -m64bit-duble -m32bit-duble -fpu -nofpu -mcpu= -mbig-endian-date
-mlittle-endian-date -msmall-data -msim -mno-sim -mas100-sintaxă -mno-as100-sintaxă
-mrelaxează-te -mmax-constant-size= -mint-registru= -mpid -mno-warn-multiple-rapid-întreruperi
-msave-acc-in-intreruperi

S / 390 și zSeries Opţiuni -mtune=tip CPU -martie=tip CPU -mhard-float -msoft-float
-mhard-dfp -mno-hard-dfp -mlong-dublu-64 -mlong-dublu-128 -mbackchain
-mno-backchain -ambalat-stivă -mno-packed-stack -msmall-exec -mno-small-exec
-mmvcle -mno-mvcle -m64 -m31 -mdebug -mno-debug -mesa -mzarch -mtpf-trace
-mno-tpf-trace -mfused-madd -mno-fuzionat-madd -mwarn-framesize -mwarn-dynamicstack
-mstack-size -mstack-guard -mhotpatch=jumătăţi de cuvinte,jumătăţi de cuvinte

Scor Opţiuni -meb -mel -mnhwloop -muls - mmac -mscore5 -mscore5u -mscore7 -mscore7d

SH Opţiuni -m1 -m2 -m2e -m2a-nofpu -m2a-singur-doar -m2a-singure -m2a -m3 -m3e
-m4-nofpu -m4-singur-doar -m4-singura -m4 -m4a-nofpu -m4a-singur-doar -m4a-singure
-m4a -m4al -m5-64media -m5-64media-nofpu -m5-32media -m5-32media-nofpu -m5-compact
-m5-compact-nofpu -mb -ml -mdalign -mrelaxează-te -mbigtable -mfmovd -mhitachi -mrenesas
-mno-renesas -mnomacsave -mieee -mno-ieee -mbitops - misize -minline-ic_invalidate
-mpadstruct -mspace -mprefergot -musemode -multcost=număr -mdiv=strategie
-mdivsi3_libfunc=nume -mfixed-range=registru-gamă -mindexed-adresare
-mgettrcost=număr -mpt-fix -maccumulate-outgoing-args -minvalid-simboluri
-matomic-model=model atomic -mbranch-cost=o -mzdcbranch -mno-zdcbranch -mfused-madd
-mno-fuzionat-madd -mfsca -mno-fsca -mfsrra -mno-fsrra -pretend-cmove -mtas

Solaris 2 Opţiuni -mclear-hwcap -mno-clear-hwcap -mipur-text -mno-impure-text
-pthreads -pthread

SPARC Opţiuni -mcpu=tip CPU -mtune=tip CPU -mcmmodel=cod-model -model-memorie=mem-
model -m32 -m64 -mapp-regs -mno-app-regs -mfaster-structs -mno-faster-structs
-mflat -mno-plat -mfpu -mno-fpu -mhard-float -msoft-float -mhard-quad-float
-msoft-quad-float -mstack-bias -mno-stack-bias -munaligned-duble
-mno-nealiniate-duble -modul-muser -mno-user-mode -mv8plus -mno-v8plus -mvis
-mno-vis -mvis2 -mno-vis2 -mvis3 -mno-vis3 -mcbcond -mno-cbcond -mfmaf -mno-fmaf
-mpopc -mno-popc -mfix-at697f -mfix-ut699

SPU Opţiuni -mwarn-reloc -merror-reloc -msafe-dma -munsafe-dma -mbranch-hints
-msmall-mem -mlarge-mem -mstdmain -mfixed-range=registru-gamă -mea32 -mea64
-maddress-space-conversion -mno-conversie-spațiu-adresă -mcache-size=mărimea cache-ului
-actualizări-matomic -actualizări-mno-atomice

Sistem V Opţiuni -Qy -Qn -Da,căi - Da,dir

TILE-Gx Opţiuni -mcpu=CPU -m32 -m64 -mbig-endian -mlittle-endian -mcmmodel=cod-model

TILEPro Opţiuni -mcpu=cpu -m32

V850 Opţiuni -mlong-apeluri -mno-lung-apeluri -mep -mno-ep -functie-mprolog
-mno-prolog-functie -mspace -mtda=n -msda=n -mzda=n -mapp-regs -mno-app-regs
-mdisable-callt -mno-disable-callt -mv850e2v3 -mv850e2 -mv850e1 -mv850es -mv850e
-mv850 -mv850e3v5 -mloop -mrelaxează-te -msalt-lung -msoft-float -mhard-float -mgcc-abi
-mrh850-abi -mbig-switch

VAX Opţiuni -mg -mgnu -munix

VMS Opţiuni -mvms-coduri-return -mdebug-main=prefix -mmalloc64 -mpointer-size=mărimea

VxWorks Opţiuni -mrtp -nestatic -Bstatic -Bdinamic -Xbind-leneș -Xbind-acum

x86-64 Opţiuni Consultați opțiunile i386 și x86-64.

Xstormy16 Opţiuni -msim

Xtensa Opţiuni -mconst16 -mno-const16 -mfused-madd -mno-fuzionat-madd -mforce-no-pic
-mserialize-volatile -mno-serializare-volatil -mtext-section-literals
-mno-text-section-literale -mtarget-align -mno-target-align -mlongcalls
-mno-apeluri lungi

zSeries Opţiuni Consultați Opțiunile S/390 și zSeries.

Cod Generație Opţiuni
-fcall-salvat-reg -fcall-folosit-reg -fixat-reg -excepții -fnon-call-exceptions
-fdelete-dead-exceptions -mesele-funwind -fasynchronous-unwind-tables -fno-gnu-unic
-directiva-dimensiune-finhibit -finstrument-funcţii
-finstrument-functions-exclude-function-list=sym,sym, ...
-finstrument-functions-exclude-file-list=fişier,fişier, ... -fno-comună -fno-ident
-fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-sarituri-mesele -frecord-gcc-switch-uri
-freg-struct-retur -fshort-enums -fscurt-dublu -fshort-wchar -fverbose-asm
-fpack-struct[=n] -fstack-check -fstack-limit-register=reg -fstack-limit-simbol=sym
-fno-stack-limit -fsplit-stack -fugatoare-subliniere -ftls-model=model
-fstack-reuse=reuse_level -ftrapv -fwrapv -fbounds-check -fvizibilitate
-fstrict-volatile-bitfields -fsync-libcalls

Opţiuni Controlul il Copil of producție
Compilarea poate implica până la patru etape: preprocesare, compilare propriu-zisă, asamblare și
conectarea, întotdeauna în această ordine. GCC este capabil să preproceseze și să compileze mai multe
fișiere fie în mai multe fișiere de intrare a asamblatorului, fie într-un fișier de intrare a asamblatorului; atunci
fiecare fișier de intrare a asamblatorului produce un fișier obiect, iar legătura combină tot obiectul
fișierele (cele nou compilate și cele specificate ca intrare) într-un fișier executabil.

Pentru orice fișier de intrare dat, sufixul numelui fișierului determină ce fel de compilare este
Terminat:

fişier.c
Cod sursă C care trebuie preprocesat.

fişier.i
Cod sursă C care nu trebuie preprocesat.

fişier.ii
Cod sursă C++ care nu trebuie preprocesat.

fişier.m
Cod sursă Objective-C. Rețineți că trebuie să vă conectați cu libobjc bibliotecă a face o
Programul de lucru Objective-C.

fişier.mi
Cod sursă Objective-C care nu ar trebui preprocesat.

fişier.mm
fişier.M
Cod sursă Objective-C++. Rețineți că trebuie să vă conectați cu libobjc bibliotecă de făcut
un program de lucru Objective-C++. Rețineți că .M se referă la un M majuscul literal.

fişier.mii
Cod sursă Objective-C++ care nu ar trebui preprocesat.

fişier.h
Fișierul antet C, C++, Objective-C sau Objective-C++ pentru a fi transformat într-un fișier precompilat
antet (implicit) sau fișierul antet C, C++ pentru a fi transformat într-o specificație Ada (prin
-fdump-ada-spec intrerupator).

fişier. Cc
fişier.cp
fişier.cxx
fişier.cpp
fişier.CPP
fişier.c ++
fişier.C
Cod sursă C++ care trebuie preprocesat. Rețineți că în .cxx, ultimele două litere
trebuie să fie ambele la propriu x. De asemenea, .C se referă la un C majuscul literal.

fişier.mm
fişier.M
Cod sursă Objective-C++ care trebuie preprocesat.

fişier.mii
Cod sursă Objective-C++ care nu ar trebui preprocesat.

fişier.hh
fişier.H
fişier.hp
fişier.hxx
fişier.hpp
fişier.HPP
fişier.h++
fişier.tcc
Fișierul antet C++ să fie transformat într-un antet precompilat sau într-o specificație Ada.

fişier.f
fişier.pentru
fişier.ftn
S-a remediat codul sursă Fortran care nu ar trebui să fie preprocesat.

fişier.F
fişier.PENTRU
fişier.fpp
fişier.FPP
fişier.FTN
S-a rezolvat codul sursă Fortran care trebuie preprocesat (cu codul tradițional
preprocesor).

fişier.f90
fişier.f95
fişier.f03
fişier.f08
Cod sursă Fortran în formă liberă, care nu ar trebui preprocesat.

fişier.F90
fişier.F95
fişier.F03
fişier.F08
Cod sursă Fortran în formă liberă care trebuie preprocesat (cu tradițional
preprocesor).

fişier.merge
Accesați codul sursă.

fişier.reclame
Fișier de cod sursă Ada care conține o declarație de unitate de bibliotecă (o declarație de a
pachet, subprogram sau generic, sau o instanțiere generică), sau o unitate de bibliotecă
declarație de redenumire (o declarație de redenumire de pachet, generică sau subprogram). Astfel de
sunt numite și fișiere Specificatii.

fişier.adb
Fișier de cod sursă Ada care conține un corp de unitate de bibliotecă (un subprogram sau un corp de pachet).
Astfel de fișiere sunt, de asemenea, numite organisme.

fişier.d
D fișier cod sursă.

fişier.di
Fișier cod de interfață D.

fişier.dd
D fișier cod de documentație.

fişier.s
Cod de asamblare.

fişier.S
fişier.s x
Cod de asamblare care trebuie preprocesat.

alte
Un fișier obiect care trebuie introdus direct în legătură. Orice nume de fișier fără a fi recunoscut
sufixul este tratat în acest fel.

Puteți specifica limba de intrare în mod explicit cu ajutorul -x opţiune:

-x limbă
Specificați în mod explicit limbă pentru următoarele fișiere de intrare (în loc de a lăsa
compilatorul alege un implicit pe baza sufixului numelui de fișier). Această opțiune se aplică tuturor
următoarele fișiere de intrare până la următoarea -x opțiune. Valori posibile pentru limbă sunt:

c c-header cpp-ieșire
c++ c++-header c++-cpp-output
obiectiv-c obiectiv-c-header obiectiv-c-cpp-ieșire
obiectiv-c++ obiectiv-c++-header obiectiv-c++-cpp-ieșire
asamblator asamblator-cu-cpp
ada
d
f77 f77-cpp-input f95 f95-cpp-input
go
Java

-x nici unul
Dezactivați orice specificație a unei limbi, astfel încât fișierele ulterioare să fie tratate
în funcție de sufixele numelor de fișiere (cum sunt dacă -x nu a fost folosit deloc).

-coduri de trecere-ieșire
În mod normal gcc programul iese cu codul 1 dacă revine vreo fază a compilatorului
un cod de returnare nereușit. Daca specificati -coduri de trecere-ieșire, gcc program în schimb
returnează cu cea mai mare eroare numeric produsă de orice fază care returnează o eroare
indicaţie. Front end-urile C, C++ și Fortran returnează 4 dacă o eroare internă a compilatorului
este întâlnită.

Dacă doriți doar câteva dintre etapele de compilare, puteți utiliza -x (sau sufixe de nume de fișier)
a spune gcc de unde să începeți și una dintre opțiuni -c, -S, Sau -E a spune unde gcc este acela de a
Stop. Rețineți că unele combinații (de exemplu, -x ieșire cpp -E) instrui gcc de a face
nimic.

-c Compilați sau asamblați fișierele sursă, dar nu legați. Etapa de legătură este pur și simplu
nu făcut. Rezultatul final este sub forma unui fișier obiect pentru fiecare fișier sursă.

În mod implicit, numele fișierului obiect pentru un fișier sursă se face prin înlocuirea sufixului .c,
.i, .s, etc., cu .o.

Fișierele de intrare nerecunoscute, care nu necesită compilare sau asamblare, sunt ignorate.

-S Opriți după etapa de compilare propriu-zisă; nu asamblați. Ieșirea este în
forma unui fișier de cod de asamblare pentru fiecare fișier de intrare non-asamblator specificat.

În mod implicit, numele fișierului de asamblare pentru un fișier sursă se face prin înlocuirea sufixului
.c, .i, etc., cu .s.

Fișierele de intrare care nu necesită compilare sunt ignorate.

-E Oprire după etapa de preprocesare; nu rulați compilatorul propriu-zis. Ieșirea este în
forma codului sursă preprocesat, care este trimis la ieșirea standard.

Fișierele de intrare care nu necesită preprocesare sunt ignorate.

-o fişier
Plasați ieșirea în fișier fişier. Acest lucru se aplică indiferent de tipul de ieșire care este produs,
fie că este un fișier executabil, un fișier obiect, un fișier de asamblare sau C preprocesat
cod.

If -o nu este specificat, implicit este să introduceți un fișier executabil a.out, obiectul
fisier pentru sursă.sufix in sursa.o, fișierul său de asamblare în sursa.s, un precompilat
fișier antet în sursă.sufix.gch, și toate sursele C preprocesate la ieșire standard.

-v Tipăriți (pe ieșire de eroare standard) comenzile executate pentru a rula etapele de
compilare. Tipăriți, de asemenea, numărul versiunii programului driver al compilatorului și al
preprocesorul și compilatorul propriu-zis.

-###
Aprecieri -v cu excepția faptului că comenzile nu sunt executate și argumentele sunt citate decât dacă acestea
conţin doar caractere alfanumerice sau „./-_”. Acest lucru este util pentru scripturile shell
captura liniile de comandă generate de driver.

-teava
Utilizați mai degrabă conducte decât fișiere temporare pentru comunicarea între diferitele etape ale
compilare. Acest lucru nu funcționează pe unele sisteme în care asamblatorul nu poate citi
dintr-o țeavă; dar asamblatorul GNU nu are probleme.

--Ajutor
Tipăriți (pe ieșirea standard) o descriere a opțiunilor de linie de comandă înțelese de
gcc. Dacă -v este specificată și opțiunea atunci --Ajutor se transmite şi la diverse
procesele invocate de gcc, astfel încât să poată afișa opțiunile din linia de comandă
Accept. Dacă -Wextra a fost specificată și opțiunea (înainte de --Ajutor opțiune),
apoi sunt și opțiunile din linia de comandă care nu au documentație asociată
afișat.

--ţintă-ajutor
Tipăriți (pe ieșirea standard) o descriere a opțiunilor de linie de comandă specifice țintei
pentru fiecare instrument. Pentru unele ținte pot fi, de asemenea, informații suplimentare specifice țintei
imprimate.

--help={clasă|[^]calificativ}[, ...]
Tipăriți (pe ieșirea standard) o descriere a opțiunilor de linie de comandă înțelese de
compilatorul care se încadrează în toate clasele și calificatorii specificati. Acestea sunt
clase suportate:

optimizatori
Afișează toate opțiunile de optimizare acceptate de compilator.

avertismente
Afișează toate opțiunile care controlează mesajele de avertizare produse de compilator.

ţintă
Afișați opțiuni specifice țintei. spre deosebire de --ţintă-ajutor opțiune totuși, țintă-
opțiunile specifice ale linkerului și ale asamblatorului nu sunt afișate. Asta pentru ca
aceste instrumente nu acceptă în prezent extinderea --ajutor= sintaxă.

parametrii
Afișează valorile recunoscute de --param opțiune.

limbă
Afișați opțiunile acceptate pentru limbă, În cazul în care limbă este numele unuia dintre
limbile acceptate în această versiune a GCC.

comun
Afișați opțiunile care sunt comune tuturor limbilor.

Acestea sunt calificativele acceptate:

nedocumentat
Afișați numai acele opțiuni care nu sunt documentate.

alăturat
Afișați opțiunile luând un argument care apare după un semn egal în același
fragment continuu de text, cum ar fi: --help=țintă.

distinct
Afișați opțiunile luând un argument care apare ca un cuvânt separat după
opțiune originală, cum ar fi: -o fisier de iesire.

Astfel, de exemplu, pentru a afișa toate comutatoarele nedocumentate specifice țintei suportate de
compilatorul, folosește:

--help=țintă, nedocumentat

Sensul unui calificativ poate fi inversat prefixându-l cu ^ caracter, deci pentru
exemplu pentru a afișa toate opțiunile binare de avertizare (adică cele care sunt fie activate, fie dezactivate
și care nu acceptă un argument) care au o descriere, folosește:

--help=warnings,^joined,^nedocumented

Argumentul pentru --ajutor= nu ar trebui să fie compus numai din calificative inversate.

Combinarea mai multor clase este posibilă, deși acest lucru limitează de obicei rezultatul
mult că nu există nimic de afișat. Un caz în care funcționează, totuși, este când
una dintre clase este ţintă. De exemplu, pentru a afișa toate obiectivele specifice
opțiuni de optimizare, utilizați:

--help=țintă,optimizatori

--ajutor= opțiunea poate fi repetată pe linia de comandă. Se afișează fiecare utilizare succesivă
clasa sa de opțiuni solicitată, sărind peste cele care au fost deja afișate.

În cazul în care -Q opțiunea apare pe linia de comandă înainte de --ajutor= opțiunea, apoi
text descriptiv afișat de --ajutor= s-a schimbat. În loc să descrie cele afișate
opțiuni, se oferă o indicație dacă opțiunea este activată, dezactivată sau setată
la o anumită valoare (presupunând că compilatorul știe acest lucru în punctul în care
--ajutor= este utilizată opțiunea).

Iată un exemplu trunchiat din portul ARM al gcc:

% gcc -Q -mabi=2 --help=target -c
Următoarele opțiuni sunt specifice țintei:
-mabi= 2
-mabort-on-noreturn [dezactivat]
-mapcs [dezactivat]

Ieșirea este sensibilă la efectele opțiunilor anterioare ale liniei de comandă, deci pentru
exemplu este posibil să aflați la ce optimizări sunt activate -O2 prin utilizarea:

-Q -O2 --help=optimizatori

Alternativ, puteți descoperi de ce optimizări binare sunt activate -O3 prin utilizarea:

gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts
gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts
diff /tmp/O2-opts /tmp/O3-opts | grep activat

-fără-prefixe-canonice
Nu extindeți nicio legătură simbolică, rezolvați referințele la /../ or /./, sau face calea
absolut atunci când se generează un prefix relativ.

--versiune
Afișați numărul versiunii și drepturile de autor ale GCC invocate.

-invelis
Invocați toate subcomenzile dintr-un program wrapper. Numele programului wrapper și
parametrii săi sunt trecuți ca o listă separată prin virgulă.

gcc -c tc -wrapper gdb,--args

Aceasta invocă toate subprogramele de gcc în gDB --args, astfel invocarea lui cc1 is
gDB --args cc1 ....

-fplugin=nume.asa de
Încărcați codul pluginului în fișier nume.deci, presupus a fi un obiect partajat de care trebuie deschis
compilatorul. Numele de bază al fișierului obiect partajat este folosit pentru a identifica pluginul
în scopul analizării argumentelor (vezi -fplugin-arg-nume-cheie=valoare de mai jos). Fiecare
pluginul ar trebui să definească funcțiile de apel invers specificate în API-ul Plugins.

-fplugin-arg-nume-cheie=valoare
Definiți un argument numit cheie cu o valoare de valoare pentru pluginul numit nume.

-fdump-ada-spec[-subţire]
Pentru fișierele sursă și include C și C++, generați specificațiile Ada corespunzătoare.

-fada-spec-parent=unitate
În legătură cu -fdump-ada-spec[-subţire] de mai sus, generați specificațiile Ada ca unități secundare ale
mamă unitate.

-fdump-go-spec=fişier
Pentru fișierele de intrare în orice limbă, generați declarațiile Go corespunzătoare în fişier. Acest
generează declarații Go „const”, „type”, „var” și „func”, care pot fi o modalitate utilă
pentru a începe să scrieți o interfață Go în codul scris într-o altă limbă.

@fişier
Citiți opțiunile din linia de comandă din fişier. Opțiunile citite sunt inserate în locul lui
original @fişier opțiune. Dacă fişier nu există, sau nu poate fi citit, atunci opțiunea
vor fi tratate la propriu și nu eliminate.

Opțiuni în fişier sunt separate prin spații albe. Poate fi inclus un caracter alb
într-o opțiune înconjurând întreaga opțiune fie între ghilimele simple, fie duble. Orice
caracterul (inclusiv o bară oblică inversă) poate fi inclus prin prefixarea caracterului care trebuie să fie
incluse cu o bară oblică inversă. The fişier poate conține în sine @ suplimentarfişier Opțiuni; orice
astfel de opțiuni vor fi procesate recursiv.

Compilarea C ++ Programe
Fișierele sursă C++ folosesc în mod convențional unul dintre sufixe .C, . Cc, .cpp, .CPP, .c ++, .cp, Sau
.cxx; Fișierele antet C++ folosesc adesea .hh, .hpp, .Hsau (pentru codul de șablon partajat) .tccŞi
fișierele C++ preprocesate folosesc sufixul .ii. GCC recunoaște fișierele cu aceste nume și
le compilează ca programe C++ chiar dacă apelați compilatorul în același mod ca și pentru compilare
Programe C (de obicei cu numele gcc).

Cu toate acestea, utilizarea gcc nu adaugă biblioteca C++. g ++ este un program care apelează GCC și
specifică automat legătura cu biblioteca C++. Se tratează .c, .h și .i fişiere ca
Fișierele sursă C++ în loc de fișierele sursă C, cu excepția cazului în care -x este folosit. Acest program este de asemenea util
la precompilarea unui fișier antet C cu a .h extensie pentru utilizare în compilațiile C++. Pe
multe sisteme, g ++ este instalat și cu numele c ++.

Când compilați programe C++, puteți specifica multe dintre aceleași opțiuni de linie de comandă care
utilizați pentru compilarea programelor în orice limbă; sau opțiuni de linie de comandă semnificative pentru C
și limbi înrudite; sau opțiuni care au sens numai pentru programele C++.

Opţiuni Controlul C dialect
Următoarele opțiuni controlează dialectul C (sau limbile derivate din C, cum ar fi C++,
Objective-C și Objective-C++) pe care compilatorul le acceptă:

-ansi
În modul C, aceasta este echivalentă cu -std=c90. În modul C++, este echivalent cu
-std=c++98.

Aceasta dezactivează anumite funcții ale GCC care sunt incompatibile cu ISO C90 (când
compilarea codului C), sau a C++ standard (la compilarea codului C++), cum ar fi „asm” și
cuvinte cheie „typeof” și macrocomenzi predefinite, cum ar fi „unix” și „vax” care identifică
tipul de sistem pe care îl utilizați. De asemenea, permite ISO nedorit și rar folosit
caracteristica trigraf. Pentru compilatorul C, acesta dezactivează recunoașterea stilului C++ //
comentarii, precum și cuvântul cheie „inline”.

Cuvintele cheie alternative „__asm__”, „__extension__”, „__inline__” și „__typeof__”
continuă să lucreze în ciuda -ansi. Nu ați dori să le utilizați într-un program ISO C,
desigur, dar este util să le puneți în fișierele antet care ar putea fi incluse în
compilatii facute cu -ansi. Alternați macrocomenzi predefinite, cum ar fi „__unix__” și
„__vax__” sunt de asemenea disponibile, cu sau fără -ansi.

-ansi opțiunea nu face ca programele non-ISO să fie respinse gratuit. Pentru
asta, -Wpedant este necesar pe lângă -ansi.

Macrocomanda „__STRICT_ANSI__” este predefinită atunci când -ansi este folosită opțiunea. Un antet
fișierele pot observa această macrocomandă și se pot abține de la declararea sau definirea anumitor funcții
anumite macrocomenzi pe care standardul ISO nu le cere; asta pentru a evita interferența
cu orice programe care ar putea folosi aceste nume pentru alte lucruri.

Funcții care sunt în mod normal încorporate, dar care nu au semantică definită de ISO C (cum ar fi
ca „alloca” și „ffs”) nu sunt funcții încorporate când -ansi este folosit.

-std=
Determinați standardul lingvistic. Această opțiune este în prezent acceptată numai când
compilarea C sau C++.

Compilatorul poate accepta mai multe standarde de bază, cum ar fi c90 or c++98, și dialectele GNU
a acelor standarde, cum ar fi gnu90 or gnu++98. Când este specificat un standard de bază,
compilatorul acceptă toate programele care urmează acel standard plus cele care utilizează extensii GNU
care nu o contrazic. De exemplu, -std=c90 dezactivează anumite funcții ale GCC
care sunt incompatibile cu ISO C90, cum ar fi cuvintele cheie „asm” și „typeof”, dar nu
alte extensii GNU care nu au un sens în ISO C90, cum ar fi omiterea
termenul mijlociu al unei expresii „?:”. Pe de altă parte, atunci când un dialect GNU al unui standard
este specificat, toate caracteristicile suportate de compilator sunt activate, chiar și atunci când acestea
caracteristicile schimbă sensul standardului de bază. Ca urmare, unele strict-conforme
programele pot fi respinse. Standardul special este folosit de -Wpedant pentru a identifica
care caracteristici sunt extensii GNU având în vedere acea versiune a standardului. De exemplu
-std=gnu90 -Wpedant avertizează despre stilul C++ // comentarii, în timp ce -std=gnu99 -Wpedant
nu.

Trebuie furnizată o valoare pentru această opțiune; valorile posibile sunt

c90
c89
iso9899:1990
Acceptă toate programele ISO C90 (anumite extensii GNU care sunt în conflict cu ISO C90
sunt dezactivate). La fel ca -ansi pentru codul C.

iso9899:199409
ISO C90, astfel cum a fost modificat în amendamentul 1.

c99
c9x
iso9899:1999
izo9899:199x
ISO C99. Acest standard este în mod substanțial complet acceptat, modulo bug-uri,
identificatori extinși (acceptați cu excepția cazurilor de colț când
-identificatori-extinși este utilizat) și probleme cu virgulă mobilă (în principal, dar nu în totalitate
referitoare la caracteristicile opționale C99 din anexele F și G). Vedea
<http://gcc.gnu.org/c99status.html> pentru mai multe informatii. Numele c9x și
izo9899:199x sunt depreciate.

c11
c1x
iso9899:2011
ISO C11, revizuirea din 2011 a standardului ISO C. Acest standard este substanțial
complet acceptat, erori modulo, identificatori extinși (acceptați cu excepția
cazuri de colţ când -identificatori-extinși este utilizat), probleme cu virgulă mobilă (în principal
dar nu se referă în totalitate la caracteristicile opționale C11 din anexele F și G) și
opționale Anexele K (Interfețe de verificare a limitelor) și L (Analizabilitate). Numele
c1x este depreciat.

gnu90
gnu89
Dialectul GNU al ISO C90 (inclusiv unele caracteristici C99). Aceasta este valoarea implicită pentru C
cod.

gnu99
gnu9x
Dialectul GNU al ISO C99. Numele gnu9x este depreciat.

gnu11
gnu1x
Dialectul GNU al ISO C11. Acesta este destinat să devină implicit în viitor
eliberarea GCC. Numele gnu1x este depreciat.

c++98
c++03
Standardul ISO C++ din 1998 plus rectificarea tehnică din 2003 și unele suplimentare
rapoarte de defecte. La fel ca -ansi pentru codul C++.

gnu++98
gnu++03
dialectul GNU al -std=c++98. Aceasta este valoarea implicită pentru codul C++.

c++11
c++0x
Standardul ISO C++ din 2011 plus amendamente. Numele c++0x este depreciat.

gnu++11
gnu++0x
dialectul GNU al -std=c++11. Numele gnu++0x este depreciat.

c++1y
Următoarea revizuire a standardului ISO C++, planificată provizoriu pentru 2014. Suport
este extrem de experimental și aproape sigur se va schimba în moduri incompatibile în
lansări viitoare.

gnu++1y
dialectul GNU al -std=c++1y. Asistența este extrem de experimentală și aproape că o va face
cu siguranță se schimbă în moduri incompatibile în versiunile viitoare.

-fgnu89-inline
Optiunea -fgnu89-inline spune GCC să folosească semantica tradițională GNU pentru „inline”
funcţionează în modul C99.
Această opțiune este acceptată și ignorată de versiunile GCC 4.1.3 până la, dar fără a include
4.3. În versiunile GCC 4.3 și ulterioare, schimbă comportamentul GCC în modul C99. Folosind
această opțiune este aproximativ echivalentă cu adăugarea atributului funcției „gnu_inline” la toate
funcții inline.

Optiunea -fno-gnu89-inline spune în mod explicit GCC să folosească semantica C99 pentru
„inline” când se află în modul C99 sau gnu99 (adică, specifică comportamentul implicit). Acest
opțiunea a fost acceptată pentru prima dată în GCC 4.3. Această opțiune nu este acceptată în -std=c90 or
-std=gnu90 Mod.

Pot fi utilizate macrocomenzile de preprocesor „__GNUC_GNU_INLINE__” și „__GNUC_STDC_INLINE__”
pentru a verifica ce semantică este în vigoare pentru funcțiile „inline”.

-aux-info nume de fișier
Ieșire la numele de fișier dat declarații prototip pentru toate funcțiile declarate și/sau
definite într-o unitate de traducere, inclusiv cele din fișierele antet. Această opțiune este
ignorat în tăcere în orice altă limbă decât C.

Pe lângă declarații, dosarul indică, în comentarii, proveniența fiecărei declarații
(fișier sursă și linie), dacă declarația a fost implicită, prototip sau
neprototipat (I, N pentru noi sau O pentru vechi, respectiv, în primul caracter după
numărul rândului și două puncte) și dacă provine dintr-o declarație sau dintr-o definiție
(C or F, respectiv, în caracterul următor). In cazul functiei
definiții, o listă de argumente în stil K&R, urmată de declarațiile lor este, de asemenea
furnizate, în comentarii, după declarație.

-funcții-variadice-fără-parametri
Acceptați funcții variadice fără parametri numiți.

Deși este posibil să se definească o astfel de funcție, aceasta nu este foarte utilă așa cum este
nu se poate citi argumentele. Acest lucru este acceptat doar pentru C așa cum este acest construct
permis de C++.

-fno-asm
Nu recunoașteți „asm”, „inline” sau „typeof” drept cuvânt cheie, astfel încât codul să le poată folosi
cuvintele ca identificatori. Puteți folosi cuvintele cheie „__asm__”, „__inline__” și
„__typeof__” în schimb. -ansi implică -fno-asm.

În C++, această comutare afectează doar cuvântul cheie „typeof”, deoarece „asm” și „inline” sunt
cuvinte cheie standard. Poate doriți să utilizați -fno-gnu-cuvinte cheie steag în schimb, care are
acelasi efect. În modul C99 (-std=c99 or -std=gnu99), acest comutator afectează numai
cuvintele cheie „asm” și „typeof”, deoarece „inline” este un cuvânt cheie standard în ISO C99.

-fno-builtin
-fno-builtin-funcţie
Nu recunoașteți funcțiile încorporate care nu încep cu __incorporat_ ca prefix.

GCC generează în mod normal cod special pentru a gestiona mai mult anumite funcții încorporate
eficient; de exemplu, apelurile la „aloca” pot deveni instrucțiuni unice care
ajustați stiva direct, iar apelurile la „memcpy” pot deveni bucle de copiere inline. The
codul rezultat este adesea și mai mic și mai rapid, dar deoarece funcția apelează nr
mai apar ca atare, nu puteți seta un punct de întrerupere pentru acele apeluri și nici nu puteți schimba
comportamentul funcțiilor prin legarea cu o bibliotecă diferită. În plus, când
o funcție este recunoscută ca o funcție încorporată, GCC poate folosi informații despre aceasta
funcția pentru a avertiza despre problemele cu apelurile la acea funcție sau pentru a genera mai multe
cod eficient, chiar dacă codul rezultat conține încă apeluri la acea funcție. Pentru
de exemplu, avertismentele sunt date cu -Wformat pentru apeluri proaste la „printf” când „printf” este
încorporat și se știe că „strlen” nu modifică memoria globală.

Cu -fno-builtin-funcţie opțiune numai funcția încorporată funcţie este dezactivat.
funcţie nu trebuie să înceapă cu __incorporat_. Dacă o funcție este numită, aceasta nu este încorporată
în această versiune a GCC, această opțiune este ignorată. Nu există nici o corespondență
-încorporat-funcţie opțiune; dacă doriți să activați selectiv funcțiile încorporate când
folosind -fno-builtin or - de sine stătător, puteți defini macrocomenzi precum:

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

-fhosted
Afirmați că compilarea vizează un mediu găzduit. Asta implică -încorporat. O
mediul găzduit este unul în care întreaga bibliotecă standard este disponibilă și în
care „main” are un tip de returnare „int”. Exemplele sunt aproape totul, cu excepția a
nucleu. Aceasta este echivalentă cu -fno-freestanding.

- de sine stătător
Afirmați că compilarea vizează un mediu independent. Asta implică
-fno-builtin. Un mediu independent este unul în care biblioteca standard nu poate
există, iar pornirea programului poate să nu fie neapărat la „principal”. Cel mai evident exemplu
este un nucleu al sistemului de operare. Aceasta este echivalentă cu -fno-hosted.

-fopenmp
Activați gestionarea directivelor OpenMP „#pragma omp” în C/C++ și „!$omp” în Fortran.
Cand -fopenmp este specificat, compilatorul generează cod paralel conform
Interfața programului de aplicație OpenMP v4.0http://www.openmp.org/>. Această opțiune
implică -pthreadși, prin urmare, este acceptat numai pe ținte care au suport pentru
-pthread. -fopenmp implică -fopenmp-simd.

-fopenmp-simd
Activați gestionarea directivelor SIMD ale OpenMP cu „#pragma omp” în C/C++ și „!$omp” în
Fortran. Alte directive OpenMP sunt ignorate.

-fcilkplus
Activați utilizarea funcțiilor de extensie a limbajului Cilk Plus pentru C/C++. Când opțiunea
-fcilkplus este specificat, activați utilizarea caracteristicilor extensiei Cilk Plus Language
pentru C/C++. Actuala implementare urmează versiunea ABI 1.2. Aceasta este o
caracteristică experimentală care este doar parțial completă și a cărei interfață se poate modifica
în versiunile viitoare ale GCC, pe măsură ce specificațiile oficiale se modifică. În prezent, toate
caracteristici, dar „_Cilk_for” au fost implementate.

-fgnu-tm
Când opțiunea -fgnu-tm este specificat, compilatorul generează cod pentru Linux
variantă a documentului de specificații ABI actual al memoriei tranzacționale Intel (Revision
1.1, 6 mai 2009). Aceasta este o caracteristică experimentală a cărei interfață se poate schimba în
versiunile viitoare ale GCC, pe măsură ce specificațiile oficiale se modifică. Vă rugăm să rețineți că nu
toate arhitecturile sunt acceptate pentru această caracteristică.

Pentru mai multe informații despre suportul GCC pentru memoria tranzacțională,

Rețineți că funcția de memorie tranzacțională nu este acceptată cu excepții fără apel
(-fnon-call-exceptions).

-fms-extensii
Acceptați unele construcții non-standard utilizate în fișierele antet Microsoft.

În codul C++, acest lucru permite ca numele membrilor din structuri să fie similare cu tipurile anterioare
declarații.

typedef int UOW;
struct ABC {
UOW UOW;
};

Unele cazuri de câmpuri nenumite în structuri și uniuni sunt acceptate doar cu aceasta
opțiune.

Rețineți că această opțiune este dezactivată pentru toate țintele, cu excepția țintelor i?86 și x86_64 care utilizează ms-abi.

-fplan9-extensii
Acceptați unele construcții non-standard utilizate în codul Planului 9.

Acest lucru permite -fms-extensii, permite trecerea de pointeri către structuri cu anonim
câmpuri la funcții care așteaptă indicatori către elemente de tipul câmpului și
permise care se referă la câmpuri anonime declarate folosind un typedef. Aceasta este numai
acceptat pentru C, nu pentru C++.

-trigrafe
Suportă trigrafii ISO C. The -ansi opțiunea (și -std opțiuni pentru ISO C strict
conformare) presupune -trigrafe.

-tradiţional
-traditional-cpp
Anterior, aceste opțiuni au determinat GCC să încerce să emuleze un compilator C pre-standard.
Acum sunt susținute doar cu -E intrerupator. Preprocesorul continuă să sprijine
un mod pre-standard. Consultați manualul GNU CPP pentru detalii.

-fcond-nepotrivire
Permiteți expresii condiționate cu tipuri nepotrivite în al doilea și al treilea argument.
Valoarea unei astfel de expresii este nulă. Această opțiune nu este acceptată pentru C++.

-conversii-vectorale-in
Permite conversii implicite între vectori cu un număr diferit de elemente și/sau
tipuri de elemente incompatibile. Această opțiune nu trebuie utilizată pentru codul nou.

-funsigned-char
Lăsați tipul „char” să fie nesemnat, ca „unsigned char”.

Fiecare tip de mașină are o valoare implicită pentru ceea ce ar trebui să fie „char”. Este fie ca
„unsigned char” în mod implicit sau ca „signed char” în mod implicit.

În mod ideal, un program portabil ar trebui să folosească întotdeauna „char signed” sau „unsigned char” atunci când acesta
depinde de semnificația unui obiect. Dar multe programe au fost scrise pentru a fi folosite
simplu „char” și așteptați ca acesta să fie semnat, sau așteptați-vă să fie nesemnat, în funcție de
mașini pentru care au fost scrise. Această opțiune și inversul ei vă permit să faceți un astfel de
programul funcționează cu implicit opus.

Tipul „char” este întotdeauna un tip distinct de fiecare dintre „signed char” sau „unsigned”.
char", chiar dacă comportamentul său este întotdeauna la fel ca unul dintre cei doi.

-fsigned-char
Lăsați tipul „char” să fie semnat, ca „signed char”.

Rețineți că aceasta este echivalentă cu -fno-unsigned-char, care este forma negativă a
-funsigned-char. La fel, opțiunea -fno-semnat-char este echivalent cu
-funsigned-char.

-fsigned-bitfields
-funsigned-bitfields
-fno-signed-bitfields
-fno-unsigned-bitfields
Aceste opțiuni controlează dacă un câmp de biți este semnat sau nesemnat, atunci când declarația
nu folosește nici „semnat” sau „nesemnat”. În mod implicit, un astfel de câmp de biți este semnat,
deoarece acest lucru este consecvent: tipurile întregi de bază precum „int” sunt tipuri cu semn.

Opţiuni Controlul C ++ dialect
Această secțiune descrie opțiunile din linia de comandă care sunt semnificative doar pentru programele C++.
De asemenea, puteți utiliza majoritatea opțiunilor de compilare GNU, indiferent de limba programului dvs
se află în. De exemplu, ați putea compila un fișier „firstClass.C” astfel:

g++ -g -frepo -O -c clasa întâi.C

În acest exemplu, numai -frepo este o opțiune destinată doar programelor C++; poți folosi
alte opțiuni cu orice limbă acceptată de GCC.

Iată o listă de opțiuni care sunt numai pentru compilarea programelor C++:

-fabi-version=n
Folosiți versiunea n din C++ ABI. Valoarea implicită este versiunea 2.

Versiunea 0 se referă la versiunea care se conformează cel mai îndeaproape specificației C++ ABI.
Prin urmare, ABI-ul obținut folosind versiunea 0 se va modifica în diferite versiuni de G++
deoarece erorile ABI sunt remediate.

Versiunea 1 este versiunea C++ ABI care a apărut pentru prima dată în G++ 3.2.

Versiunea 2 este versiunea C++ ABI care a apărut pentru prima dată în G++ 3.4.

Versiunea 3 corectează o eroare în manipularea unei adrese constante ca argument șablon.

Versiunea 4, care a apărut pentru prima dată în G++ 4.5, implementează o manipulare standard pentru vector
tipuri.

Versiunea 5, care a apărut pentru prima dată în G++ 4.6, corectează alterarea atributului
const/volatile pe tipuri de pointer de funcție, decltype a unui decl simplu și utilizarea a
parametrul funcției în declarația altui parametru.

Versiunea 6, care a apărut pentru prima dată în G++ 4.7, corectează comportamentul de promovare al C++11
enumerări cu scop și modificarea pachetelor de argumente șablon, const/static_cast, prefix ++
și -- și o funcție de domeniu de clasă folosită ca argument șablon.

Vezi si - Wabi.

-fno-control-acces
Dezactivați toate verificările de acces. Acest comutator este util în principal pentru a rezolva erorile în
codul de control acces.

-fcheck-new
Verificați dacă indicatorul returnat de „operator new” nu este nul înainte de a încerca
modifica spațiul de stocare alocat. Această verificare este în mod normal inutilă deoarece C++
standardul specifică că „operator nou” returnează doar 0 dacă este declarat arunca(), În
caz în care compilatorul verifică întotdeauna valoarea returnată chiar și fără această opțiune. În
toate celelalte cazuri, când „operator nou” are o specificație de excepție non-vide, memorie
epuizarea este semnalată prin aruncarea „std::bad_alloc”. Vezi si nou (nothrow).

-fconstexpr-depth=n
Setați adâncimea maximă de evaluare imbricată pentru funcțiile constexpr C++11 la n. O limită
este necesar pentru a detecta recursiunea nesfârșită în timpul evaluării constante a expresiei. The
minimul specificat de standard este 512.

-fdeduce-init-list
Activați deducerea unui parametru de tip șablon ca „std::initializer_list” dintr-o acoladă-
lista de inițializare inclusă, de ex

șablon înainte automată (T t) -> decltype (realfn (t))
{
return realfn (t);
}

void f()
{
înainte({1,2}); // redirectionare apel >
}

Această deducere a fost implementată ca o posibilă extindere față de cea propusă inițial
semantică pentru standardul C++11, dar nu a făcut parte din standardul final, așa că este
dezactivat implicit. Această opțiune este învechită și poate fi eliminată în viitor
versiunea G++.

-ffriend-injectie
Injectați funcții prieten în spațiul de nume care îl încadrează, astfel încât acestea să fie vizibile în exterior
domeniul de aplicare al clasei în care sunt declarate. Funcțiile prietenului au fost documentate
să funcționeze în acest fel în vechiul manual de referință C++ adnotat și versiunile de G++ înainte
4.1 a funcționat întotdeauna așa. Cu toate acestea, în ISO C++ o funcție prieten care nu este
declarate într-un domeniu de acoperire pot fi găsite numai folosind căutarea dependentă de argument.
Această opțiune face ca prietenii să fie injectați așa cum erau în versiunile anterioare.

Această opțiune este pentru compatibilitate și poate fi eliminată într-o versiune viitoare a G++.

-fno-elide-constructori
Standardul C++ permite unei implementări să omite crearea unui temporar care este doar
folosit pentru a inițializa un alt obiect de același tip. Specificarea acestei opțiuni dezactivează
acea optimizare și forțează G++ să apeleze constructorul de copiere în toate cazurile.

-fno-enforce-eh-specs
Nu generați cod pentru a verifica încălcarea specificațiilor de excepție în timpul rulării.
Această opțiune încalcă standardul C++, dar poate fi utilă pentru reducerea dimensiunii codului
construcții de producție, la fel ca definirea NDEBUG. Acest lucru nu dă permisiunea codului utilizatorului
să arunce excepții cu încălcarea specificațiilor de excepție; compilatorul încă
optimizează pe baza specificațiilor, astfel încât aruncarea unei excepții neașteptate are ca rezultat
comportament nedefinit în timpul rulării.

-fextern-tls-init
-fno-extern-tls-init
Standardele C++11 și OpenMP permit thread_local și fir privat variabile de a avea
inițializare dinamică (în timp de rulare). Pentru a sprijini acest lucru, orice utilizare a unei astfel de variabile merge
printr-o functie wrapper care realizeaza orice initializare necesara. Când utilizarea
și definiția variabilei sunt în aceeași unitate de translație, acest overhead poate fi
optimizat departe, dar atunci când utilizarea este într-o unitate de traducere diferită, există
cheltuieli generale semnificative chiar dacă variabila nu are nevoie de fapt de dinamică
initializare. Dacă programatorul poate fi sigur că nu se utilizează variabila într-un
definirea TU trebuie să declanșeze inițializarea dinamică (fie pentru că variabila este
inițializat static, sau se va executa o utilizare a variabilei în TU definitorie
înainte de orice utilizare într-un alt TU), ei pot evita această suprasarcină cu
-fno-extern-tls-init opțiune.

Pe ținte care acceptă aliasuri de simbol, valoarea implicită este -fextern-tls-init. Pe ținte
care nu acceptă aliasuri de simbol, implicit este -fno-extern-tls-init.

-ffor-sfera
-fno-pentru-sfera
If -ffor-sfera este specificat, domeniul de aplicare al variabilelor declarate în a for-init-instrucțiune
este limitat la pentru buclă în sine, așa cum este specificat de standardul C++. Dacă
-fno-pentru-sfera este specificat, domeniul de aplicare al variabilelor declarate în a for-init-instrucțiune
se extinde până la sfârșitul domeniului de aplicare, așa cum a fost cazul în versiunile vechi de G++ și
alte implementări (tradiționale) ale C++.

Dacă niciunul nu este dat, implicit este să urmeze standardul, dar să permită și să dea
un avertisment pentru codul vechi care altfel ar fi invalid sau ar avea diferit
comportament.

-fno-gnu-cuvinte cheie
Nu recunoașteți „typeof” ca cuvânt cheie, astfel încât codul să poată folosi acest cuvânt ca un
identificator. Puteți folosi în schimb cuvântul cheie „__typeof__”. -ansi implică
-fno-gnu-cuvinte cheie.

-fno-implicite-şabloane
Nu emite niciodată cod pentru șabloanele non-inline care sunt instanțiate implicit (adică de
utilizare); emit cod numai pentru instanțieri explicite.

-fno-implicit-inline-templates
Nu emite cod nici pentru instanțieri implicite de șabloane inline. Implicit
este de a gestiona inline diferit, astfel încât să se compile cu și fără nevoie de optimizare
același set de instanțieri explicite.

-fno-implementare-inline
Pentru a economisi spațiu, nu emite copii out-of-line ale funcțiilor inline controlate de
#pragma implementarea. Acest lucru cauzează erori de linker dacă aceste funcții nu sunt aliniate
oriunde sunt numiti.

-fms-extensii
Dezactivați avertismentele Wpedantic despre constructele utilizate în MFC, cum ar fi implicit int și
obținerea unui pointer către funcția membru prin sintaxă non-standard.

-fno-nonansi-builtins
Dezactivați declarațiile încorporate ale funcțiilor care nu sunt impuse de ANSI/ISO C. Acestea
includ „ffs”, „alloca”, „_exit”, „index”, „bzero”, „conjf” și altele conexe
funcții.

-fnothrow-opt
Tratați o specificație de excepție „throw()” ca și cum ar fi o specificație „noexcept”.
reduceți sau eliminați supraîncărcarea dimensiunii textului în raport cu o funcție, fără excepție
specificație. Dacă funcţia are variabile locale de tipuri cu non-trivial
destructori, specificația excepției face de fapt funcția mai mică deoarece
curățările EH pentru acele variabile pot fi optimizate departe. Efectul semantic este
că o excepție aruncată dintr-o funcție cu o astfel de specificație de excepție
are ca rezultat un apel la „încheierea” mai degrabă decât „neașteptat”.

-fno-operator-names
Nu tratați numele operatorului cuvintele cheie „și”, „bitand”, „bitor”, „compl”, „nu”, „sau”
și „xor” ca sinonime ca cuvinte cheie.

-fno-optional-diags
Dezactivați diagnosticele pe care standardul spune că un compilator nu trebuie să le emită.
În prezent, singurul astfel de diagnostic emis de G++ este cel pentru un nume care are
sensuri multiple în cadrul unei clase.

-fpermisiv
Treceți la o versiune superioară a unor diagnostice despre codul neconform de la erori la avertismente. Prin urmare,
folosind -fpermisiv permite compilarea unui cod neconform.

-fno-pretty-şabloane
Când un mesaj de eroare se referă la o specializare a unui șablon de funcție, compilatorul
în mod normal, tipărește semnătura șablonului urmată de argumentele șablonului și
orice tip de tip sau nume de tip în semnătură (de exemplu, „void f(T) [cu T = int]” mai degrabă
decât „void f(int)”), astfel încât să fie clar ce șablon este implicat. Când o eroare
mesajul se referă la o specializare a unui șablon de clasă, compilatorul omite orice
argumente șablon care se potrivesc cu argumentele șablon implicite pentru șablonul respectiv. Dacă
oricare dintre aceste comportamente îngreunează mai degrabă înțelegerea mesajului de eroare decât
mai ușor, puteți folosi -fno-pretty-şabloane pentru a le dezactiva.

-frepo
Activați instanțiarea automată a șablonului la momentul conexiunii. Această opțiune implică și
-fno-implicite-şabloane.

-fno-rtti
Dezactivați generarea de informații despre fiecare clasă cu funcții virtuale pentru utilizare de către
caracteristicile de identificare a tipului de rulare C++ (dinamic_cast și tipid). Dacă nu
folosiți acele părți ale limbii, puteți economisi spațiu folosind acest steag. Notă
gestionarea excepțiilor folosește aceleași informații, dar G++ le generează după cum este necesar. The
dinamic_cast operatorul poate fi folosit în continuare pentru modele care nu necesită tip de rulare
informații, adică transformă în „void *” sau în clase de bază fără ambiguitate.

-fstats
Emiteți statistici despre procesarea front-end la sfârșitul compilației. Acest
informațiile sunt în general utile doar echipei de dezvoltare G++.

-fstrict-enums
Permiteți compilatorului să optimizeze folosind ipoteza că o valoare de tip enumerat
poate fi doar una dintre valorile enumerării (așa cum este definită în standardul C++;
practic, o valoare care poate fi reprezentată în numărul minim de biți necesar pentru
reprezintă toţi enumeratorii). Această ipoteză poate să nu fie validă dacă programul utilizează
o transformare pentru a converti o valoare întreagă arbitrară în tipul enumerat.

-ftemplate-backtrace-limit=n
Setați numărul maxim de note de instanțiere a șablonului pentru o singură avertizare sau eroare
la n. Valoarea implicită este 10.

-ftemplate-depth=n
Setați adâncimea maximă de instanțiere pentru clasele șablon la n. O limită asupra
Profunzimea de instanțiere a șablonului este necesară pentru a detecta recursiuni nesfârșite în timpul șablonului
instanțierea clasei. Programele conforme cu ANSI/ISO C++ nu trebuie să se bazeze pe un maxim
adâncime mai mare de 17 (modificată la 1024 în C++11). Valoarea implicită este 900, ca
compilatorul poate rămâne fără spațiu în stivă înainte de a atinge 1024 în unele situații.

-fno-threadsafe-statics
Nu emite codul suplimentar pentru a utiliza rutinele specificate în C++ ABI pentru thread-
inițializarea în siguranță a staticii locale. Puteți utiliza această opțiune pentru a reduce dimensiunea codului
ușor în cod care nu trebuie să fie sigur pentru fire.

-fuzibil-cxa-atexit
Înregistrați destructori pentru obiecte cu durată de stocare statică cu „__cxa_atexit”
funcția mai degrabă decât funcția „atexit”. Această opțiune este necesară pentru totalitate
gestionarea conformă cu standardele a destructorilor statici, dar funcționează numai dacă biblioteca dvs. C
acceptă „__cxa_atexit”.

-fno-use-cxa-get-exception-ptr
Nu utilizați rutina de rulare „__cxa_get_exception_ptr”. Asta duce la
„std::uncaught_exception” să fie incorect, dar este necesar dacă rutina de rulare este
nu e disponibil.

-fvizibility-inline-hidden
Acest comutator declară că utilizatorul nu încearcă să compare pointerii cu inline
funcții sau metode în care adresele celor două funcții sunt luate în mod diferit
obiecte comune.

Efectul acestui lucru este că GCC poate, în mod eficient, să marcheze metodele inline cu
„__attribute__ ((vizibilitate („ascuns”)))” astfel încât să nu apară în export
tabelul unui DSO și nu necesită o indirectă PLT atunci când sunt utilizate în cadrul DSO.
Activarea acestei opțiuni poate avea un efect dramatic asupra timpilor de încărcare și de conectare ai unui DSO
reduce masiv dimensiunea tabelului de export dinamic atunci când biblioteca devine grea
utilizarea șabloanelor.

Comportamentul acestui comutator nu este chiar același cu marcarea metodelor ca fiind ascunse
direct, deoarece nu afectează variabilele statice locale funcției sau cauzei
compilatorul să deducă că funcția este definită într-un singur obiect partajat.

Puteți marca o metodă ca având o vizibilitate în mod explicit pentru a anula efectul
comutați pentru acea metodă. De exemplu, dacă doriți să comparați pointerii cu a
anumită metodă inline, o puteți marca ca având vizibilitate implicită. Marcarea
includerea clasei cu vizibilitate explicită nu are niciun efect.

Metodele inline instanțiate în mod explicit nu sunt afectate de această opțiune ca legătură
altfel ar putea traversa granița unei biblioteci partajate.

-fvizibility-ms-compat
Acest indicator încearcă să folosească setările de vizibilitate pentru a crea modelul de legătură C++ al GCC
compatibil cu cel al Microsoft Visual Studio.

Steagul face aceste modificări la modelul de conectare al GCC:

1. Setează vizibilitatea implicită la „ascuns”, cum ar fi -fvizibility=ascuns.

2. Tipurile, dar nu membrii lor, nu sunt ascunse implicit.

3. Regula cu o singură definiție este relaxată pentru tipurile fără vizibilitate explicită
specificații care sunt definite în mai multe obiecte partajate: acele declarații
sunt permise dacă sunt permise atunci când această opțiune nu este utilizată.

În codul nou, este mai bine să îl utilizați -fvizibility=ascuns și exportați acele clase care sunt
destinat să fie vizibil în exterior. Din păcate, este posibil ca codul să se bazeze,
poate accidental, pe comportamentul Visual Studio.

Printre consecințele acestor modificări se numără faptul că membrii datelor statice de același tip
cu același nume, dar definite în diferite obiecte partajate sunt diferite, deci se schimbă
unul nu îl schimbă pe celălalt; și că indică către membrii funcției definiți în
diferite obiecte comune pot să nu fie comparate egale. Când acest steag este dat, este a
încălcarea ODR pentru a defini diferit tipurile cu același nume.

-fvtable-verify=std|preinit|niciuna
Porniți (sau opriți, dacă utilizați -fvtable-verify=niciunul) caracteristica de securitate care verifică la
runtime, pentru fiecare apel virtual efectuat, care pointerul vtable prin care
apelul este efectuat este valabil pentru tipul obiectului și nu a fost corupt sau
suprascris. Dacă este detectat un pointer vtable invalid (în timpul rulării), apare o eroare
raportat și execuția programului este imediat oprită.

Această opțiune face ca structurile de date de rulare să fie construite, la pornirea programului, pentru
verificarea indicatorilor vtable. Opțiunile „std” și „preinit” controlează sincronizarea
atunci când aceste structuri de date sunt construite. În ambele cazuri sunt construite structurile de date
înainte ca execuția să ajungă la „principal”. The -fvtable-verify=std cauzează aceste structuri de date
să fie construit după ce bibliotecile partajate au fost încărcate și inițializate.
-fvtable-verify=preinit face ca acestea să fie construite înainte ca bibliotecile partajate să fi fost
încărcat și inițializat.

Dacă această opțiune apare de mai multe ori în linia compilatorului, cu valori diferite
specificat, „none” va avea cea mai mare prioritate atât asupra „std” cât și asupra „preinit”; 'preinit'
va avea prioritate față de „std”.

-fvtv-debug
Determină versiunile de depanare ale funcțiilor de rulare pentru caracteristica de verificare vtable
fi numit. Aceasta presupune că -fvtable-verify=std or -fvtable-verify=preinit a fost
folosit. Acest flag va determina compilatorul să țină evidența indicatorilor vtable
a găsit pentru fiecare clasă și înregistrează acele informații în fișier
„vtv_set_ptr_data.log”, în directorul fișierelor de descărcare de pe computerul utilizatorului.

Notă: Această caracteristică ANEXĂ date la fișierul jurnal. Dacă doriți un fișier jurnal proaspăt, fiți
sigur că ștergeți oricare dintre cele existente.

-fvtv-contează
Acesta este un semnal de depanare. Când este utilizat împreună cu -fvtable-verify=std or
-fvtable-verify=preinit, acest lucru face ca compilatorul să țină evidența numărului total de
apelurile virtuale pe care le-a întâlnit și numărul de verificări pe care le-a introdus. De asemenea
numără numărul de apeluri către anumite funcții ale bibliotecii de rulare pe care le inserează. Acest
informațiile, pentru fiecare unitate de compilare, sunt scrise într-un fișier numit
„vtv_count_data.log”, în directorul dump_file de pe computerul utilizatorului. De asemenea
numără dimensiunea seturilor de pointeri vtable pentru fiecare clasă și scrie aceste informații
la „vtv_class_set_sizes.log” în același director.

Notă: Această caracteristică ANEXĂ date la fișierele jurnal. Pentru a obține fișiere jurnal noi, asigurați-vă
pentru a le șterge pe cele existente.

-fno-slab
Nu utilizați suport pentru simboluri slabe, chiar dacă este furnizat de linker. Implicit, G++
folosește simboluri slabe dacă sunt disponibile. Această opțiune există doar pentru testare și
nu ar trebui să fie utilizat de utilizatorii finali; rezultă un cod inferior și nu are beneficii.
Această opțiune poate fi eliminată într-o versiune viitoare a G++.

-nostdinc++
Nu căutați fișiere de antet în directoarele standard specifice C++, dar faceți
caută în continuare în celelalte directoare standard. (Această opțiune este utilizată la construirea fișierului
biblioteca C++.)

În plus, aceste opțiuni de optimizare, avertizare și generare de cod au doar semnificații
pentru programele C++:

- Wabi (doar C, Objective-C, C++ și Objective-C++)
Avertizați când G++ generează cod care probabil nu este compatibil cu furnizorul neutru
C++ ABI. Deși s-a depus un efort pentru a avertiza despre toate astfel de cazuri, există
probabil unele cazuri despre care nu sunt avertizate, chiar dacă G++ se generează
cod incompatibil. Pot exista și cazuri în care sunt emise avertismente chiar dacă
codul care este generat este compatibil.

Ar trebui să rescrieți codul pentru a evita aceste avertismente dacă sunteți îngrijorat de
faptul că codul generat de G++ poate să nu fie compatibil binar cu codul generat de
alte compilatoare.

Incompatibilitățile cunoscute în -fabi-version=2 (implicit) includ:

· Un șablon cu un parametru șablon non-tip de tip de referință este alterat
incorect:

extern int N;
șablon struct S {};
gol n (S ) {2}

Acest lucru este fixat în -fabi-version=3.

· Tipurile de vector SIMD declarate folosind „__attribute ((vector_size))” sunt alterate într-un
mod nestandard care nu permite supraîncărcarea funcțiilor care iau vectori
de dimensiuni diferite.

Manipularea este schimbată în -fabi-version=4.

Incompatibilitățile cunoscute în -fabi-version=1 includ:

· Manipularea incorectă a tail-padding-ului pentru câmpurile de biți. G++ poate încerca să împacheteze date
în același octet ca o clasă de bază. De exemplu:

struct A { virtual void f(); int f1 : 1; };
struct B : public A { int f2 : 1; };

În acest caz, G++ plasează „B::f2” în același octet cu „A::f1”; alți compilatori fac
nu. Puteți evita această problemă completând în mod explicit „A”, astfel încât dimensiunea sa să fie a
multiplu al mărimii octeților de pe platforma dvs.; care determină G++ și alte compilatoare să
așezați „B” identic.

· Manevrarea incorectă a umpluturii de coadă pentru bazele virtuale. G++ nu folosește coada
umplutură la așezarea bazelor virtuale. De exemplu:

struct A { virtual void f(); char c1; };
struct B { B(); char c2; };
struct C : public A, public virtual B {};

În acest caz, G++ nu plasează „B” în tail-padding pentru „A”; alte
compilatorii fac. Puteți evita această problemă completând în mod explicit „A”, astfel încât să fie
dimensiunea este un multiplu al alinierii sale (ignorând clasele de bază virtuale); care cauzează
G++ și alte compilatoare pentru a prezenta „C” identic.

· Manipularea incorectă a câmpurilor de biți cu lățimi declarate mai mari decât cea a acestora
tipurile de bază, când câmpurile de biți apar într-o uniune. De exemplu:

unire U { int i : 4096; };

Presupunând că un „int” nu are 4096 de biți, G++ face uniunea prea mică prin
numărul de biți dintr-un „int”.

· Clasele goale pot fi plasate la decalaje incorecte. De exemplu:

struct A {};

structura B {
A a;
gol virtual f ();
};

struct C : public B, public A {};

G++ plasează clasa de bază „A” a lui „C” la un offset diferit de zero; ar trebui plasat la
offset zero. G++ crede în mod eronat că membrul de date „A” al lui „B” este deja
la offset zero.

· Numele funcțiilor șablon ale căror tipuri implică „nume de tip” sau șablon șablon
parametrii pot fi alterați incorect.

șablon
void f(nume tip Q::X) {}

șablon clasa Q>
void f(nume tip Q ::X) {}

Instanciațiile acestor șabloane pot fi alterate incorect.

De asemenea, avertizează asupra modificărilor legate de psABI. PsABI cunoscut se modifică în acest moment
includ:

· Pentru SysV/x86-64, uniunile cu membri „duble lungi” sunt trecute în memorie ca
specificate în psABI. De exemplu:

unire U {
lung dublu ld;
int i;
};

„uniunea U” este întotdeauna trecută în memorie.

-Wctor-dtor-privacy (doar C++ și Objective-C++)
Avertizați când o clasă pare inutilizabilă deoarece toți constructorii sau destructorii din aceasta
clasa sunt private și nu are nici prieteni, nici funcții publice de membru statice.
De asemenea, avertizați dacă nu există metode non-private și există cel puțin un membru privat
funcție care nu este un constructor sau un destructor.

-Wdelete-non-virtual-dtor (doar C++ și Objective-C++)
Avertizați când șterge este folosit pentru a distruge o instanță a unei clase care are funcții virtuale
și destructor non-virtual. Este nesigur să ștergeți o instanță a unei clase derivate
printr-un pointer către o clasă de bază dacă clasa de bază nu are un virtual
distrugător. Acest avertisment este activat de -Perete.

-Wliteral-sufix (doar C++ și Objective-C++)
Avertizați când un șir sau un caracter literal este urmat de un sufix ud care nu
începe cu o subliniere. Ca o extensie conformă, GCC tratează astfel de sufixe ca
jetoane de preprocesare separate pentru a menține compatibilitatea cu codul
care utilizează macrocomenzi de formatare din " ". De exemplu:

#define __STDC_FORMAT_MACROS
#include
#include

int main () {
int64_t i64 = 123;
printf("My int64: %"PRId64"\n", i64);
}

În acest caz, „PRId64” este tratat ca un simbol separat de preprocesare.

Acest avertisment este activat în mod implicit.

-Îngustare (doar C++ și Objective-C++)
Avertizați când are loc o conversie de restrângere interzisă de C++11 { }, de exemplu

int i = { 2.2 }; // eroare: îngustare de la dublu la int

Acest steag este inclus în -Perete și -Wc++11-compat.

Cu -std=c++11, -Wno-îngustare suprimă diagnosticul cerut de standard.
Rețineți că acest lucru nu afectează semnificația codului bine format; îngustarea conversiilor
sunt considerate încă prost formate în contextul SFINAE.

- Nu, cu excepția (doar C++ și Objective-C++)
Avertizați când o expresie noexcept este evaluată ca false din cauza unui apel la o funcție
care nu are o specificație de excepție care nu se aruncă (de ex arunca() or nuexcept)
dar este cunoscut de către compilator că nu aruncă niciodată o excepție.

-Wnon-virtual-dtor (doar C++ și Objective-C++)
Avertizați când o clasă are funcții virtuale și un destructor non-virtual accesibil
în sine sau într-o clasă de bază polimorfă accesibilă, caz în care este posibil dar
nesigur să ștergeți o instanță a unei clase derivate printr-un pointer către clasa în sine
sau clasa de bază. Acest avertisment este activat automat dacă -Weffc++ este specificat.

-Wreorder (doar C++ și Objective-C++)
Avertizați când ordinea inițializatorilor de membri dată în cod nu se potrivește cu ordinea
în care acestea trebuie executate. De exemplu:

struct A {
int i;
int j;
A(): j (0), i (1) { }
};

Compilatorul rearanjează inițializatoarele membre pentru i și j pentru a se potrivi cu declarația
ordinul membrilor, emitând un avertisment în acest sens. Acest avertisment este activat de
-Perete.

-fext-numerice-literale (doar C++ și Objective-C++)
Acceptați sufixe de numere literale imaginare, în punct fix sau definite de mașină ca GNU
extensii. Când această opțiune este dezactivată, aceste sufixe sunt tratate ca utilizator C++11.
sufixe numerice literale definite. Aceasta este activată în mod implicit pentru toate dialectele pre-C++11
și toate dialectele GNU: -std=c++98, -std=gnu++98, -std=gnu++11, -std=gnu++1y. Acest
opțiunea este dezactivată în mod implicit pentru ISO C++ 11 și începând (-std=c++11, ...).

Următoarele -W... opțiunile nu sunt afectate de -Perete.

-Weffc++ (doar C++ și Objective-C++)
Avertizați despre încălcările următoarelor reguli de stil de la Scott Meyers Eficace
C ++ serie de carti:

· Definiți un constructor de copiere și un operator de atribuire pentru clasele cu
memorie alocată.

· Preferați inițializarea atribuirii în constructori.

· Solicitați „operator=" să returneze o referință la *this.

· Nu încercați să returnați o referință când trebuie să returnați un obiect.

· Distingeți formele de prefix și postfix ale operatorilor de creștere și decrementare.

· Nu supraîncărcați niciodată „&&”, „||”, sau ",".

Această opțiune permite și -Wnon-virtual-dtor, care este, de asemenea, unul dintre C++ eficient
recomandări. Cu toate acestea, verificarea este extinsă pentru a avertiza despre lipsa virtualului
destructor și în clasele de baze nepolimorfe accesibile.

Când selectați această opțiune, rețineți că anteturile bibliotecii standard nu se supun tuturor
a acestor linii directoare; utilizare grep -v pentru a filtra acele avertismente.

-Wstrict-null-sentinel (doar C++ și Objective-C++)
Avertizați despre utilizarea unui „NULL” necastat ca sentinelă. Când compilați numai cu GCC
aceasta este o sentinelă validă, deoarece „NULL” este definit ca „__null”. Deși este un nul
constantă pointer mai degrabă decât un pointer nul, este garantat că va avea aceeași dimensiune
ca un indicator. Dar această utilizare nu este portabilă în diferite compilatoare.

-Wno-non-template-prieten (doar C++ și Objective-C++)
Dezactivați avertismentele atunci când sunt declarate funcții prieten care nu sunt șablonate într-un șablon.
De la apariția suportului explicit pentru specificațiile șablonului în G++, dacă numele
prietenul este un ID necalificat (adică prieten foo(int)), specificația limbajului C++
cere ca prietenul să declare sau să definească o funcție obișnuită, fără șablon. (Secțiune
14.5.3). Înainte ca G++ să implementeze specificația explicită, ID-urile necalificate ar putea fi
interpretată ca o specializare particulară a unei funcții șablonizate. Pentru că asta
comportamentul neconform nu mai este comportamentul implicit pentru G++,
-Wnon-șablon-prieten permite compilatorului să verifice codul existent pentru eventuale probleme
spoturi și este activat în mod implicit. Acest nou comportament al compilatorului poate fi dezactivat cu
-Wno-non-template-prieten, care păstrează codul compilatorului conform, dar dezactivează
avertisment util.

-Distribuie în stil Wold (doar C++ și Objective-C++)
Avertizați dacă în cadrul unui program C++ se folosește un model vechi (stil C) într-un tip non-void.
Distribuțiile în stil nou (dinamic_cast, static_cast, reinterpret_cast, și const_cast) sunteți
mai puțin vulnerabil la efectele nedorite și mult mai ușor de căutat.

-Woverloaded-virtual (doar C++ și Objective-C++)
Avertizați când o declarație de funcție ascunde funcții virtuale dintr-o clasă de bază. Pentru
exemplu, în:

struct A {
gol virtual f();
};

structura B: public A {
void f(int);
};

versiunea de clasă „A” a lui „f” este ascunsă în „B” și codează ca:

B* b;
b->f();

nu reușește să compileze.

-Wno-pmf-conversii (doar C++ și Objective-C++)
Dezactivați diagnosticul pentru conversia unui pointer legat la funcția membru într-un simplu
indicator.

-Wsign-promoție (doar C++ și Objective-C++)
Avertizați când rezoluția supraîncărcării alege o promoție de la tipul nesemnat sau enumerat la
un tip semnat, peste o conversie într-un tip nesemnat de aceeași dimensiune. Anterior
versiunile de G++ au încercat să păstreze caracterul nesemnat, dar standardul impune actualul
comportament.

Opţiuni Controlul Obiectiv-C și Obiectiv-C++ dialecte
(NOTĂ: Acest manual nu descrie limbajele Objective-C și Objective-C++
înșiși.

Această secțiune descrie opțiunile liniei de comandă care sunt semnificative doar pentru Objective-C
și programe Objective-C++. De asemenea, puteți utiliza majoritatea GNU independent de limbă
opțiunile compilatorului. De exemplu, ați putea compila un fișier „some_class.m” astfel:

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

În acest exemplu, -fgnu-runtime este o opțiune destinată doar pentru Objective-C și Objective-C++
programe; puteți utiliza celelalte opțiuni cu orice limbă acceptată de GCC.

Rețineți că, deoarece Objective-C este o extensie a limbajului C, compilațiile Objective-C
poate folosi, de asemenea, opțiuni specifice front-end-ului C (de exemplu, - Tradițional). În mod similar,
Compilările Objective-C++ pot folosi opțiuni specifice C++ (de exemplu, - Wabi).

Iată o listă de opțiuni care sunt numai pentru compilarea Objective-C și Objective-C++
programe:

-fconstant-string-class=numele clasei
Utilizare numele clasei ca numele clasei de instanțiat pentru fiecare șir literal
specificat cu sintaxa "@"..."". Numele implicit al clasei este „NXConstantString” dacă
timpul de execuție GNU este utilizat și „NSConstantString” dacă este utilizat timpul de execuție NeXT
folosit (vezi mai jos). The -fconstant-cfstrings opțiunea, dacă este și prezentă, înlocuiește
-fconstant-string-class setarea și determinarea caracterelor „@”...”” să fie așezate ca constante
CoreFoundation șiruri.

-fgnu-runtime
Generați cod obiect compatibil cu runtime-ul standard GNU Objective-C. Aceasta este
implicit pentru majoritatea tipurilor de sisteme.

-fnext-runtime
Generați o ieșire compatibilă cu timpul de rulare NeXT. Aceasta este valoarea implicită pentru NeXT
sisteme, inclusiv Darwin și Mac OS X. Macro-ul „__NEXT_RUNTIME__” este predefinit dacă
(și numai dacă) se folosește această opțiune.

-fno-nil-receptoare
Să presupunem că toate mesajele Objective-C sunt expediate ("[receiver message:arg]") în acest
unitatea de traducere asigurați-vă că receptorul nu este „nul”. Acest lucru permite mai mult
puncte de intrare eficiente în timpul de execuție care urmează să fie utilizate. Această opțiune este disponibilă numai în
împreună cu NeXT runtime și versiunea ABI 0 sau 1.

-fobjc-abi-version=n
Folosiți versiunea n a Objective-C ABI pentru timpul de execuție selectat. Această opțiune este
suportat în prezent numai pentru timpul de execuție NeXT. În acest caz, versiunea 0 este
ABI tradițional (32 de biți) fără suport pentru proprietăți și alte Objective-C 2.0
adaosuri. Versiunea 1 este ABI tradițional (32 de biți) cu suport pentru proprietăți și
alte completări Obiective-C 2.0. Versiunea 2 este ABI modern (64 de biți). Dacă nimic nu este
specificat, valoarea implicită este Versiunea 0 pe mașinile țintă pe 32 de biți și Versiunea 2 pe 64 de biți
mașini țintă.

-fobjc-call-cxx-cdtors
Pentru fiecare clasă Objective-C, verificați dacă vreuna dintre variabilele sale de instanță este un obiect C++
cu un constructor implicit non-trivial. Dacă da, sintetizează un „- (id) special
.cxx_construct" metoda de instanță care rulează constructori impliciti non-triviali pe oricare
astfel de variabile de instanță, în ordine, și apoi returnează „self”. În mod similar, verificați dacă există
variabila de instanță este un obiect C++ cu un destructor non-trivial și, dacă da, sintetizează
o metodă specială „- (void) .cxx_destruct” care rulează toți astfel de destructori impliciti, în
ordine inversă.

Metodele „- (id) .cxx_construct” și „- (void) .cxx_destruct” au fost astfel generate numai
operează pe variabile de instanță declarate în clasa curentă Objective-C, și nu pe acelea
moștenit de la superclase. Este responsabilitatea runtime-ului Objective-C să
invocați toate astfel de metode în ierarhia de moștenire a unui obiect. „- (id)
Metodele .cxx_construct" sunt invocate de runtime imediat după un nou obiect
instanța este alocată; metodele „- (void) .cxx_destruct” sunt invocate imediat
înainte ca runtime-ul să dealoca o instanță de obiect.

În momentul în care am scris acest articol, numai timpul de execuție NeXT pe Mac OS X 10.4 și versiunile ulterioare are suport pentru
invocând metodele „- (id) .cxx_construct” și „- (void) .cxx_destruct”.

-fobjc-direct-dispecer
Permite sărituri rapide la dispecerul de mesaje. Pe Darwin, acest lucru se realizează prin intermediul
pagina de comunicații.

-fobjc-excepții
Activați suportul sintactic pentru gestionarea structurată a excepțiilor în Objective-C, similar cu
ceea ce este oferit de C++ și Java. Această opțiune este necesară pentru a utiliza Objective-C
cuvintele cheie @try, @throw, @catch, @finally și @synchronized. Această opțiune este disponibilă
atât cu runtime GNU, cât și cu runtime NeXT (dar nu este disponibil împreună cu
timpul de execuție NeXT pe Mac OS X 10.2 și versiuni anterioare).

-fobjc-gc
Activați colectarea gunoiului (GC) în programele Objective-C și Objective-C++. Această opțiune
este disponibil numai cu timpul de rulare NeXT; runtime-ul GNU are un alt gunoi
implementare de colecție care nu necesită steaguri speciale ale compilatorului.

-fobjc-nilcheck
Pentru timpul de execuție NeXT cu versiunea 2 a ABI, verificați dacă există un receptor zero în metoda
invocări înainte de a efectua apelul efectiv de metodă. Acesta este implicit și poate fi
dezactivat folosind -fno-objc-nilcheck. Metodele de clasă și apelurile super nu sunt niciodată verificate
pentru nil în acest fel indiferent la ce este setat acest steag. În prezent, acest steag o face
nimic atunci când GNU runtime, sau o versiune mai veche a NeXT runtime ABI, este folosit.

-fobjc-std=objc1
Respectați sintaxa limbajului Objective-C 1.0, limbajul recunoscut de GCC 4.0.
Acest lucru afectează doar completările Objective-C la limbajul C/C++; nu afectează
conformitatea cu standardele C/C++, care este controlată de dialectul separat C/C++
steaguri opțiuni. Când această opțiune este utilizată cu Objective-C sau Objective-C++
compilator, orice sintaxă Objective-C care nu este recunoscută de GCC 4.0 este respinsă. Acest
este util dacă trebuie să vă asigurați că codul dvs. Objective-C poate fi compilat cu
versiuni mai vechi de GCC.

-freplace-objc-clasele
Emite un marker special de instrucțiuni ld(1) să nu se lege static în obiectul rezultat
fișier și permiteți dyld(1) pentru a-l încărca în timpul rulării. Aceasta este folosită în
împreună cu modul de depanare Fix-and-Continue, în care se află fișierul obiect
întrebarea poate fi recompilată și reîncărcată dinamic în cursul programului
execuție, fără a fi nevoie să reporniți programul în sine. În prezent, fix-and-
Funcționalitatea Continuare este disponibilă numai împreună cu runtime NeXT pe Mac
OS X 10.3 și versiuni ulterioare.

-fzero-link
La compilarea pentru runtime NeXT, compilatorul înlocuiește de obicei apelurile către
"objc_getClass("...")" (când numele clasei este cunoscut în momentul compilării) cu
referințe statice de clasă care sunt inițializate în timpul încărcării, ceea ce îmbunătățește timpul de execuție
performanţă. Specificând -fzero-link flag suprimă acest comportament și cauzează
apelurile la "objc_getClass("...")" pentru a fi reținute. Acest lucru este util în Zero-Link
modul de depanare, deoarece permite modificarea implementărilor individuale ale claselor
în timpul executării programului. Runtime GNU în prezent reține întotdeauna apelurile către
"objc_get_class("...")" indiferent de opțiunile din linia de comandă.

-gen-decls
Dumpează declarațiile de interfață pentru toate clasele văzute în fișierul sursă într-un fișier numit
sourcename.decl.

-Wassign-intercept (Numai Objective-C și Objective-C++)
Avertizați de fiecare dată când o atribuire Objective-C este interceptată de colectorul de gunoi.

-Wno-protocol (Numai Objective-C și Objective-C++)
Dacă o clasă este declarată pentru a implementa un protocol, este emis un avertisment pentru fiecare metodă
în protocolul care nu este implementat de clasă. Comportamentul implicit este să
emite un avertisment pentru fiecare metodă care nu este implementată în mod explicit în clasă, chiar dacă a
implementarea metodei este moștenită de la superclasă. Dacă utilizați -Wno-protocol
opțiunea, atunci metodele moștenite de la superclasă sunt considerate a fi implementate,
și nu se emite niciun avertisment pentru ei.

-Wselector (Numai Objective-C și Objective-C++)
Avertizați dacă mai multe metode de tipuri diferite pentru același selector sunt găsite în timpul
compilare. Verificarea se efectuează pe lista de metode în etapa finală a
compilare. În plus, se efectuează o verificare pentru fiecare selector care apare în a
Expresia „@selector(...)” și o metodă corespunzătoare pentru acel selector a fost
găsite în timpul compilării. Deoarece aceste verificări scanează tabelul de metode doar la sfârșit
de compilare, aceste avertismente nu sunt produse dacă etapa finală de compilare este
nu a fost atins, de exemplu pentru că a fost găsită o eroare în timpul compilării sau pentru că
-doar fsyntax este folosită opțiunea.

-Wstrict-selector-potrivire (Numai Objective-C și Objective-C++)
Avertizați dacă sunt găsite mai multe metode cu argumente și/sau tipuri de returnare diferite pentru a
selector dat atunci când încercați să trimiteți un mesaj utilizând acest selector către un receptor de
tastați „id” sau „Class”. Când acest steag este dezactivat (care este comportamentul implicit),
compilatorul omite astfel de avertismente dacă diferențele găsite sunt limitate la tipurile care partajează
aceeași dimensiune și aliniament.

-Wundeclared-selector (Numai Objective-C și Objective-C++)
Avertizați dacă este găsită o expresie „@selector(...)” care se referă la un selector nedeclarat. A
selectorul este considerat nedeclarat dacă nicio metodă cu acel nume nu a fost declarată înainte
expresia „@selector(...)”, fie explicit într-o @interfață sau @protocol
declarație sau implicit într-o secțiune @implementation. Această opțiune funcționează întotdeauna
își verifică de îndată ce o expresie „@selector(...)” este găsită, în timp ce -Wselector numai
efectuează verificările sale în etapa finală de compilare. Acest lucru impune și codarea
convenție de stil conform căreia metodele și selectorii trebuie declarați înainte de a fi utilizate.

-print-objc-runtime-info
Generați antetul C care descrie cea mai mare structură care este transmisă după valoare, dacă există.

Opţiuni la Controlul Diagnostic Chat intern Formatarea
În mod tradițional, mesajele de diagnosticare au fost formatate, indiferent de dispozitivul de ieșire
aspect (ex. lățimea acestuia, ...). Puteți utiliza opțiunile descrise mai jos pentru a controla
algoritm de formatare pentru mesajele de diagnosticare, de exemplu câte caractere pe linie, cât de des
informațiile despre locația sursă ar trebui raportate. Rețineți că unele interfețe de limbă pot
nu onora aceste opțiuni.

-fmessage-length=n
Încercați să formatați mesajele de eroare astfel încât să se potrivească pe linii de aproximativ n personaje.
implicit este de 72 de caractere pentru g ++ și 0 pentru restul capetelor frontale susținute de
GCC. Dacă n este zero, atunci nu se face nicio înfășurare a liniilor; fiecare mesaj de eroare apare pe a
o singura linie.

-fdiagnostics-show-location=o dată
Numai semnificativ în modul de înfășurare a liniilor. Instruiește raportorul de mesaje de diagnosticare să
emită informații despre locația sursei dată; adică în cazul în care mesajul este prea lung pentru a se potrivi
pe o singură linie fizică și trebuie să fie împachetat, locația sursei nu va fi emisă
(ca prefix) din nou, din nou și din nou, în rândurile de continuare ulterioare. Acesta este
comportament implicit.

-fdiagnostics-show-location=fiecare-linie
Numai semnificativ în modul de înfășurare a liniilor. Instruiește raportorul de mesaje de diagnosticare să
emit aceleași informații despre locația sursă (ca prefix) pentru liniile fizice care rezultă
din procesul de spargere a unui mesaj care este prea lung pentru a se potrivi pe o singură linie.

-fdiagnostics-culoare[=CÂND]
-fno-diagnostic-culoare
Utilizați culoarea în diagnosticare. CÂND is nu, mereu, Sau Auto. Implicit este nu if
GCC_COLORS variabila de mediu nu este prezentă în mediu și Auto in caz contrar.
Auto înseamnă a folosi culoarea numai atunci când eroarea standard este un terminal. Formele
-fdiagnostics-culoare și -fno-diagnostic-culoare sunt pseudonime pentru
-fdiagnostics-color=intotdeauna și -fdiagnostics-color=niciodată, respectiv.

Culorile sunt definite de variabila de mediu GCC_COLORS. Valoarea sa este de două puncte
listă separată de capabilități și subșiruri Select Graphic Rendition (SGR). SGR
comenzile sunt interpretate de terminalul sau emulatorul de terminal. (Vezi secțiunea în
documentația terminalului dvs. text pentru valorile permise și semnificațiile acestora ca
atribute de caractere.) Aceste valori subșir sunt numere întregi în reprezentare zecimală
și poate fi concatenat cu punct și virgulă. Valorile comune de concatenat includ 1 pentru
îndrăzneţ, 4 pentru subliniere, 5 pentru clipire, 7 pentru invers, 39 pentru culoarea prim-plan implicită, 30
la 37 pentru culorile din prim plan, 90 la 97 pentru culorile din prim plan în modul 16 culori, 38; 5; 0 la
38; 5; 255 pentru modurile de 88 de culori și 256 de culori, culori din prim-plan, 49 pentru fundal implicit
culoare, 40 la 47 pentru culorile de fundal, 100 la 107 pentru culori de fundal în modul 16 culori,
și 48; 5; 0 la 48; 5; 255 pentru 88 de culori și 256 de culori culori de fundal.

Valoarea implicită GCC_COLORS is
error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01 Unde 01; 31 este îndrăzneață
roșu, 01; 35 este magenta îndrăzneț, 01; 36 este cyan îndrăzneț, 01; 32 este verde îndrăzneț și 01 este îndrăzneață.
reglaj GCC_COLORS la șirul gol dezactivează culorile. Capacitățile acceptate sunt ca
urmează.

"eroare="
Subșir SGR pentru eroare: markeri.

"avertisment="
Subșir SGR pentru avertizare: markeri.

"notă="
Subșir SGR pentru notă: markeri.

"caret="
Subșir SGR pentru linia caret.

"locus="
Subșir SGR pentru informații despre locație, fișier:linie or file:line:column etc

"quote="
Subșir SGR pentru informații tipărite între ghilimele.

-fno-diagnostics-show-option
În mod implicit, fiecare diagnostic emis include text care indică opțiunea din linia de comandă
care controlează direct diagnosticul (dacă o astfel de opțiune este cunoscută de diagnostic
utilaje). Specificând -fno-diagnostics-show-option steagul suprimă asta
comportament.

-fno-diagnostic-show-caret
În mod implicit, fiecare diagnostic emis include linia sursă inițială și semnul „^”
indicând coloana. Această opțiune suprimă aceste informații.

Opţiuni la Cerere or Suprima Avertismente
Avertismentele sunt mesaje de diagnosticare care raportează construcții care nu sunt în mod inerent
eronate, dar care sunt riscante sau sugerează că ar fi putut fi o eroare.

Următoarele opțiuni independente de limbă nu activează avertismente specifice, ci controlează
tipuri de diagnostice produse de GCC.

-doar fsyntax
Verificați codul pentru erori de sintaxă, dar nu faceți nimic în afară de asta.

-fmax-erori=n
Limitează numărul maxim de mesaje de eroare la n, moment în care GCC salvează mai degrabă
decât încercarea de a continua procesarea codului sursă. Dacă n este 0 (prestabilit),
nu există o limită a numărului de mesaje de eroare produse. Dacă -Wfatale-erori De asemenea, este
specificat, atunci -Wfatale-erori are prioritate fata de aceasta optiune.

-w Inhibați toate mesajele de avertizare.

-Eroare
Transformă toate avertismentele în erori.

-Weroare=
Transformați avertismentul specificat într-o eroare. Specificatorul unui avertisment este anexat;
de exemplu -Werror=comutator întoarce avertismentele controlate de - Întrerupător în erori.
Acest comutator ia o formă negativă, pentru a fi folosit pentru a anula -Eroare pentru avertismente specifice;
de exemplu -Wno-error=comutator face - Întrerupător avertismentele să nu fie erori, chiar dacă -Eroare
este în vigoare.

Mesajul de avertizare pentru fiecare avertizare controlabilă include opțiunea care controlează
avertismentul. Această opțiune poate fi apoi utilizată cu -Weroare= și -Wno-eroare= după cum este descris
de mai sus. (Imprimarea opțiunii din mesajul de avertizare poate fi dezactivată folosind funcția
-fno-diagnostics-show-option steag.)

Rețineți că specificarea -Weroare=foo implică automat -Wfoo. Cu toate acestea, -Wno-eroare=foo
nu presupune nimic.

-Wfatale-erori
Această opțiune determină compilatorul să anuleze compilarea la prima eroare care a apărut
mai degrabă decât să încercați să continuați și să imprimați mesaje de eroare suplimentare.

Puteți solicita multe avertismente specifice cu opțiuni care încep cu -W, De exemplu,
-Wimplicit să solicite avertismente asupra declaraţiilor implicite. Fiecare dintre aceste avertismente specifice
Opțiunile are și un început de formă negativă -Nu- a dezactiva avertismentele; de exemplu,
- Nu-implicit. Acest manual listează doar una dintre cele două forme, oricare dintre acestea nu este implicit.
Pentru alte opțiuni specifice limbii, consultați C ++ dialect Opţiuni și Obiectiv-C
și Obiectiv-C++ dialect Opţiuni.

Când este solicitată o opțiune de avertizare nerecunoscută (de exemplu, - Avertisment necunoscut), GCC emite a
diagnostic care afirmă că opțiunea nu este recunoscută. Cu toate acestea, dacă -Nu- se folosește forma,
comportamentul este uşor diferit: nu se realizează nici un diagnostic pentru -Wno-necunoscut-avertisment
cu excepția cazului în care se produc alte diagnostice. Acest lucru permite utilizarea noilor -Nu- Opțiuni
cu compilatoare vechi, dar dacă ceva nu merge bine, compilatorul avertizează că un nerecunoscut
opțiunea este prezentă.

-Wpedant
-pedant
Emite toate avertismentele cerute de ISO C și ISO C++ strict; respinge toate programele care
utilizați extensii interzise și alte programe care nu respectă ISO C și ISO
C++. Pentru ISO C, urmează versiunea standardului ISO C specificată de oricare -std
optiunea folosita.

Programele ISO C și ISO C++ valide ar trebui să fie compilate corect cu sau fără această opțiune
(deși câteva rare necesită -ansi sau un -std opțiunea care specifică versiunea necesară a
ISO C). Cu toate acestea, fără această opțiune, anumite extensii GNU și tradiționale C și
Caracteristicile C++ sunt, de asemenea, acceptate. Cu această opțiune, acestea sunt respinse.

-Wpedant nu generează mesaje de avertizare pentru utilizarea cuvintelor cheie alternative ale căror
numele încep și se termină cu __. Avertismentele pedante sunt, de asemenea, dezactivate în expresie
care urmează „__extensie__”. Cu toate acestea, numai fișierele antet de sistem ar trebui să le folosească
căi de evacuare; programele de aplicație ar trebui să le evite.

Unii utilizatori încearcă să folosească -Wpedant pentru a verifica programele pentru conformitatea strictă cu ISO C. ei
în curând constată că nu face exact ceea ce își doresc: găsește unele practici non-ISO,
dar nu toate --- doar cele pentru care ISO C Necesită un diagnostic, iar altele pentru
care diagnosticare au fost adăugate.

O caracteristică pentru a raporta orice neconformitate cu ISO C poate fi utilă în unele cazuri,
dar ar necesita o muncă suplimentară considerabilă și ar fi destul de diferită de
-Wpedant. Nu avem planuri de a sprijini o astfel de caracteristică în viitorul apropiat.

Acolo unde standardul specificat cu -std reprezintă un dialect C extins GNU, cum ar fi
gnu90 or gnu99, există o corespondență de bază standard, versiunea ISO C pe care
se bazează dialectul extins GNU. Avertismente de la -Wpedant sunt date acolo unde sunt
cerute de standardul de bază. (Nu are sens ca astfel de avertismente să fie date
numai pentru caracteristici care nu sunt în dialectul GNU C specificat, deoarece prin definiție GNU
dialectele C includ toate caracteristicile pe care compilatorul le suportă cu opțiunea dată și
nu ar fi nimic de avertizat.)

-pedant-erori
Aprecieri -Wpedant, cu excepția faptului că sunt produse mai degrabă erori decât avertismente.

-Perete
Acest lucru activează toate avertismentele despre construcții pe care unii utilizatori le consideră
discutabile și care sunt ușor de evitat (sau modificate pentru a preveni avertismentul), chiar și în
împreună cu macro-urile. Acest lucru permite, de asemenea, unele avertismente specifice limbii descrise
in C ++ dialect Opţiuni și Obiectiv-C și Obiectiv-C++ dialect Opţiuni.

-Perete aprinde următoarele steaguri de avertizare:

-Waddress - Limite de război (doar cu -O2) -Wc++11-compat -Wchar-indice
-Wenum-compara (în C/ObjC; aceasta este activată implicit în C++) -Wimplicit-int (C și
Numai obiectivul-C) -Wimplicit-funcție-declarație (doar C și Objective-C) -Wcomentează
-Wformat -Wmain (numai pentru C/ObjC și dacă nu - de sine stătător) -Wpoate-neinițializat
- Acolade lipsă (doar pentru C/ObjC) -Wnonnull -Wopenmp-simd - Paranteze
-Wpointer-semn -Wreorder -de tip Wreturn -Wsecvența-punct -Wsign-compara (doar în C++)
-Wstrict-aliasing -Wstrict-overflow=1 - Întrerupător - Trigrafii -Winitializat
-Wuncunoscut-pragmas -Wunused-funcție -Wunused-etichetă -Valoare-neutilizată -Wunused-variabilă
-Wvolatile-registru-var

Rețineți că unele steaguri de avertizare nu sunt implicate de -Perete. Unii dintre ei avertizează despre
construcții pe care utilizatorii în general nu le consideră discutabile, dar care
ocazional ați putea dori să verificați; alţii avertizează asupra construcţiilor care sunt
necesar sau greu de evitat în unele cazuri și nu există o modalitate simplă de a modifica
cod pentru a suprima avertismentul. Unele dintre ele sunt activate de -Wextra dar multe dintre ele
trebuie activat individual.

-Wextra
Acest lucru activează unele steaguri de avertizare suplimentare care nu sunt activate de -Perete. (Această opțiune este folosită
a se numi -W. Numele mai vechi este încă acceptat, dar numele mai nou este mai mult
descriptiv.)

-Wclobbered -Corpul umed -Wignored-calificative -Inițializatoare-câmp lipsesc
-Wmissing-parametru-tip (doar C) -Declarație în stil Wold (doar C) -Woverride-init
-Wsign-compara -Wtip-limite -Winitializat -Wunused-parametru (doar cu -Wunused or
-Perete) -Wunused-dar-setat-parametru (doar cu -Wunused or -Perete)

Optiunea -Wextra de asemenea, tipărește mesaje de avertizare pentru următoarele cazuri:

· Un indicator este comparat cu întregul zero cu <, <=, >, Sau >=.

· (doar C++) Un enumerator și un non-enumerator apar ambele într-un condițional
expresie.

· (doar C++) Baze virtuale ambigue.

· (doar C++) Subscrierea unui tablou care a fost declarat Inregistreaza-te.

· (doar C++) Preluarea adresei unei variabile care a fost declarată Inregistreaza-te.

· (doar C++) O clasă de bază nu este inițializată în constructorul de copiere al unei clase derivate.

-Wchar-indice
Avertizați dacă un indice de matrice are tipul „char”. Aceasta este o cauză comună de eroare, așa cum
programatorii uită adesea că acest tip este semnat pe unele mașini. Acest avertisment este
activat de -Perete.

-Wcomentează
Avertizați de fiecare dată când începe o secvență de comentarii /* apare într-o /* comentariu sau ori de câte ori a
Backslash-Newline apare într-un // cometariu. Acest avertisment este activat de -Perete.

-Wno-acoperire-nepotrivire
Avertizați dacă profilurile de feedback nu se potrivesc atunci când utilizați -fprofile-use opțiune. În cazul în care o
fișierul sursă este schimbat între compilarea cu -fprofile-gen si cu -fprofile-use,
fișierele cu feedback de profil pot să nu se potrivească cu fișierul sursă și GCC nu
utilizați informațiile de feedback de profil. În mod implicit, acest avertisment este activat și este
tratată ca o eroare. -Wno-acoperire-nepotrivire poate fi folosit pentru a dezactiva avertismentul sau
-Wno-error=acoperire-nepotrivire poate fi folosit pentru a dezactiva eroarea. Dezactivarea erorii
deoarece acest avertisment poate avea ca rezultat un cod slab optimizat și este util doar în cazul
modificări foarte minore, cum ar fi remedieri de erori la o bază de cod existentă. Dezactivare completă
avertismentul nu este recomandat.

-Wno-cpp
(doar C, Objective-C, C++, Objective-C++ și Fortran)

Suprimați mesajele de avertizare emise de directivele „#warning”.

-Wdubla-promovare (doar C, C++, Objective-C și Objective-C++)
Dați un avertisment când o valoare de tip „float” este implicit promovată la „double”. CPU-uri
cu o unitate cu virgulă mobilă „cu precizie unică” pe 32 de biți implementează „float” în hardware,
dar emulează „dublu” în software. Pe o astfel de mașină, făcând calcule folosind
valorile „duble” sunt mult mai costisitoare din cauza cheltuielilor generale necesare pentru software
emulare.

Este ușor să faci din greșeală calcule cu „dublu” deoarece este în virgulă mobilă
literalele sunt implicit de tip „dublu”. De exemplu, în:

zona de plutire (raza de plutire)
{
întoarcere 3.14159 * rază * rază;
}

compilatorul efectuează întregul calcul cu „dublu” deoarece virgulă mobilă
literal este un „dublu”.

-Wformat
-Wformat=n
Verificați apelurile la „printf” și „scanf”, etc., pentru a vă asigura că argumentele furnizate
au tipuri adecvate șirului de format specificat și că conversiile
specificate în șirul de format au sens. Aceasta include funcții standard și
altele specificate prin atribute de format, în „printf”, „scanf”, „strftime” și
„strfmon” (o extensie X/Open, nu în standardul C) familii (sau alte
familii specifice). Ce funcții sunt verificate fără să fi fost atribute de format
specificat depinde de versiunea standard selectată și de astfel de verificări ale funcțiilor
fără atributul specificat sunt dezactivate de - de sine stătător or -fno-builtin.

Formatele sunt verificate cu caracteristicile de format acceptate de GNU libc versiunea 2.2.
Acestea includ toate caracteristicile ISO C90 și C99, precum și caracteristicile de la Single Unix
Specificație și unele extensii BSD și GNU. Este posibil ca alte implementări de bibliotecă să nu
susține toate aceste caracteristici; GCC nu acceptă avertismente cu privire la funcțiile care depășesc
limitările unei anumite biblioteci. Cu toate acestea, dacă -Wpedant este folosit cu -Wformat,
sunt date avertismente despre caracteristicile de format care nu sunt în versiunea standard selectată (dar nu
pentru formatele „strfmon”, deoarece acestea nu sunt în nicio versiune a standardului C).

-Wformat=1
-Wformat
Opțiune -Wformat este echivalent cu -Wformat=1, și -Wno-format este echivalent cu
-Wformat=0. De cand -Wformat de asemenea, verifică pentru mai multe argumente de format nul
funcții, -Wformat implică de asemenea -Wnonnull. Câteva aspecte ale acestui nivel de format
verificarea poate fi dezactivată prin opțiunile: -Wno-formatul-contine-nul,
-Wno-format-extra-args, și -Wno-format-lungime-zero. -Wformat este activat de
-Perete.

-Wno-formatul-contine-nul
If -Wformat este specificat, nu avertizați despre șirurile de format care conțin octeți NUL.

-Wno-format-extra-args
If -Wformat este specificat, nu avertizați despre excesul de argumente la un „printf” sau
funcția de format „scanf”. Standardul C specifică că astfel de argumente sunt
ignorat.

Unde argumentele neutilizate se află între argumentele utilizate care sunt specificate cu $
specificațiile numărului de operanzi, în mod normal sunt încă date avertismente, deoarece
implementarea nu a putut ști ce tip să treacă la „va_arg” pentru a omite cele neutilizate
argumente. Cu toate acestea, în cazul formatelor „scanf”, această opțiune suprimă
avertisment dacă argumentele neutilizate sunt toate pointeri, deoarece Unix unic
Specificația spune că astfel de argumente neutilizate sunt permise.

-Wno-format-lungime-zero
If -Wformat este specificat, nu avertizați despre formatele cu lungime zero. Standardul C
specifică faptul că sunt permise formatele cu lungime zero.

-Wformat=2
Permite -Wformat plus verificări suplimentare de format. În prezent echivalent cu -Wformat
-Wformat-nonliteral -Wformat-securitate -Wformat-y2k.

-Wformat-nonliteral
If -Wformat este specificat, avertizează și dacă șirul de format nu este un șir literal
și astfel nu poate fi verificată, cu excepția cazului în care funcția de format își ia argumentele de format ca
o „va_list”.

-Wformat-securitate
If -Wformat este specificat, avertizează și despre utilizările funcțiilor de format care reprezintă
posibile probleme de securitate. În prezent, acest lucru avertizează despre apelurile către „printf” și
funcțiile „scanf” în care șirul de format nu este un șir literal și nu există
argumente de format, ca în „printf (foo);”. Aceasta poate fi o gaură de securitate dacă
șirul de format a venit de la o intrare neîncrezătoare și conține %n. (Acesta este în prezent un
subset de ce -Wformat-nonliteral avertizează despre, dar în viitor avertismentele pot fi
adăugate -Wformat-securitate care nu sunt incluse în -Wformat-nonliteral.)

NOTĂ: În Ubuntu 8.10 și versiunile ulterioare, această opțiune este activată implicit pentru C,
C++, ObjC, ObjC++. Pentru a dezactiva, utilizați -Wno-format-securitate, sau dezactivați toate formatele
avertismente cu -Wformat=0. Pentru a face fatale avertismentele de securitate de format, specificați
-Werror=format-securitate.

-Wformat-y2k
If -Wformat este specificat, avertizează, de asemenea, despre formatele „strftime” care pot produce doar a
an cu două cifre.

-Wnonnull
Avertizați despre trecerea unui pointer nul pentru argumentele marcate ca necesitând o valoare non-nulă
prin atributul funcției „nonnull”.

-Wnonnull este inclus în -Perete și -Wformat. Poate fi dezactivat cu -Wno-nonnull
opțiune.

- Winit-self (doar C, C++, Objective-C și Objective-C++)
Avertizați despre variabilele neinițializate care sunt inițializate cu ele însele. Rețineți acest lucru
opțiunea poate fi utilizată numai cu -Winitializat opțiune.

De exemplu, GCC avertizează că „i” nu este inițializat numai în următorul fragment
cand - Winit-self a fost specificat:

int f()
{
int i = i;
întoarce i;
}

Acest avertisment este activat de -Perete în C++.

-Wimplicit-int (doar C și Objective-C)
Avertizați când o declarație nu specifică un tip. Acest avertisment este activat de -Perete.

-Wimplicit-funcție-declarație (doar C și Objective-C)
Dați un avertisment ori de câte ori o funcție este utilizată înainte de a fi declarată. În modul C99
(-std=c99 or -std=gnu99), acest avertisment este activat implicit și este transformat într-un
eroare de către -pedant-erori. Acest avertisment este activat și de -Perete.

-Wimplicit (doar C și Objective-C)
La fel ca -Wimplicit-int și -Wimplicit-funcție-declarație. Acest avertisment este activat
by -Perete.

-Wignored-calificative (doar C și C++)
Avertizați dacă tipul returnat al unei funcții are un calificator de tip, cum ar fi „const”. Pentru ISO C
un astfel de calificator de tip nu are niciun efect, deoarece valoarea returnată de o funcție nu este an
lvaloarea. Pentru C++, avertismentul este emis doar pentru tipurile scalare sau „void”. ISO C
interzice tipurile de returnare „void” calificate pe definițiile funcției, deci astfel de tipuri de returnare
primiți întotdeauna un avertisment chiar și fără această opțiune.

Acest avertisment este activat și de -Wextra.

-Wmain
Avertizați dacă tipul de principal este suspect. principal ar trebui să fie o funcție cu extern
linkage, returnând int, luând fie zero argumente, fie două sau trei argumente ale
tipuri adecvate. Acest avertisment este activat implicit în C++ și este activat de oricare
-Perete or -Wpedant.

- Acolade lipsă
Avertizați dacă un inițializator agregat sau union nu este complet între paranteze. În cele ce urmează
de exemplu, inițializatorul pentru a nu este complet între paranteze, dar asta pentru b este pe deplin
între paranteze. Acest avertisment este activat de -Perete în C.

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

Acest avertisment este activat de -Perete.

-Fără-include-dir-uri (doar C, C++, Objective-C și Objective-C++)
Avertizați dacă nu există un director de includere furnizat de utilizator.

- Paranteze
Avertizați dacă parantezele sunt omise în anumite contexte, cum ar fi atunci când există o
atribuire într-un context în care se așteaptă o valoare de adevăr sau când operatorii sunt imbricați
despre a cărei precedență oamenii devin adesea confuzi.

De asemenea, avertizează dacă o comparație ca x<=y<=z apare; aceasta este echivalentă cu (x<=y ? 1 : 0)
<= z, care este o interpretare diferită de cea a notației matematice obișnuite.

De asemenea, avertizați despre construcții în care poate exista confuzie la care afirmație „dacă” an
ramura „altfel” aparține. Iată un exemplu de astfel de caz:

{
în cazul în care o)
dacă (b)
foo ();
altfel
bar ();
}

În C/C++, fiecare ramură „altfel” aparține celei mai interioare instrucțiuni posibile „dacă”, care
în acest exemplu este „dacă (b)”. Acest lucru nu este adesea ceea ce programatorul se aștepta, așa cum
ilustrat în exemplul de mai sus prin indentare aleasă de programator. Atunci când există
potențialul pentru această confuzie, GCC emite un avertisment atunci când acest indicator este specificat.
Pentru a elimina avertismentul, adăugați acolade explicite în jurul celei mai intime declarații „dacă”.
nu există nicio posibilitate ca „altfel” să aparțină „dacă” care este inclus. Codul rezultat arată
asa:

{
în cazul în care o)
{
dacă (b)
foo ();
altfel
bar ();
}
}

De asemenea, avertizați pentru utilizări periculoase ale extensiei GNU la „?:” cu operandul de mijloc omis.
Când condiția din operatorul "?": este o expresie booleană, valoarea omisă este
întotdeauna 1. Adesea programatorii se așteaptă să fie o valoare calculată în interiorul condiționalului
expresie în schimb.

Acest avertisment este activat de -Perete.

-Wsecvența-punct
Avertizați despre codul care poate avea o semantică nedefinită din cauza încălcării secvenței
regulile punctuale din standardele C și C++.

Standardele C și C++ definesc ordinea în care sunt expresiile dintr-un program C/C++
evaluat în termeni de secvenţă puncte, care reprezintă o ordonare parțială între
execuția unor părți ale programului: cele executate înainte de punctul de secvență și cele
executat după el. Acestea apar după evaluarea unei expresii complete (una care
nu face parte dintr-o expresie mai mare), după evaluarea primului operand al lui a
Operatorul „&&”, „||”, „? :” sau "," (virgulă), înainte ca o funcție să fie apelată (dar după
evaluarea argumentelor sale și a expresiei care denotă funcția numită), iar în
anumite alte locuri. În afară de ceea ce este exprimat de regulile punctului secvenței, ordinea
de evaluare a subexpresiilor unei expresii nu este specificată. Toate aceste reguli
descrie doar o ordine parțială, mai degrabă decât o ordine totală, deoarece, de exemplu, dacă doi
funcțiile sunt numite într-o expresie fără un punct de secvență între ele, the
ordinea în care sunt apelate funcțiile nu este specificată. Cu toate acestea, standardele
comisia au decis că apelurile de funcții nu se suprapun.

Nu este specificat când între punctele de secvență se modifică valorile lui
obiectele produc efect. Programele al căror comportament depinde de aceasta au un comportament nedefinit;
standardele C și C++ specifică că „Între punctul de secvență anterior și următorul an
obiectul va avea valoarea stocată modificată cel mult o dată prin evaluarea unui
expresie. În plus, valoarea anterioară trebuie citită numai pentru a determina valoarea pentru
fi stocate.". Dacă un program încalcă aceste reguli, rezultatele la orice anume
implementarea sunt complet imprevizibile.

Exemple de cod cu comportament nedefinit sunt „a = a++;”, „a[n] = b[n++]” și „a[i++] =
i;". Unele cazuri mai complicate nu sunt diagnosticate prin această opțiune și poate da un
rezultat fals pozitiv ocazional, dar în general s-a găsit destul de eficient la
detectarea acestui tip de problemă în programe.

Standardul este formulat în mod confuz, prin urmare există o dezbatere cu privire la exact
sensul regulilor punctului de secvență în cazuri subtile. Link-uri către discuțiile despre
problema, inclusiv definițiile formale propuse, pot fi găsite pe pagina de citiri GCC,
lahttp://gcc.gnu.org/readings.html>.

Acest avertisment este activat de -Perete pentru C și C++.

-Wno-return-local-adr
Nu avertizați despre returnarea unui pointer (sau în C++, o referință) la o variabilă care merge
în afara domeniului de aplicare după revenirea funcției.

-de tip Wreturn
Avertizați de fiecare dată când o funcție este definită cu un tip de returnare care este implicit „int”. De asemenea
avertizează despre orice instrucțiune „return” fără valoare de returnare într-o funcție al cărei tip de returnare
nu este „nulă” (căderea de la capătul corpului funcției este considerată revenire
fără valoare), și despre o instrucțiune „return” cu o expresie într-o funcție
al cărui tip de returnare este „void”.

Pentru C++, o funcție fără tip de returnare produce întotdeauna un mesaj de diagnosticare, chiar
cand -Wno-retur-tip este specificat. Singurele excepții sunt principal și funcții
definite în anteturile sistemului.

Acest avertisment este activat de -Perete.

- Întrerupător
Avertizați ori de câte ori o instrucțiune „switch” are un index de tip enumerat și nu are un „caz”
pentru unul sau mai multe dintre codurile numite ale acelei enumerari. (Prezența unui „implicit”
label previne acest avertisment.) „caz” etichete și în afara intervalului de enumerare
provoacă avertismente atunci când se folosește această opțiune (chiar dacă există o etichetă „implicit”). Acest
avertismentul este activat de -Perete.

-Wswitch-implicit
Avertizați ori de câte ori o declarație „switch” nu are un caz „implicit”.

-Wswitch-enum
Avertizați ori de câte ori o instrucțiune „switch” are un index de tip enumerat și nu are un „caz”
pentru unul sau mai multe dintre codurile numite ale acelei enumerari. etichete „caz” în afara
intervalul de enumerare provoacă și avertismente atunci când se utilizează această opțiune. Singura diferenta
între - Întrerupător și această opțiune este că această opțiune dă un avertisment cu privire la o omisă
cod de enumerare chiar dacă există o etichetă „implicit”.

-Wsync-nand (doar C și C++)
Avertizați când funcțiile încorporate „__sync_fetch_and_nand” și „__sync_nand_and_fetch” sunt
folosit. Aceste funcții au schimbat semantica în GCC 4.4.

- Trigrafii
Avertizați dacă sunt întâlnite trigrafe care ar putea schimba sensul programului
(trigrafele din comentarii nu sunt avertizate). Acest avertisment este activat de -Perete.

-Wunused-dar-setat-parametru
Avertizați de fiecare dată când un parametru de funcție este alocat, dar nu este utilizat (în afară de
declarația acesteia).

Pentru a suprima acest avertisment, utilizați nefolosit atribut.

Acest avertisment este activat și de -Wunused Împreună cu -Wextra.

-Wunused-dar-set-variable
Avertizați ori de câte ori o variabilă locală este atribuită, dar nu este utilizată (în afară de aceasta
declaraţie). Acest avertisment este activat de -Perete.

Pentru a suprima acest avertisment, utilizați nefolosit atribut.

Acest avertisment este activat și de -Wunused, care este activat de -Perete.

-Wunused-funcție
Avertizați ori de câte ori o funcție statică este declarată, dar nu este definită sau o funcție statică non-inline
funcția este neutilizată. Acest avertisment este activat de -Perete.

-Wunused-etichetă
Avertizați de fiecare dată când o etichetă este declarată, dar nu este utilizată. Acest avertisment este activat de -Perete.

Pentru a suprima acest avertisment, utilizați nefolosit atribut.

-Wunused-local-typedefs (doar C, Objective-C, C++ și Objective-C++)
Avertizați când nu este utilizat un typedef definit local într-o funcție. Acest avertisment este
activat de -Perete.

-Wunused-parametru
Avertizați ori de câte ori un parametru de funcție este neutilizat în afară de declarația sa.

Pentru a suprima acest avertisment, utilizați nefolosit atribut.

-Wno-neutilizat-rezultat
Nu avertizați dacă un apelant al unei funcții marcată cu atributul „warn_unused_result” face
nu utilizați valoarea returnată. Valoarea implicită este -Wunused-rezultat.

-Wunused-variabilă
Avertizați ori de câte ori o variabilă locală sau o variabilă statică neconstantă nu este utilizată în afară de
declarația acesteia. Acest avertisment este activat de -Perete.

Pentru a suprima acest avertisment, utilizați nefolosit atribut.

-Valoare-neutilizată
Avertizați de fiecare dată când o declarație calculează un rezultat care nu este utilizat în mod explicit. A suprima
acest avertisment aruncă expresia nefolosită către anula. Aceasta include o afirmație de expresie
sau partea stângă a unei expresii virgulă care nu conține efecte secundare. Pentru
exemplu, o expresie precum x[i,j] provoacă un avertisment, în timp ce x[(void)i,j] nu.

Acest avertisment este activat de -Perete.

-Wunused
Toate cele de mai sus -Wunused opțiuni combinate.

Pentru a primi un avertisment despre un parametru de funcție neutilizat, trebuie fie să specificați
-Wextra -Wunused (Rețineți că -Perete implică -Wunused), sau specificați separat
-Wunused-parametru.

-Winitializat
Avertizați dacă o variabilă automată este utilizată fără a fi mai întâi inițializată sau dacă o variabilă
poate fi lovit de un apel „setjmp”. În C++, avertizați dacă o referință non-statică sau non-
static CONST membru apare într-o clasă fără constructori.

Dacă doriți să avertizați despre codul care utilizează valoarea neinițializată a variabilei în
propriul său inițializator, utilizați - Winit-self opțiune.

Aceste avertismente apar pentru elementele individuale ale structurii neinițializate sau cioplite,
variabile union sau matrice, precum și pentru variabilele care sunt neinițializate sau blocate
ca un intreg, per total. Ele nu apar pentru variabile sau elemente declarate „volatile”. pentru că
aceste avertismente depind de optimizare, de variabilele sau elementele exacte pentru care există
Aceste avertismente depind de opțiunile precise de optimizare și de versiunea GCC utilizată.

Rețineți că este posibil să nu existe niciun avertisment cu privire la o variabilă care este utilizată numai pentru a calcula a
valoare care în sine nu este niciodată folosită, deoarece astfel de calcule pot fi șterse de fluxul de date
analiza înainte de tipărirea avertismentelor.

-Wpoate-neinițializat
Pentru o variabilă automată, dacă există o cale de la intrarea funcției la o utilizare a
variabila care este inițializată, dar există alte căi pentru care
variabila nu este inițializată, compilatorul emite un avertisment dacă nu poate dovedi
căile neinițializate nu sunt executate în timpul rulării. Aceste avertismente sunt opționale
deoarece GCC nu este suficient de inteligent pentru a vedea toate motivele pentru care codul ar putea fi corect
în ciuda faptului că pare să aibă o eroare. Iată un exemplu despre cum se poate întâmpla acest lucru:

{
int x;
comutator (y)
{
cazul 1: x = 1;
rupe;
cazul 2: x = 4;
rupe;
cazul 3: x = 5;
}
foo (x);
}

Dacă valoarea lui „y” este întotdeauna 1, 2 sau 3, atunci „x” este întotdeauna inițializat, dar GCC
nu stie asta. Pentru a suprima avertismentul, trebuie să furnizați un caz implicit
afirma(0) sau cod similar.

Această opțiune avertizează, de asemenea, când o variabilă automată nevolatilă poate fi modificată de a
apel la „longjmp”. De asemenea, aceste avertismente sunt posibile doar în optimizare
compilare.

Compilatorul vede doar apelurile la „setjmp”. Nu poate ști unde va fi „longjmp”.
numit; de fapt, un handler de semnal l-ar putea apela în orice punct al codului. Ca
rezultat, este posibil să primiți un avertisment chiar și atunci când de fapt nu există nicio problemă, deoarece „longjmp”
nu poate fi de fapt chemat la locul care ar cauza o problemă.

Unele avertismente false pot fi evitate dacă declari toate funcțiile pe care le folosești
nu se întoarce niciodată ca „noreturn”.

Acest avertisment este activat de -Perete or -Wextra.

-Wuncunoscut-pragmas
Avertizați când este întâlnită o directivă „#pragma” care nu este înțeleasă de GCC. Dacă aceasta
este utilizată opțiunea de linie de comandă, sunt chiar emise avertismente pentru pragmate necunoscute în sistem
fișiere antet. Acesta nu este cazul dacă avertismentele sunt activate numai de către -Perete
opțiunea de linie de comandă.

-Wno-pragmas
Nu avertizați cu privire la utilizarea greșită a pragmelor, cum ar fi parametrii incorecți, sintaxa invalidă sau
conflicte între pragmate. Vezi si -Wuncunoscut-pragmas.

-Wstrict-aliasing
Această opțiune este activă numai atunci când -fstrict-aliasing este activ. Acesta avertizează despre codul că
ar putea încălca regulile stricte de aliasing pe care compilatorul le folosește pentru optimizare.
Avertismentul nu prinde toate cazurile, dar încearcă să le surprindă pe cele mai frecvente
capcanele. Este inclus în -Perete. Este echivalent cu -Wstrict-aliasing=3

-Wstrict-aliasing=n
Această opțiune este activă numai atunci când -fstrict-aliasing este activ. Acesta avertizează despre codul că
ar putea încălca regulile stricte de aliasing pe care compilatorul le folosește pentru optimizare.
Niveluri mai mari corespund unei precizii mai mari (mai puține false pozitive). Niveluri superioare
corespund de asemenea unui efort mai mare, asemănător modului -O funcționează. -Wstrict-aliasing is
echivalent cu -Wstrict-aliasing=3.

Nivelul 1: Cel mai agresiv, rapid, cel mai puțin precis. Posibil util atunci când niveluri mai înalte
nu avertiza dar -fstrict-aliasing încă rupe codul, deoarece are foarte puține false
negative. Cu toate acestea, are multe fals pozitive. Avertizează pentru toate conversiile pointerului
între tipuri posibil incompatibile, chiar dacă nu au fost niciodată dereferențiate. Aleargă în față
doar sfârşitul.

Nivelul 2: Agresiv, rapid, nu prea precis. Poate avea încă multe rezultate false pozitive (nu
la fel de multe ca nivelul 1 totuși) și puține negative false (dar posibil mai mult decât nivelul 1).
Spre deosebire de nivelul 1, acesta avertizează doar atunci când este preluată o adresă. Avertizează despre tipurile incomplete.
Funcționează doar în partea din față.

Nivelul 3 (implicit pentru -Wstrict-aliasing): Ar trebui să aibă foarte puține false pozitive și puține
false negative. Puțin mai lent decât nivelurile 1 sau 2 când optimizarea este activată.
Are grijă de tiparul comun de joc de cuvinte + dereferință din partea din față:
„*(int*)&some_float”. Dacă optimizarea este activată, rulează și în back-end, unde
se ocupă cu mai multe cazuri de declarații folosind informații sensibile la flux.
Avertizează numai când pointerul convertit este dereferențiat. Nu avertizează despre incomplet
tipuri.

-Wstrict-debordare
-Wstrict-overflow=n
Această opțiune este activă numai atunci când -fstrict-overflow este activ. Avertizează despre cazuri
unde compilatorul se optimizează pe baza presupunerii că overflow semnat nu
apar. Rețineți că nu avertizează cu privire la toate cazurile în care codul ar putea depăși: it
avertizează doar despre cazurile în care compilatorul implementează o anumită optimizare. Astfel aceasta
avertismentul depinde de nivelul de optimizare.

O optimizare care presupune că depășirea semnată nu are loc este perfect sigură dacă
valorile variabilelor implicate sunt astfel încât depășirea nu face niciodată, de fapt,
apar. Prin urmare, acest avertisment poate da cu ușurință un fals pozitiv: un avertisment despre cod
asta nu este de fapt o problema. Pentru a ajuta la concentrarea asupra problemelor importante, mai multe avertismente
nivelurile sunt definite. Nu sunt emise avertismente pentru utilizarea overflow semnat nedefinit
când se estimează câte iterații necesită o buclă, în special când se determină
dacă o buclă va fi executată deloc.

-Wstrict-overflow=1
Avertizați asupra cazurilor care sunt atât discutabile, cât și ușor de evitat. De exemplu, cu
-fstrict-overflow, compilatorul simplifică „x + 1 > x” la 1. Acest nivel de
-Wstrict-debordare este activat de -Perete; nivelurile superioare nu sunt și trebuie să fie
solicitat în mod explicit.

-Wstrict-overflow=2
Avertizați și despre alte cazuri în care o comparație este simplificată la o constantă. Pentru
exemplu: „abs (x) >= 0”. Acest lucru poate fi simplificat doar atunci când -fstrict-overflow este in
efect, deoarece „abs (INT_MIN)” depășește la „INT_MIN”, care este mai mic decât zero.
-Wstrict-debordare (fără nivel) este la fel ca -Wstrict-overflow=2.

-Wstrict-overflow=3
Avertizați și despre alte cazuri în care o comparație este simplificată. De exemplu: „x + 1
> 1" se simplifică la "x > 0".

-Wstrict-overflow=4
De asemenea, avertizează asupra altor simplificări care nu sunt acoperite de cazurile de mai sus. Pentru
exemplu: „(x * 10) / 5” este simplificat la „x * 2”.

-Wstrict-overflow=5
De asemenea, avertizează despre cazurile în care compilatorul reduce mărimea unei constante
implicat într-o comparație. De exemplu: „x + 2 > y” se simplifică în „x + 1 >= y”.
Acest lucru este raportat doar la cel mai înalt nivel de avertizare, deoarece această simplificare
se aplică multor comparații, astfel încât acest nivel de avertizare oferă un număr foarte mare de
fals pozitive.

-Wsuggest-atribut=[pur|CONST|fără întoarcere|format]
Avertizați pentru cazurile în care adăugarea unui atribut poate fi benefică. Atributele în prezent
suportate sunt enumerate mai jos.

-Wsuggest-attribute=pur
-Wsuggest-attribute=const
-Wsuggest-attribute=noreturn
Avertizați despre funcțiile care ar putea fi candidate pentru atributele „pure”, „const” sau
"fără întoarcere". Compilatorul avertizează doar pentru funcțiile vizibile în alte compilații
unități sau (în cazul „pură” și „const”) dacă nu poate dovedi că funcția
revine normal. O funcție revine în mod normal dacă nu conține un infinit
buclă sau întoarce anormal prin aruncare, apelând „abort()” sau prindere. Acest
analiza necesită opțiune -fipa-pură-const, care este activat implicit la -O și
superior. Nivelurile mai ridicate de optimizare îmbunătățesc acuratețea analizei.

-Wsuggest-attribute=format
-Atribut-format-lipsă
Avertizați despre indicatorii de funcție care ar putea fi candidați pentru atributele „format”.
Rețineți că aceștia sunt doar candidați posibili, nu absoluti. GCC presupune că
indicatori de funcție cu atribute „format” care sunt utilizate în atribuire,
Instrucțiunile de inițializare, transmiterea parametrilor sau returnarea ar trebui să aibă o corespondență
atributul „format” în tipul rezultat. Adică partea stângă a
atribuirea sau inițializarea, tipul variabilei parametrului sau returnarea
respectiv tipul funcției care le conține ar trebui să aibă și un atribut „format”.
pentru a evita avertismentul.

GCC avertizează, de asemenea, despre definițiile funcțiilor care ar putea fi candidate pentru „format”
atribute. Din nou, aceștia sunt doar candidați posibili. GCC ghicește acel „format”
atributele ar putea fi adecvate pentru orice funcție care apelează o funcție ca
„vprintf” sau „vscanf”, dar s-ar putea să nu fie întotdeauna cazul și unele funcții
pentru care atributele „format” sunt adecvate este posibil să nu fie detectate.

- Limite de război
Această opțiune este activă numai atunci când -ftree-vrp este activ (implicit pentru -O2 Si mai sus). Aceasta
avertizează despre indicele la matrice care sunt întotdeauna în afara limitelor. Acest avertisment este
activat de -Perete.

-Wno-div-by-zero
Nu avertizați despre împărțirea întregului în timpul compilării la zero. Împărțirea în virgulă mobilă cu
zero nu este avertizat, deoarece poate fi o modalitate legitimă de a obține infinitate și
NaNs.

-Wsystem-anteturi
Imprimați mesaje de avertizare pentru constructele găsite în fișierele antet de sistem. Avertismente de la
Anteturile de sistem sunt în mod normal suprimate, presupunând că de obicei nu
indică probleme reale și ar face doar ieșirea compilatorului mai greu de citit. Folosind
această opțiune de linie de comandă îi spune GCC să emită avertismente din anteturile sistemului ca și cum ar fi
a avut loc în codul utilizatorului. Cu toate acestea, rețineți că folosind -Perete în legătură cu această opțiune
face nu avertizează despre pragmatele necunoscute din anteturile sistemului --- pentru asta, -Wuncunoscut-pragmas
trebuie de asemenea folosit.

-Wtrambuline
Avertizați despre trambuline generate pentru indicatorii către funcții imbricate.

O trambulină este o mică bucată de date sau cod care este creată la alergare
timpul pe stivă când se ia adresa unei funcții imbricate și
este folosit pentru a apela indirect funcția imbricată. Pentru unele ținte, asta
este format numai din date și, prin urmare, nu necesită un tratament special. Dar,
pentru majoritatea țintelor, este alcătuit din cod și, prin urmare, necesită stiva
să fie făcut executabil pentru ca programul să funcționeze corect.

-Wfloat-egal
Avertizați dacă valorile în virgulă mobilă sunt utilizate în comparațiile de egalitate.

Ideea din spatele acestui lucru este că uneori este convenabil (pentru programator) să
considerați valorile în virgulă mobilă ca aproximări la numere reale infinit de precise.
Dacă faceți acest lucru, atunci trebuie să calculați (prin analizarea codului sau în unele
în alt mod) eroarea maximă sau maximă probabilă pe care o introduce calculul și
permiteți acest lucru atunci când efectuați comparații (și când produceți rezultate, dar asta este a
problemă diferită). În special, în loc să testați pentru egalitate, ar trebui să verificați
pentru a vedea dacă cele două valori au intervale care se suprapun; iar asta se face cu
operatori relaționali, astfel încât comparațiile de egalitate sunt probabil greșite.

- Tradițional (doar C și Objective-C)
Avertizați asupra anumitor constructe care se comportă diferit în tradițional și ISO C. De asemenea
avertizează despre constructele ISO C care nu au echivalent C tradițional și/sau problematice
constructe care ar trebui evitate.

· Parametrii macro care apar în literalele șir din corpul macrocomenzii. În
înlocuirea tradițională a macro-urilor C are loc în cadrul literalelor șir, dar în ISO C
aceasta nu.

· În C tradițional, unele directive de preprocesor nu existau. Tradiţional
preprocesoarele considerau o linie ca o directivă numai dacă # apărut în coloană
1 pe linie. Prin urmare - Tradițional avertizează asupra directivelor pe care tradiționalul C
înțelege dar ignoră deoarece # nu apare ca primul caracter pe
linia. De asemenea, vă sugerează să ascundeți directive precum #pragma neînțeles de
C tradițional prin indentarea lor. Unele implementări tradiționale nu
recunoaște #elif, deci această opțiune sugerează evitarea ei cu totul.

· O macrocomandă asemănătoare unei funcții care apare fără argumente.

· Operatorul unar plus.

· U sufixul constant întreg sau F or L sufixe constante în virgulă mobilă.
(C tradițional acceptă L sufix pe constante întregi.) Rețineți, acestea
sufixele apar în macro-urile definite în anteturile de sistem ale majorității sistemelor moderne,
de ex _MIN/_MAX macrocomenzi în " „. Utilizarea acestor macrocomenzi în codul utilizatorului ar putea
duc în mod normal la avertismente false, totuși preprocesorul integrat al GCC are
suficient context pentru a evita avertismentul în aceste cazuri.

· O funcție declarată externă într-un singur bloc și apoi utilizată după sfârșitul
bloc.

· O instrucțiune „switch” are un operand de tip „long”.

· O declarație de funcție non-„statică” urmează una „statică”. Acest construct nu este
acceptate de unele compilatoare tradiționale C.

· Tipul ISO al unei constante întregi are o lățime sau semnătură diferită de a acesteia
tip tradițional. Acest avertisment este emis numai dacă baza constantei este zece.
Adică valorile hexazecimale sau octale, care reprezintă de obicei modele de biți, nu sunt
avertizat despre.

· Utilizarea concatenării șirurilor ISO este detectată.

· Initializarea agregatelor automate.

· Identificatorul intră în conflict cu etichetele. C tradițional nu are un spațiu de nume separat pentru
etichete.

· Inițializarea sindicatelor. Dacă inițializatorul este zero, avertismentul este omis.
Acest lucru se face în ipoteza că inițializatorul zero în codul utilizatorului apare
condiționat de, de exemplu, „__STDC__” pentru a evita avertismentele de inițializare lipsă și se bazează pe
inițializarea implicită la zero în cazul tradițional C.

· Conversii prin prototipuri între valori fixe/în virgulă mobilă și invers. The
absența acestor prototipuri la compilarea cu C tradițional cauzează serioase
Probleme. Acesta este un subset al posibilelor avertismente de conversie; pentru setul complet
utilizare -Wtradițional-conversie.

· Utilizarea definițiilor de funcții în stil ISO C. Acest avertisment este în mod intenționat nu eliberat
pentru declarații prototip sau funcții variadice deoarece aceste caracteristici ISO C
apar în codul dvs. atunci când utilizați macrocomenzile tradiționale de compatibilitate C ale liberty,
„PARAMS” și „VPARAMS”. Acest avertisment este ocolit și pentru funcțiile imbricate
deoarece această caracteristică este deja o extensie GCC și, prin urmare, nu este relevantă pentru
compatibilitatea tradițională C.

-Wtradițional-conversie (doar C și Objective-C)
Avertizați dacă un prototip provoacă o conversie de tip diferită de ceea ce s-ar întâmpla
la același argument în absența unui prototip. Aceasta include conversiile de
punct fix la plutitor și invers, iar conversiile schimbând lățimea sau
semnificația unui argument cu punct fix, cu excepția cazului în care este aceeași cu promovarea implicită.

-Wdeclarație-după-declarație (doar C și Objective-C)
Avertizați când se găsește o declarație după o declarație dintr-un bloc. Acest construct, cunoscut
din C++, a fost introdus cu ISO C99 și este permis implicit în GCC. Nu este
acceptat de ISO C90 și nu a fost acceptat de versiunile GCC înainte de GCC 3.0.

-Wundef
Avertizați dacă un identificator nedefinit este evaluat într-un #dacă directivă.

-Wno-endif-etichete
Nu avertiza ori de câte ori un #altfel sau un #endif sunt urmate de text.

-Wshadow
Avertizați de fiecare dată când o variabilă locală sau o declarație de tip umbră o altă variabilă,
parametru, tip sau membru al clasei (în C++) sau ori de câte ori este o funcție încorporată
umbrite. Rețineți că în C++, compilatorul avertizează dacă o variabilă locală umbrește un explicit
typedef, dar nu și dacă umbră o struct/class/enum.

-Mai mare decât=len
Avertizați ori de câte ori un obiect mai mare decât len octeții sunt definiți.

-Wframe-mai mare-decat=len
Avertizați dacă dimensiunea unui cadru de funcție este mai mare decât len octeți. Calculul făcut
pentru a determina dimensiunea cadrului stivei este aproximativă și nu conservatoare. Actualul
cerințele pot fi ceva mai mari decât len chiar dacă nu primești un avertisment. În
În plus, orice spațiu alocat prin „alloca”, matrice de lungime variabilă sau înrudit
constructele nu este inclusă de compilator atunci când determină dacă să emită sau nu a
avertizare.

-Wno-free-nonheap-obiect
Nu avertizați când încercați să eliberați un obiect care nu a fost alocat pe heap.

-Wstack-usage=len
Avertizați dacă utilizarea stivei unei funcții poate fi mai mare decât len octeți. Calculul
făcut pentru a determina utilizarea stivei este conservatoare. Orice spațiu alocat prin „alloca”,
tablourile cu lungime variabilă sau constructele asociate sunt incluse de compilator când
stabilirea dacă să emită sau nu un avertisment.

Mesajul este în concordanță cu rezultatul lui -fstack-usage.

· Dacă utilizarea stivei este complet statică, dar depășește cantitatea specificată, aceasta este:

avertisment: utilizarea stivei este de 1120 de octeți

· Dacă utilizarea stivei este (parțial) dinamică, dar limitată, este:

avertisment: utilizarea stivei poate fi de 1648 de octeți

· Dacă utilizarea stivei este (parțial) dinamică și nu este limitată, aceasta este:

avertisment: utilizarea stivei poate fi nelimitată

-Wunsafe-loop-optimizations
Avertizați dacă bucla nu poate fi optimizată deoarece compilatorul nu poate presupune nimic
limitele indicilor buclei. Cu -optimizări-funsafe-loop avertizează dacă compilatorul
face astfel de presupuneri.

-Format-wno-pedant-ms (doar ținte MinGW)
Când este utilizat în combinație cu -Wformat și -pedant fără extensii GNU, asta
opțiunea dezactivează avertismentele despre specificatorii de lățime a formatului non-ISO „printf” / „scanf”
„I32”, „I64” și „I” sunt utilizate pe ținte Windows, care depind de timpul de execuție MS.

-Wpointer-arith
Avertizați despre orice depinde de „dimensiunea” unui tip de funcție sau de „void”. GNU C
atribuie acestor tipuri o dimensiune de 1, pentru comoditate în calcule cu „void *”
pointeri și pointeri către funcții. În C++, avertizează și atunci când o operație aritmetică
implică „NULL”. Acest avertisment este activat și de -Wpedant.

-Wtip-limite
Avertizați dacă o comparație este întotdeauna adevărată sau întotdeauna falsă din cauza intervalului limitat al
tip de date, dar nu avertizați pentru expresii constante. De exemplu, avertizați dacă este nesemnat
variabila este comparată cu zero cu < or >=. Acest avertisment este activat și de
-Wextra.

-Wbad-funcție-cast (doar C și Objective-C)
Avertizați de fiecare dată când un apel de funcție este transmis la un tip care nu se potrivește. De exemplu, avertizați dacă
„int malloc()” este turnat la „orice *”.

-Wc++-compat (doar C și Objective-C)
Avertizați despre constructele ISO C care se află în afara subsetului comun ISO C și ISO
C++, de exemplu cerere de conversie implicită de la „void *” la un pointer la non-“void”
tip.

-Wc++11-compat (doar C++ și Objective-C++)
Avertizați despre constructele C++ a căror semnificație diferă între ISO C++ 1998 și ISO C++ 2011,
de exemplu, identificatori în ISO C++ 1998 care sunt cuvinte cheie în ISO C++ 2011. Acest avertisment
se aprinde -Îngustare și este activat de -Perete.

-Wcast-qual
Avertizați de fiecare dată când un indicator este proiectat pentru a elimina un calificativ de tip din tipul țintă.
De exemplu, avertizați dacă un „const char *” este transformat într-un „char *” obișnuit.

De asemenea, avertizați când faceți o distribuție care introduce un calificativ de tip într-un mod nesigur. Pentru
De exemplu, turnarea „char **” la „const char **” este nesigură, ca în acest exemplu:

/* p este valoarea char **. */
const char **q = (const char **) p;
/* Atribuirea șirului numai în citire la const char * este OK. */
*q = „șir”;
/* Acum char** pointerul indică către memoria doar pentru citire. */
**p = 'b';

-Wcast-align
Avertizați de fiecare dată când un indicator este proiectat astfel încât să fie alinierea necesară a țintei
a crescut. De exemplu, avertizați dacă un „char *” este turnat la un „int *” pe mașinile unde
numerele întregi pot fi accesate numai la granițele de doi sau patru octeți.

-Scrie-șiruri
Când compilați C, dați constantelor șir de tipul „const char[lungime]" astfel încât copierea
adresa unuia într-un pointer non-"const" "char *" produce un avertisment. Aceste
avertismentele vă ajută să găsiți la compilare un cod de timp care poate încerca să scrieți într-un șir
constantă, dar numai dacă ai fost foarte atent la utilizarea „const” în declarații
și prototipuri. Altfel, este doar o pacoste. Acesta este motivul pentru care nu am făcut -Perete
solicita aceste avertismente.

Când compilați C++, avertizați cu privire la conversia depreciată de la literalele șir în „char
*". Acest avertisment este activat în mod implicit pentru programele C++.

-Wclobbered
Avertizați pentru variabilele care ar putea fi modificate de longjmp or vfurca. Acest avertisment este, de asemenea
activat de -Wextra.

-Asistență condiționată (doar C++ și Objective-C++)
Avertizare pentru construcții acceptate condiționat (C++11 [intro.defs]).

-Wconversie
Avertizare pentru conversii implicite care pot modifica o valoare. Aceasta include conversiile
între real și întreg, cum ar fi „abs (x)” când „x” este „dublu”; conversii între
semnat și nesemnat, cum ar fi „unsigned ui = -1”; și conversii în tipuri mai mici, cum ar fi
„sqrtf (M_PI)”. Nu avertizați pentru turnări explicite precum „abs ((int) x)” și „ui =
(fără semn) -1”, sau dacă valoarea nu este modificată de conversie ca în „abs (2.0)”.
Avertismentele despre conversiile între numere întregi semnate și nesemnate pot fi dezactivate de
folosind -Wno-semn-conversie.

Pentru C++, avertizați și pentru rezoluția confuză a supraîncărcării pentru conversiile definite de utilizator; și
conversii care nu folosesc niciodată un operator de conversie de tip: conversii la „void”, la fel
tip, o clasă de bază sau o referință la acestea. Avertismente despre conversii între semnate
iar numerele întregi fără semn sunt dezactivate implicit în C++, cu excepția cazului în care -Wsign-conversie is
activat în mod explicit.

-Wno-conversie-null (doar C++ și Objective-C++)
Nu avertizați pentru conversiile între tipurile „NULL” și non-pointer. -Wconversion-null is
activat implicit.

-Wzero-ca-pointer-null-constant (doar C++ și Objective-C++)
Avertizați când un „0” literal este folosit ca constantă de indicator nul. Acest lucru poate fi util pentru
facilitează conversia la „nullptr” în C++11.

-Wdata-ora
Avertizați când macrocomenzile „__TIME__”, „__DATE__” sau „__TIMESTAMP__” sunt întâlnite deoarece acestea
ar putea preveni compilațiile reproductibile identice la nivel de biți.

-Wdelete-incomplet (doar C++ și Objective-C++)
Avertizați când ștergeți un pointer către un tip incomplet, care poate provoca un comportament nedefinit la
timpul de rulare. Acest avertisment este activat în mod implicit.

-Wuseless-distribuie (doar C++ și Objective-C++)
Avertizați când o expresie este turnată la propriul tip.

-Corpul umed
Avertizați dacă apare un corp gol într-un if, altfel or do în timp ce afirmație. Acest avertisment este
activat de asemenea de -Wextra.

-Wenum-compara
Avertizați despre o comparație între valorile diferitelor tipuri enumerate. În enumerarea C++
Nepotrivirile în expresiile condiționate sunt, de asemenea, diagnosticate și avertismentul este activat de
Mod implicit. În C, acest avertisment este activat de -Perete.

-Wjump-doar-init (C, doar Objective-C)
Avertizați dacă o declarație „goto” sau o declarație „switch” sare înainte peste
inițializarea unei variabile sau sare înapoi la o etichetă după ce variabila a fost
initializat. Acest lucru avertizează doar despre variabilele care sunt inițializate atunci când sunt
declarat. Acest avertisment este acceptat numai pentru C și Objective-C; în C++ acest tip de
ramura este o eroare în orice caz.

-Wjump-doar-init este inclus în -Wc++-compat. Poate fi dezactivat cu
-Wno-sarit-rare-init opțiune.

-Wsign-compara
Avertizați când o comparație între valorile semnate și nesemnate poate produce o incorectă
rezultat când valoarea semnată este convertită în nesemnată. Acest avertisment este de asemenea activat
by -Wextra; pentru a primi celelalte avertismente ale -Wextra fără acest avertisment, folosiți -Wextra
-Wno-semn-compara.

-Wsign-conversie
Avertizați pentru conversiile implicite care pot schimba semnul unei valori întregi, cum ar fi
atribuirea unei expresii întregi cu semn unei variabile întregi fără semn. Un explicit
cast reduce la tăcere avertismentul. În C, această opțiune este activată și de -Wconversie.

-Wfloat-conversie
Avertizați pentru conversii implicite care reduc precizia unei valori reale. Acest
include conversii din real în întreg și de la real cu precizie mai mare la mai mic
precizie valori reale. Această opțiune este, de asemenea, activată de -Wconversie.

-Wsizeof-pointer-memaccess
Avertizați pentru parametrii de lungime suspecti pentru anumite funcții de șir și memorie încorporate
dacă argumentul folosește „sizeof”. Acest avertisment avertizează, de exemplu, despre „memset (ptr, 0, sizeof
(ptr));" dacă "ptr" nu este o matrice, ci un pointer și sugerează o posibilă remediere sau
despre „memcpy (&foo, ptr, sizeof (&foo));”. Acest avertisment este activat de -Perete.

-Wmemset-transpus-args
Avertizați pentru apeluri suspecte la funcția încorporată „memset”, dacă al doilea argument este
nu este zero și al treilea argument este zero. Acest lucru avertizează, de exemplu, despre „memset (buf, sizeof
buf, 0)" unde, cel mai probabil, se însemna "memset (buf, 0, sizeof buf)".
diagnosticul este emis doar dacă al treilea argument este zero literal, dacă este ceva
expresie care este pliată la zero, sau de exemplu, o transformare de zero la un anumit tip etc., este departe
mai puțin probabil ca utilizatorul să fi schimbat din greșeală argumentele și nici un avertisment
emise. Acest avertisment este activat de -Perete.

-Waddress
Avertizați despre utilizările suspecte ale adreselor de memorie. Acestea includ utilizarea adresei a
funcția într-o expresie condiționată, cum ar fi „void func(void); if (func)”, și
comparații cu adresa de memorie a unui șir literal, cum ar fi „dacă (x == „abc”)”.
Astfel de utilizări indică de obicei o eroare a programatorului: adresa unei funcții întotdeauna
evaluează la adevărat, astfel încât utilizarea lor într-un condițional indică de obicei că programatorul
a uitat parantezele într-un apel de funcție; și comparații cu literalele șir
rezultă într-un comportament nespecificat și nu sunt portabile în C, așa că de obicei indică
că programatorul a intenționat să folosească „strcmp”. Acest avertisment este activat de -Perete.

-Wlogic-op
Avertizați despre utilizările suspecte ale operatorilor logici în expresii. Aceasta include utilizarea
operatori logici în contexte în care este probabil să se aștepte un operator pe biți.

-Waggregate-retur
Avertizați dacă sunt definite sau apelate funcții care returnează structuri sau uniuni. (În
limbi în care puteți returna o matrice, acest lucru provoacă și un avertisment.)

-Wno-agresive-bucle-optimizări
Avertizați dacă într-o buclă cu număr constant de iterații, compilatorul detectează nedefinit
comportament într-o declarație în timpul uneia sau mai multor iterații.

-Wno-atribute
Nu avertizați dacă este utilizat un „__atribut__” neașteptat, cum ar fi atribute nerecunoscute,
atributele funcției aplicate variabilelor etc. Acest lucru nu oprește erorile pentru
utilizarea incorectă a atributelor acceptate.

-Wno-builtin-macro-redefinit
Nu avertizați dacă anumite macrocomenzi încorporate sunt redefinite. Acest lucru suprimă avertismentele pentru
redefinirea „__TIMESTAMP__”, „__TIME__”, „__DATE__”, „__FILE__” și
„__BASE_FILE__”.

-Wstrict-prototipuri (doar C și Objective-C)
Avertizați dacă o funcție este declarată sau definită fără a specifica tipurile de argument. (Un
definirea funcției în stil vechi este permisă fără avertisment dacă este precedată de a
declarație care specifică tipurile de argument.)

-Declarație în stil Wold (doar C și Objective-C)
Avertizați pentru utilizări învechite, conform Standardului C, într-o declarație. Pentru
de exemplu, avertizați dacă specificatorii clasei de stocare precum „static” nu sunt primele lucruri în a
declaraţie. Acest avertisment este activat și de -Wextra.

-Wold-stil-definiție (doar C și Objective-C)
Avertizați dacă este utilizată o definiție de funcție în stil vechi. Se dă un avertisment chiar dacă există
un prototip anterior.

-Wmissing-parametru-tip (doar C și Objective-C)
Un parametru de funcție este declarat fără un specificator de tip în funcțiile în stil K&R:

void foo(bar) { }

Acest avertisment este activat și de -Wextra.

- Lipsă-prototipuri (doar C și Objective-C)
Avertizați dacă o funcție globală este definită fără o declarație anterioară de prototip. Acest
avertismentul este emis chiar dacă definiția în sine oferă un prototip. Utilizați această opțiune
pentru a detecta funcții globale care nu au o declarație de prototip potrivită în a
fișier antet. Această opțiune nu este validă pentru C++ deoarece toate declarațiile de funcție
furnizați prototipuri și o declarație care nu se potrivește va declara o supraîncărcare mai degrabă decât
conflict cu o declarație anterioară. Utilizare - Declarații lipsă pentru a detecta lipsa
declarații în C++.

- Declarații lipsă
Avertizați dacă o funcție globală este definită fără o declarație anterioară. Fă-o chiar dacă
definiția în sine oferă un prototip. Utilizați această opțiune pentru a detecta global
funcții care nu sunt declarate în fișierele antet. În C, nu sunt emise avertismente pentru
funcții cu declarații anterioare non-prototip; utilizare -Wmissing-prototip pentru a detecta
prototipuri lipsă. În C++, nu sunt emise avertismente pentru șabloanele de funcție sau pentru
funcții inline sau pentru funcții din spații de nume anonime.

-Inițializatoare-câmp lipsesc
Avertizați dacă inițializatorul unei structuri are unele câmpuri lipsă. De exemplu, următoarele
codul provoacă un astfel de avertisment, deoarece „xh” este implicit zero:

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

Această opțiune nu avertizează despre inițializatoarele desemnate, deci modificarea următoare
nu declanșează un avertisment:

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

Acest avertisment este inclus în -Wextra. Pentru a obține altele -Wextra avertismente fără acesta,
utilizare -Wextra -Wno-lipsă-câmp-inițializatori.

-Wno-multichar
Nu avertizați dacă o constantă cu mai multe caractere („FOOF”) este folosit. De obicei ele indică a
greșeli de scriere în codul utilizatorului, deoarece au valori definite de implementare și nu ar trebui să fie
folosit în codul portabil.

-Wnormalizat=
În ISO C și ISO C++, doi identificatori sunt diferiți dacă sunt secvențe diferite de
personaje. Cu toate acestea, uneori, când caracterele din afara setului de caractere ASCII de bază
sunt utilizate, puteți avea două secvențe de caractere diferite care arată la fel. A evita
confuzie, standardul ISO 10646 stabilește câteva normalizare norme care atunci când este aplicat
asigurați-vă că două secvențe care arată la fel sunt transformate în aceeași secvență. GCC
vă poate avertiza dacă utilizați identificatori care nu au fost normalizați; această opțiune
controlează acel avertisment.

Există patru niveluri de avertizare acceptate de GCC. Valoarea implicită este -Wnormalized=nfc,
care avertizează cu privire la orice identificator care nu este în forma normalizată ISO 10646 „C”,
NFC. NFC este forma recomandată pentru majoritatea utilizărilor.

Din păcate, există unele caractere permise în identificatori de ISO C și ISO C++
care, atunci când sunt transformate în NFC, nu sunt permise în identificatori. Adică, nu există nicio cale
să utilizați aceste simboluri în ISO portabil C sau C++ și să aveți toți identificatorii în NFC.
-Wnormalizat=id suprimă avertismentul pentru aceste caractere. Se speră că viitorul
versiunile standardelor implicate vor corecta acest lucru, motiv pentru care această opțiune nu este
implicit.

Puteți dezactiva avertismentul pentru toate caracterele prin scriere -Wnormalizat=nici unul. Tu
ar trebui să faceți acest lucru numai dacă utilizați o altă schemă de normalizare (cum ar fi „D”),
pentru că altfel puteți crea cu ușurință bug-uri care sunt literalmente imposibil de văzut.

Unele caractere din ISO 10646 au semnificații distincte, dar arată identic în unele fonturi
sau afișează metodologii, mai ales după ce formatarea a fost aplicată. De exemplu
„\u207F”, „SUPERSCRIPT LATINA MINUSCULĂ N”, se afișează la fel ca un „n” obișnuit care
a fost plasat într-un superscript. ISO 10646 definește NFKC schema de normalizare la
convertiți toate acestea într-o formă standard, iar GCC vă avertizează dacă codul dvs. nu este inclus
NFKC dacă utilizați -Wnormalized=nfkc. Acest avertisment este comparabil cu avertismentul despre fiecare
identificator care conține litera O deoarece ar putea fi confundat cu cifra 0,
și nu este implicit, dar poate fi util ca convenție locală de codare dacă
mediul de programare nu poate fi fixat pentru a afișa aceste caractere distinct.

-Wno-depreciat
Nu avertizați despre utilizarea funcțiilor depreciate.

-Wno-depreciate-declarations
Nu avertizați cu privire la utilizările de funcții, variabile și tipuri marcate ca fiind depreciate de
folosind atributul „depreciat”.

-Wno-overflow
Nu avertizați despre depășirea timpului de compilare în expresiile constante.

-Wopenmp-simd
Avertizați dacă modelul de cost al vectorizatorului depășește directiva OpenMP sau Cilk Plus simd
stabilit de utilizator. The -fsimd-cost-model=nelimitat poate fi folosit pentru a relaxa modelul de cost.

-Woverride-init (doar C și Objective-C)
Avertizați dacă un câmp inițializat fără efecte secundare este suprascris atunci când utilizați desemnat
inițializatoare.

Acest avertisment este inclus în -Wextra. Pentru a obține altele -Wextra avertismente fără acesta,
utilizare -Wextra -Wno-override-init.

-Ambalat
Avertizați dacă unei structuri i se dă atributul împachetat, dar atributul împachetat nu are
efect asupra aspectului sau dimensiunii structurii. Astfel de structuri pot fi aliniate greșit pentru
putin beneficiu. De exemplu, în acest cod, variabila „fx” din „struct bar” este
aliniat greșit, chiar dacă „structura bară” nu are în sine atributul împachetat:

struct foo {
int x;
char a, b, c, d;
} __attribute __ ((ambalat));
struct bar {
char z;
struct foo f;
};

-Wpacked-bitfield-compat
Seriile 4.1, 4.2 și 4.3 ale GCC ignoră atributul „ambalat” pe câmpurile de biți de tip
„char”. Acest lucru a fost remediat în GCC 4.4, dar modificarea poate duce la diferențe în
dispunerea structurii. GCC vă informează când offset-ul unui astfel de câmp s-a modificat în GCC
4.4. De exemplu, nu mai există o umplutură de 4 biți între câmpul „a” și „b” în aceasta
structura:

struct foo
{
char a:4;
char b:8;
} __atribut__ ((ambalat));

Acest avertisment este activat în mod implicit. Utilizare -Wno-ambalat-bitfield-compat pentru a dezactiva acest lucru
avertizare.

-Wcaptusit
Avertizați dacă umplutura este inclusă într-o structură, fie pentru a alinia un element al
structura sau pentru a alinia întreaga structură. Uneori, când se întâmplă acest lucru, este posibil
pentru a rearanja câmpurile structurii pentru a reduce umplutura și astfel a face
structura mai mica.

-Wredundant-decls
Avertizați dacă ceva este declarat de mai multe ori în același domeniu, chiar și în cazurile în care
declarația multiplă este valabilă și nu schimbă nimic.

-Wned-externs (doar C și Objective-C)
Avertizați dacă o declarație „externă” este întâlnită într-o funcție.

-Wno-moștenit-variadic-ctor
Suprimați avertismentele despre utilizarea constructorilor care moștenesc C++11 atunci când clasa de bază
mostenit de la are un constructor variadic C; avertismentul este activat în mod implicit deoarece
punctele de suspensie nu se moștenesc.

-Winline
Avertizați dacă o funcție care este declarată ca inline nu poate fi inline. Chiar și cu asta
opțiunea, compilatorul nu avertizează asupra eșecurilor la funcțiile inline declarate în
anteturile sistemului.

Compilatorul folosește o varietate de euristici pentru a determina dacă să inline sau nu a
funcţie. De exemplu, compilatorul ține cont de dimensiunea funcției fiind
inlined și cantitatea de inline care a fost deja făcută în funcția curentă.
Prin urmare, modificări aparent nesemnificative ale programului sursă pot cauza
avertismente produse de -Winline să apară sau să dispară.

-Wno-invalid-offsetof (doar C++ și Objective-C++)
Suprimați avertismentele de la aplicarea offsetof macro la un tip non-POD. Conform
se aplică standardul ISO C++ din 1998 offsetof la un tip non-POD este nedefinit. În
implementările C++ existente, totuși, offsetof de obicei dă rezultate semnificative
chiar și atunci când se aplică anumitor tipuri de tipuri non-POD (cum ar fi un simplu structura acea
nu reușește să fie un tip POD doar în virtutea faptului că are un constructor). Acest steag este pentru
utilizatorii care sunt conștienți că scriu cod neportabil și care au făcut-o în mod deliberat
ales să ignore avertismentul despre aceasta.

Restricțiile privind offsetof poate fi relaxat într-o versiune viitoare a standardului C++.

-Wno-int-to-pointer-cast
Suprimați avertismentele de la turnări la tipul de indicator al unui număr întreg de o dimensiune diferită. În
C++, turnarea la un tip de indicator de dimensiune mai mică este o eroare. Wint-to-pointer-cast is
activat implicit.

-Wno-pointer-to-int-cast (doar C și Objective-C)
Suprimați avertismentele de la proiecții de la un pointer la un tip întreg de o dimensiune diferită.

-Winvalid-pch
Avertizați dacă un antet precompilat este găsit în calea de căutare, dar nu poate fi utilizat.

-Lung-lung
Avertizați dacă lung lung este folosit tipul. Acest lucru este activat de oricare -Wpedant or - Tradițional
în modurile ISO C90 și C++98. Pentru a inhiba mesajele de avertizare, utilizați -Wno-lung-lung.

-Wvariadic-macro
Avertizați dacă macrocomenzile variadice sunt utilizate în modul ISO C90 pedant sau sintaxa alternativă GNU
când se află în modul pedant ISO C99. Acesta este implicit. Pentru a inhiba mesajele de avertizare, utilizați
-Wno-variadic-macro.

-Wvarargs
Avertizați la utilizarea îndoielnică a macrocomenzilor utilizate pentru a gestiona argumente variabile, cum ar fi
va_start. Acesta este implicit. Pentru a inhiba mesajele de avertizare, utilizați -Wno-varargs.

-Wvector-operare-performanță
Avertizați dacă operarea vectorială nu este implementată prin capabilitățile SIMD ale arhitecturii.
Util în principal pentru reglarea performanței. Operația vectorială poate fi implementată
„pe bucăți”, ceea ce înseamnă că operația scalară este efectuată pe fiecare vector
element; „în paralel”, ceea ce înseamnă că operația vectorială este implementată folosind
scalari de tip mai larg, care în mod normal este mai eficient în performanță; și „ca un singur
scalar”, ceea ce înseamnă că vectorul se încadrează într-un tip scalar.

-Wno-virtual-mutare-alocare
Suprimați avertismentele despre moștenirea de la o bază virtuală cu o mișcare C++11 non-trivială
operator de atribuire. Acest lucru este periculos pentru că dacă baza virtuală este accesibilă de-a lungul
mai mult de o cale, aceasta va fi mutată de mai multe ori, ceea ce poate însemna că ambele obiecte se termină
sus în starea mutată de la. Dacă operatorul de atribuire a mutarii este scris pentru a evita
deplasarea dintr-un obiect mutat de la, acest avertisment poate fi dezactivat.

-Wvla
Avertizați dacă în cod este utilizată matrice de lungime variabilă. -Wno-vla previne -Wpedant
avertizare asupra matricei de lungime variabilă.

-Wvolatile-registru-var
Avertizați dacă o variabilă de registru este declarată volatilă. Modificatorul volatil nu
inhibați toate optimizările care pot elimina citirile și/sau scrierile pentru înregistrare
variabile. Acest avertisment este activat de -Perete.

-Wdisabled-optimizare
Avertizați dacă o trecere de optimizare solicitată este dezactivată. Acest avertisment nu este în general
indicați că există ceva în neregulă cu codul dvs.; indică doar că GCC-urile
optimizatorii nu sunt capabili să gestioneze codul în mod eficient. Adesea, problema este că dvs
codul este prea mare sau prea complex; GCC refuză să optimizeze programele în momentul optimizării
în sine este probabil să ia o perioadă exagerată de timp.

-Wpointer-semn (doar C și Objective-C)
Avertisment pentru trecerea argumentului indicator sau atribuirea cu semnătură diferită. Acest
opțiunea este acceptată numai pentru C și Objective-C. Este subînțeles de -Perete și de
-Wpedant, care poate fi dezactivat cu -Wno-pointer-semn.

-Wstack-protector
Această opțiune este activă numai atunci când -festack-protector este activ. Avertizează despre funcții
care nu sunt protejate împotriva spargerii stivelor.

-Woverlungime-şiruri
Avertizați despre constantele șirurilor care sunt mai lungi decât lungimea „minimă maximă”.
specificate în standardul C. Compilatoarele moderne permit în general constante șir care
sunt mult mai lungi decât limita minimă a standardului, dar programele foarte portabile ar trebui
evitați să folosiți șiruri mai lungi.

Se aplică limita după concatenarea constantă a șirurilor și nu contorizează finalul
NUL. În C90, limita a fost de 509 caractere; în C99, a fost ridicat la 4095. C++98 face
nu se specifică un minim minim normativ, deci nu diagnosticăm șiruri de supralungime în
C ++.

Această opțiune este implicată de -Wpedant, și poate fi dezactivat cu
-Wno-supralungime-șiruri.

-Wunsufixed-float-constante (doar C și Objective-C)
Emiteți un avertisment pentru orice constantă flotantă care nu are un sufix. Când este folosit
Împreună cu -Wsystem-anteturi avertizează despre astfel de constante în fișierele antet de sistem.
Acest lucru poate fi util atunci când pregătiți codul de utilizat cu pragma „FLOAT_CONST_DECIMAL64”
de la extensia zecimală în virgulă mobilă la C99.

Opţiuni pentru Depanarea Ta Program or CGC
GCC are diverse opțiuni speciale care sunt utilizate pentru depanarea fie programului, fie GCC:

-g Produceți informații de depanare în formatul nativ al sistemului de operare (stabs, COFF,
XCOFF sau DWARF 2). GDB poate lucra cu aceste informații de depanare.

Pe majoritatea sistemelor care folosesc formatul stabs, -g permite utilizarea informațiilor suplimentare de depanare
pe care numai GDB îl poate folosi; aceste informații suplimentare fac ca depanarea să funcționeze mai bine în GDB dar
probabil că face ca alți depanatoare să se blocheze sau să refuze să citească programul. Dacă doriți să
controlați cu siguranță dacă să generați informații suplimentare, utilizați -gstabs+, -gstabs,
-gxcoff+, -gxcoff, Sau -gvms (Vezi mai jos).

GCC vă permite să utilizați -g cu -O. Comenzile rapide luate de codul optimizat pot
produc ocazional rezultate surprinzătoare: unele variabile pe care le-ați declarat este posibil să nu existe
toate; fluxul de control se poate muta pentru scurt timp acolo unde nu te-ai așteptat; unele afirmatii pot
nu pot fi executate deoarece calculează rezultate constante sau valorile lor sunt deja la
mână; unele instrucțiuni se pot executa în locuri diferite deoarece au fost mutate
de bucle.

Cu toate acestea, se dovedește posibilă depanarea ieșirii optimizate. Acest lucru îl face rezonabil
pentru a utiliza optimizatorul pentru programe care ar putea avea erori.

Următoarele opțiuni sunt utile atunci când GCC este generat cu capacitatea pentru mai multe
decât un format de depanare.

-gsplit-pitic
Separați cât mai multe informații de depanare pitic posibil într-un fișier de ieșire separat
cu extensia .dwo. Această opțiune permite sistemului de compilare să evite conectarea fișierelor
cu informații de depanare. Pentru a fi utilă, această opțiune necesită un depanator capabil
citirea fișierelor .dwo.

-ggdb
Produceți informații de depanare pentru utilizare de către GDB. Aceasta înseamnă să folosești cel mai expresiv
format disponibil (DWARF 2, stabs sau formatul nativ dacă niciunul dintre acestea nu este
acceptate), inclusiv extensiile GDB, dacă este posibil.

-gpubnames
Generați secțiuni pitice .debug_pubnames și .debug_pubtypes.

-ggnu-pubnames
Generați secțiuni .debug_pubnames și .debug_pubtypes într-un format potrivit pentru
conversie într-un indice GDB. Această opțiune este utilă numai cu un linker care poate
produce indexul GDB versiunea 7.

-gstabs
Produceți informații de depanare în format stabs (dacă este acceptat), fără GDB
extensii. Acesta este formatul folosit de DBX pe majoritatea sistemelor BSD. Pe MIPS, Alpha și
Sistemele System V Release 4 această opțiune produce o ieșire de depanare a împunsărilor care nu este
înțeles de DBX sau SDB. Pe sistemele System V Release 4, această opțiune necesită GNU
asamblator.

-elimină-neutilizate-debug-simboluri
Produceți informații de depanare în format stabs (dacă este acceptat), numai pentru simboluri
care sunt de fapt folosite.

-femit-class-debug-intotdeauna
În loc să emită informații de depanare pentru o clasă C++ într-un singur fișier obiect,
emite-l în toate fișierele obiect folosind clasa. Această opțiune ar trebui folosită numai cu
depanatoare care nu pot gestiona modul în care GCC emite în mod normal informații de depanare
pentru clase, deoarece utilizarea acestei opțiuni crește dimensiunea informațiilor de depanare cu
cât un factor de doi.

-fdebug-types-section
Când utilizați DWARF Versiunea 4 sau o versiune superioară, matrițele de tip pot fi puse în propriile lor
Secțiunea „.debug_types” în loc să le facă parte din secțiunea „.debug_info”. Aceasta
este mai eficient să le puneți într-o secțiune de comdat separată, deoarece linkerul poate atunci
eliminați duplicatele. Dar nu toți consumatorii DWARF acceptă încă secțiunile „.debug_types”.
iar pe unele obiecte „.debug_types” produce o depanare mai mare în loc de mai mică
informaţii.

-gstabs+
Produceți informații de depanare în format stabs (dacă este acceptat), folosind GNU
extensii înțelese doar de GNU debugger (GDB). Utilizarea acestor extensii este
probabil să provoace blocarea altor dispozitive de depanare sau să refuze să citească programul.

-gcoff
Produceți informații de depanare în format COFF (dacă este acceptat). Acesta este
format utilizat de SDB pe majoritatea sistemelor System V înainte de System V Release 4.

-gxcoff
Produceți informații de depanare în format XCOFF (dacă este acceptat). Acesta este
format utilizat de depanatorul DBX pe sistemele IBM RS/6000.

-gxcoff+
Produceți informații de depanare în format XCOFF (dacă este acceptat), folosind GNU
extensii înțelese doar de GNU debugger (GDB). Utilizarea acestor extensii este
probabil să provoace blocarea altor aplicații de depanare sau să refuze să citească programul și poate provoca
asamblatorii alții decât asamblatorul GNU (GAS) să eșueze cu o eroare.

-pitic-versiune
Produceți informații de depanare în format DWARF (dacă este acceptat). Valoarea a
versiune poate fi fie 2, 3 sau 4; versiunea implicită pentru majoritatea țintelor este 4.

Rețineți că, cu DWARF Versiunea 2, unele porturi necesită și folosesc întotdeauna unele non-conflictuale
DWARF 3 extensii în mesele de relaxare.

Versiunea 4 poate necesita GDB 7.0 și -fvar-tracking-assignments pentru beneficii maxime.

-grecord-gcc-switch-uri
Această comutare determină opțiunile de linie de comandă utilizate pentru a invoca compilatorul care poate
afectează generarea de cod pentru a fi atașată la atributul DW_AT_producer în DWARF
informații de depanare. Opțiunile sunt concatenate cu spații care le separă
unul pe altul și din versiunea compilatorului. Vezi si -frecord-gcc-switch-uri pentru altul
mod de stocare a opțiunilor compilatorului în fișierul obiect. Aceasta este valoarea implicită.

-gno-record-gcc-switch-uri
Nu permiteți adăugarea de opțiuni de linie de comandă la atributul DW_AT_producer în DWARF
informații de depanare.

-gstrict-pitic
Nu permiteți utilizarea extensiilor versiunii standard DWARF ulterioare decât cele selectate cu
-pitic-versiune. Pe majoritatea țintelor folosind extensii DWARF fără conflicte de mai târziu
versiunile standard sunt permise.

-gno-strict-pitic
Permite utilizarea extensiilor versiunii standard DWARF ulterioare decât cele alese cu
-pitic-versiune.

-gvms
Produceți informații de depanare în format Alpha/VMS (dacă este acceptat). Acest
este formatul folosit de DEBUG pe sistemele Alpha/VMS.

-gnivel
-ggdbnivel
-gstabsnivel
-gcoffnivel
-gxcoffnivel
-gvmsnivel
Solicitați informații de depanare și, de asemenea, utilizați nivel pentru a specifica câte informații. The
nivelul implicit este 2.

Nivelul 0 nu produce deloc informații de depanare. Prin urmare, -g0 neagă -g.

Nivelul 1 produce informații minime, suficiente pentru a face urme înapoi în anumite părți ale
program pe care nu intenționați să îl depanați. Aceasta include descrieri ale funcțiilor și
variabile externe și tabele cu numere de linii, dar nu există informații despre variabilele locale.

Nivelul 3 include informații suplimentare, cum ar fi toate definițiile macro prezente în
program. Unele programe de depanare acceptă extinderea macro atunci când utilizați -g3.

-gdwarf-2 nu acceptă un nivel de depanare concatenat, deoarece GCC suporta un
opțiune -pitic asta a însemnat să genereze informații de depanare în versiunea 1 a DWARF
format (care este foarte diferit de versiunea 2) și ar fi fost prea confuz.
Formatul respectiv de depanare este de mult învechit, dar opțiunea nu poate fi schimbată acum. Utilizați în schimb
o suplimentare -gnivel opțiunea de a schimba nivelul de depanare pentru DWARF.

-gtoggle
Dezactivați generarea informațiilor de depanare, dacă omiterea acestei opțiuni o generează, sau transformați-o
pe la nivelul 2 altfel. Poziția acestui argument în linia de comandă nu
materie; are efect după ce toate celelalte opțiuni sunt procesate și face acest lucru numai
o dată, indiferent de câte ori este dat. Acesta este destinat în principal a fi utilizat cu
-fcompare-debug.

-fsanitize=adresa
Activați AddressSanitizer, un detector rapid de erori de memorie. Instrucțiuni de acces la memorie
vor fi instrumentate pentru a detecta erorile care nu sunt în limitele limitelor și ale utilizării după eliberare. Vedea
<http://code.google.com/p/address-sanitizer/> pentru mai multe detalii. Comportamentul de rulare
poate fi influențat folosind ASAN_OPTIONS variabilă de mediu; vedea
<https://code.google.com/p/address-sanitizer/wiki/Flags#Run-time_flags> pentru o listă de
opțiunile acceptate.

-fsanitize=adresa-kernel
Activați AddressSanitizer pentru nucleul Linux. Vedea
<http://code.google.com/p/address-sanitizer/wiki/AddressSanitizerForKernel> pentru mai multe
Detalii.

-fsanitize=thread
Activați ThreadSanitizer, un detector rapid de curse de date. Instrucțiunile de acces la memorie vor fi
instrumentat pentru a detecta erori de cursă de date. Vedea
<http://code.google.com/p/thread-sanitizer/> pentru mai multe detalii. Comportamentul de rulare
poate fi influențat folosind TSAN_OPTIONS variabilă de mediu; vedea
<https://code.google.com/p/thread-sanitizer/wiki/Flags> pentru o listă de suportate
opțiuni.

-fsanitize=scurgere
Activați LeakSanitizer, un detector de scurgeri de memorie. Această opțiune contează doar pentru conectarea la
executabile și dacă nici unul -fsanitize=adresa nici -fsanitize=thread este folosit. In aceea
în cazul în care va lega executabilul cu o bibliotecă care suprascrie „malloc” și altele
funcții de alocare. Vedea
<https://code.google.com/p/address-sanitizer/wiki/LeakSanitizer> pentru mai multe detalii.
Comportamentul la timpul de rulare poate fi influențat folosind LSAN_OPTIONS variabilă de mediu.

-fsanitize=nedefinit
Activați UndefinedBehaviorSanitizer, un detector rapid de comportament nedefinit. Variat
calculele vor fi instrumentate pentru a detecta comportamentul nedefinit în timpul execuției. Actual
subopțiunile sunt:

-fsanitize=shift
Această opțiune permite verificarea faptului că rezultatul unei operațiuni de schimbare nu este
nedefinit. Rețineți că ceea ce este considerat exact nedefinit diferă ușor
între C și C++, precum și între ISO C90 și C99 etc.

-fsanitize=împarte-întreg-la-zero
Detectați diviziunea întregului cu zero, precum și diviziunea „INT_MIN / -1”.

-fsanitize=inaccesibil
Cu această opțiune, compilatorul va transforma apelul „__builtin_unreachable” într-un
în schimb, apelul mesajului de diagnosticare. Când ajungeți la apelul „__builtin_unreachable”,
comportamentul este nedefinit.

-fsanitize=vla-bound
Această opțiune instruiește compilatorul să verifice dacă dimensiunea unei lungimi variabile
matricea este pozitivă. Această opțiune nu are niciun efect în -std=c++1y modul, ca
standardul cere ca excepția să fie aruncată în schimb.

-fsanitize=null
Această opțiune permite verificarea indicatorului. În special, aplicația construită cu
această opțiune activată va emite un mesaj de eroare atunci când încearcă să anuleze referința a
Pointer NULL sau dacă o referință (posibil o referință rvalue) este legată de un NULL
indicator.

-fsanitize=return
Această opțiune permite verificarea extrasului de returnare. Programe create cu această opțiune
pornit va emite un mesaj de eroare atunci când se încheie o funcție non-void
atins fără a returna efectiv o valoare. Această opțiune funcționează numai în C++.

-fsanitize=depășire-întreg-semnat
Această opțiune permite verificarea depășirii întregului semnat. Verificăm că rezultatul de
„+”, „*”, și atât unar, cât și binar „-” nu depășește semnul
aritmetica. Rețineți că trebuie luate în considerare regulile de promovare a numărului întreg. Acesta este,
următorul nu este un depășire:

caracter semnat a = SCHAR_MAX;
a++;

In timp ce -ftrapv determină emisia de capcane pentru revărsări semnate, -fsanitize=nedefinit
dă un mesaj de diagnosticare. Acest lucru funcționează în prezent numai pentru familia de limbi C.

-fdump-final-insns[=fişier]
Transferați reprezentarea internă finală (RTL) la fişier. Dacă argumentul opțional este
omis (sau dacă fişier este „.”), numele fișierului dump este determinat prin adăugare
„.gkd” la numele fișierului de ieșire al compilației.

-fcompare-debug[=optează]
Dacă nu apare nicio eroare în timpul compilării, rulați compilatorul a doua oară, adăugând optează și
-fcompare-debug-second la argumentele trecute la a doua compilare. Aruncă
reprezentarea internă finală în ambele compilații și imprimați o eroare dacă diferă.

Dacă semnul egal este omis, implicit -gtoggle este folosit.

Variabila de mediu GCC_COMPARE_DEBUG, dacă este definit, non-vid și non-zero,
permite implicit -fcompare-debug. Dacă GCC_COMPARE_DEBUG este definită într-un șir
începând cu o liniuță, apoi este folosit pentru optează, altfel implicit -gtoggle is
folosit.

-fcompare-debug=, cu semnul egal dar fără optează, este echivalent cu
-fno-compare-debug, care dezactivează dumpingul reprezentării finale și
a doua compilare, prevenind chiar GCC_COMPARE_DEBUG de la intrarea în vigoare.

Pentru a verifica acoperirea completă în timpul -fcompare-debug testare, set GCC_COMPARE_DEBUG a zice
-fcompare-debug-not-overriden, pe care GCC o respinge ca opțiune nevalidă în orice moment
compilare (mai degrabă decât preprocesare, asamblare sau legare). Pentru a primi doar un avertisment,
instalare GCC_COMPARE_DEBUG la -w%n-fcompare-debug nu suprascris se va face.

-fcompare-debug-second
Această opțiune este transmisă implicit compilatorului pentru a doua compilare solicitată
by -fcompare-debug, împreună cu opțiunile pentru a opri avertismentele și omiterea altor opțiuni
care ar provoca ieșiri ale compilatorului cu efecte secundare către fișiere sau către ieșirea standard.
Fișierele de descărcare și fișierele temporare păstrate sunt redenumite astfel încât să conțină „.gk”
extensie suplimentară în timpul celei de-a doua compilări, pentru a evita suprascrierea acestora
generat de primul.

Când această opțiune este transmisă driverului de compilare, provoacă primul compilare la
să fie omis, ceea ce îl face util pentru altceva decât pentru depanarea compilatorului propriu-zis.

-feliminate-dwarf2-dups
Comprimați informațiile de depanare DWARF 2 eliminând informațiile duplicate despre
fiecare simbol. Această opțiune are sens numai atunci când se generează depanarea DWARF 2
informații cu -gdwarf-2.

-femit-struct-debug-baseonly
Emiteți informații de depanare pentru tipurile de tip struct numai atunci când numele de bază al
fișierul sursă de compilare se potrivește cu numele de bază al fișierului în care este definită structura.

Această opțiune reduce substanțial dimensiunea informațiilor de depanare, dar la
pierdere potențială semnificativă a informațiilor de tip pentru depanator. Vedea
-femit-struct-debug-reduced pentru o variantă mai puțin agresivă. Vedea
-femit-struct-debug-detailed pentru un control mai detaliat.

Această opțiune funcționează numai cu DWARF 2.

-femit-struct-debug-reduced
Emiteți informații de depanare pentru tipurile de tip struct numai atunci când numele de bază al
fișierul sursă de compilare se potrivește cu numele de bază al fișierului în care este definit tipul,
cu excepția cazului în care structura este un șablon sau definită într-un antet de sistem.

Această opțiune reduce semnificativ dimensiunea informațiilor de depanare, cu unele
pierderea potențială a informațiilor de tip pentru depanator. Vedea -femit-struct-debug-baseonly
pentru o variantă mai agresivă. Vedea -femit-struct-debug-detailed pentru mai detaliat
controla.

Această opțiune funcționează numai cu DWARF 2.

-femit-struct-debug-detailed[=lista de specificații]
Specificați tipurile de tip struct pentru care compilatorul generează informații de depanare. The
intenția este de a reduce informațiile duplicate de depanare a structurii între diferite fișiere obiect
in cadrul aceluiasi program.

Această opțiune este o versiune detaliată a -femit-struct-debug-reduced și
-femit-struct-debug-baseonly, care servește pentru majoritatea nevoilor.

O specificație are sintaxa[este:|ind:][ord:|gen:](Orice|SYS|de bază|nici unul)

Primul cuvânt opțional limitează specificația la structurile care sunt utilizate direct
(este:) sau folosit indirect (ind:). Un tip struct este utilizat direct atunci când este tipul
a unei variabile, membru. Utilizările indirecte apar prin indicatorii către structuri. Acesta este,
când utilizarea unui struct incomplet este validă, utilizarea este indirectă. Un exemplu este structura
unu direct; structura Două * indirect;.

Al doilea cuvânt opțional limitează specificația la structuri obișnuite (ord:) Sau
structuri generice (gen:). Structurile generice sunt puțin complicat de explicat. Pentru C++,
acestea sunt specializări non-explicite ale claselor șablon sau clase fără șablon
în cadrul celor de mai sus. Alte limbaje de programare au generice, dar
-femit-struct-debug-detailed încă nu le implementează.

Al treilea cuvânt specifică fișierele sursă pentru acele structuri pentru care compilatorul
ar trebui să emită informații de depanare. Valorile nici unul și Orice au sensul normal. The
valoare de bază înseamnă că baza numelui fișierului în care se află declarația de tip
apare trebuie să se potrivească cu baza numelui fișierului de compilare principal. In practica,
aceasta înseamnă că la compilare foo.c, informațiile de depanare sunt generate pentru tipuri
declarată în acel dosar şi foo.h, dar nu și alte fișiere antet. Valoarea SYS mijloace
acele tipuri satisfăcătoare de bază sau declarat în anteturile de sistem sau compilator.

Poate fi necesar să experimentați pentru a determina cele mai bune setări pentru aplicația dvs.

Valoarea implicită este -femit-struct-debug-detailed=toate.

Această opțiune funcționează numai cu DWARF 2.

-fno-merge-debug-strings
Direcționați linker-ul să nu îmbine șirurile din informațiile de depanare care sunt
identice în diferite fișiere obiect. Fuzionarea nu este acceptată de toți asamblatorii sau
linkerii. Fuzionarea scade dimensiunea informațiilor de depanare din fișierul de ieșire la
costul creșterii timpului de procesare a legăturilor. Îmbinarea este activată în mod implicit.

-fdebug-prefix-map=vechi=nou
La compilarea fișierelor în director vechi, înregistrați informațiile de depanare descriindu-le ca
in nou in schimb.

-fno-dwarf2-cfi-asm
Emiteți informații despre derulare DWARF 2 ca secțiune „.eh_frame” generată de compilator în loc să utilizați
Directive GAZ „.cfi_*”.

-p Generați cod suplimentar pentru a scrie informații de profil potrivite pentru programul de analiză
Prof. Trebuie să utilizați această opțiune atunci când compilați fișierele sursă despre care doriți date,
și trebuie să îl utilizați și atunci când conectați.

-pag Generați cod suplimentar pentru a scrie informații de profil potrivite pentru programul de analiză
gprof. Trebuie să utilizați această opțiune atunci când compilați fișierele sursă despre care doriți date,
și trebuie să îl utilizați și atunci când conectați.

-Q Face ca compilatorul să imprime fiecare nume de funcție pe măsură ce este compilat și să imprime unele
statistici despre fiecare trecere când se termină.

-ftime-raport
Face ca compilatorul să imprime câteva statistici despre timpul consumat de fiecare trecere atunci când acesta
finisaje.

-fmem-report
Face ca compilatorul să imprime câteva statistici despre alocarea memoriei permanente atunci când acesta
finisaje.

-fmem-report-wpa
Face ca compilatorul să imprime câteva statistici despre alocarea permanentă a memoriei pentru WPA
numai faza.

-fpre-ipa-mem-report
-fpost-ipa-mem-report
Face ca compilatorul să imprime câteva statistici despre alocarea permanentă a memoriei înainte de sau
după optimizarea interprocedurală.

-fprofil-raport
Face ca compilatorul să imprime câteva statistici despre consistența profilului (estimat).
și efectul trecerilor individuale.

-fstack-usage
Creează informații despre utilizarea stivei de ieșire a compilatorului pentru program, pe o funcție
bază. Numele fișierului pentru dump se face prin adăugare .su la nume auxiliar. nume auxiliar is
generat din numele fișierului de ieșire, dacă este specificat în mod explicit și nu este un
executabil, altfel este numele de bază al fișierului sursă. O intrare este formată din
trei domenii:

· Numele funcției.

· Un număr de octeți.

· Unul sau mai multe calificative: „static”, „dinamic”, „mărginit”.

Calificatorul „static” înseamnă că funcția manipulează stiva static: a
un număr fix de octeți sunt alocați pentru cadrul la intrarea funcției și eliberați pe
ieșire din funcție; altfel nu se fac ajustări ale stivei în funcție. Al doilea
câmpul este acest număr fix de octeți.

Calificatorul „dinamic” înseamnă că funcția manipulează stiva în mod dinamic: în
pe lângă alocarea statică descrisă mai sus, ajustările stivei sunt făcute în
corpul funcției, de exemplu pentru a împinge/pop argumente în jurul apelurilor de funcție. Dacă
calificativul „mărginit” este de asemenea prezent, valoarea acestor ajustări este delimitată la
timpul de compilare și al doilea câmp este o limită superioară a cantității totale de stivă utilizată
prin functie. Dacă nu este prezent, valoarea acestor ajustări nu este limitată
la momentul compilării, iar al doilea câmp reprezintă doar partea mărginită.

-fprofil-arcuri
Adăugați codul astfel încât programul să curgă arce sunt instrumentate. În timpul executării programului
înregistrează de câte ori este executată fiecare ramură și apel și de câte ori este preluată
sau se întoarce. Când programul compilat iese, acesta salvează aceste date într-un fișier numit
auxname.gcda pentru fiecare fișier sursă. Datele pot fi utilizate pentru direcționarea profilului
optimizări (-fbranch-probabilităţi), sau pentru analiza acoperirii testelor
(-ftest-acoperire). Fiecare fișier obiect nume auxiliar este generat din numele
fișier de ieșire, dacă este specificat în mod explicit și nu este executabilul final, în caz contrar
este numele de bază al fișierului sursă. În ambele cazuri, orice sufix este eliminat (de ex
foo.gcda pentru fișierul de intrare dir/foo.c, Sau dir/foo.gcda pentru fișierul de ieșire specificat ca -o
dir/foo.o).

--acoperire
Această opțiune este utilizată pentru a compila și a lega codul instrumentat pentru analiza acoperirii. The
opțiunea este un sinonim pentru -fprofil-arcuri -ftest-acoperire (la compilare) și -lgcov
(la conectarea). Consultați documentația pentru aceste opțiuni pentru mai multe detalii.

· Compilați fișierele sursă cu -fprofil-arcuri plus optimizare și generare de cod
Opțiuni. Pentru analiza acoperirii testului, utilizați suplimentar -ftest-acoperire opțiune.
Nu trebuie să profilați fiecare fișier sursă dintr-un program.

· Conectați fișierele obiect cu -lgcov or -fprofil-arcuri (cel din urmă implică
fost).

· Rulați programul pe o sarcină de lucru reprezentativă pentru a genera profilul arcului
informație. Acest lucru poate fi repetat de orice număr de ori. Puteți rula simultan
instanțe ale programului dvs. și cu condiția ca sistemul de fișiere să accepte blocarea,
fișierele de date vor fi corect actualizate. De asemenea, sunt detectate apeluri „furcate” și
manipulate corect (nu se va întâmpla dubla numărare).

· Pentru optimizări direcționate pe profil, compilați din nou fișierele sursă cu aceleași
opțiuni de optimizare și generare de cod plus -fbranch-probabilităţi.

· Pentru analiza acoperirii testului, utilizați gcov pentru a produce informații care pot fi citite de om
il .gcno și .gcda fișiere. Consultați gcov documentatie pentru mai departe
informaţii.

Cu -fprofil-arcuri, pentru fiecare funcție a programului dvs. GCC creează un flux de program
grafic, apoi găsește un arbore de acoperire pentru grafic. Doar arcuri care nu sunt pe
spanning tree trebuie instrumentat: compilatorul adaugă cod pentru a număra numărul de
ori când aceste arcuri sunt executate. Când un arc este singura ieșire sau singura intrare în
un bloc, codul de instrumentare poate fi adăugat la bloc; în caz contrar, o nouă bază
blocul trebuie creat pentru a deține codul de instrumentare.

-ftest-acoperire
Produceți un fișier de note pe care gcov utilitarul de acoperire a codului poate folosi pentru a afișa programul
acoperire. Fișierul notă al fiecărui fișier sursă este apelat auxname.gcno. Consultați
-fprofil-arcuri opțiunea de mai sus pentru o descriere a nume auxiliar și instrucțiuni despre cum să
generați date de acoperire a testului. Datele de acoperire se potrivesc mai strâns cu fișierele sursă dacă
nu optimizezi.

-fdbg-cnt-list
Tipăriți numele și limita superioară a contorului pentru toate contoarele de depanare.

-fdbg-cnt=contra-lista-valoare
Setați limita superioară a contorului intern de depanare. contra-lista-valoare este separat prin virgulă
lista nume:valoare perechi care stabilesc limita superioară a fiecărui contor de depanare nume la
valoare. Toate contoarele de depanare au limita superioară inițială a „UINT_MAX”; prin urmare
„dbg_cnt()” returnează întotdeauna adevărat, cu excepția cazului în care limita superioară este stabilită de această opțiune. Pentru
exemplu, cu -fdbg-cnt=dce:10,tail_call:0, „dbg_cnt(dce)” returnează adevărat numai pentru primul
10 invocari.

-fenabil-natură-trece
-fdezactiv-natură-trece=listă-gamă
Acesta este un set de opțiuni care sunt utilizate pentru a dezactiva/activa în mod explicit optimizarea
trece. Aceste opțiuni sunt destinate utilizării pentru depanarea GCC. Utilizatorii compilatorului ar trebui
folosiți opțiunile obișnuite pentru activarea/dezactivarea permiselor.

-fdisable-ipa-trece
Dezactivați permisul IPA trece. trece este numele permisului. Dacă aceeași trecere este static
invocat în compilator de mai multe ori, numele trecerii trebuie adăugat cu a
număr secvenţial începând de la 1.

-fdisable-rtl-trece
-fdisable-rtl-trece=listă-gamă
Dezactivați permisul RTL trece. trece este numele permisului. Dacă aceeași trecere este static
invocat în compilator de mai multe ori, numele trecerii trebuie adăugat cu a
număr secvenţial începând de la 1. listă-gamă este o listă separată prin virgulă de
intervale de funcții sau nume de asamblare. Fiecare interval este o pereche de numere separate prin a
colon. Gama este incluzivă la ambele capete. Dacă intervalul este trivial, numărul
perechea poate fi simplificată ca un singur număr. Dacă funcția apelează nodul grafic
uid se încadrează într-unul dintre intervalele specificate, the trece este dezactivat pentru asta
funcţie. uid este afișat în antetul funcției unui fișier dump și trecerea
numele pot fi aruncate folosind opțiunea -fdump-trece.

-fdisable-tree-trece
-fdisable-tree-trece=listă-gamă
Dezactivează tree pass trece. Vedea -fdisable-rtl pentru descrierea opțiunii
argumente.

-fenable-ipa-trece
Activați permisul IPA trece. trece este numele permisului. Dacă aceeași trecere este static
invocat în compilator de mai multe ori, numele trecerii trebuie adăugat cu a
număr secvenţial începând de la 1.

-fenable-rtl-trece
-fenable-rtl-trece=listă-gamă
Activați permisul RTL trece. Vedea -fdisable-rtl pentru descrierea argumentului de opțiune și
exemple.

-copac-fenable-trece
-copac-fenable-trece=listă-gamă
Activați trecerea arborelui trece. Vedea -fdisable-rtl pentru descrierea argumentelor opțiunii.

Iată câteva exemple care arată utilizările acestor opțiuni.

# dezactivați ccp1 pentru toate funcțiile
-fdisable-tree-ccp1
# dezactivați derulare completă pentru funcția al cărei uid al nodului cgraph este 1
-fenable-tree-cunroll=1
# dezactivați gcse2 pentru funcțiile din următoarele intervale [1,1],
# [300,400] și [400,1000]
# dezactivați gcse2 pentru funcțiile foo și foo2
-fdisable-rtl-gcse2=foo,foo2
# dezactivează introducerea timpurie
-fdisable-tree-einline
# dezactivează ipa inlining
-fdisable-ipa-inline
# activați derularea completă a arborelui
-fenable-tree-unroll

-dlitere
-fdump-rtl-trece
-fdump-rtl-trece=nume de fișier
Spune să facem dumpuri de depanare în timpul compilării la momentele specificate de litere. Acest
este folosit pentru depanarea trecerilor bazate pe RTL ale compilatorului. Numele fișierelor pentru majoritatea
a depozitelor se fac prin adăugarea unui număr de trecere și a unui cuvânt la dumpname, Şi
fișierele sunt create în directorul fișierului de ieșire. In caz de =nume de fișier opțiune,
dump-ul este scos pe fișierul dat în loc de fișierele dump numerotate. Notă
că numărul permisului este calculat static pe măsură ce trecerile sunt înregistrate în permis
administrator. Astfel numerotarea nu este legată de ordinea dinamică de execuție a
trece. În special, o trecere instalată de un plugin ar putea avea un număr peste 200 chiar
dacă s-a executat destul de devreme. dumpname este generat din numele fișierului de ieșire,
dacă este specificat în mod explicit și nu este un executabil, altfel este numele de bază al
fișierul sursă. Aceste comutatoare pot avea efecte diferite atunci când -E este folosit pentru
preprocesare.

Dumpurile de depanare pot fi activate cu a -fdump-rtl comutator sau ceva -d opțiune litere. Aici
sunt literele posibile pentru utilizare în trece și litere, și semnificațiile lor:

-fdump-rtl-alignments
Dump după ce au fost calculate aliniamentele ramurilor.

-fdump-rtl-asmcons
Dumpează după remedierea instrucțiunilor rtl care au constrângeri de intrare/ieșire nesatisfăcute.

-fdump-rtl-auto_inc_dec
Dump după descoperirea auto-inc-dec. Această trecere este rulată numai pe arhitecturi care
au instrucțiuni de auto inc sau auto dec.

-fdump-rtl-bariere
Deversați după curățarea instrucțiunilor de barieră.

-fdump-rtl-bbpart
Dumpează după împărțirea blocurilor de bază calde și reci.

-fdump-rtl-bbro
Dump după reordonarea blocului.

-fdump-rtl-btl1
-fdump-rtl-btl2
-fdump-rtl-btl1 și -fdump-rtl-btl2 permite dumpingul după ținta celor două ramuri
trece de optimizare a încărcăturii.

-fdump-rtl-bypass
Ocolirea dump după salt și controlul optimizărilor fluxului.

-fdump-rtl-combină
Dump după trecerea combinației de instrucțiuni RTL.

-fdump-rtl-compgotos
Dump după duplicarea gotos-urilor calculate.

-fdump-rtl-ce1
-fdump-rtl-ce2
-fdump-rtl-ce3
-fdump-rtl-ce1, -fdump-rtl-ce2, și -fdump-rtl-ce3 permite dumpingul după cele trei
dacă trece conversia.

-fdump-rtl-cprop_hardreg
Dump după propagarea copiei registrului pe hârtie.

-fdump-rtl-csa
Deversați după combinarea ajustărilor stivei.

-fdump-rtl-cse1
-fdump-rtl-cse2
-fdump-rtl-cse1 și -fdump-rtl-cse2 permite dumpingul după cele două comune
eliminarea subexpresiilor trece.

-fdump-rtl-dce
Dumpează după eliminarea codului mort autonom.

-fdump-rtl-dbr
Dump după programarea întârziată a sucursalelor.

-fdump-rtl-dce1
-fdump-rtl-dce2
-fdump-rtl-dce1 și -fdump-rtl-dce2 permite aruncarea după depozitul doi morți
trece de eliminare.

-fdump-rtl-eh
Dumpează după finalizarea codului de manipulare EH.

-fdump-rtl-eh_ranges
Evacuarea după conversia regiunilor din domeniul de manipulare EH.

-fdump-rtl-expand
Dump după generarea RTL.

-fdump-rtl-fwprop1
-fdump-rtl-fwprop2
-fdump-rtl-fwprop1 și -fdump-rtl-fwprop2 permite dumpingul după cele două înainte
propagarea trece.

-fdump-rtl-gcse1
-fdump-rtl-gcse2
-fdump-rtl-gcse1 și -fdump-rtl-gcse2 permite dumpingul după comun global
eliminarea subexpresiilor.

-fdump-rtl-init-regs
Dump după inițializarea registrelor.

-fdump-rtl-initvals
Dump după calculul seturilor de valori inițiale.

-fdump-rtl-into_cfglayout
Dump după convertirea în modul cfglayout.

-fdump-rtl-ira
Dump după alocare de registru iterată.

-fdump-rtl-sări
Dump după optimizarea al doilea salt.

-fdump-rtl-loop2
-fdump-rtl-loop2 permite descărcarea după trecerea optimizării buclei rtl.

-fdump-rtl-mach
Dumpează după efectuarea trecerii de reorganizare dependentă de mașină, dacă aceasta trece
există.

-fdump-rtl-mode_sw
Dumpează după eliminarea comutatoarelor de mod redundante.

-fdump-rtl-rnreg
Dump după renumerotarea registrului.

-fdump-rtl-outof_cfglayout
Dumpează după conversia din modul cfglayout.

-fdump-rtl-peephole2
Dump după trecerea vizorului.

-fdump-rtl-postreload
Dump după optimizările post-reîncărcare.

-fdump-rtl-pro_and_epilogue
Dump după generarea funcției prologuri și epiloguri.

-fdump-rtl-sched1
-fdump-rtl-sched2
-fdump-rtl-sched1 și -fdump-rtl-sched2 permite dumpingul după blocul de bază
programarea permiselor.

-fdump-rtl-ree
Dump după eliminarea semnului/zero extensie.

-fdump-rtl-seqabstr
Dump după descoperirea secvenței comune.

-fdump-rtl-scurta
Deversați după scurtarea ramurilor.

-fdump-rtl-frate
Dump după optimizarea apelurilor de la frați.

-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 și
-fdump-rtl-split5 permite descărcarea după cinci runde de împărțire a instrucțiunilor.

-fdump-rtl-sms
Dump după programarea modulo. Această trecere se rulează doar pe unele arhitecturi.

-fdump-rtl-stack
Dumpează după conversia din registrele „fișierului de registru plat” ale GCC în cele x87
registre de tip stivă. Această trecere se rulează numai pe variante x86.

-fdump-rtl-subreg1
-fdump-rtl-subreg2
-fdump-rtl-subreg1 și -fdump-rtl-subreg2 permite dumpingul după cele două subreg
trece de expansiune.

-fdump-rtl-unshare
Descarcă după ce toate rtl-urile au fost anulate.

-fdump-rtl-vartrack
Dump după urmărirea variabilelor.

-fdump-rtl-vregs
Dump după convertirea registrelor virtuale în registre hard.

-fdump-rtl-web
Dump după împărțirea intervalului în timp real.

-fdump-rtl-regclass
-fdump-rtl-subregs_of_mode_init
-fdump-rtl-subregs_of_mode_finish
-fdump-rtl-dfinit
-fdump-rtl-dfinish
Aceste imagini sunt definite, dar produc întotdeauna fișiere goale.

-in
-fdump-rtl-toate
Produceți toate depozitele enumerate mai sus.

-dA Adnotați rezultatul asamblatorului cu informații diverse de depanare.

-dD Eliminați toate definițiile macro, la sfârșitul preprocesării, în plus față de normal
ieșire.

-dH Produceți un dump de miez ori de câte ori apare o eroare.

-dp Adnotați rezultatul asamblatorului cu un comentariu care indică ce model și
se foloseste alternativa. Lungimea fiecărei instrucțiuni este de asemenea tipărită.

-dP Eliminați RTL în ieșirea asamblatorului ca comentariu înainte de fiecare instrucțiune. De asemenea
se aprinde -dp adnotare.

-dx Doar generați RTL pentru o funcție în loc să o compilați. De obicei folosit cu
-fdump-rtl-expand.

-fdump-noaddr
Când faceți imagini de depanare, suprimați ieșirea adresei. Acest lucru face să fie mai fezabil
utilizați diff pentru depanarea depozitelor pentru invocări ale compilatorului cu diferite binare ale compilatorului
și/sau diferite locații de pornire text / bss / date / heap / stack / dso.

-fdump-nenumerotat
Când faceți depozitări de depanare, suprimați numerele de instrucțiuni și ieșirea adreselor. Acest
face mai fezabilă folosirea diff pe depozitele de depanare pentru invocări ale compilatorului cu
opțiuni diferite, în special cu și fără -g.

-fdump-linkuri-nenumerotate
Când faceți depozitări de depanare (vezi -d opțiunea de mai sus), suprimați numerele de instrucțiuni pentru
link-uri către instrucțiunile anterioare și următoare într-o secvență.

-fdump-unitate-traducere (doar C++)
-fdump-traducere-unitate-Opțiuni (doar C++)
Transferați o reprezentare a structurii arborescente pentru întreaga unitate de traducere într-un fișier.
Numele fișierului se face prin adăugare .tu la numele fișierului sursă, iar fișierul este
creat în același director cu fișierul de ieșire. Dacă -Opțiuni se folosește forma,
Opțiuni controlează detaliile depozitului așa cum este descris pentru -fdump-tree opțiuni.

-fdump-clasă-ierarhie (doar C++)
-fdump-clasă-ierarhie-Opțiuni (doar C++)
Transferați o reprezentare a ierarhiei fiecărei clase și a aspectului tabelului de funcții virtuale la a
fişier. Numele fișierului se face prin adăugare .clasă la numele fișierului sursă și fișierul
este creat în același director cu fișierul de ieșire. Dacă -Opțiuni se folosește forma,
Opțiuni controlează detaliile depozitului așa cum este descris pentru -fdump-tree opțiuni.

-fdump-ipa-comuta
Controlați dumpingul în diferite etape ale arborelui de limbaj de analiză inter-procedurală la a
fişier. Numele fișierului este generat prin adăugarea unui sufix specific comutatorului la sursă
nume de fișier, iar fișierul este creat în același director ca și fișierul de ieșire. The
sunt posibile următoarele depozite:

toate Activează toate depozitele de analiză inter-procedurală.

cgraf
Deversează informații despre optimizarea graficului de apel, eliminarea funcțiilor neutilizate și
luarea deciziilor.

inline
Dump after function inlining.

-fdump-trece
Eliminați lista trecerilor de optimizare care sunt activate și oprite de curent
opțiunile din linia de comandă.

-fdump-statistics-opțiune
Activați și controlați descărcarea statisticilor de trecere într-un fișier separat. Numele fișierului este
generat prin adăugarea unui sufix care se termină în .statistici la numele fișierului sursă și
fișierul este creat în același director cu fișierul de ieșire. Dacă -opțiune forma este
folosit, -statistici face ca contoarele să fie însumate pe întreaga unitate de compilare în timp ce
-Detalii aruncă fiecare eveniment pe măsură ce trecerile le generează. Valoarea implicită fără opțiune este
pentru a suma contoare pentru fiecare funcție compilată.

-fdump-tree-comuta
-fdump-tree-comuta-Opțiuni
-fdump-tree-comuta-Opțiuni=nume de fișier
Controlați descărcarea în diferite etape de procesare a arborelui limbaj intermediar la
un fișier. Numele fișierului este generat prin adăugarea unui sufix specific comutatorului la
numele fișierului sursă, iar fișierul este creat în același director ca și fișierul de ieșire. În
caz de =nume de fișier opțiunea, dump-ul este scos pe fișierul dat în loc de auto
fișiere dump numite. Dacă -Opțiuni se folosește forma, Opțiuni este o listă a - separat
opțiuni care controlează detaliile depozitului. Nu toate opțiunile sunt aplicabile tuturor
haldele; cele care nu au sens sunt ignorate. Următoarele opțiuni sunt disponibile

adresa
Tipăriți adresa fiecărui nod. De obicei, acest lucru nu are sens deoarece se schimbă
conform mediului și fișierului sursă. Utilizarea sa principală este pentru legarea a
fișier dump cu un mediu de depanare.

asmname
Dacă „DECL_ASSEMBLER_NAME” a fost setat pentru o anumită declinare, utilizați-l în dump
în loc de „DECL_NAME”. Utilizarea sa principală este ușurința de utilizare lucrând înapoi de la
nume alterate în fișierul de asamblare.

subţire
Când dumpingul reprezentărilor intermediare front-end, inhibați dumpingul membrilor
un scop sau un corp al unei funcții doar pentru că acel domeniu a fost atins. Numai
aruncați astfel de articole atunci când sunt accesibile direct pe o altă cale.

Când aruncați copaci destul de imprimați, această opțiune inhibă aruncarea cadavrelor
structuri de control.

Când descărcați RTL, imprimați RTL în formă subțire (condensată) în loc de cea implicită
Reprezentare asemănătoare LISP.

crud Tipăriți o reprezentare brută a arborelui. În mod implicit, copacii sunt destul de imprimați
o reprezentare asemănătoare C.

detalii
Activați depozitări mai detaliate (nu sunt onorate de fiecare opțiune de descărcare). Include, de asemenea
informațiile din trecerile de optimizare.

Statistici
Activați descărcarea diferitelor statistici despre permis (nu sunt onorate de fiecare descărcare
opțiune).

blocuri
Activați afișarea limitelor de bază ale blocurilor (dezactivat în depozitele brute).

grafic
Pentru fiecare dintre celelalte fișiere dump indicate (-fdump-rtl-trece), gunoi a
reprezentarea graficului fluxului de control potrivit pentru vizualizare cu GraphViz pentru
fișier.passid.pass.dot. Fiecare funcție din fișier este destul de tipărită ca subgraf,
astfel încât GraphViz să le poată reda pe toate într-o singură parcelă.

Această opțiune funcționează în prezent numai pentru depozitele RTL, iar RTL este întotdeauna aruncat
formă subțire.

vops
Activați afișarea operanzilor virtuali pentru fiecare instrucțiune.

lineno
Activați afișarea numerelor de rând pentru instrucțiuni.

uid Activați afișarea ID-ului unic ("DECL_UID") pentru fiecare variabilă.

prolix
Activați afișarea arborelui dump pentru fiecare instrucțiune.

eh Activați afișarea numărului regiunii EH care conține fiecare declarație.

scev
Activați afișarea detaliilor analizei evoluției scalare.

optimizate
Activați afișarea informațiilor de optimizare (disponibil numai în anumite treceri).

ratat
Activați afișarea informațiilor de optimizare ratate (disponibilă numai pentru anumite treceri).

notiţe
Activați alte informații detaliate de optimizare (disponibile doar în anumite treceri).

=nume de fișier
În loc de un fișier dump cu nume automat, ieșiți în numele fișierului dat. Fișierul
nume stdout și stderr sunt tratate special și sunt considerate deja deschise
fluxuri standard. De exemplu,

gcc -O2 -ftree-vectorize -fdump-tree-vect-blocks=foo.dump
-fdump-tree-pre=stderr file.c

scoate vectorizatorul de descărcare în foo.dump, în timp ce dump-ul PRE este scos la stderr.
Dacă sunt date două nume de fișiere de descărcare în conflict pentru aceeași trecere, atunci aceasta din urmă
opțiunea o înlocuiește pe cea anterioară.

toate Activați toate opțiunile, cu excepția crud, subţire, prolix și lineno.

optall
Activați toate opțiunile de optimizare, adică optimizate, ratat, și nota.

Sunt posibile următoarele halde:

original
Dump înainte de orice optimizare bazată pe arbore, la dosar.original.

optimizate
Dump după toate optimizarea bazată pe arbore, la fişier.optimizat.

gimple
Eliminați fiecare funcție înainte și după trecerea de gimplificare într-un fișier. Fișierul
denumirea se face prin anexare .gimple la numele fișierului sursă.

cFG Transferați graficul fluxului de control al fiecărei funcție într-un fișier. Numele fișierului este făcut de
alăturarea .CFG la numele fișierului sursă.

ch Eliminați fiecare funcție după copierea antetelor buclei. Numele fișierului se face prin adăugare
.ch la numele fișierului sursă.

ssa Transferați informațiile legate de SSA într-un fișier. Numele fișierului se face prin adăugare .ssa
la numele fișierului sursă.

alias
Descarcă informațiile de aliasing pentru fiecare funcție. Numele fișierului se face prin adăugare
.alias la numele fișierului sursă.

ccp Eliminați fiecare funcție după CCP. Numele fișierului se face prin adăugare .ccp la
numele fișierului sursă.

storeccp
Eliminați fiecare funcție după STORE-CCP. Numele fișierului se face prin adăugare .storeccp
la numele fișierului sursă.

pre Aruncați copacii după eliminarea parțială a redundanței. Numele fișierului este făcut de
alăturarea .pre la numele fișierului sursă.

Frecvență Aruncați copacii după eliminarea completă a redundanței. Numele fișierului se face prin adăugare
.fre la numele fișierului sursă.

copyprop
Arbori copacii după propagarea copiei. Numele fișierului se face prin adăugare .copyprop
la numele fișierului sursă.

store_copyprop
Aruncați copacii după reproducerea în depozit. Numele fișierului se face prin adăugare
.store_copyprop la numele fișierului sursă.

dce Eliminați fiecare funcție după eliminarea codului mort. Numele fișierului este făcut de
alăturarea .dce la numele fișierului sursă.

Domnul Doamna Eliminați fiecare funcție după efectuarea înlocuirii scalare a agregatelor. Fișierul
denumirea se face prin anexare .sra la numele fișierului sursă.

chiuvetă
Eliminați fiecare funcție după efectuarea codului de scufundare. Numele fișierului este făcut de
alăturarea .chiuvetă la numele fișierului sursă.

cadou Eliminați fiecare funcție după aplicarea optimizărilor arborelui dominator. Numele fișierului este
realizat prin anexare .dom la numele fișierului sursă.

Spune Eliminați fiecare funcție după aplicarea eliminării depozitului mort. Numele fișierului este făcut
prin anexare .dse la numele fișierului sursă.

phiopt
Eliminați fiecare funcție după optimizarea nodurilor PHI în cod liniar. Fișierul
denumirea se face prin anexare .phiopt la numele fișierului sursă.

forwprop
Eliminați fiecare funcție după propagarea directă a variabilelor de unică folosință. Numele fișierului
se face prin anexare .forwprop la numele fișierului sursă.

copyrename
Eliminați fiecare funcție după aplicarea optimizării pentru redenumirea copiei. Numele fișierului este
realizat prin anexare .copyrenume la numele fișierului sursă.

nrv Eliminați fiecare funcție după aplicarea optimizării valorii returnate numite pe generic
copaci. Numele fișierului se face prin adăugare .nrv la numele fișierului sursă.

vector
Eliminați fiecare funcție după aplicarea vectorizării buclelor. Numele fișierului este făcut
prin anexare .vect la numele fișierului sursă.

SLP Eliminați fiecare funcție după aplicarea vectorizării blocurilor de bază. Numele fișierului este
realizat prin anexare .slp la numele fișierului sursă.

VRP Eliminați fiecare funcție după propagarea intervalului de valori (VRP). Numele fișierului este făcut de
alăturarea .vrp la numele fișierului sursă.

toate Activați toate depozitele de arbore disponibile cu steagurile furnizate în această opțiune.

-fopt-info
-fopt-info-Opțiuni
-fopt-info-Opțiuni=nume de fișier
Controlează depozitele de optimizare din diferite treceri de optimizare. Dacă -Opțiuni forma este
folosit, Opțiuni este o listă a - opțiuni separate pentru a selecta detaliile de descărcare și
optimizări. Dacă Opțiuni nu este specificat, este implicit optimizate pentru detalii si
optall pentru grupuri de optimizare. Dacă nume de fișier nu este specificat, este implicit
stderr. Rețineți că ieșirea nume de fișier va fi suprascris în caz de multiplu
unități de traducere. Dacă se dorește o ieșire combinată din mai multe unități de traducere,
stderr ar trebui folosit în schimb.

Opțiunile pot fi împărțite în două grupuri, 1) opțiuni care descriu verbozitatea
dump și 2) opțiuni care descriu ce optimizări ar trebui incluse. Opțiunile
din ambele grupuri pot fi amestecate liber deoarece nu se suprapun. Totuși, în caz
din orice conflicte, ultimele opțiuni înlocuiesc opțiunile anterioare din linia de comandă.
Deși sunt acceptate mai multe opțiuni -fopt-info, doar una dintre ele poate avea =nume fișier.
Dacă sunt furnizate alte nume de fișiere, atunci toate, cu excepția primei, sunt ignorate.

Verbozitatea de descărcare are următoarele opțiuni

optimizate
Imprimați informații atunci când o optimizare este aplicată cu succes. Depinde de o trecere
pentru a decide care informații sunt relevante. De exemplu, vectorizatorul trece prin imprimare
locația sursă a buclelor care au fost vectorizate cu succes.

ratat
Imprimați informații despre optimizările ratate. Controlul trecerilor individuale care
informații de inclus în rezultat. De exemplu,

gcc -O2 -ftree-vectorize -fopt-info-vec-ratat

va imprima informații despre oportunitățile ratate de optimizare din vectorizare
trece pe stderr.

nota
Tipăriți informații detaliate despre optimizări, cum ar fi anumite transformări,
mesaje mai detaliate despre decizii etc.

toate Imprimați informații detaliate de optimizare. Aceasta include optimizate, ratat, și
nota.

Al doilea set de opțiuni descrie un grup de optimizări și poate include una sau
mai multe dintre următoarele.

ipa Activați depozitele de la toate optimizările interprocedurale.

buclă
Activați imaginile de la toate optimizările buclei.

inline
Activați depozitele de la toate optimizările inline.

vec Activați depozitele din toate optimizările de vectorizare.

optall
Activați depozitele de la toate optimizările. Acesta este un superset al grupurilor de optimizare
listat mai sus.

De exemplu,

gcc -O3 -fopt-info-missed=ratat.toate

iese raport de optimizare ratat de la toate trecerile în ratat.toate.

Ca un alt exemplu,

gcc -O3 -fopt-info-inline-optimized-missed=inline.txt

va afișa informații despre optimizări ratate, precum și locații optimizate din
toată inlinierea trece în inline.txt.

În cazul în care nume de fișier este furnizat, apoi depozitele de la toate optimizările aplicabile sunt
concatenat în nume de fișier. În caz contrar, descărcarea este trimisă stderr. Dacă Opțiuni
este omis, este implicit total optal, ceea ce înseamnă să eliminați toate optimizările disponibile
informații din toate trecerile. În exemplul următor, toate informațiile de optimizare sunt afișate
la stderr.

gcc -O3 -fopt-info

Rețineți că -fopt-info-vec-ratat se comportă la fel ca -fopt-info-ratat-vec.

Ca un alt exemplu, luați în considerare

gcc -fopt-info-vec-missed=vec.miss -fopt-info-loop-optimized=loop.opt

Aici cele două nume de fișiere de ieșire vec.domn și buclă.opt sunt în conflict din moment ce doar unul
fișierul de ieșire este permis. În acest caz, doar prima opțiune are efect și
opțiunile ulterioare sunt ignorate. Astfel doar cel vec.domn se produce care contine
aruncări din vectorizator despre oportunități ratate.

-frandom-seed=şir
Această opțiune oferă o sămânță pe care GCC o folosește în loc de numere aleatorii la generare
anumite nume de simbol care trebuie să fie diferite în fiecare fișier compilat. Este, de asemenea
folosit pentru a plasa ștampile unice în fișierele de date de acoperire și fișierele obiect care le produc
lor. Puteți folosi -sămânță-frandom opțiunea de a produce un obiect identic reproductibil
fișiere.

şir ar trebui să fie diferit pentru fiecare fișier pe care îl compilați.

-fsched-verbose=n
Pe ținte care utilizează programarea instrucțiunilor, această opțiune controlează cantitatea de
ieșirea de depanare pe care planificatorul o imprimă. Aceste informații sunt scrise în eroare standard,
dacă nu -fdump-rtl-sched1 or -fdump-rtl-sched2 este specificat, caz în care este scos
la fișierul obișnuit cu listare de descărcare, .sched1 or .sched2 respectiv. Cu toate acestea pentru n
mai mare de nouă, rezultatul este întotdeauna tipărit la eroare standard.

Pentru n mai mare decat zero, -fsched-verbose scoate aceleași informații ca
-fdump-rtl-sched1 și -fdump-rtl-sched2. Pentru n mai mare de unu, iese și de bază
probabilități de blocare, informații detaliate despre lista gata și informații despre unitate/insn. Pentru n
mai mare de două, include RTL la punctul de anulare, flux de control și informații despre regiuni. Și
pentru n peste patru, -fsched-verbose include, de asemenea, informații despre dependență.

-save-temps
-save-temps=cwd
Stocați în permanență fișierele intermediare obișnuite „provizorii”; plasează-le în curent
director și numiți-le pe baza fișierului sursă. Astfel, compilarea foo.c cu -c
-save-temps produce fișiere foo.i și foo.s, precum și foo.o. Acest lucru creează un
preprocesate foo.i fișier de ieșire chiar dacă compilatorul utilizează acum în mod normal un
preprocesor integrat.

Când este utilizat în combinație cu -x opțiune de linie de comandă, -save-temps este sensibil
suficient pentru a evita suprascrierea unui fișier sursă de intrare cu aceeași extensie ca și un
dosar intermediar. Fișierul intermediar corespunzător poate fi obținut prin redenumire
fișierul sursă înainte de utilizare -save-temps.

Dacă invocați GCC în paralel, compilați mai multe fișiere sursă diferite care partajează a
nume de bază comun în diferite subdirectoare sau același fișier sursă compilat pentru
destinații de ieșire multiple, este probabil ca diferitele compilatoare paralele să o facă
interferează unul cu celălalt și suprascrie fișierele temporare. De exemplu:

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

poate duce la foo.i și foo.o fiind scrise simultan de ambii compilatori.

-save-temps=obj
Stocați în mod permanent fișierele intermediare obișnuite „provizorii”. Dacă -o este folosită opțiunea,
fișierele temporare se bazează pe fișierul obiect. Dacă -o opțiunea nu este utilizată,
-save-temps=obj comutatorul se comportă ca -save-temps.

De exemplu:

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

creează foo.i, foo.s, dir/xbar.i, dir/xbar.s, dir2/yfoobar.i, dir2/yfoobar.s, și
dir2/yfoobar.o.

-timp[=fişier]
Raportați timpul CPU luat de fiecare subproces din secvența de compilare. Pentru C
fișierele sursă, acesta este compilatorul propriu-zis și asamblatorul (plus linkerul dacă linkul este
Terminat).

Fără specificarea unui fișier de ieșire, rezultatul arată astfel:

# cc1 0.12 0.01
# ca 0.00 0.01

Primul număr de pe fiecare linie este „timpul utilizatorului”, adică timpul petrecut executând
programul în sine. Al doilea număr este „timpul sistemului”, timpul petrecut pentru execuție
rutine de sistem în numele programului. Ambele numere sunt în secunde.

Cu specificarea unui fișier de ieșire, rezultatul este atașat la fișierul numit,
si arata cam asa:

0.12 0.01 cc1
0.00 0.01 ca

„Ora utilizatorului” și „ora sistemului” sunt mutate înaintea numelui programului și
sunt afișate opțiunile transmise programului, astfel încât se poate spune ulterior ce fișier a fost
în curs de compilare și cu ce opțiuni.

-fvar-urmărire
Rulați trecerea de urmărire variabilă. Acesta calculează unde sunt stocate variabilele la fiecare poziție
în cod. Apoi sunt generate informații de depanare mai bune (dacă informațiile de depanare
formatul acceptă aceste informații).

Este activat implicit la compilarea cu optimizare (-Os, -O, -O2, ...),
informații de depanare (-g) și formatul de informații de depanare îl acceptă.

-fvar-tracking-assignments
Adnotați atribuirile variabilelor utilizatorului la începutul compilării și încercați să le efectuați
adnotările de-a lungul întregii compilații până la sfârșit, într-o încercare
pentru a îmbunătăți informațiile de depanare în timp ce se optimizează. Utilizarea de -gdwarf-4 este recomandat împreună
cu ea.

Poate fi activat chiar dacă urmărirea var. este dezactivată, caz în care adnotările sunt
creat și întreținut, dar aruncat la sfârșit.

-fvar-tracking-assignments-toggle
Comuta -fvar-tracking-assignments, în același mod în care -gtoggle Comuta -g.

-print-file-name=bibliotecă
Tipăriți numele absolut complet al fișierului bibliotecă bibliotecă care ar fi folosit când
legarea --- și nu faceți nimic altceva. Cu această opțiune, GCC nu se compilează și nu se conectează
orice; imprimă doar numele fișierului.

-print-multi-director
Tipăriți numele directorului corespunzător bibliotecii multiple selectate de orice alte comutatoare
prezent în linia de comandă. Acest director ar trebui să existe în GCC_EXEC_PREFIX.

-print-multi-lib
Imprimați maparea de la nume de directoare multilib la comutatoarele compilatorului care le activează.
Numele directorului este separat de comutatoare prin ;, iar fiecare comutator începe cu un
@ în loc de -, fără spații între mai multe comutatoare. Asta ar trebui
ușurează procesarea shell-ului.

-print-multi-os-director
Tipăriți calea către bibliotecile OS pentru multilib selectat, în raport cu unele lib
subdirectorul. Dacă bibliotecile OS sunt prezente în lib subdirector și fără multilibs
sunt folosite, aceasta este de obicei doar ., dacă bibliotecile OS sunt prezente în sufixul lib frate
directoarele pe care le tipăresc de ex ../lib64, ../ lib or ../lib32, sau dacă bibliotecile OS sunt
prezent în lib/subdir subdirectoarele pe care le imprimă de ex amd64, sparcv9 or ev6.

-print-multiarh
Tipăriți calea către bibliotecile OS pentru multiarch selectat, în raport cu unele lib
subdirector.

-print-prog-name=program
Aprecieri -print-file-name, dar caută un program precum cpp.

-print-libgcc-file-name
La fel ca -print-file-name=libgcc.a.

Acest lucru este util atunci când utilizați -nostdlib or -nodefaultlibs dar vrei să faci legătura cu
libgcc.a. Poti sa faci:

gcc -nostdlib ... `gcc -print-libgcc-file-name`

-print-search-dirs
Tipăriți numele directorului de instalare configurat și o listă de programe și
directoarele bibliotecii gcc caută --- și nu face nimic altceva.

Acest lucru este util atunci când gcc imprimă mesajul de eroare instalare problema nu poti Exec
cpp0: Nu astfel de fişier or director. Pentru a rezolva acest lucru trebuie fie să puneți cpp0 si
alte componente ale compilatorului unde gcc se așteaptă să le găsească, sau puteți seta
variabilă de mediu GCC_EXEC_PREFIX în directorul în care le-ați instalat. Nu
uita de urma /.

-print-sysroot
Imprimați directorul sysroot țintă care este utilizat în timpul compilării. Acesta este
țintă sysroot specificat fie la momentul configurării, fie folosind --sysroot opțiune,
eventual cu un sufix suplimentar care depinde de opțiunile de compilare. Dacă nu țintă
sysroot este specificat, opțiunea nu imprimă nimic.

-print-sysroot-headers-sufix
Imprimați sufixul adăugat la rădăcina sistem țintă când căutați antete sau dați un
eroare dacă compilatorul nu este configurat cu un astfel de sufix --- și nu faceți nimic
altceva.

-basculantă
Imprimați mașina țintă a compilatorului (de exemplu, i686-pc-linux-gnu)---și nu faceți
altceva.

-versiunea de gunoi
Tipăriți versiunea compilatorului (de exemplu, 3.0)---si nu face nimic altceva.

-specii de gunoi
Tipăriți specificațiile încorporate ale compilatorului --- și nu faceți nimic altceva. (Acest lucru este folosit când
GCC în sine este în curs de construire.)

-fno-elimină-tipurile-de-depanare-neutilizate
În mod normal, atunci când produce ieșire DWARF 2, GCC evită producerea de ieșire simbol de depanare pentru
tipuri care nu sunt folosite nicăieri în fișierul sursă care este compilat. Uneori este util
pentru ca GCC să emită informații de depanare pentru toate tipurile declarate într-o unitate de compilare,
indiferent dacă sunt sau nu folosite efectiv în acea unitate de compilare, pt
exemplu dacă, în depanator, doriți să turnați o valoare într-un tip care nu este de fapt
folosit în programul dvs. (dar este declarat). Mai des, însă, acest lucru are ca rezultat a
cantitate semnificativă de spațiu irosit.

Opţiuni Controlul Optimizare
Aceste opțiuni controlează diferite tipuri de optimizări.

Fără nicio opțiune de optimizare, scopul compilatorului este de a reduce costul compilării
și pentru a face ca depanarea să producă rezultatele așteptate. Declarațiile sunt independente: dacă tu
opriți programul cu un punct de întrerupere între instrucțiuni, apoi îi puteți atribui o nouă valoare
orice variabilă sau schimbați contorul programului cu orice altă instrucțiune din funcție și obțineți
exact rezultatele pe care le așteptați de la codul sursă.

Activarea steagurilor de optimizare face ca compilatorul să încerce să îmbunătățească performanța și/sau
dimensiunea codului în detrimentul timpului de compilare și, eventual, capacitatea de a depana
programul.

Compilatorul realizează optimizarea pe baza cunoștințelor pe care le are despre program.
Compilarea mai multor fișiere simultan într-un singur mod de fișier de ieșire permite compilatorului să utilizeze
informațiile obținute din toate fișierele la compilarea fiecăruia dintre ele.

Nu toate optimizările sunt controlate direct de un steag. Doar optimizările care au un
steag sunt listate în această secțiune.

Majoritatea optimizărilor sunt activate numai dacă an -O nivelul este setat pe linia de comandă. In caz contrar
sunt dezactivate, chiar dacă sunt specificate steaguri de optimizare individuale.

În funcție de țintă și de modul în care a fost configurat GCC, un set ușor diferit de
optimizările pot fi activate la fiecare -O nivel decât cele enumerate aici. Puteți invoca GCC
cu -Q --help=optimizatori pentru a afla setul exact de optimizări care sunt activate la
fiecare nivel.

-O
-O1 Optimizați. Optimizarea compilației necesită ceva mai mult timp și mult mai multă memorie pentru
o funcție mare.

Cu -O, compilatorul încearcă să reducă dimensiunea codului și timpul de execuție, fără a efectua
orice optimizări care necesită mult timp de compilare.

-O activează următoarele steaguri de optimizare:

-fauto-inc-dec -fcompare-elim -fcprop-registre -fdce -fdefer-pop -framură-întârziată
-fdse -fguess-ramură-probabilitate -cinci-conversie2 -cinci-conversie -fipa-pură-const
-fipa-profil -fipa-referință -fmerge-constante -fsplit-wide-types -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -fttree-ch -fttree-copyrename -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -fttree-phiprop -ftree-slsr
-ftree-sra -fttree-pta -ftree-ter -funit-la-o dată

-O se aprinde de asemenea -fomit-cadru-pointer pe mașinile unde acest lucru nu interferează
cu depanare.

-O2 Optimizați și mai mult. GCC realizează aproape toate optimizările acceptate care nu le fac
implică un compromis spațiu-viteză. În comparație cu -O, această opțiune le mărește pe ambele
timpul de compilare și performanța codului generat.

-O2 activează toate steaguri de optimizare specificate de -O. De asemenea, activează următoarele
steaguri de optimizare: -fthread-sărituri -falign-funcții -falign-sărituri -falign-bucle
-falign-etichete -fcaller-salvează -fcrossjumping -fcse-urmare-sărituri -fcse-skip-blocks
-fdelete-null-pointer-checks -fdevirtualizați -fdevirtualizare-speculativ
-optimizări scumpe -fgcse -fgcse-lm -fhoist-încărcături-adiacente
-finline-funcții-mici -findirect-inlining -fipa-sra
-fizolare-cai-eronate-dereferinta -foptimize-frate-apeluri -fpartial-inlining
-fpeehole2 -blocuri-freorder -funcții-freorder -frerun-cse-după-buclă
-fsched-interblock -fsched-spec -fschedule-insns -fschedule-insns2 -fstrict-aliasing
-fstrict-overflow -ftree-switch-conversie -fttree-tail-merge -fttree-pre -ftree-vrp

Vă rugăm să rețineți avertismentul de mai jos -fgcse despre invocare -O2 pe programele care folosesc calculator
mergi la S.

NOTĂ: În Ubuntu 8.10 și versiunile ulterioare, -D_FORTIFY_SOURCE=2 este setat implicit și este
activat când -O este setat la 2 sau mai mare. Acest lucru permite timp de compilare suplimentar și
verificări în timpul rulării pentru mai multe funcții libc. Pentru a dezactiva, specificați oricare
-U_FORTIFY_SOURCE or -D_FORTIFY_SOURCE=0.

-O3 Optimizați încă mai mult. -O3 activează toate optimizările specificate de -O2 și, de asemenea, se aprinde
il -funcții-finline, -funswitch-bucle, -fpredictiv-comuning, -fgcse-după-reîncărcare,
-ftree-loop-vectorize, -ftree-slp-vectoriza, -modelul-cost-fvect, -fttree-partial-pre și
-fipa-cp-clona opțiuni.

-O0 Reduceți timpul de compilare și faceți ca depanarea să producă rezultatele așteptate. Acesta este
Mod implicit.

-Os Optimizați pentru dimensiune. -Os permite tuturor -O2 optimizări care de obicei nu cresc
dimensiunea codului. De asemenea, efectuează optimizări suplimentare menite să reducă dimensiunea codului.

-Os dezactivează următoarele steaguri de optimizare: -falign-funcții -falign-sărituri
-falign-bucle -falign-etichete -blocuri-freorder -freorder-blocuri-și-partiție
-fprefetch-loop-arrays

-De repede
Ignorați respectarea strictă a standardelor. -De repede permite tuturor -O3 optimizări. De asemenea
permite optimizări care nu sunt valabile pentru toate programele conforme cu standardele. Aceasta
se aprinde -ffast-matematică și specificul Fortran -fno-protect-parents și -fstack-arrays.

-Og Optimizați experiența de depanare. -Og permite optimizări care nu interferează cu
depanare. Ar trebui să fie nivelul de optimizare ales pentru editarea standard.
ciclu de compilare-depanare, oferind un nivel rezonabil de optimizare în timp ce se menține
compilare rapidă și o experiență bună de depanare.

Dacă utilizați mai multe -O opțiuni, cu sau fără numere de nivel, ultima astfel de opțiune este
cel care este eficient.

Opțiuni ale formularului -fpavilion specificați steaguri independente de mașină. Majoritatea steagurilor au ambele
forme pozitive și negative; forma negativă a -ffoo is -fno-foo. În tabelul de mai jos,
doar una dintre forme este listată --- cea pe care o utilizați de obicei. Îți poți da seama de celălalt
formează fie prin eliminare nO- sau adăugându-l.

Următoarele opțiuni controlează optimizări specifice. Ele sunt fie activate de -O
opțiuni sau sunt legate de cele care sunt. Puteți folosi următoarele steaguri în rare
cazurile în care se dorește „ajustarea fină” a optimizărilor de efectuat.

-fno-defer-pop
Introduceți întotdeauna argumentele pentru fiecare apel de funcție de îndată ce acea funcție revine. Pentru
mașinile care trebuie să apară argumente după un apel de funcție, compilatorul permite în mod normal
argumentele se acumulează pe stivă pentru mai multe apeluri de funcții și le afișează pe toate
o singura data.

Dezactivat la niveluri -O, -O2, -O3, -Os.

-înainte-propagă
Efectuați o trecere de propagare înainte pe RTL. Permisul încearcă să combine două instrucțiuni
și verifică dacă rezultatul poate fi simplificat. Dacă derularea buclei este activă, două treceri
sunt efectuate și al doilea este programat după derularea buclei.

Această opțiune este activată implicit la nivelurile de optimizare -O, -O2, -O3, -Os.

-ffp-contract=stil
-ffp-contract=off dezactivează contracția expresiei în virgulă mobilă. -ffp-contract=rapid
permite contracția expresiei în virgulă mobilă, cum ar fi formarea de multiplicare-adunare fuzionată
operațiuni dacă ținta are suport nativ pentru acestea. -ffp-contract=on permite
contracția expresiei în virgulă mobilă dacă este permisă de standardul de limbaj. Aceasta este
momentan neimplementat și tratat egal cu -ffp-contract=off.

Valoarea implicită este -ffp-contract=rapid.

-fomit-cadru-pointer
Nu păstrați indicatorul de cadru într-un registru pentru funcțiile care nu au nevoie de unul. Acest
evită instrucțiunile de salvare, configurare și restaurare a indicatorilor de cadru; face de asemenea o
registru suplimentar disponibil în multe funcții. It de asemenea face depanare imposibil on
unele Mașini.

Pe unele mașini, cum ar fi VAX, acest steag nu are efect, deoarece standardul
secvența de apeluri tratează automat indicatorul de cadru și nimic nu este salvat de
prefăcându-se că nu există. Macrocomanda descriere a mașinii „FRAME_POINTER_REQUIRED”
controlează dacă o mașină țintă acceptă acest indicator.

Începând cu versiunea GCC 4.6, setarea implicită (când nu se optimizează pentru dimensiune) pentru
Țintele GNU/Linux x32 pe 86 de biți și Darwin x32 pe 86 de biți au fost modificate în
-fomit-cadru-pointer. Se poate reveni la valoarea implicită -fno-omite-cadru-pointer by
configurarea GCC cu --enable-frame-pointer opțiunea de configurare.

Activat la niveluri -O, -O2, -O3, -Os.

-foptimize-frate-apeluri
Optimizați apelurile recursive între frați și coadă.

Activat la niveluri -O2, -O3, -Os.

-fno-inline
Nu extindeți nicio funcție în linie în afară de cele marcate cu „always_inline”
atribut. Aceasta este valoarea implicită când nu se optimizează.

Funcțiile individuale pot fi scutite de la inline prin marcarea lor cu „noinline”
atribut.

-finline-funcții-mici
Integrați funcții în apelanții lor atunci când corpul lor este mai mic decât se aștepta
codul de apelare a funcției (deci dimensiunea totală a programului devine mai mică). Compilatorul
decide euristic care funcții sunt suficient de simple pentru a merita să fie integrate
Pe aici. Această inline se aplică tuturor funcțiilor, chiar și celor care nu sunt declarate inline.

Activat la nivel -O2.

-findirect-inlining
Inline, de asemenea, apeluri indirecte care sunt descoperite a fi cunoscute în timpul compilării datorită
alinierea anterioară. Această opțiune are efect numai atunci când inlining-ul în sine este activat
langa -funcții-finline or -finline-funcții-mici opțiuni.

Activat la nivel -O2.

-funcții-finline
Luați în considerare toate funcțiile pentru inline, chiar dacă nu sunt declarate inline. The
compilatorul decide euristic ce funcții merită să fie integrate în acest fel.

Dacă toate apelurile la o anumită funcție sunt integrate, iar funcția este declarată
„static”, atunci funcția nu este scoasă în mod normal ca cod de asamblare în sine.

Activat la nivel -O3.

-funcții-finline-numite-o dată
Luați în considerare toate funcțiile „statice” numite o singură dată pentru a fi introduse în apelantul lor, chiar dacă
nu sunt marcate „inline”. Dacă este integrat un apel către o anumită funcție, atunci
funcția nu este scoasă ca cod de asamblare în sine.

Activat la niveluri -O1, -O2, -O3 și -Os.

-înspăimântător
Funcții inline marcate cu „always_inline” și funcții al căror corp pare mai mic decât
apelul de funcție devreme înainte de a face -fprofile-generate instrumentare şi
pasă de inline reală. Procedând astfel, profilarea este semnificativ mai ieftină și de obicei
alinierea mai rapidă a programelor care au lanțuri mari de funcții de wrapper imbricate.

Activat în mod implicit.

-fipa-sra
Efectuați înlocuirea scalară interprocedurală a agregatelor, eliminarea parametrilor neutilizați
și înlocuirea parametrilor trecuți prin referință cu parametrii trecuți prin valoare.

Activat la niveluri -O2, -O3 și -Os.

-finline-limit=n
În mod implicit, GCC limitează dimensiunea funcțiilor care pot fi integrate. Acest steag permite
control grosier al acestei limite. n este dimensiunea funcțiilor în care pot fi introduse
numărul de pseudo instrucțiuni.

Inlinierea este de fapt controlată de o serie de parametri, care pot fi specificați
individual prin utilizarea --param nume=valoare. -finline-limit=n opțiunea setează unele dintre
acești parametri după cum urmează:

max-inline-insns-single
este setat la n/ 2.

max-inline-insns-auto
este setat la n/ 2.

Vedeți mai jos pentru o documentație a parametrilor individuali care controlează inlining și
pentru valorile implicite ale acestor parametri.

Notă: s-ar putea să nu existe valoare pentru -finline-limit care are ca rezultat un comportament implicit.

Notă: pseudo-instrucțiunea reprezintă, în acest context particular, un abstract
măsurarea dimensiunii funcției. În niciun caz nu reprezintă un număr de asamblare
instrucțiuni și, ca atare, sensul său exact s-ar putea schimba de la o ediție la alta
altul.

-fno-keep-inline-dllexport
Aceasta este o versiune mai fină a -fkeep-inline-functions, care se aplică numai la
funcțiile care sunt declarate folosind atributul „dllexport” sau declspec

-fkeep-inline-functions
În C, emite funcții „statice” care sunt declarate „inline” în fișierul obiect, chiar dacă
funcția a fost integrată în toți cei care apelează. Acest comutator nu afectează
funcții folosind extensia „extern inline” din GNU C90. În C++, emite orice
funcții inline în fișierul obiect.

-fkeep-static-const
Emiteți variabile declarate „static const” atunci când optimizarea nu este activată, chiar dacă
variabilele nu sunt referite.

GCC activează această opțiune în mod implicit. Dacă doriți să forțați compilatorul să verifice dacă a
variabila este referită, indiferent dacă optimizarea este activată sau nu, utilizați
il -fno-keep-static-const opțiune.

-fmerge-constante
Încercați să îmbinați constante identice (constante șir și constante în virgulă mobilă)
între unitățile de compilare.

Această opțiune este implicită pentru compilarea optimizată în cazul asamblatorului și linkerului
susține-l. Utilizare -fno-merge-constante pentru a inhiba acest comportament.

Activat la niveluri -O, -O2, -O3, -Os.

-fmerge-toate-constantele
Încercați să îmbinați constante identice și variabile identice.

Această opțiune implică -fmerge-constante. Pe lângă -fmerge-constante acest
ia în considerare de exemplu chiar și tablouri constante inițializate sau variabile constante inițializate cu
tipuri integrale sau în virgulă mobilă. Limbaje precum C sau C++ necesită fiecare variabilă,
incluzând mai multe instanțe ale aceleiași variabile în apelurile recursive, pentru a avea distinct
locații, astfel încât utilizarea acestei opțiuni are ca rezultat un comportament neconform.

-fmodulo-sched
Efectuați programarea swing modulo imediat înainte de prima trecere de programare. Acest
pass se uită la cele mai interioare bucle și își reordonează instrucțiunile prin suprapunerea diferită
iterații.

-fmodulo-sched-allow-regmoves
Efectuați o programare modulo mai agresivă bazată pe SMS, cu mișcări de registru permise. De
setarea acestui flag anumite margini antidependențe sunt șterse, ceea ce declanșează
generarea de reg-mișcări pe baza analizei intervalului de viață. Această opțiune este eficientă
doar cu -fmodulo-sched activat.

-fno-ramură-număr-reg
Nu folosiți instrucțiunile „decreștere și ramificare” pe un registru de numărare, ci în schimb
generează o secvență de instrucțiuni care decrementează un registru, compară-l cu acesta
zero, apoi ramificație pe baza rezultatului. Această opțiune are sens numai pe
arhitecturi care suportă astfel de instrucțiuni, care includ x86, PowerPC, IA-64 și
S/390.

Valoarea implicită este -fbranch-count-reg.

-fno-funcție-cse
Nu introduceți adrese de funcții în registre; face fiecare instrucțiune care apelează a
funcția constantă conține adresa funcției în mod explicit.

Această opțiune are ca rezultat un cod mai puțin eficient, dar unele hack-uri ciudate care modifică
Ieșirea asamblatorului poate fi confuză de optimizările efectuate atunci când această opțiune este
nefolosit.

Valoarea implicită este -funcție-cse

-fno-zero-inițializat-în-bss
Dacă ținta acceptă o secțiune BSS, GCC pune implicit variabile care sunt
inițializat la zero în BSS. Acest lucru poate economisi spațiu în codul rezultat.

Această opțiune dezactivează acest comportament deoarece unele programe se bazează în mod explicit pe variabile
mergând la secțiunea de date --- de exemplu, astfel încât executabilul rezultat să poată găsi
începutul acelei secțiuni și/sau să facă ipoteze pe baza acesteia.

Valoarea implicită este -fzero-initializat-in-bss.

-fthread-sărituri
Efectuați optimizări care verifică pentru a vedea dacă un salt se ramifică într-o locație în care alta
se găseşte comparaţie subsumată primului. Dacă da, prima ramură este redirecționată către
fie destinația celei de-a doua ramuri, fie un punct imediat după ea,
în funcție de faptul dacă se știe că condiția este adevărată sau falsă.

Activat la niveluri -O2, -O3, -Os.

-fsplit-wide-types
Când utilizați un tip care ocupă mai multe registre, cum ar fi „long long” pe 32 de biți
sistem, împărțiți registrele și alocați-le independent. Asta in mod normal
generează cod mai bun pentru aceste tipuri, dar poate face depanarea mai dificilă.

Activat la niveluri -O, -O2, -O3, -Os.

-fcse-urmare-sărituri
În eliminarea subexpresiilor comune (CSE), scanați instrucțiunile de salt atunci când
ținta săriturii nu este atinsă prin nicio altă cale. De exemplu, când CSE întâlnește
o instrucțiune „dacă” cu o clauză „altfel”, CSE urmează saltul când condiția
testat este fals.

Activat la niveluri -O2, -O3, -Os.

-fcse-skip-blocks
Acest lucru este similar cu -fcse-urmare-sărituri, dar face ca CSE să urmeze salturi care
săriți condiționat peste blocuri. Când CSE întâlnește o declarație simplă „dacă” cu nr
clauza else, -fcse-skip-blocks determină CSE să urmărească saltul în jurul corpului
"dacă".

Activat la niveluri -O2, -O3, -Os.

-frerun-cse-după-buclă
Reluați eliminarea subexpresiilor comune după ce sunt efectuate optimizările buclei.

Activat la niveluri -O2, -O3, -Os.

-fgcse
Efectuați o trecere globală de eliminare a subexpresiilor comune. Această trecere funcționează și
constanta globala si propagarea copiei.

Notă: Când compilați un program folosind gotos calculate, o extensie GCC, puteți obține
performanță mai bună la timp de execuție dacă dezactivați eliminarea subexpresiilor comune la nivel global
trece prin adăugare -fno-gcse la linia de comandă.

Activat la niveluri -O2, -O3, -Os.

-fgcse-lm
Cand -fgcse-lm este activată, eliminarea subexpresiilor comune la nivel global încearcă să se mute
încărcături care sunt ucise numai de magazine în sine. Acest lucru permite o buclă care conține a
secvența de încărcare/stocare să fie schimbată într-o încărcare în afara buclei și o copiere/stocare în interior
bucla.

Activat implicit când -fgcse este activat.

-fgcse-sm
Cand -fgcse-sm este activat, o trecere de mișcare a magazinului este rulată după comun global
eliminarea subexpresiilor. Această trecere încearcă să mute magazinele din bucle. Când este folosit
în legătură cu -fgcse-lm, buclele care conțin o secvență de încărcare/stocare pot fi modificate
la o sarcină înainte de buclă și la un depozit după buclă.

Nu este activat la niciun nivel de optimizare.

-fgcse-las
Cand -fgcse-las este activată, trece eliminarea subexpresiei comune la nivel global
elimină încărcările redundante care vin după stocarea în aceeași locație de memorie (ambele
concedieri parțiale și complete).

Nu este activat la niciun nivel de optimizare.

-fgcse-după-reîncărcare
Cand -fgcse-după-reîncărcare este activat, se efectuează o trecere redundantă de eliminare a sarcinii
după reîncărcare. Scopul acestei treceri este de a curăța scurgerile redundante.

-optimizări-agresive-buclă
Această opțiune îi spune optimizatorului de bucle să folosească constrângerile de limbă pentru a deriva limite pentru
numărul de iterații ale unei bucle. Aceasta presupune că codul buclă nu invocă
comportament nedefinit, de exemplu, provocând depășiri de numere întregi semnate sau în afara limitelor
acces la matrice. Limitele pentru numărul de iterații ale unei bucle sunt folosite pentru a ghida
derularea buclei și decojirea și optimizările testului de ieșire a buclei. Această opțiune este activată
în mod implicit.

-optimizări-funsafe-loop
Această opțiune îi spune optimizatorului de bucle să presupună că indicii de buclă nu se depășesc și
că buclele cu condiția de ieșire netrivială nu sunt infinite. Acest lucru permite o mai largă
gamă de optimizări de bucle, chiar dacă optimizatorul de bucle în sine nu poate dovedi că acestea
ipotezele sunt valabile. Dacă utilizați -Wunsafe-loop-optimizations, vă avertizează compilatorul
dacă găsește acest tip de buclă.

-fcrossjumping
Efectuați transformarea sărituri încrucișate. Această transformare unifică codul echivalent și
salvează dimensiunea codului. Codul rezultat poate sau nu poate funcționa mai bine decât fără încrucișare.
jumping.

Activat la niveluri -O2, -O3, -Os.

-fauto-inc-dec
Combinați creșteri sau decremente ale adreselor cu accesele de memorie. Această trecere este
a omis întotdeauna arhitecturile care nu au instrucțiuni pentru a sprijini acest lucru.
Activat implicit la -O și mai mult pe arhitecturile care suportă acest lucru.

-fdce
Efectuați eliminarea codului mort (DCE) pe RTL. Activat implicit la -O și mai mare.

-fdse
Efectuați eliminarea magazinului mort (DSE) pe RTL. Activat implicit la -O și mai mare.

-cinci-conversie
Încercați să transformați salturile condiționate în echivalente fără ramuri. Aceasta include
folosirea mișcărilor condiționate, min, max, set de steaguri și instrucțiuni pentru abs și câteva trucuri
realizabil prin aritmetica standard. Utilizarea execuției condiționate pe jetoane acolo unde este
disponibil este controlat de „if-conversion2”.

Activat la niveluri -O, -O2, -O3, -Os.

-cinci-conversie2
Utilizați execuția condiționată (acolo unde este disponibilă) pentru a transforma salturile condiționate în
echivalente fără ramuri.

Activat la niveluri -O, -O2, -O3, -Os.

-fdeclone-ctor-dtor
C++ ABI necesită mai multe puncte de intrare pentru constructori și destructori: unul pentru a
subobiect de bază, unul pentru un obiect complet și unul pentru un destructor virtual care apelează
ștergerea operatorului ulterior. Pentru o ierarhie cu baze virtuale, baza și complet
variantele sunt clone, ceea ce înseamnă două copii ale funcției. Cu această opțiune,
variantele de bază și complete sunt modificate pentru a fi thunks care apelează la o implementare comună.

Activat de -Os.

-fdelete-null-pointer-checks
Să presupunem că programele nu pot dereferi în siguranță pointerii nuli și că nu există cod sau date
elementul rezidă acolo. Acest lucru permite optimizări simple de pliere constantă
niveluri de optimizare. În plus, alte treceri de optimizare din GCC folosesc acest indicator pentru
controlează analizele globale ale fluxului de date care elimină verificările inutile pentru pointerii nuli;
acestea presupun că dacă un pointer este verificat după ce a fost deja dereferențiat, acesta
nu poate fi nulă.

Rețineți totuși că în unele medii această presupunere nu este adevărată. Utilizare
-fno-delete-null-pointer-checks pentru a dezactiva această optimizare pentru programele care depind
pe acel comportament.

Unele ținte, în special cele încorporate, dezactivează această opțiune la toate nivelurile. In caz contrar
este activat la toate nivelurile: -O0, -O1, -O2, -O3, -Os. Trecerile care folosesc informațiile
sunt activate independent la diferite niveluri de optimizare.

-fdevirtualizați
Încercați să convertiți apelurile în funcții virtuale în apeluri directe. Acest lucru se face ambele
în cadrul unei proceduri și interprocedural ca parte a inlineării indirecte
("-findirect-inlining") și propagare constantă interprocedurală (-fipa-cp). Activat
la niveluri -O2, -O3, -Os.

-fdevirtualizare-speculativ
Încercați să convertiți apelurile în funcții virtuale în apeluri directe speculative. Bazat pe
analiza graficului de moștenire de tip, determinați pentru un apel dat mulțimea de
ținte probabile. Dacă setul este mic, de preferință de dimensiunea 1, schimbați apelul într-un
decizia condiționată asupra apelului direct și indirect. Apelurile speculative permit mai mult
optimizări, cum ar fi inlining. Când par inutile după o optimizare ulterioară,
sunt convertite înapoi în forma originală.

-optimizări scumpe
Efectuați o serie de optimizări minore care sunt relativ costisitoare.

Activat la niveluri -O2, -O3, -Os.

-gratuit
Încercați să eliminați instrucțiunile de extensie redundante. Acest lucru este util în special pentru
arhitectura x86-64, care implicit zero se extinde în registre de 64 de biți după
scriind în jumătatea lor inferioară de 32 de biți.

Activat pentru Alpha, AArch64 și x86 la niveluri -O2, -O3, -Os.

-fno-lifetime-dse
În C++ valoarea unui obiect este afectată doar de modificările din timpul de viață: când
constructorul începe, obiectul are o valoare nedeterminată și orice modificări în timpul
durata de viață a obiectului este moartă atunci când obiectul este distrus. În mod normal, magazin mort
eliminarea va profita de acest lucru; dacă codul dvs. se bazează pe valoarea
stocarea obiectelor care persistă dincolo de durata de viață a obiectului, puteți utiliza acest indicator pentru
dezactivați această optimizare.

-flive-gamă-contracție
Încercați să micșorați presiunea din registru prin micșorarea intervalului de viteză al registrului. Aceasta este
util pentru procesoarele rapide cu seturi de registre de dimensiuni mici sau moderate.

-fira-algoritm=Algoritmul
Utilizați algoritmul de colorare specificat pentru alocatorul de registru integrat. The
Algoritmul argumentul poate fi prioritate, care specifică colorarea prioritară a lui Chow, sau CB,
care specifică colorarea Chaitin-Briggs. Colorarea Chaitin-Briggs nu este implementată
pentru toate arhitecturile, dar pentru acele ținte care îl acceptă, este implicit
deoarece generează un cod mai bun.

-fira-region=regiune
Utilizați regiunile specificate pentru alocatorul de registru integrat. The regiune argument
ar trebui să fie unul dintre următoarele:

toate Utilizați toate buclele ca regiuni de alocare a registrului. Acest lucru poate da cele mai bune rezultate pentru
mașini cu un set de registre mic și/sau neregulat.

mixt
Utilizați toate buclele, cu excepția buclelor cu o presiune mică de registru ca regiuni. Acest
value dă de obicei cele mai bune rezultate în majoritatea cazurilor și pentru majoritatea arhitecturilor și
este activat implicit la compilarea cu optimizare pentru viteză (-O, -O2, ...).

unu Utilizați toate funcțiile ca o singură regiune. Acest lucru duce de obicei la cel mai mic cod
dimensiune și este activat implicit pentru -Os or -O0.

-fira-pala-presiune
Utilizați IRA pentru a evalua presiunea din registru în trecerea codului de ridicare pentru deciziile de ridicare
expresii. Această opțiune are de obicei ca rezultat un cod mai mic, dar poate încetini
compilatorul jos.

Această opțiune este activată la nivel -Os pentru toate obiectivele.

-fira-bucla-presiune
Utilizați IRA pentru a evalua presiunea registrului în bucle pentru deciziile de mutare a invarianților buclei.
Această opțiune are ca rezultat, de obicei, generarea de cod mai rapid și mai mic pe mașinile cu
fișiere de registre mari (>= 32 de registre), dar poate încetini compilatorul.

Această opțiune este activată la nivel -O3 pentru unele tinte.

-fno-ira-share-save-slots
Dezactivați partajarea sloturilor de stivă utilizate pentru salvarea registrelor hard utilizate pentru apeluri care trăiesc
un apel. Fiecare registru dur primește un slot de stivă separat și, ca rezultat, stiva de funcții
ramele sunt mai mari.

-fno-ira-share-spill-slots
Dezactivați partajarea sloturilor de stivă alocate pentru pseudo-registruri. Fiecare pseudo-registru
care nu primește un registru dur primește un slot separat de stivă și, ca rezultat, funcția
cadrele stivelor sunt mai mari.

-fira-verbose=n
Controlați gradul de nivelare a fișierului dump pentru alocatorul de registru integrat. The
valoarea implicită este 5. Dacă valoarea n este mai mare sau egală cu 10, ieșirea de descărcare este trimisă
la stderr folosind același format ca n minus 10.

-framură-întârziată
Dacă este acceptat pentru mașina țintă, încercați să reordonați instrucțiunile de exploatat
sloturi de instrucțiuni disponibile după instrucțiunile de ramificare întârziate.

Activat la niveluri -O, -O2, -O3, -Os.

-fschedule-insns
Dacă este acceptat pentru mașina țintă, încercați să reordonați instrucțiunile pentru eliminare
execuția se blochează din cauza indisponibilității datelor necesare. Acest lucru ajută mașinile care
au instrucțiuni cu virgulă mobilă lentă sau de încărcare a memoriei, permițând altor instrucțiuni
să fie emis până când rezultatul sarcinii sau instrucțiunii în virgulă mobilă este necesar.

Activat la niveluri -O2, -O3.

-fschedule-insns2
similar -fschedule-insns, dar solicită o trecere suplimentară a programării instrucțiunilor
după ce a fost făcută alocarea registrului. Acest lucru este util în special pe mașinile cu a
număr relativ mic de registre și unde instrucțiunile de încărcare a memoriei durează mai mult de
un ciclu.

Activat la niveluri -O2, -O3, -Os.

-fno-sched-interbloc
Nu programați instrucțiuni pentru blocurile de bază. Acest lucru este în mod normal activat în mod implicit
la programarea înainte de alocarea registrului, adică cu -fschedule-insns sau la -O2 or
superior.

-fno-sched-spec
Nu permiteți mișcarea speculativă a instrucțiunilor fără încărcare. Acest lucru este în mod normal activat de
implicit la programarea înainte de alocarea registrului, adică cu -fschedule-insns sau la
-O2 sau mai mare.

-fsched-presiune
Activați programarea insn sensibilă la presiunea registrului înainte de alocarea registrului. Acest
are sens numai atunci când se programează înainte ca alocarea registrului să fie activată, adică cu
-fschedule-insns sau la -O2 sau mai sus. Utilizarea acestei opțiuni poate îmbunătăți cea generată
codificați și micșorați dimensiunea acestuia împiedicând creșterea presiunii din registru peste număr
a registrelor rigide disponibile și deversările ulterioare în alocarea registrelor.

-fsched-spec-load
Permite mișcarea speculativă a unor instrucțiuni de încărcare. Acest lucru are sens doar când
programare înainte de alocarea registrului, adică cu -fschedule-insns sau la -O2 sau mai mare.

-fsched-spec-load-dangerous
Permiteți mișcarea speculativă a mai multor instrucțiuni de încărcare. Acest lucru are sens doar când
programare înainte de alocarea registrului, adică cu -fschedule-insns sau la -O2 sau mai mare.

-fsched-stalled-insns
-fsched-stalled-insns=n
Definiți câte insns (dacă există) pot fi mutate prematur din coada de stagnate
insns în lista gata în timpul celei de-a doua treceri de programare. -fno-sched-stalled-insns
înseamnă că niciun insn nu este mutat prematur, -fsched-stalled-insns=0 înseamnă că nu există
limitează numărul de insn-uri aflate în coadă pot fi mutate prematur. -fsched-stalled-insns
fără valoare este echivalent cu -fsched-stalled-insns=1.

-fsched-stalled-insns-dep
-fsched-stalled-insns-dep=n
Definiți câte grupuri de insn (cicluri) sunt examinate pentru o dependență de un insn blocat
care este un candidat pentru eliminarea prematură din coada de insns blocate. Aceasta are
un efect numai în timpul celei de-a doua treceri de programare și numai dacă -fsched-stalled-insns is
folosit. -fno-sched-stalled-insns-dep este echivalent cu -fsched-stalled-insns-dep=0.
-fsched-stalled-insns-dep fără valoare este echivalent cu
-fsched-stalled-insns-dep=1.

-fsched2-use-superblocuri
Când programați după alocarea registrului, utilizați programarea superbloc. Asta permite
mișcarea peste granițele blocurilor de bază, rezultând programe mai rapide. Această opțiune este
experimental, deoarece nu toate descrierile de mașini utilizate de GCC modelează CPU suficient de aproape
pentru a evita rezultate nesigure ale algoritmului.

Acest lucru are sens doar atunci când se programează după alocarea registrului, adică cu
-fschedule-insns2 sau la -O2 sau mai mare.

-fsched-group-euristic
Activați euristica grupului în planificator. Această euristică favorizează instruirea
care aparține unui grup de program. Acest lucru este activat în mod implicit atunci când programarea este
activat, adică cu -fschedule-insns or -fschedule-insns2 sau la -O2 sau mai mare.

-fsched-critical-path-euristic
Activați euristica căii critice în planificator. Această euristică favorizează
instrucțiuni pe calea critică. Acest lucru este activat în mod implicit atunci când programarea este
activat, adică cu -fschedule-insns or -fschedule-insns2 sau la -O2 sau mai mare.

-fsched-spec-insn-euristic
Activați euristica instrucțiunii speculative în planificator. Această euristică favorizează
instrucțiuni speculative cu o mai mare slăbiciune a dependenței. Aceasta este activată implicit
când programarea este activată, adică cu -fschedule-insns or -fschedule-insns2 sau la -O2
sau mai mare.

-fsched-rank-euristic
Activați euristica de rang în planificator. Această euristică favorizează instruirea
aparținând unui bloc de bază cu dimensiune sau frecvență mai mare. Aceasta este activată implicit
când programarea este activată, adică cu -fschedule-insns or -fschedule-insns2 sau la -O2
sau mai mare.

-fsched-last-insn-euristic
Activați euristica ultimei instrucțiuni în planificator. Această euristică favorizează
instrucție care este mai puțin dependentă de ultima instrucțiune programată. Acest lucru este activat
implicit când programarea este activată, adică cu -fschedule-insns or -fschedule-insns2
sau la -O2 sau mai mare.

-fsched-dep-count-euristic
Activați euristica de numărare dependentă în planificator. Această euristică favorizează
instrucțiune care are mai multe instrucțiuni în funcție de ea. Aceasta este activată implicit
când programarea este activată, adică cu -fschedule-insns or -fschedule-insns2 sau la -O2
sau mai mare.

-freschedule-modulo-scheduled-loops
Programarea modulului este efectuată înainte de programarea tradițională. Dacă o buclă este modulo
programat, permisele de programare ulterioare își pot schimba programul. Utilizați această opțiune pentru a
controlează acel comportament.

-fselectiv-programare
Programați instrucțiuni folosind algoritmul de programare selectivă. Cursele de programare selectivă
în loc de prima trecere de planificator.

-fselectiv-scheduling2
Programați instrucțiuni folosind algoritmul de programare selectivă. Cursele de programare selectivă
în loc de a doua trecere de planificator.

-fsel-sched-pipelining
Activați canalizarea software a buclelor cele mai interioare în timpul programării selective. Acest
opțiunea nu are efect decât dacă unul dintre -fselectiv-programare or -fselectiv-scheduling2
este activată.

-fsel-sched-pipelining-bucle-exterioare
La canalizarea buclelor în timpul programării selective, conductați și buclele exterioare. Acest
opțiunea nu are efect decât dacă -fsel-sched-pipelining este activată.

-fshrink-wrap
Emiteți prologuri de funcții numai înaintea părților funcției care au nevoie de ele, mai degrabă decât la
partea de sus a funcției. Acest steag este activat implicit la -O și mai mare.

-fcaller-salvează
Activați alocarea de valori la registrele care sunt afectate de apelurile de funcții, de
emitând instrucțiuni suplimentare pentru a salva și a restabili registrele din jurul unor astfel de apeluri. Astfel de
alocarea se face numai atunci când pare să rezulte un cod mai bun.

Această opțiune este întotdeauna activată implicit pe anumite mașini, de obicei cele care au
nu există registre păstrate pentru apeluri de utilizat.

Activat la niveluri -O2, -O3, -Os.

-fcombine-stiva-ajustări
Urmărește ajustările stivei (apăsări și pops) și stivuiește referințele de memorie și apoi încearcă
pentru a găsi modalități de a le combina.

Activat implicit la -O1 și mai mare.

-fconserve-stack
Încercați să minimizați utilizarea stivei. Compilatorul încearcă să folosească mai puțin spațiu de stivă, chiar și
dacă asta face programul mai lent. Această opțiune implică setarea cadru de stivă mare
parametrul la 100 și mare-stiva-cadru-creştere parametru la 400.

-fttree-reassoc
Efectuați reasociere pe copaci. Acest steag este activat implicit la -O și mai mare.

-fttree-pre
Efectuați eliminarea parțială a redundanței (PRE) pe copaci. Acest steag este activat de
implicit la -O2 și -O3.

-fttree-partial-pre
Faceți eliminarea parțială a redundanței (PRE) mai agresivă. Acest steag este activat de
implicit la -O3.

-ftree-forwprop
Efectuați propagarea înainte pe copaci. Acest steag este activat implicit la -O și
superior.

-ftree-fre
Efectuați eliminarea completă a redundanței (FRE) pe copaci. Diferența dintre FRE și
PRE este că FRE ia în considerare doar expresiile care sunt calculate pe toate căile care duc la
calculul redundant. Această analiză este mai rapidă decât PRE, deși expune mai puține
concedieri. Acest steag este activat implicit la -O și mai mare.

-fttree-phiprop
Efectuați ridicarea sarcinilor de la indicatoarele condiționate de pe copaci. Această trecere este activată de
implicit la -O și mai mare.

-fhoist-încărcături-adiacente
În mod speculativ, ridicați sarcinile din ambele ramuri ale unui dacă-atunci-altfel dacă sarcinile sunt de la
locații adiacente în aceeași structură și arhitectura țintă are un condiționat
instrucțiunea de mutare. Acest steag este activat implicit la -O2 și mai mare.

-ftree-copie-prop
Efectuați propagarea copiei pe copaci. Această trecere elimină operațiunile de copiere inutile.
Acest steag este activat implicit la -O și mai mare.

-fipa-pură-const
Descoperiți care funcții sunt pure sau constante. Activat implicit la -O și mai mare.

-fipa-referință
Descoperiți care variabile statice nu scapă din unitatea de compilare. Activat de
implicit la -O și mai mare.

-fipa-pta
Efectuați analiză interprocedurală pointer și modificare interprocedurală și
analiza de referință. Această opțiune poate provoca o memorie excesivă și utilizarea timpului de compilare
unități mari de compilare. Nu este activat implicit la niciun nivel de optimizare.

-fipa-profil
Efectuați propagarea profilului interprocedural. Funcțiile apelate numai de la rece
funcțiile sunt marcate ca reci. De asemenea, funcții executate o dată (cum ar fi „rece”,
„noreturn”, constructori statici sau destructori) sunt identificați. Funcții la rece și
buclă mai puține părți ale funcțiilor executate o dată sunt apoi optimizate pentru dimensiune. Activat de
implicit la -O și mai mare.

-fipa-cp
Efectuați propagarea constantă interprocedurală. Această optimizare analizează programul
pentru a determina când valorile transmise funcțiilor sunt constante și apoi se optimizează
în consecinţă. Această optimizare poate crește substanțial performanța dacă
aplicația are constante transmise funcțiilor. Acest steag este activat implicit la
-O2, -Os și -O3.

-fipa-cp-clona
Efectuați clonarea funcției pentru a întări propagarea constantă interprocedurală. Cand
activată, propagarea constantă interprocedurală realizează clonarea funcției când
funcția vizibilă extern poate fi apelată cu argumente constante. Pentru că asta
optimizarea poate crea mai multe copii ale funcțiilor, poate crește semnificativ
dimensiunea codului (vezi --param ipcp-unit-growth=valoare). Acest steag este activat implicit la
-O3.

-fizolare-cai-eronate-dereferinta
Detectați căile care declanșează un comportament eronat sau nedefinit din cauza dereferențării a
pointer NULL. Izolați acele căi din fluxul de control principal și întoarceți declarația
cu comportament eronat sau nedefinit într-o capcană.

-fisolate-errone-paths-attribute
Detectați căile care declanșează un comportament eronat sau nedefinit din cauza existenței unei valori NULL
folosit într-un mod care este interzis de un atribut „returns_nonnull” sau „nonnull”.
Izolați acele căi din fluxul de control principal și transformați declarația cu eroare
sau comportament nedefinit într-o capcană. Acest lucru nu este activat în prezent, dar poate fi activat
de „-O2” în viitor.

-ftree-chiuvetă
Efectuați mișcarea înainte de depozitare pe copaci. Acest steag este activat implicit la -O și
superior.

-ftree-bit-ccp
Efectuați propagarea constantă a biților condiționali pe copaci și propagați pointerul
informații de aliniere. Această trecere operează numai pe variabile scalare locale și este
activat implicit la -O si mai sus. Se cere ca -ftree-ccp este activat.

-ftree-ccp
Efectuați propagarea constantă condițională rară (CCP) pe copaci. Doar această trecere
operează pe variabile scalare locale și este activat implicit la -O și mai mare.

-ftree-switch-conversie
Efectuați conversia inițializărilor simple într-o trecere la inițializări de la a
tablou scalar. Acest steag este activat implicit la -O2 și mai mare.

-fttree-tail-merge
Căutați secvențe de cod identice. Când este găsit, înlocuiți unul cu un salt la celălalt.
Această optimizare este cunoscută sub numele de tail merge sau cross jumping. Acest steag este activat de
implicit la -O2 si mai sus. Timpul de compilare în această trecere poate fi limitat folosind
max-tail-merge-comparations parametru și max-tail-merge-iterații parametru.

-ftree-dce
Efectuați eliminarea codului mort (DCE) pe copaci. Acest steag este activat implicit la -O
și mai mare.

-ftree-builtin-call-dce
Efectuați eliminarea codului mort condiționat (DCE) pentru apelurile către funcții încorporate care
poate seta „errno”, dar nu are efecte secundare. Acest steag este activat implicit
at -O2 si mai mare daca -Os nu este de asemenea specificat.

-ftree-dominator-opts
Efectuați o varietate de curățări scalare simple (propagare constantă/copie, redundanță
eliminarea, propagarea intervalului și simplificarea expresiei) pe baza unui dominator
traversarea copacilor. Aceasta efectuează, de asemenea, salt threading (pentru a reduce salturile la salturi). Acest
flag este activat implicit la -O și mai mare.

-ftree-dse
Efectuați eliminarea depozitelor moarte (DSE) pe copaci. Un magazin mort este un depozit într-o memorie
locație care este ulterior suprascrisă de un alt magazin fără încărcături intermediare. În
în acest caz, magazinul anterior poate fi șters. Acest steag este activat implicit la -O și
superior.

-fttree-ch
Efectuați copierea antetului buclei pe copaci. Acest lucru este benefic deoarece crește
eficacitatea optimizărilor de mișcare a codului. De asemenea, economisește un salt. Acest steag este
activat implicit la -O si mai sus. Nu este activat pentru -Os, deoarece de obicei
mărește dimensiunea codului.

-ftree-loop-optimize
Efectuați optimizări de buclă pe arbori. Acest steag este activat implicit la -O și
superior.

-ftree-loop-liniar
Efectuați transformări de schimb de bucle pe arbore. La fel ca -floop-interchange. A folosi
această transformare de cod, GCC trebuie configurat cu --cu-perpl și --cu-cloog la
activați infrastructura de transformare a buclei de grafit.

-floop-interchange
Efectuați transformări de schimb de bucle pe bucle. Schimbarea a două bucle imbricate
comută buclele interioare și exterioare. De exemplu, având în vedere o buclă ca:

DO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
ENDDO
ENDDO

schimbul de bucle transformă bucla ca și cum ar fi fost scrisă:

DO I = 1, N
DO J = 1, M
A(J, I) = A(J, I) * C
ENDDO
ENDDO

ceea ce poate fi benefic atunci când „N” este mai mare decât cache-urile, deoarece în Fortran, the
elementele unui tablou sunt stocate în memorie contiguu pe coloană și originalul
bucla repetă peste rânduri, creând potențial la fiecare acces o pierdere de cache. Acest
optimizarea se aplică tuturor limbilor acceptate de GCC și nu se limitează la
Fortran. Pentru a utiliza această transformare de cod, GCC trebuie să fie configurat cu --cu-perpl
și --cu-cloog pentru a activa infrastructura de transformare a buclei de grafit.

-floop-strip-mina
Efectuați transformări de extragere a benzilor de bucle pe bucle. Strip mining împarte o buclă în
două bucle imbricate. Bucla exterioară are pași egali cu dimensiunea benzii și cu cea interioară
bucla are pași din bucla originală într-o bandă. Lungimea benzii poate fi modificată
folosind bucla-bloc-tigla-dimensiune parametru. De exemplu, având în vedere o buclă ca:

DO I = 1, N
A(I) = A(I) + C
ENDDO

minarea benzilor de buclă transformă bucla ca și cum ar fi scrisă:

DO II = 1, N, 51
DO I = II, min (II + 50, N)
A(I) = A(I) + C
ENDDO
ENDDO

Această optimizare se aplică tuturor limbilor acceptate de GCC și nu se limitează la
Fortran. Pentru a utiliza această transformare de cod, GCC trebuie să fie configurat cu --cu-perpl
și --cu-cloog pentru a activa infrastructura de transformare a buclei de grafit.

-floop-bloc
Efectuați transformări de blocare a buclei pe bucle. Banda de blocare minează fiecare buclă din
loop nest astfel încât accesele de memorie ale buclelor de elemente să se încadreze în interiorul cache-urilor. The
lungimea benzii poate fi modificată folosind bucla-bloc-tigla-dimensiune parametru. De exemplu,
dat o buclă ca:

DO I = 1, N
DO J = 1, M
A(J, I) = B(I) + C(J)
ENDDO
ENDDO

blocarea buclei transformă bucla ca și cum ar fi scrisă:

DO II = 1, N, 51
DO JJ = 1, M, 51
DO I = II, min (II + 50, N)
DO J = JJ, min (JJ + 50, M)
A(J, I) = B(I) + C(J)
ENDDO
ENDDO
ENDDO
ENDDO

ceea ce poate fi benefic atunci când „M” este mai mare decât cache-urile, deoarece bucla cea mai interioară
iterează pe o cantitate mai mică de date care pot fi păstrate în cache. Acest
optimizarea se aplică tuturor limbilor acceptate de GCC și nu se limitează la
Fortran. Pentru a utiliza această transformare de cod, GCC trebuie să fie configurat cu --cu-perpl
și --cu-cloog pentru a activa infrastructura de transformare a buclei de grafit.

-fgrafit-identitate
Activați transformarea identității pentru grafit. Pentru fiecare SCoP generăm
reprezentare poliedrică și transformați-o înapoi în gimple. Folosind -fgrafit-identitate
putem verifica costurile sau beneficiile transformării GIMPLE -> GRAPHITE -> GIMPLE.
Unele optimizări minime sunt, de asemenea, efectuate de generatorul de cod CLooG, cum ar fi index
divizarea și eliminarea codului mort în bucle.

-floop-nest-optimize
Activați optimizatorul de cuib de bucle bazat pe ISL. Acesta este un optimizator generic de cuib de bucle
pe algoritmii de optimizare Pluto. Acesta calculează o structură de buclă optimizată pentru
date-localitate și paralelism. Această opțiune este experimentală.

-floop-paraleliza-toate
Utilizați analiza dependenței de date Graphite pentru a identifica buclele care pot fi paralelizate.
Paralelizați toate buclele care pot fi analizate pentru a nu conține dependențe purtate de bucle
fără a verifica dacă este rentabilă paralelizarea buclelor.

-fcheck-data-deps
Comparați rezultatele mai multor analizoare de dependență de date. Această opțiune este folosită pentru
depanarea analizoarelor de dependență de date.

-ftree-loop-dacă-conversie
Încercați să transformați salturile condiționate în buclele cele mai interioare în fără ramuri
echivalente. Intenția este de a elimina fluxul de control din cele mai interioare bucle în ordine
pentru a îmbunătăți capacitatea trecerii de vectorizare de a gestiona aceste bucle. Aceasta este
activat în mod implicit dacă vectorizarea este activată.

-ftree-loop-if-convert-magazine
Încercați să convertiți, de asemenea, salturile condiționate care conțin scrieri de memorie. Acest
transformarea poate fi nesigură pentru programele cu mai multe fire, deoarece se transformă condiționată
memorie scrie în memorie necondiționată scrie. De exemplu,

pentru (i = 0; i < N; i++)
dacă (cond)
A[i] = expr;

este transformat în

pentru (i = 0; i < N; i++)
A[i] = cond ? expr : A[i];

potențial producând curse de date.

-ftree-loop-distribution
Efectuați distribuția buclei. Acest semnalizare poate îmbunătăți performanța memoriei cache pe corpuri de bucle mari
și permiteți optimizarea ulterioară a buclei, cum ar fi paralelizarea sau vectorizarea
loc. De exemplu, bucla

DO I = 1, N
A(I) = B(I) + C
D(I) = E(I) * F
ENDDO

este transformat în

DO I = 1, N
A(I) = B(I) + C
ENDDO
DO I = 1, N
D(I) = E(I) * F
ENDDO

-ftree-loop-distribute-patterns
Efectuați distribuția în buclă a modelelor care pot fi generate de cod cu apeluri la a
bibliotecă. Acest steag este activat implicit la -O3.

Această trecere distribuie buclele de inițializare și generează un apel către memset zero.
De exemplu, bucla

DO I = 1, N
A(I) = 0
B(I) = A(I) + I
ENDDO

este transformat în

DO I = 1, N
A(I) = 0
ENDDO
DO I = 1, N
B(I) = A(I) + I
ENDDO

iar bucla de inițializare este transformată într-un apel la memset zero.

-fttree-loop-im
Efectuați mișcare invariantă în buclă pe copaci. Această trecere mută doar invarianții care sunt greu
de gestionat la nivel RTL (apeluri de funcții, operații care se extind la secvențe netriviale
de insns). Cu -funswitch-bucle se mută şi operanzi ai condiţiilor care sunt
invariant în afara buclei, astfel încât să putem folosi doar analiza invariantă trivială în
deconectarea buclei. Permisul include și mișcarea magazinului.

-ftree-loop-ivcanon
Creați un contor canonic pentru numărul de iterații în bucle pentru care se determină
numărul de iterații necesită o analiză complicată. Optimizări ulterioare mai apoi
determina cu ușurință numărul. Util mai ales in legatura cu derularea.

-fivopt
Efectuați optimizări ale variabilelor de inducție (reducerea forței, variabila de inducție
contopirea şi eliminarea variabilei de inducţie) pe arbori.

-fttree-paraleliza-bucle=n
Paralelizați bucle, adică împărțiți spațiul lor de iterație pentru a rula în n fire. Aceasta este
posibil numai pentru bucle ale căror iterații sunt independente și pot fi în mod arbitrar
reordonat. Optimizarea este profitabilă doar pe mașini multiprocesor, pentru bucle
care consumă intens CPU, mai degrabă decât sunt constrânse, de exemplu, de lățimea de bandă a memoriei. Această opțiune
implică -pthreadși, prin urmare, este acceptat numai pe ținte care au suport pentru
-pthread.

-fttree-pta
Efectuați analiza funcției-puncte locale-pentru copaci. Acest steag este activat implicit
at -O și mai mare.

-ftree-sra
Efectuați înlocuirea scalară a agregatelor. Această trecere înlocuiește referințele de structură
cu scalari pentru a preveni angajarea structurilor în memorie prea devreme. Acest steag este
activat implicit la -O și mai mare.

-fttree-copyrename
Efectuați redenumirea copiei pe copaci. Această trecere încearcă să redenumească temporar compilatorului la
alte variabile în locații de copiere, de obicei rezultând nume de variabile care mai mult
seamănă foarte mult cu variabilele originale. Acest steag este activat implicit la -O și
superior.

-fttree-coalesce-inlined-vars
Spuneți trecerea numelui copiei (vezi -fttree-copyrename) pentru a încerca să combine mici utilizatori-
variabile definite de asemenea, dar numai dacă acestea au fost aliniate din alte funcții. Este un
formă mai limitată de -fttree-coalesce-vars. Acest lucru poate dăuna informațiilor de depanare ale acestora
variabilele înliniate, dar va păstra variabilele funcției înliniate în afară de
unul pe altul, astfel încât sunt mai probabil să conțină valorile așteptate în a
sesiune de depanare. Acesta a fost implicit în versiunile GCC mai vechi de 4.7.

-fttree-coalesce-vars
Spuneți trecerea numelui copiei (vezi -fttree-copyrename) pentru a încerca să combine mici utilizatori-
variabile definite de asemenea, în loc de doar temporare ale compilatorului. Acest lucru poate limita sever
capacitatea de a depana un program optimizat compilat cu -fno-var-tracking-assignments.
În forma negată, acest indicator previne unirea SSA a variabilelor utilizator, inclusiv
cele inlineate. Această opțiune este activată implicit.

-ftree-ter
Efectuați înlocuirea temporară a expresiei în timpul fazei SSA->normale. Singur
temporare de utilizare/single def sunt înlocuite la locul de utilizare cu definirea lor
expresie. Acest lucru are ca rezultat cod non-GIMPLE, dar oferă expansoarelor mult mai mult
arbori complecși pentru a lucra, rezultând o generare RTL mai bună. Acest lucru este activat de
implicit la -O și mai mare.

-ftree-slsr
Efectuați reducerea forței în linie dreaptă pe copaci. Acest lucru recunoaște legate
expresii care implică înmulțiri și le înlocuiește cu calcule mai puțin costisitoare
cand este posibil. Acesta este activat implicit la -O și mai mare.

-fttree-vectoriza
Efectuați vectorizarea pe copaci. Acest steag activează -ftree-loop-vectorize și
-ftree-slp-vectoriza dacă nu este specificat în mod explicit.

-ftree-loop-vectorize
Efectuați vectorizarea buclei pe copaci. Acest steag este activat implicit la -O3 și atunci când
-fttree-vectoriza este activat.

-ftree-slp-vectoriza
Efectuați vectorizarea blocurilor de bază pe copaci. Acest steag este activat implicit la -O3 și
cand -fttree-vectoriza este activat.

-fvect-cost-model=model
Modificați modelul de cost utilizat pentru vectorizare. The model argumentul ar trebui să fie unul dintre
„nelimitat”, „dinamic” sau „ieftin”. Cu modelul „nelimitat” codul vectorizat-
calea este considerată a fi profitabilă, în timp ce cu modelul „dinamic” o verificare a timpului de rulare va fi
protejați calea codului vectorizat pentru a o activa numai pentru numărul de iterații care va fi probabil
se execută mai rapid decât atunci când se execută bucla scalară originală. Modelul „ieftin” va
dezactivați vectorizarea buclelor unde, de exemplu, acest lucru ar fi prohibitiv
din cauza verificărilor de rulare necesare pentru dependența sau alinierea datelor, dar altfel este egală
la modelul „dinamic”. Modelul de cost implicit depinde de alte indicatori de optimizare
și este fie „dinamic”, fie „ieftin”.

-fsimd-cost-model=model
Modificați modelul de cost utilizat pentru vectorizarea buclelor marcate cu OpenMP sau Cilk
Plus directiva simd. The model argumentul ar trebui să fie unul dintre „nelimitat”, „dinamic”,
"ieftin". Toate valorile de model au același sens ca cel descris în -modelul-cost-fvect
iar implicit un model de cost definit cu -modelul-cost-fvect este folosit.

-ftree-vrp
Efectuați Propagarea intervalului de valori pe copaci. Aceasta este similară cu propagarea constantă
trece, dar în loc de valori, se propagă intervale de valori. Acest lucru permite
optimizatori pentru a elimina verificările de interval inutile, cum ar fi verificările legate de matrice și pointerul nul
verificări. Acesta este activat implicit la -O2 si mai sus. Eliminarea verificării indicatorului nul
se face numai dacă -fdelete-null-pointer-checks este activat.

-ftracer
Efectuați duplicarea cozii pentru a mări dimensiunea superblocului. Această transformare simplifică
fluxul de control al funcției permițând altor optimizări să facă o treabă mai bună.

-bucle-funroll
Derulați bucle al căror număr de iterații poate fi determinat în timpul compilării sau la momentul compilării
intrarea în buclă. -bucle-funroll implică -frerun-cse-după-buclă. Această opțiune face
codul mai mare și poate sau nu să-l facă să ruleze mai rapid.

-funroll-toate-buclele
Derulați toate buclele, chiar dacă numărul lor de iterații este incert când este bucla
a intrat. Acest lucru face de obicei programele să ruleze mai lent. -funroll-toate-buclele implică
aceleasi optiuni ca -bucle-funroll,

-fsplit-ivs-in-unroller
Permite exprimarea valorilor variabilelor de inducție în iterațiile ulterioare ale
buclă derulată folosind valoarea din prima iterație. Acest lucru rupe dependența îndelungată
lanțuri, îmbunătățind astfel eficiența trecerilor de programare.

O combinație de -fweb iar CSE este adesea suficientă pentru a obține același efect.
Cu toate acestea, acest lucru nu este de încredere în cazurile în care corpul buclei este mai complicat decât a
un singur bloc de bază. De asemenea, nu funcționează deloc pe unele arhitecturi din cauza
restricții în permisul CSE.

Această optimizare este activată în mod implicit.

-fexpansiune-variabilă-în-unroler
Cu această opțiune, compilatorul creează mai multe copii ale unor variabile locale când
derularea unei bucle, ceea ce poate duce la un cod superior.

-fpartial-inlining
Părți inline ale funcțiilor. Această opțiune are vreun efect numai atunci când înlinierea în sine este
pornit de către -funcții-finline or -finline-funcții-mici opțiuni.

Activat la nivel -O2.

-fpredictiv-comuning
Efectuați optimizarea predictivă a comunității, adică reutilizarea calculelor (în special
încărcări și stocări de memorie) efectuate în iterațiile anterioare ale buclelor.

Această opțiune este activată la nivel -O3.

-fprefetch-loop-arrays
Dacă este acceptat de mașina țintă, generați instrucțiuni pentru a prelua memoria în avans
îmbunătăți performanța buclelor care accesează matrice mari.

Această opțiune poate genera cod mai bun sau mai rău; rezultatele sunt foarte dependente de
structura buclelor din codul sursă.

Dezactivat la nivel -Os.

-fno-vizor
-fno-vizor2
Dezactivați orice optimizări specifice mașinii. Diferența dintre
-fno-vizor și -fno-vizor2 este modul în care sunt implementate în compilator; niste
ținte folosesc unul, unii îl folosesc pe celălalt, câțiva le folosesc pe ambele.

-fbeehole este activat implicit. -fpeehole2 activat la niveluri -O2, -O3, -Os.

-fno-ghici-ramură-probabilitate
Nu ghiciți probabilitățile de ramuri folosind euristica.

GCC folosește euristica pentru a ghici probabilitățile de ramuri dacă acestea nu sunt furnizate de
feedback de profilare (-fprofil-arcuri). Aceste euristici se bazează pe fluxul de control
grafic. Dacă unele probabilităţi de ramură sunt specificate de __așteptați_încorporat, apoi
euristicile sunt folosite pentru a ghici probabilitățile de ramificare pentru restul fluxului de control
grafic, luând __așteptați_încorporat informațiile luate în considerare. Interacțiunile dintre
euristică şi __așteptați_încorporat poate fi complex și, în unele cazuri, poate fi util
dezactivați euristica astfel încât efectele de __așteptați_încorporat sunt mai ușor de
a intelege.

Valoarea implicită este -fguess-ramură-probabilitate la niveluri -O, -O2, -O3, -Os.

-blocuri-freorder
Reordonați blocurile de bază în funcția compilată pentru a reduce numărul de luate
filiale și îmbunătățirea localității codului.

Activat la niveluri -O2, -O3.

-freorder-blocuri-și-partiție
Pe lângă reordonarea blocurilor de bază în funcția compilată, pentru a reduce
numărul de ramuri luate, despărțirea blocurilor de bază la cald și la rece în secțiuni separate
a fișierelor de asamblare și .o, pentru a îmbunătăți performanța localității de paginare și cache.

Această optimizare este dezactivată automat în prezența gestionării excepțiilor,
pentru secțiuni linkonce, pentru funcții cu un atribut de secțiune definit de utilizator și pe oricare
arhitectură care nu acceptă secțiuni denumite.

Activat pentru x86 la niveluri -O2, -O3.

-funcții-freorder
Reordonați funcțiile în fișierul obiect pentru a îmbunătăți localitatea codului. Aceasta este
implementat prin utilizarea subsecțiunilor speciale „.text.hot” pentru cele mai frecvent executate
funcții și „.text.unlikely” pentru funcțiile executate puțin probabil. Reordonarea se face de către
linkerul, astfel încât formatul de fișier obiect trebuie să accepte secțiuni numite și linkerul trebuie să fie plasat
le într-un mod rezonabil.

De asemenea, feedbackul de profil trebuie să fie disponibil pentru a face această opțiune eficientă. Vedea
-fprofil-arcuri pentru detalii.

Activat la niveluri -O2, -O3, -Os.

-fstrict-aliasing
Permiteți compilatorului să asume cele mai stricte reguli de aliasing aplicabile limbii
fiind compilat. Pentru C (și C++), aceasta activează optimizări în funcție de tipul de
expresii. În special, se presupune că un obiect de un tip nu locuiește niciodată la
aceeași adresă ca un obiect de alt tip, cu excepția cazului în care tipurile sunt aproape aceleași.
De exemplu, un „unsigned int” poate alias un „int”, dar nu un „void*” sau un „double”. A
tipul de caracter poate alias orice alt tip.

Acordați o atenție deosebită codului ca acesta:

union a_union {
int i;
dublu d;
};

int f() {
unire a_union t;
td = 3.0;
return ti;
}

Practica citirii de la un alt membru de sindicat decât cel mai recent
scris la (numit „punning tip”) este comun. Chiar si cu -fstrict-aliasing, tip-
jocul de cuvinte este permis, cu condiția ca memoria să fie accesată prin tipul uniune. Asa ca
codul de mai sus funcționează conform așteptărilor. Cu toate acestea, acest cod ar putea să nu:

int f() {
unire a_union t;
int* ip;
td = 3.0;
ip = &t.i;
return *ip;
}

În mod similar, accesați luând adresa, aruncând indicatorul rezultat și
dereferențiarea rezultatului are un comportament nedefinit, chiar dacă distribuția folosește un tip de uniune,
de exemplu:

int f() {
dublu d = 3.0;
return ((uniunea a_uniunea *) &d)->i;
}

-fstrict-aliasing opțiunea este activată la niveluri -O2, -O3, -Os.

-fstrict-overflow
Permiteți compilatorului să asume reguli stricte de overflow semnate, în funcție de limbă
fiind compilat. Pentru C (și C++), aceasta înseamnă că depășirea atunci când faceți aritmetică cu
numerele cu semne sunt nedefinite, ceea ce înseamnă că compilatorul poate presupune că nu
întâmpla. Acest lucru permite diverse optimizări. De exemplu, compilatorul presupune că
o expresie precum „i + 10 > i” este întotdeauna adevărată pentru „i” cu semn. Această presupunere este
valabil numai dacă overflow semnat este nedefinit, deoarece expresia este falsă dacă „i + 10”
debordează atunci când se utilizează aritmetica complementului în doi. Când această opțiune este în vigoare, oricare
încercarea de a determina dacă trebuie scrisă o operațiune asupra depășirilor de numere semnate
cu grijă să nu implice de fapt debordarea.

Această opțiune permite, de asemenea, compilatorului să asume o semantică strictă a pointerului: dat a
pointer către un obiect, dacă adăugarea unui offset la acel pointer nu produce un pointer
la același obiect, adăugarea este nedefinită. Acest lucru permite compilatorului să încheie
că „p + u > p” este întotdeauna adevărat pentru un indicator „p” și un întreg fără semn „u”. Acest
ipoteza este validă numai pentru că întinderea pointerului este nedefinită, așa cum este expresia
fals dacă „p + u” depășește folosind aritmetica complementului de doi.

Consultați și -fwrapv opțiune. Folosind -fwrapv înseamnă că overflow cu semn întreg este
complet definit: înfășoară. Cand -fwrapv este folosit, nu există nicio diferență între
-fstrict-overflow și -fno-strict-debordare pentru numere întregi. Cu -fwrapv anumite tipuri
de preaplin sunt permise. De exemplu, dacă compilatorul primește un overflow când o face
aritmetică pe constante, valoarea depășită poate fi încă folosită cu -fwrapv, Dar nu
in caz contrar.

-fstrict-overflow opțiunea este activată la niveluri -O2, -O3, -Os.

-falign-funcții
-falign-functions=n
Aliniați începutul funcțiilor la următoarea putere a doi mai mare decât n, sărind până la n
octeți. De exemplu, -funcții-falign=32 aliniază funcțiile la următorii 32 de octeți
hotar, dar -funcții-falign=24 se aliniază la următoarea graniță de 32 de octeți numai dacă aceasta
se poate face prin sărirea a 23 de octeți sau mai puțin.

-funcții-fno-align și -funcții-falign=1 sunt echivalente și înseamnă că funcționează
nu sunt aliniate.

Unii asamblatori acceptă acest steag doar când n este o putere a doi; în acest caz, este
rotunjit.

If n nu este specificat sau este zero, utilizați o valoare implicită dependentă de mașină.

Activat la niveluri -O2, -O3.

-falign-etichete
-falign-labels=n
Aliniați toate țintele ramurilor la o limită de putere a două, săriți până la n octeți ca
-falign-funcții. Această opțiune poate face codul mai lent, deoarece trebuie să se insereze
operațiuni dummy pentru atunci când ținta de ramură este atinsă în fluxul obișnuit al codului.

-fno-align-labels și -falign-labels=1 sunt echivalente și înseamnă că etichetele nu sunt
aliniat.

If -falign-bucle or -falign-sărituri sunt aplicabile și sunt mai mari decât această valoare, atunci
valorile lor sunt folosite în schimb.

If n nu este specificat sau este zero, utilizați o valoare implicită dependentă de mașină, care este foarte probabil
pentru a fi 1, adică fără aliniere.

Activat la niveluri -O2, -O3.

-falign-bucle
-falign-loops=n
Aliniați buclele la o limită de putere a doi, săriți până la n octeți ca -falign-funcții.
Dacă buclele sunt executate de mai multe ori, aceasta compensează orice execuție a manechinului
operațiuni.

-fno-align-loops și -falign-loops=1 sunt echivalente și înseamnă că buclele nu sunt
aliniat.

If n nu este specificat sau este zero, utilizați o valoare implicită dependentă de mașină.

Activat la niveluri -O2, -O3.

-falign-sărituri
-falign-salt=n
Aliniați țintele de ramuri la o graniță de putere a două, pentru ținte de ramuri unde țintele
se poate ajunge doar sărind, sărind până la n octeți ca -falign-funcții. În
în acest caz, nu trebuie executate operațiuni fictive.

-fno-align-salt și -falign-jumps=1 sunt echivalente și înseamnă că buclele nu sunt
aliniat.

If n nu este specificat sau este zero, utilizați o valoare implicită dependentă de mașină.

Activat la niveluri -O2, -O3.

-funit-la-o dată
Această opțiune este lăsată din motive de compatibilitate. -funit-la-o dată nu are efect, în timp ce
-fno-unitate-la-o dată implică -fno-toplevel-reorder și -fno-sectiune-ancore.

Activat în mod implicit.

-fno-toplevel-reorder
Nu reordonați funcțiile de nivel superior, variabilele și instrucțiunile „asm”. Ieșiți-le înăuntru
aceeași ordine în care apar în fișierul de intrare. Când se utilizează această opțiune,
variabilele statice fără referință nu sunt eliminate. Această opțiune este menită să sprijine
cod existent care se bazează pe o anumită comandă. Pentru codul nou, este mai bine să îl utilizați
atribute atunci când este posibil.

Activat la nivel -O0. Când este dezactivat în mod explicit, implică și -fno-sectiune-ancore,
care altfel este activat la -O0 asupra unor tinte.

-fweb
Construiește rețele web așa cum sunt utilizate în mod obișnuit în scopuri de alocare a registrelor și atribuie fiecare web
pseudoregistru individual. Acest lucru permite ca permisul de alocare a registrului să funcționeze
pseudos direct, dar întărește și câteva alte treceri de optimizare, cum ar fi CSE,
optimizator de bucle și eliminare trivial de cod mort. Cu toate acestea, poate face depanare
imposibil, deoarece variabilele nu mai rămân într-un „registru de acasă”.

Activat implicit cu -bucle-funroll.

-întregul-program
Să presupunem că unitatea de compilare curentă reprezintă întregul program care este compilat.
Toate funcțiile și variabilele publice, cu excepția celor „principale” și a celor fuzionate de
atributul „externally_visible” devin funcții statice și de fapt sunt optimizate
mai agresiv de către optimizatorii interprocedurali.

Această opțiune nu trebuie utilizată în combinație cu „-flto”. În schimb, bazându-se pe a
Pluginul de linker ar trebui să ofere informații mai sigure și mai precise.

-flto[=n]
Această opțiune rulează optimizatorul de timp de legătură standard. Când este invocat cu codul sursă, acesta
generează GIMPLE (una dintre reprezentările interne ale GCC) și îl scrie în ELF special
secțiuni din fișierul obiect. Când fișierele obiect sunt legate între ele, toate
corpurile de funcții sunt citite din aceste secțiuni ELF și instanțiate ca și cum ar fi fost
parte a aceleiași unități de traducere.

Pentru a utiliza optimizatorul de timp de legătură, -flto iar opțiunile de optimizare ar trebui specificate la
timpul de compilare și în timpul legăturii finale. De exemplu:

gcc -c -O2 -flto foo.c
gcc -c -O2 -flto bar.c
gcc -o myprog -flto -O2 foo.o bar.o

Primele două invocări la GCC salvează o reprezentare bytecode a GIMPLE în special
Secțiuni ELF în interior foo.o și bar.o. Invocarea finală citește bytecode GIMPLE
din foo.o și bar.o, îmbină cele două fișiere într-o singură imagine internă și compilează
rezultatul ca de obicei. Din moment ce ambele foo.o și bar.o sunt îmbinate într-o singură imagine, aceasta
face ca toate analizele și optimizările interprocedurale din GCC să funcționeze în întreaga
două dosare de parcă ar fi unul singur. Aceasta înseamnă, de exemplu, că interiorul este
capabil să integreze funcții în bar.o în funcții în foo.o si invers.

O altă modalitate (mai simplă) de a activa optimizarea timpului de legătură este:

gcc -o myprog -flto -O2 foo.c bar.c

Cele de mai sus generează bytecode pentru foo.c și bar.c, le unește într-un singur
reprezentarea GIMPLE și le optimizează ca de obicei pentru a produce myprog.

Singurul lucru important de reținut este că pentru a vă permite optimizările timpului de conectare
trebuie să utilizați driverul GCC pentru a efectua pasul de legătură. GCC funcționează apoi automat
optimizarea timpului de legătură dacă oricare dintre obiectele implicate a fost compilat cu -flto.
În general, ar trebui să specificați opțiunile de optimizare care vor fi utilizate pentru timpul de conectare
optimizarea deși GCC va încerca să fie inteligent în a ghici un nivel de optimizare de utilizat
din opțiunile folosite la compilare dacă nu reușiți să specificați una la momentul link-ului. Tu
poate anula întotdeauna decizia automată de a face optimizarea timpului de conectare la momentul legăturii
prin trecere -fno-lto la comanda link.

Pentru a face optimizarea întregului program eficient, este necesar să faceți anumite întregi
ipotezele programului. Compilatorul trebuie să știe ce funcții și variabile pot fi
accesat de biblioteci și runtime în afara unității optimizate în timp de legătură. Cand
suportat de linker, pluginul linker (vezi -fuse-linker-plugin) trece
informații către compilator despre simbolurile utilizate și vizibile din exterior. Cand
Pluginul de linker nu este disponibil, -întregul-program ar trebui folosit pentru a permite compilatorului
pentru a face aceste ipoteze, ceea ce duce la decizii de optimizare mai agresive.

Cand -fuse-linker-plugin nu este activat atunci, atunci când un fișier este compilat cu -flto,
fișierul obiect generat este mai mare decât un fișier obiect obișnuit deoarece conține GIMPLE
codurile de octet și codul final obișnuit (vezi -ffat-lto-obiecte. Aceasta înseamnă acel obiect
fișierele cu informații LTO pot fi legate ca fișiere obiect normale; dacă -fno-lto a trecut
linkerului, nu sunt aplicate optimizări interprocedurale. Rețineți că atunci când
-fno-fat-lto-obiecte este activat, etapa de compilare este mai rapidă, dar nu puteți efectua a
link obișnuit, non-LTO pe ele.

În plus, steaguri de optimizare utilizate pentru a compila fișiere individuale nu sunt
legate neapărat de cele utilizate la momentul link-ului. De exemplu,

gcc -c -O0 -ffat-lto-obiecte -flto foo.c
gcc -c -O0 -ffat-lto-obiecte -flto bar.c
gcc -o myprog -O3 foo.o bar.o

Aceasta produce fișiere obiect individuale cu cod de asamblare neoptimizat, dar
binar rezultat myprog este optimizat la -O3. Dacă, în schimb, binarul final este
generat cu -fno-lto, Apoi myprog nu este optimizat.

Atunci când produce binarul final, GCC aplică numai optimizările de timp a legăturii acestora
fișiere care conțin bytecode. Prin urmare, puteți combina și potrivi fișierele obiect și
biblioteci cu bytecodes GIMPLE și cod obiect final. GCC selectează automat
ce fișiere să optimizeze în modul LTO și ce fișiere să se conecteze fără alte
prelucrare.

Există câteva steaguri de generare a codului păstrate de GCC atunci când generează bytecodes, cum ar fi
acestea trebuie utilizate în etapa finală a legăturii. În general, opțiunile specificate la
link-time le suprascrie pe cele specificate la compilare.

Dacă nu specificați o opțiune de nivel de optimizare -O la momentul link-ului, atunci GCC va
calculați unul pe baza nivelurilor de optimizare utilizate la compilarea fișierelor obiect.
Cel mai înalt nivel de optimizare va câștiga aici.

În prezent, următoarele opțiuni și setările lor sunt preluate din primul fișier obiect
care a specificat-o în mod explicit: -fPIC, -fpic, -fpie, -fcomun, -excepții,
-fnon-call-exceptions, -fgnu-tm și toate -m steaguri țintă.

Anumite steaguri de schimbare ABI sunt necesare pentru a se potrivi în toate unitățile de compilare și încercări
pentru a înlocui acest lucru la momentul conexiunii cu o valoare conflictuală este ignorată. Aceasta include
opțiuni precum -freg-struct-retur și -fpcc-struct-return.

Alte opțiuni, cum ar fi -ffp-contract, -fno-strict-debordare, -fwrapv, -fno-trapv or
-fno-strict-aliasing sunt trecute la etapa de legătură și fuzionate în mod conservator
pentru unitățile de traducere conflictuale. Specific -fno-strict-debordare, -fwrapv și
-fno-trapv să aibă prioritate și de exemplu -ffp-contract=off are prioritate asupra
-ffp-contract=rapid. Le puteți suprascrie la momentul link-ului.

Se recomandă să compilați toate fișierele care participă la aceeași legătură cu
aceleași opțiuni și, de asemenea, specificați acele opțiuni la momentul linkului.

Dacă LTO întâlnește obiecte cu legături C declarate cu tipuri incompatibile separat
unitățile de traducere care urmează să fie legate între ele (comportament nedefinit conform ISO C99
6.2.7), poate fi emis un diagnostic non-fatal. Comportamentul este încă nedefinit la rulare
timp. Diagnosticele similare pot fi ridicate pentru alte limbi.

O altă caracteristică a LTO este că este posibil să se aplice optimizări interprocedurale
pe fișiere scrise în diferite limbi:

gcc -c -flto foo.c
g++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran

Observați că legătura finală este terminată cu g ++ pentru a obține bibliotecile de rulare C++ și
-lgfortran este adăugat pentru a obține bibliotecile de rulare Fortran. În general, la amestecare
limbi în modul LTO, ar trebui să utilizați aceleași opțiuni de comandă de link ca atunci când amestecați
limbi într-o compilație obișnuită (non-LTO).

Dacă fișierele obiect care conțin codul octet GIMPLE sunt stocate într-o arhivă de bibliotecă, de exemplu
libfoo.a, este posibil să le extrageți și să le utilizați într-o legătură LTO dacă utilizați un
linker cu suport pentru plugin. Pentru a crea biblioteci statice potrivite pentru LTO, utilizați gcc-ar
și gcc-ranlib în loc de ar și „ranlib”; pentru a arăta simbolurile fișierelor obiect cu
GIMPLE bytecode, folosește gcc-nm. Acele comenzi necesită asta ar, ranlib și nm au fost
compilat cu suport pentru plugin. La momentul linkului, utilizați steag-ul -fuse-linker-plugin la
asigurați-vă că biblioteca participă la procesul de optimizare LTO:

gcc -o myprog -O2 -flto -fuse-linker-plugin ao bo -lfoo

Cu pluginul de linker activat, linkerul extrage fișierele GIMPLE necesare din
libfoo.a și le transmite GCC-ului care rulează pentru a le face parte din agregat
Imaginea GIMPLE de optimizat.

Dacă nu utilizați un linker cu suport pentru plugin și/sau nu activați linkerul
plugin, apoi obiectele din interior libfoo.a sunt extrase și legate ca de obicei, dar ei
nu participați la procesul de optimizare LTO. Pentru a face o bibliotecă statică
potrivit atât pentru optimizarea LTO, cât și pentru conectarea obișnuită, compilați fișierele obiect cu
-flto „-ffat-lto-obiecte”.

Optimizările timpului de legătură nu necesită prezența întregului program pentru a funcționa.
Dacă programul nu necesită nici un simbol pentru a fi exportat, este posibil să se combine
-flto și -întregul-program pentru a permite optimizatorilor interprocedurali să utilizeze mai mult
ipoteze agresive care pot duce la oportunități îmbunătățite de optimizare. Utilizarea de
-întregul-program nu este necesar când pluginul de linker este activ (vezi -fuse-linker-plugin).

Implementarea actuală a LTO nu face nicio încercare de a genera bytecode
portabil între diferite tipuri de gazde. Fișierele bytecode sunt versionate și acolo
este o verificare strictă a versiunii, deci fișierele bytecode generate într-o versiune de GCC nu vor
lucrați cu o versiune mai veche sau mai nouă de GCC.

Optimizarea timpului de legătură nu funcționează bine cu generarea de informații de depanare.
Combinând -flto cu -g este în prezent experimental și se așteaptă să producă neașteptate
rezultate.

Dacă specificați opționalul n, optimizarea și generarea codului efectuate la momentul link-ului
se execută în paralel folosind n lucrări paralele prin utilizarea unui instalat face programul.
Variabila de mediu FACE poate fi folosit pentru a suprascrie programul utilizat. Implicit
valoare pentru n este 1.

De asemenea, puteți specifica -flto=jobserver pentru a utiliza modul server de joburi GNU make pentru a determina
numărul de locuri de muncă paralele. Acest lucru este util atunci când Makefile care apelează GCC este deja
executând în paralel. Trebuie să adaugi a + la rețeta de comandă din părinte
Makefile pentru ca acest lucru să funcționeze. Această opțiune probabil funcționează numai dacă FACE este marca GNU.

-flato-partition=ALG
Specificați algoritmul de partiționare utilizat de optimizatorul de timp de legătură. Valoarea este
fie „1to1” pentru a specifica o partiționare care să reflecte fișierele sursă originale sau
„echilibrat” pentru a specifica partiţionarea în bucăţi de dimensiuni egale (ori de câte ori este posibil) sau
„max” pentru a crea o nouă partiție pentru fiecare simbol, acolo unde este posibil. Specificând „niciunul” ca
un algoritm dezactivează complet partiționarea și streamingul. Valoarea implicită este
"echilibrat". În timp ce „1to1” poate fi folosit ca o soluție pentru diverse comenzi de cod
probleme, partiționarea „max” este destinată doar testării interne.

-flato-compression-level=n
Această opțiune specifică nivelul de compresie utilizat pentru limbajul intermediar scris
la fișierele obiect LTO și are sens numai împreună cu modul LTO (-flto).
Valorile valide sunt de la 0 (fără compresie) la 9 (compresie maximă). Valori în afara acesteia
intervalul sunt fixate fie la 0, fie la 9. Dacă opțiunea nu este oferită, un echilibrat implicit
este utilizată setarea compresiei.

-flto-raport
Imprimă un raport cu detalii interne despre funcționarea optimizatorului de timp de legătură. The
conținutul acestui raport variază de la o versiune la alta. Este menit să fie util pentru GCC
dezvoltatorii atunci când procesează fișiere obiect în modul LTO (prin -flto).

Dezactivat în mod implicit.

-flato-report-wpa
Aprecieri -flto-raport, dar imprimați numai pentru faza WPA a Link Time Optimization.

-fuse-linker-plugin
Permite utilizarea unui plugin de linker în timpul optimizării timpului de conectare. Această opțiune se bazează
pe suport pentru plugin în linker, care este disponibil în aur sau în GNU ld 2.21 sau
mai nou.

Această opțiune permite extragerea fișierelor obiect cu bytecode GIMPLE din bibliotecă
arhive. Acest lucru îmbunătățește calitatea optimizării prin expunerea mai multor cod la link-ul
optimizator de timp. Aceste informații specifică ce simboluri pot fi accesate extern
(prin obiect non-LTO sau în timpul conexiunii dinamice). Îmbunătățirile rezultate ale calității codului
binarele (și bibliotecile partajate care folosesc vizibilitate ascunsă) sunt similare cu
„-întregul-program”. Vedea -flto pentru o descriere a efectului acestui steag și cum să
foloseste-l.

Această opțiune este activată în mod implicit când suportul LTO în GCC este activat și GCC a fost
configurat pentru utilizare cu un linker care acceptă pluginuri (GNU ld 2.21 sau mai nou sau gold).

-ffat-lto-obiecte
Obiectele Fat LTO sunt fișiere obiect care conțin atât limbajul intermediar, cât și limbajul
cod obiect. Acest lucru le face utilizabile atât pentru conectarea LTO, cât și pentru conectarea normală. Acest
opțiunea este eficientă numai la compilarea cu -flto și este ignorat la momentul linkului.

-fno-fat-lto-obiecte îmbunătățește timpul de compilare față de LTO simplu, dar necesită
lanțul de instrumente complet pentru a fi la curent cu LTO. Este nevoie de un linker cu suport pentru plugin pentru linker
pentru funcționalitatea de bază. În plus, nm, ar și ranlib trebuie să suporte linker
pluginuri pentru a permite un mediu de compilare cu funcții complete (capabil să construiască statică
biblioteci etc). GCC oferă gcc-ar, gcc-nm, gcc-ranlib ambalaje pentru a trece
opțiunile potrivite pentru aceste instrumente. Cu LTO fără grăsimi, fișierele makefile trebuie modificate pentru a fi utilizate
Le.

Valoarea implicită este -fno-fat-lto-obiecte pe ținte cu suport pentru plugin pentru linker.

-fcompare-elim
După alocarea registrului și împărțirea instrucțiunilor de alocare post-registru, identificați
instrucțiuni aritmetice care calculează steagurile procesorului similar cu o operație de comparare
pe baza acelei aritmetici. Dacă este posibil, eliminați operația de comparare explicită.

Această trecere se aplică numai anumitor ținte care nu pot reprezenta în mod explicit
operațiunea de comparație înainte ca alocarea registrului să fie finalizată.

Activat la niveluri -O, -O2, -O3, -Os.

-fuse-ld=bfd
Folosește BFD linker în loc de linkerul implicit.

-fuse-ld=aur
Folosește aur linker în loc de linkerul implicit.

-fcprop-registre
După alocarea registrului și împărțirea instrucțiunilor de alocare post-registru, efectuați
o trecere de copiere-propagare pentru a încerca să reducă dependențele de programare și ocazional
elimina copia.

Activat la niveluri -O, -O2, -O3, -Os.

-fprofile-corectie
Profilurile colectate folosind un binar instrumentat pentru programe cu mai multe fire pot fi
inconsecventă din cauza actualizărilor de contor ratate. Când este specificată această opțiune, GCC folosește
euristice pentru a corecta sau a netezi astfel de inconsecvențe. În mod implicit, GCC emite un
mesaj de eroare când este detectat un profil inconsecvent.

-fprofile-dir=cale
Setați directorul în care să căutați fișierele de date de profil în care se află cale. Această opțiune
afectează numai datele de profil generate de -fprofile-generate, -ftest-acoperire,
-fprofil-arcuri și folosit de -fprofile-use și -fbranch-probabilităţi și conexe
Opțiuni. Pot fi utilizate atât căile absolute, cât și căile relative. În mod implicit, GCC utilizează
directorul curent ca cale, astfel fișierul de date de profil apare în același director cu
fișierul obiect.

-fprofile-generate
-fprofile-generate=cale
Activați opțiunile utilizate de obicei pentru instrumentarea aplicației pentru a produce un profil util
pentru recompilare ulterioară cu optimizare bazată pe feedback de profil. Trebuie să utilizați
-fprofile-generate atât la compilare, cât și la conectarea programului dvs.

Sunt activate următoarele opțiuni: „-fprofile-arcs”, „-fprofile-values”, „-fvpt”.

If cale este specificat, GCC se uită la cale pentru a găsi fișierele de date cu feedback de profil.
Vedea -fprofile-dir.

-fprofile-use
-fprofile-use=cale
Activați optimizările direcționate pentru feedbackul de profil, iar optimizările, în general, sunt profitabile
numai cu feedback de profil disponibil.

Sunt activate următoarele opțiuni: „-fbranch-probabilities”, „-fvpt”,
„-funroll-loops”, „-fpeel-loops”, „-ftracer”, „-ftree-vectorize”,
„ftree-loop-distribute-patterns”

În mod implicit, GCC emite un mesaj de eroare dacă profilurile de feedback nu se potrivesc cu
cod sursa. Această eroare poate fi transformată într-un avertisment prin utilizarea -Wacoperire-nepotrivire.
Rețineți că acest lucru poate duce la un cod slab optimizat.

If cale este specificat, GCC se uită la cale pentru a găsi fișierele de date cu feedback de profil.
Vedea -fprofile-dir.

Următoarele opțiuni controlează comportamentul compilatorului în ceea ce privește aritmetica în virgulă mobilă.
Aceste opțiuni schimbă între viteză și corectitudine. Toate trebuie să fie special activate.

-float-magazin
Nu stocați variabile în virgulă mobilă în registre și inhibați alte opțiuni care
s-ar putea schimba dacă o valoare în virgulă mobilă este preluată dintr-un registru sau memorie.

Această opțiune previne excesul de precizie nedorit pe mașini precum 68000 unde
registrele plutitoare (ale 68881) păstrează mai multă precizie decât se presupune un „dublu”
a avea. La fel și pentru arhitectura x86. Pentru majoritatea programelor, excesul de precizie
face numai bine, dar câteva programe se bazează pe definiția precisă a IEEE flotant
punct. Utilizare -float-magazin pentru astfel de programe, după modificarea acestora pentru a le stoca pe toate
calcule intermediare pertinente în variabile.

-exces-precizie=stil
Această opțiune permite un control suplimentar asupra excesului de precizie la mașinile unde plutesc
registrele de puncte au mai multă precizie decât tipurile IEEE „float” și „duble” și
procesorul nu acceptă operațiuni de rotunjire la aceste tipuri. În mod implicit,
-fexcess-precision=rapid este în vigoare; aceasta înseamnă că operațiunile sunt efectuate în
precizia registrelor si ca este imprevizibila la rotunjirea la tipuri
specificat în codul sursă are loc. La compilarea C, dacă
-fexcess-precision=standard este specificată atunci excesul de precizie urmează regulile
specificate în ISO C99; în special, atât turnările, cât și atribuirile fac ca valorile să fie
rotunjite la tipurile lor semantice (în timp ce -float-magazin afectează doar sarcinile).
Această opțiune este activată în mod implicit pentru C dacă o opțiune de conformitate strictă, cum ar fi
-std=c99 este folosit.

-fexcess-precision=standard nu este implementat pentru alte limbi decât C și nu are
efect dacă -optimizări-funsafe-matematice or -ffast-matematică este specificat. Pe x86, asta
nici nu are efect dacă -mfpmath=sse or -mfpmath=sse+387 este specificat; în fosta
caz, semantica IEEE se aplică fără o precizie excesivă, iar în cea din urmă, rotunjirea este
imprevizibile.

-ffast-matematică
Sets -fno-matematică-errno, -optimizări-funsafe-matematice, -finit-doar matematică,
-fno-rotunjire-matematică, -fno-semnalizare-nans și -fcx-rază-limitată.

Această opțiune determină definirea macrocomenzii preprocesorului „__FAST_MATH__”.

Această opțiune nu este activată de nimeni -O varianta in plus -De repede deoarece poate avea ca rezultat
ieșire incorectă pentru programele care depind de o implementare exactă a IEEE sau ISO
reguli/specificații pentru funcții matematice. Cu toate acestea, poate genera un cod mai rapid pentru
programe care nu necesită garanțiile acestor specificații.

-fno-matematică-errno
Nu setați „errno” după apelarea funcțiilor matematice care sunt executate cu un singur
instrucțiune, de exemplu, „sqrt”. Un program care se bazează pe excepțiile IEEE pentru erori de matematică
manipularea poate dori să folosească acest indicator pentru viteză, menținând în același timp aritmetica IEEE
compatibilitate.

Această opțiune nu este activată de nimeni -O opțiune, deoarece poate duce la o ieșire incorectă
pentru programe care depind de o implementare exactă a IEEE sau ISO
reguli/specificații pentru funcții matematice. Cu toate acestea, poate genera un cod mai rapid pentru
programe care nu necesită garanțiile acestor specificații.

Valoarea implicită este -fmath-errno.

Pe sistemele Darwin, biblioteca de matematică nu stabilește niciodată „errno”. Prin urmare, nu există niciun motiv
pentru compilator să ia în considerare posibilitatea ca s-ar putea, și -fno-matematică-errno este
Mod implicit.

-optimizări-funsafe-matematice
Permiteți optimizări pentru aritmetica în virgulă mobilă care (a) presupun că argumentele și
rezultatele sunt valide și (b) pot încălca standardele IEEE sau ANSI. Când este utilizat în timpul link-ului,
poate include biblioteci sau fișiere de pornire care modifică cuvântul de control FPU implicit sau
alte optimizări similare.

Această opțiune nu este activată de nimeni -O opțiune, deoarece poate duce la o ieșire incorectă
pentru programe care depind de o implementare exactă a IEEE sau ISO
reguli/specificații pentru funcții matematice. Cu toate acestea, poate genera un cod mai rapid pentru
programe care nu necesită garanțiile acestor specificații. Activează
-fno-semnat-zerouri, -fno-capcană-matematică, -asociativ-matematică și -freciprocal-matematică.

Valoarea implicită este -fno-nesigure-optimizări-matematice.

-asociativ-matematică
Permite reasociere operanzilor în serii de operații în virgulă mobilă. Acest
încalcă standardul de limbaj ISO C și C++ modificând posibil rezultatul calculului.
NOTĂ: reordonarea poate schimba semnul zero, precum și poate ignora NaN și inhiba sau
creați underflow sau overflow (și, prin urmare, nu poate fi utilizat pe codul care se bazează pe rotunjire
comportament precum „(x + 2**52) - 2**52”. De asemenea, poate reordona comparațiile în virgulă mobilă și
prin urmare, nu poate fi utilizat atunci când sunt necesare comparații comandate. Această opțiune necesită asta
atât -fno-semnat-zerouri și -fno-capcană-matematică fi în vigoare. Mai mult, nu face
mult sens cu -întemeierea-matematică. Pentru Fortran, opțiunea este activată automat când
atât -fno-semnat-zerouri și -fno-capcană-matematică sunt în vigoare.

Valoarea implicită este -fno-asociativ-matematică.

-freciprocal-matematică
Permiteți utilizarea reciprocă a unei valori în loc de împărțire la valoare dacă aceasta
permite optimizări. De exemplu, „x / y” poate fi înlocuit cu „x * (1/y)”, adică
util dacă „(1/y)” este supus eliminării subexpresiilor comune. Rețineți că aceasta
pierde precizia și crește numărul de flop-uri care operează pe valoare.

Valoarea implicită este -fno-reciprocă-matematică.

-finit-doar matematică
Permite optimizări pentru aritmetica în virgulă mobilă care presupun că argumentele și
rezultatele nu sunt NaN sau +-Inf.

Această opțiune nu este activată de nimeni -O opțiune, deoarece poate duce la o ieșire incorectă
pentru programe care depind de o implementare exactă a IEEE sau ISO
reguli/specificații pentru funcții matematice. Cu toate acestea, poate genera un cod mai rapid pentru
programe care nu necesită garanțiile acestor specificații.

Valoarea implicită este -fno-finit-numai-matematică.

-fno-semnat-zerouri
Permite optimizări pentru aritmetica în virgulă mobilă care ignoră semnificația lui zero.
Aritmetica IEEE specifică comportamentul valorilor distincte +0.0 și -0.0, care apoi
interzice simplificarea expresiilor precum x+0.0 sau 0.0*x (chiar și cu
-finit-doar matematică). Această opțiune implică faptul că semnul unui rezultat zero nu este
semnificativ.

Valoarea implicită este -fsemnat-zerouri.

-fno-capcană-matematică
Compilați codul presupunând că operațiunile în virgulă mobilă nu pot genera vizibilitate pentru utilizator
capcane. Aceste capcane includ împărțirea la zero, preaplin, depășire, rezultat inexact și
operație nevalidă. Această opțiune necesită asta -fno-semnalizare-nans fi în vigoare.
Setarea acestei opțiuni poate permite un cod mai rapid dacă se bazează pe aritmetica IEEE „non-stop”,
de exemplu.

Această opțiune nu ar trebui să fie activată de nimeni -O opțiune deoarece poate avea ca rezultat
ieșire incorectă pentru programele care depind de o implementare exactă a IEEE sau ISO
reguli/specificații pentru funcții matematice.

Valoarea implicită este -ftrapping-matematică.

-întemeierea-matematică
Dezactivați transformările și optimizările care presupun rotunjirea implicită în virgulă mobilă
comportament. Aceasta este rotunjită la zero pentru toate conversiile virgulă mobilă în întreg și
rotunjire la cea mai apropiată pentru toate celelalte trunchieri aritmetice. Această opțiune ar trebui să fie
specificat pentru programele care modifică modul de rotunjire FP în mod dinamic sau care pot fi
executat cu un mod de rotunjire non-implicit. Această opțiune dezactivează plierea constantă a
expresii în virgulă mobilă în timpul compilării (care pot fi afectate de modul de rotunjire)
și transformări aritmetice care sunt nesigure în prezența semnelor dependente
moduri de rotunjire.

Valoarea implicită este -fno-rotunjire-matematică.

Această opțiune este experimentală și nu garantează în prezent dezactivarea tuturor GCC
optimizări care sunt afectate de modul de rotunjire. Versiunile viitoare ale GCC pot oferi
control mai fin al acestei setări folosind pragma „FENV_ACCESS” a C99. Această linie de comandă
opțiunea va fi utilizată pentru a specifica starea implicită pentru „FENV_ACCESS”.

-fsignaling-nans
Compilați codul presupunând că NaN-urile de semnalizare IEEE pot genera capcane vizibile de utilizator în timpul
operații în virgulă mobilă. Setarea acestei opțiuni dezactivează optimizările care se pot schimba
numărul de excepții vizibile cu NaN de semnalizare. Această opțiune implică
-ftrapping-matematică.

Această opțiune determină definirea macrocomenzii preprocesorului „__SUPPORT_SNAN__”.

Valoarea implicită este -fno-semnalizare-nans.

Această opțiune este experimentală și nu garantează în prezent dezactivarea tuturor GCC
optimizări care afectează comportamentul de semnalizare NaN.

-fsingura-precizie-constant
Tratează constantele în virgulă mobilă ca precizie unică, în loc de conversie implicită
ele la constante de dublă precizie.

-fcx-rază-limitată
Când este activată, această opțiune afirmă că un pas de reducere a intervalului nu este necesar când
efectuarea diviziunii complexe. De asemenea, nu se verifică dacă rezultatul a
înmulțirea sau împărțirea complexă este „NaN + I*NaN”, cu o încercare de a salva
situatie in acel caz. Valoarea implicită este -fno-cx-raza-limitata, dar este activat de
-ffast-matematică.

Această opțiune controlează setarea implicită a pragma ISO C99 „CX_LIMITED_RANGE”.
Cu toate acestea, opțiunea se aplică tuturor limbilor.

-fcx-fortran-rules
Înmulțirea și împărțirea complexe urmează regulile Fortran. Reducerea intervalului se face ca
parte a diviziunii complexe, dar nu se verifică dacă rezultatul unui complex
înmulțirea sau împărțirea este „NaN + I*NaN”, cu încercarea de a salva situația
în acest caz.

Valoarea implicită este -fno-cx-fortran-rules.

Următoarele opțiuni controlează optimizările care pot îmbunătăți performanța, dar nu sunt
activat de oricare -O Opțiuni. Această secțiune include opțiuni experimentale care pot produce
cod spart.

-fbranch-probabilităţi
După rularea unui program compilat cu -fprofil-arcuri, îl puteți compila a doua oară
folosind -fbranch-probabilităţi, pentru a îmbunătăți optimizările în funcție de numărul de ori
fiecare ramură a fost luată. Când un program compilat cu -fprofil-arcuri iese, salvează
execuția arcului contează la un fișier numit sursă.gcda pentru fiecare fișier sursă. The
informațiile din acest fișier de date sunt foarte dependente de structura celor generate
cod, deci trebuie să utilizați același cod sursă și aceleași opțiuni de optimizare pentru ambele
compilații.

Cu -fbranch-probabilităţi, GCC pune a REG_BR_PROB nota pe fiecare JUMP_INSN și
CALL_INSN. Acestea pot fi folosite pentru a îmbunătăți optimizarea. În prezent, ele sunt folosite doar
într-un singur loc: în reorg.c, în loc să ghiciți pe ce cale este cea mai probabilă o ramură
ia, cel REG_BR_PROB valorile sunt folosite pentru a determina exact ce cale este luată mai mult
de multe ori.

-fprofile-values
Dacă este combinat cu -fprofil-arcuri, adaugă cod astfel încât unele date despre valorile lui
expresiile din program sunt adunate.

Cu -fbranch-probabilităţi, citește înapoi datele culese din valorile de profilare ale
expresii pentru utilizare în optimizări.

Activat cu -fprofile-generate și -fprofile-use.

-fprofile-reordonare-funcții
Reordonarea funcției pe baza instrumentării profilului colectează prima execuție
a unei funcții și ordonează aceste funcții în ordine crescătoare.

Activat cu -fprofile-use.

-fvpt
Dacă este combinat cu -fprofil-arcuri, această opțiune indică compilatorului să adauge cod la
adună informații despre valorile expresiilor.

Cu -fbranch-probabilităţi, citește înapoi datele culese și realizează efectiv
optimizări bazate pe acestea. În prezent, optimizările includ specializarea
operațiuni de împărțire folosind cunoștințele despre valoarea numitorului.

-frename-registre
Încercați să evitați dependențele false în codul programat utilizând registrele rămase
peste după alocarea registrului. Această optimizare beneficiază cel mai mult procesoarelor cu multe
a registrelor. În funcție de formatul de informații de depanare adoptat de țintă,
cu toate acestea, poate face imposibilă depanarea, deoarece variabilele nu mai rămân într-o „acasă
Inregistreaza-te".

Activat implicit cu -bucle-funroll și -fpeel-bucle.

-ftracer
Efectuați duplicarea cozii pentru a mări dimensiunea superblocului. Această transformare simplifică
fluxul de control al funcției permițând altor optimizări să facă o treabă mai bună.

Activat cu -fprofile-use.

-bucle-funroll
Derulați bucle al căror număr de iterații poate fi determinat în timpul compilării sau la momentul compilării
intrarea în buclă. -bucle-funroll implică -frerun-cse-după-buclă, -fweb și
-frename-registre. De asemenea, activează peelingul complet al buclei (adică îndepărtarea completă a
bucle cu un număr mic constant de iterații). Această opțiune face codul mai mare și
poate sau nu să o facă să ruleze mai repede.

Activat cu -fprofile-use.

-funroll-toate-buclele
Derulați toate buclele, chiar dacă numărul lor de iterații este incert când este bucla
a intrat. Acest lucru face de obicei programele să ruleze mai lent. -funroll-toate-buclele implică
aceleasi optiuni ca -bucle-funroll.

-fpeel-bucle
Decojește buclele pentru care există suficiente informații încât nu se rostogolesc prea mult (de la
feedback de profil). De asemenea, activează peelingul complet al buclei (adică îndepărtarea completă a
bucle cu număr mic constant de iterații).

Activat cu -fprofile-use.

-fmove-loop-invariants
Activează trecerea de mișcare invariantă a buclei în optimizatorul de bucle RTL. Activat la nivel
-O1

-funswitch-bucle
Mutați ramurile cu condiții invariante de buclă în afara buclei, cu duplicate ale
buclă pe ambele ramuri (modificată în funcție de rezultatul stării).

-secţiuni-funcţii
-fdata-secțiuni
Plasați fiecare funcție sau element de date în propria sa secțiune în fișierul de ieșire dacă este țintă
acceptă secțiuni arbitrare. Numele funcției sau numele elementului de date
determină numele secțiunii în fișierul de ieșire.

Utilizați aceste opțiuni pe sistemele în care linkerul poate efectua optimizări pentru a îmbunătăți
localitatea de referință în spațiul de instrucție. Majoritatea sistemelor folosesc obiectul ELF
procesoarele cu format și SPARC care rulează Solaris 2 au linkere cu astfel de optimizări.
AIX poate avea aceste optimizări în viitor.

Folosiți aceste opțiuni numai atunci când există beneficii semnificative din acest lucru. Cand tu
specificați aceste opțiuni, asamblatorul și linkerul creează obiecte mai mari și executabile
fișiere și sunt, de asemenea, mai lente. Nu puteți folosi „gprof” pe toate sistemele dacă specificați acest lucru
opțiunea și este posibil să aveți probleme cu depanarea dacă specificați atât această opțiune, cât și
-g.

-fbranch-target-load-optimize
Efectuați optimizarea încărcării registrului țintă al ramurilor înainte de threadingul prolog/epilog.
Utilizarea registrelor țintă poate fi de obicei expusă numai în timpul reîncărcării, astfel ridicarea
se încarcă din bucle și planificarea între blocuri necesită o optimizare separată
trece.

-fbranch-target-load-optimize2
Efectuați optimizarea încărcării registrului țintă al ramurilor după threadingul prolog/epilog.

-fbtr-bb-exclusiv
Când efectuați optimizarea încărcării registrului țintă a ramurilor, nu reutilizați ținta ramurilor
se înregistrează în cadrul oricărui bloc de bază.

-festack-protector
Emiteți cod suplimentar pentru a verifica dacă există depășiri de buffer, cum ar fi atacurile de distrugere a stivei. Acest
se face prin adăugarea unei variabile de gardă la funcțiile cu obiecte vulnerabile. Acest
include funcții care apelează „alloca” și funcții cu buffer-uri mai mari de 8 octeți.
Gărzile sunt inițializate când este introdusă o funcție și apoi verificate când
funcția iese. Dacă o verificare de pază eșuează, este tipărit un mesaj de eroare și programul
iesirile.

-fstack-protector-all
Aprecieri -festack-protector cu excepția faptului că toate funcțiile sunt protejate.

-fstack-protector-puternic
Aprecieri -festack-protector dar include funcții suplimentare care trebuie protejate --- acelea
care au definiții de matrice locale sau au referințe la adrese de cadru locale.

NOTĂ: În Ubuntu 14.10 și versiunile ulterioare, -fstack-protector-puternic este activat de
implicit pentru C, C++, ObjC, ObjC++, dacă niciunul dintre acestea -fno-stack-protector, -nostdlib, nici
- de sine stătător sunt găsite.

-fsectiune-ancore
Încercați să reduceți numărul de calcule de adrese simbolice utilizând „ancoră” partajată
simboluri pentru a se adresa obiectelor din apropiere. Această transformare poate ajuta la reducerea numărului
de intrări GOT și accesări GOT pe unele ținte.

De exemplu, implementarea următoarei funcții „foo”:

static int a, b, c;
int foo (void) { return a + b + c; }

de obicei calculează adresele tuturor celor trei variabile, dar dacă îl compilați cu
-fsectiune-ancore, accesează variabilele dintr-un punct de ancorare comun. The
efectul este similar cu următorul pseudocod (care nu este valid C):

int foo (gol)
{
înregistrare int *xr = &x;
returnează xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}

Nu toate obiectivele acceptă această opțiune.

--param nume=valoare
În unele locuri, GCC utilizează diverse constante pentru a controla cantitatea de optimizare care
este gata. De exemplu, GCC nu include funcții care conțin mai mult de un anumit
numărul de instrucțiuni. Puteți controla unele dintre aceste constante pe linia de comandă
folosind --param opțiune.

Numele parametrilor specifici și semnificația valorilor sunt legate de
componentele interne ale compilatorului și pot fi modificate fără notificare în viitor
de presă.

În fiecare caz, valoare este un număr întreg. Opțiunile permise pentru nume sunt:

previzibil-ramură-rezultat
Când se prevede că ramura va fi luată cu o probabilitate mai mică decât acest prag
(în procente), atunci este considerat bine previzibil. Valoarea implicită este 10.

max-salt-încrucișat-margini
Numărul maxim de margini de intrare de luat în considerare pentru sărituri încrucișate. Algoritmul
folosit de -fcrossjumping este O(N^2) în numărul de muchii care intră în fiecare bloc.
Creșterea valorilor înseamnă o optimizare mai agresivă, făcând timpul de compilare
crește probabil cu o mică îmbunătățire a dimensiunii executabilului.

min-crossjump-insns
Numărul minim de instrucțiuni care trebuie potrivite la sfârșitul a două blocuri
înainte de a se executa sărituri încrucișate asupra lor. Această valoare este ignorată în caz
unde toate instrucțiunile din blocul din care săriți încrucișați sunt potrivite. The
valoarea implicită este 5.

max-grow-copy-bb-insns
Factorul de extindere a dimensiunii maxime a codului la copierea blocurilor de bază în loc de
jumping. Expansiunea este relativă la o instrucțiune de salt. Valoarea implicită este
8.

max-goto-duplication-insns
Numărul maxim de instrucțiuni de duplicat într-un bloc care sare la a
goto calculat. Pentru a evita comportamentul O(N^2) într-un număr de treceri, factorii GCC
au calculat gotos la începutul procesului de compilare și le defactoriază chiar și mai târziu
posibil. Numai săriturile calculate la sfârșitul unui bloc de bază cu cel mult max-
goto-duplication-insns sunt nefactorizate. Valoarea implicită este 8.

max-delay-slot-insn-search
Numărul maxim de instrucțiuni de luat în considerare atunci când căutați o instrucțiune
umpleți un slot de întârziere. Dacă mai mult decât acest număr arbitrar de instrucțiuni sunt
căutat, economiile de timp de la umplerea intervalului de întârziere sunt minime, așa că opriți
in cautarea. Creșterea valorilor înseamnă o optimizare mai agresivă, făcând
Creșterea timpului de compilare cu probabil o mică îmbunătățire a timpului de execuție.

max-delay-slot-live-search
Când încercați să umpleți spațiile de întârziere, numărul maxim de instrucțiuni de luat în considerare
atunci când căutați un bloc cu informații valide de înregistrare live. Creșterea asta
valoarea aleasă în mod arbitrar înseamnă o optimizare mai agresivă, crescând
timpul de compilare. Acest parametru ar trebui eliminat atunci când codul slotului de întârziere este
rescris pentru a menține graficul control-flux.

max-gcse-memory
Cantitatea maximă aproximativă de memorie care poate fi alocată pentru a funcționa
optimizarea eliminării subexpresiilor comune globale. Dacă mai multă memorie decât
specificat este necesar, optimizarea nu se face.

raportul-de-inserție max-gcse
Dacă raportul dintre inserțiile de expresie și ștergerile este mai mare decât această valoare pt
orice expresie, apoi RTL PRE inserează sau elimină expresia și astfel pleacă
calcule parțial redundante în fluxul de instrucțiuni. Valoarea implicită este
20.

lungime-listă-în așteptare maximă
Numărul maxim de dependențe în așteptare pe care îl permite programarea înainte de a spăla
starea actuală și o luare de la capăt. Funcții mari cu puține ramuri sau apeluri pot
creați liste excesiv de mari care consumă inutil memorie și resurse.

max-modulo-încercări-backtrack
Numărul maxim de încercări de întoarcere pe care planificatorul ar trebui să le facă atunci când este modulo
programarea unei bucle. Valorile mai mari pot crește exponențial timpul de compilare.

max-inline-insns-single
Mai mulți parametri controlează inlinerul arborelui utilizat în GCC. Acest număr setează
numărul maxim de instrucțiuni (contorizate în reprezentarea internă a GCC) în a
o singură funcție pe care tree inliner o ia în considerare pentru inlining. Acest lucru afectează doar
funcții declarate inline și metode implementate într-o declarație de clasă (C++).
Valoarea implicită este 400.

max-inline-insns-auto
Când utilizați -funcții-finline (inclus în -O3), o mulțime de funcții care ar
altfel nu vor fi luate în considerare pentru inline de către compilator sunt investigate. La
acele funcții, o limită diferită (mai restrictivă) față de funcții
declarat inline poate fi aplicat. Valoarea implicită este 40.

inline-min-speedup
Când îmbunătățirea estimată a performanței apelantului + timpului de rulare a apelantului depășește acest lucru
prag (în precent), funcția poate fi aliniată indiferent de limită
--param max-inline-insns-single și --param max-inline-insns-auto.

large-function-insns
Limita care specifică funcții cu adevărat mari. Pentru funcții mai mari decât această limită
după înliniere, înlinierea este constrânsă de --param mare-funcție-creștere. Acest
parametrul este util în primul rând pentru a evita timpul extrem de compilare cauzat de non-
algoritmi liniari utilizați de back-end. Valoarea implicită este 2700.

mare-funcție-creștere
Specifică creșterea maximă a funcției mari cauzată de integrarea în procente. The
valoarea implicită este 100, ceea ce limitează creșterea mare a funcției la 2.0 ori mai mare decât cea originală
mărimea.

mare-unitate-insns
Limita care specifică unitatea mare de traducere. Creștere cauzată de integrarea unităților
mai mare decât această limită este limitată de --param inline-unitate-creștere. Pentru unitati mici
s-ar putea să fie prea strâns. De exemplu, să considerăm o unitate formată din funcția A
care este în linie și B care îl sună pe A de trei ori. Dacă B este mic în raport cu A,
creșterea unității este de 300\% și totuși, o astfel de înălțime este foarte sănătoasă. Pentru foarte mari
unități constând din mici funcții inlineabile, cu toate acestea, creșterea generală a unității
limită este necesară pentru a evita explozia exponențială a dimensiunii codului. Astfel pentru mai mici
unități, dimensiunea este mărită la --param mare-unitate-insns înainte de a aplica --param
inline-unitate-creștere. Valoarea implicită este 10000.

inline-unitate-creștere
Specifică creșterea totală maximă a unității de compilare cauzată de inline. The
valoarea implicită este 30, ceea ce limitează creșterea unității la 1.3 ori dimensiunea inițială.

ipcp-unitate-creștere
Specifică creșterea totală maximă a unității de compilare cauzată de interprocedural
propagare constantă. Valoarea implicită este 10, ceea ce limitează creșterea unității la 1.1
ori mărimea originală.

cadru de stivă mare
Limita care specifică cadrele stive mari. În timp ce se încearcă alinierea algoritmului
pentru a nu depăși prea mult această limită. Valoarea implicită este de 256 de octeți.

mare-stiva-cadru-creştere
Specifică creșterea maximă a cadrelor stive mari cauzată de inline în procente.
Valoarea implicită este 1000, ceea ce limitează creșterea cadrelor stivei mari la de 11 ori
Dimensiunea originală.

max-inline-insns-recursiv
max-inline-insns-recursive-auto
Specifică numărul maxim de instrucțiuni o copie în afara liniilor unui auto-
funcția recursive inline poate deveni prin efectuarea recursive inline.

Pentru funcțiile declarate inline, --param max-inline-insns-recursiv este luat în
cont. Pentru funcțiile care nu sunt declarate inline, inlinearea recursivă are loc numai atunci când
-funcții-finline (inclus în -O3) este activat și --param max-inline-insns-
recursiv-auto este folosit. Valoarea implicită este 450.

max-inline-recursive-depth
max-inline-recursive-depth-auto
Specifică adâncimea maximă de recursivitate utilizată pentru inlinearea recursivă.

Pentru funcțiile declarate inline, --param max-inline-recursive-depth este luat în
cont. Pentru funcțiile care nu sunt declarate inline, inlinearea recursivă are loc numai atunci când
-funcții-finline (inclus în -O3) este activat și --param max-inline-recursiv-
adâncime-auto este folosit. Valoarea implicită este 8.

min-inline-probabilitate-recursivă
Inlinearea recursiv este profitabilă numai pentru funcțiile care au recursivitate profundă
medie și poate răni pentru funcția care are o adâncime mică de recursivitate prin creșterea
dimensiunea prologului sau complexitatea corpului funcției către alți optimizatori.

Când feedbackul de profil este disponibil (vezi -fprofile-generate) recursiunea propriu-zisă
adâncimea poate fi ghicită din probabilitatea ca funcția să se repete printr-un apel dat
expresie. Acest parametru limitează integrarea numai la expresiile de apel ale căror
probabilitatea depășește pragul dat (în procente). Valoarea implicită este 10.

early-inlining-insns
Specificați creșterea pe care o poate face inlinerul timpuriu. De fapt, crește cantitatea
de inline pentru codul care are o penalizare mare de abstractizare. Valoarea implicită este 10.

max-iterații-inliner-timpurii
max-iterații-inliner-timpurii
Limită de iterații ale inlinerului timpuriu. Acest lucru limitează practic numărul de
apeluri indirecte imbricate pe care inlinerul timpuriu le poate rezolva. Lanțurile mai adânci sunt încă
tratate de inlining tardiv.

probabilitate-comdat-sharing
probabilitate-comdat-sharing
Probabilitatea (în procente) ca funcția inline C++ cu vizibilitate comdat să fie
partajată în mai multe unități de compilare. Valoarea implicită este 20.

min-vect-bucla-legat
Numărul minim de iterații sub care buclele nu sunt vectorizate când
-fttree-vectoriza este folosit. Numărul de iterații după vectorizare trebuie să
să fie mai mare decât valoarea specificată de această opțiune pentru a permite vectorizarea. The
valoarea implicită este 0.

raportul-distanță-cost-gcse
Factorul de scalare în calculul distanței maxime prin care poate fi mutată o expresie
Optimizări GCSE. Acest lucru este acceptat în prezent numai în permisul de ridicare a codului.
Cu cât raportul este mai mare, cu atât ridicarea codului este mai agresivă cu simplu
expresii, adică expresiile care au costat mai puțin decât gcse-nerestricted-
costa. Specificarea 0 dezactivează ridicarea expresiilor simple. Valoarea implicită este
10.

gcse-cost-nerestricționat
Costul, măsurat aproximativ ca costul unei singure instrucțiuni tipice de mașină, la
pe care optimizările GCSE nu constrâng distanța pe care o poate parcurge o expresie.
Acest lucru este acceptat în prezent numai în permisul de ridicare a codului. Cu cât costul este mai mic,
cu cât ridicarea codului este mai agresivă. Specificarea 0 permite tuturor expresiilor
parcurge distante nelimitate. Valoarea implicită este 3.

adancime maxima de palan
Adâncimea căutării în arborele dominator pentru expresii de ridicat. Acesta este folosit
pentru a evita comportamentul pătratic în algoritmul de ridicare. Valoarea lui 0 nu limitează
pe căutare, dar poate încetini compilarea de funcții uriașe. Valoarea implicită
este 30.

max-tail-merge-comparations
Cantitatea maximă de bbs similare cu care se compară un bb. Acesta este folosit pentru a evita
comportament pătratic în îmbinarea cozii de copac. Valoarea implicită este 10.

max-tail-merge-iterații
Cantitatea maximă de iterații ale trecerii peste funcție. Aceasta este obișnuită
limitează timpul de compilare în îmbinarea cozii de arbore. Valoarea implicită este 2.

max-unrolled-insns
Numărul maxim de instrucțiuni pe care o buclă poate avea să fie derulată. Dacă o buclă
este derulat, acest parametru determină și de câte ori este codul buclei
derulat.

max-medie-unrolled-insns
Numărul maxim de instrucţiuni părtinite de probabilităţile executării lor care
poate fi necesar să fie derulată o buclă. Dacă o buclă este derulată, acest parametru este de asemenea
determină de câte ori este derulat codul buclei.

timpi-maxim de derulare
Numărul maxim de derulări ale unei singure bucle.

max-peeled-insns
Numărul maxim de instrucțiuni pe care o buclă poate avea să fie dezlipită. Dacă o buclă
este dezlipit, acest parametru determină și de câte ori este dezlipit codul buclei.

max-peel-times
Numărul maxim de peelinguri ale unei singure bucle.

max-peel-ramuri
Numărul maxim de ramuri pe calea fierbinte prin secvența decojită.

max-complet-decojite-insns
Numărul maxim de insns al unei bucle complet decojite.

timpi-max-complet-peeling
Numărul maxim de iterații ale unei bucle să fie potrivit pentru peeling complet.

adâncimea-max-complet-peel-loop-cuib
Adâncimea maximă a unui cuib buclă potrivită pentru peeling complet.

max-unswitch-insns
Numărul maxim de insns al unei bucle necomutate.

max-unswitch-level
Numărul maxim de ramuri necomutate într-o singură buclă.

lim-scump
Costul minim al unei expresii costisitoare în mișcarea invariantă a buclei.

iv-a lua în considerare-toți-candidații-legați
Limitat în funcție de numărul de candidați pentru variabilele de inducție, sub care toți candidații
sunt luate în considerare pentru fiecare utilizare în optimizările variabilelor de inducție. Dacă există
mai mulți candidați decât acesta, doar cei mai relevanți sunt considerați a evita
complexitatea timpului pătratic.

iv-max-utilizari-considerate
Optimizările variabilelor de inducție renunță la bucle care conțin mai multă inducție
utilizări variabile.

iv-totdeauna-prune-cand-set-legat
Dacă numărul de candidați din set este mai mic decât această valoare, încercați întotdeauna
eliminați iv-urile inutile din set atunci când adăugați unul nou.

scev-max-expr-size
Legat de dimensiunea expresiilor utilizate în analizatorul de evoluții scalare. Mare
expresiile încetinesc analizorul.

scev-max-expr-complexitate
Limitat de complexitatea expresiilor din analizatorul de evoluții scalare.
Expresiile complexe încetinesc analizatorul.

omega-max-vars
Numărul maxim de variabile dintr-un sistem de constrângeri Omega. Valoarea implicită
este 128.

omega-max-geqs
Numărul maxim de inegalități dintr-un sistem de constrângeri Omega. Implicit
valoarea este 256.

echivalenti omega-max
Numărul maxim de egalități într-un sistem de constrângeri Omega. Valoarea implicită
este 128.

omega-max-wild-cards
Numărul maxim de variabile wildcard pe care solutorul Omega este capabil să le insereze.
Valoarea implicită este 18.

dimensiunea-tabelului-omega-hash
Dimensiunea tabelului hash din solutorul Omega. Valoarea implicită este 550.

chei omega-max
Numărul maxim de chei utilizate de soluția Omega. Valoarea implicită este 500.

omega-elimină-redundante-constrângeri
Când este setată la 1, utilizați metode scumpe pentru a elimina toate constrângerile redundante. The
valoarea implicită este 0.

versiunea-vect-max-pentru-verificări-aliniere
Numărul maxim de verificări în timpul execuției care pot fi efectuate atunci când se efectuează bucla
versiunea pentru aliniere în vectorizator.

versiunea-vect-max-pentru-verificări-alias
Numărul maxim de verificări în timpul execuției care pot fi efectuate atunci când se efectuează bucla
versiunea pentru alias în vectorizator.

vect-max-peeling-pentru-aliniere
Numărul maxim de decupări de bucle pentru a îmbunătăți alinierea accesului pentru vectorizator. Valoare
-1 înseamnă „fără limită”.

max-iterații-pentru a urmări
Numărul maxim de iterații ale unei bucle a algoritmului de forță brută pentru analiză
a numărului de iterații ale buclei pe care încearcă să le evalueze.

hot-bb-count-ws-permille
Un număr de profil de bloc de bază este considerat fierbinte dacă contribuie la data
permilajul (adică 0...1000) al întregii execuţii profilate.

fracție-frecvență-hot-bb
Selectați o fracțiune din frecvența blocului de intrare a execuțiilor blocului de bază în
funcția dată de blocul de bază trebuie să fie considerată fierbinte.

max-predicte-iterații
Numărul maxim de iterații în buclă pe care îl prezicem static. Acest lucru este util în
cazurile în care o funcție conține o singură buclă cu o legătură cunoscută și o altă buclă
cu legat necunoscut. Numărul cunoscut de iterații este prezis corect, în timp ce
numărul necunoscut de iterații este în medie la aproximativ 10. Aceasta înseamnă că bucla
fără limite apare artificial rece în raport cu celălalt.

probabilitate-așteaptă-încorporată
Controlați probabilitatea ca expresia să aibă valoarea specificată. Acest
parametrul ia un procent (adică 0 ... 100) ca intrare. Probabilitatea implicită
de 90 se obţine empiric.

alinierea-prag
Selectați o fracțiune din frecvența maximă a execuțiilor unui bloc de bază în a
funcția de aliniere a blocului de bază.

aliniere-bucla-iterații
O buclă care se așteaptă să repete cel puțin numărul selectat de iterații este aliniată.

tracer-dinamic-acoperire
tracer-dinamic-acoperire-feedback
Această valoare este utilizată pentru a limita formarea superblocului odată ce procentul dat de
instrucțiunile executate sunt acoperite. Acest lucru limitează extinderea inutilă a dimensiunii codului.

tracer-dinamic-acoperire-feedback este utilizat numai atunci când feedbackul de profil este
disponibil. Profilurile reale (spre deosebire de cele estimate static) sunt multe
mai puțin echilibrat, permițând pragului să fie o valoare mai mare.

tracer-max-cod-creștere
Opriți duplicarea cozii odată ce creșterea codului a atins un anumit procent. Acesta este un
limită mai degrabă artificială, deoarece majoritatea duplicatelor sunt eliminate ulterior prin încrucișare
săritură, deci poate fi setat la valori mult mai mari decât este creșterea dorită a codului.

tracer-min-ramură-raport
Opriți creșterea inversă atunci când probabilitatea inversă de cea mai bună margine este mai mică decât aceasta
prag (în procente).

tracer-min-ramură-raport
tracer-min-ramură-raport-feedback
Opriți creșterea înainte dacă cea mai bună margine are probabilitatea mai mică decât acest prag.

În mod similar cu tracer-dinamic-acoperire două valori sunt prezente, una pentru compilare
pentru feedback de profil și unul pentru compilare fără. Valoarea pentru compilare
cu feedback de profil trebuie să fie mai conservator (mai mare) pentru a face
trasor eficient.

max-cse-path-lungime
Numărul maxim de blocuri de bază pe cale pe care le ia în considerare CSE. Valoarea implicită este 10.

max-cse-insns
Numărul maxim de instrucțiuni procesate de CSE înainte de spălare. Valoarea implicită este
1000.

ggc-min-expand
GCC folosește un colector de gunoi pentru a-și gestiona propria alocare de memorie. Acest parametru
specifică procentul minim cu care ar trebui să fie grămada colectorului de gunoi
permis să se extindă între colecții. Ajustarea acestui lucru poate îmbunătăți viteza de compilare;
nu are niciun efect asupra generării codului.

Valoarea implicită este 30% + 70% * (RAM/1GB) cu o limită superioară de 100% când RAM >= 1GB.
Dacă „getrlimit” este disponibil, noțiunea de „RAM” este cea mai mică dintre RAM-ul real și
„RLIMIT_DATA” sau „RLIMIT_AS”. Dacă GCC nu este capabil să calculeze RAM pe un anumit
platformă, se utilizează limita inferioară de 30%. Setarea acestui parametru și ggc-min-
heapsize la zero face ca o colectare completă să aibă loc la fiecare ocazie. Aceasta este
extrem de lent, dar poate fi util pentru depanare.

ggc-min-heapsize
Dimensiunea minimă a mormanului colectorului de gunoi înainte ca acesta să înceapă să se deranjeze să colecteze
gunoi. Prima colecție are loc după ce grămada se extinde ggc-min-expand%
Dincolo de ggc-min-heapsize. Din nou, reglarea acestui lucru poate îmbunătăți viteza de compilare și
nu are niciun efect asupra generării codului.

Valoarea implicită este cea mai mică dintre RAM/8, RLIMIT_RSS sau o limită pe care încearcă să o asigure
că RLIMIT_DATA sau RLIMIT_AS nu sunt depășite, dar cu o limită inferioară de 4096
(patru megaocteți) și o limită superioară de 131072 (128 megaocteți). Dacă GCC nu poate
pentru a calcula RAM pe o anumită platformă, se folosește limita inferioară. Setarea asta
parametrul foarte mare dezactivează efectiv colectarea gunoiului. Setarea asta
parametru și ggc-min-expand la zero determină o colectare completă la fiecare
oportunitate.

max-reload-search-insns
Numărul maxim de reîncărcări de instrucțiuni ar trebui să caute echivalentul înapoi
Inregistreaza-te. Creșterea valorilor înseamnă o optimizare mai agresivă, făcând
Creșterea timpului de compilare cu o performanță probabil puțin mai bună. Implicit
valoarea este 100.

max-cselib-memory-locations
Numărul maxim de locații de memorie ar trebui să ia în considerare cselib.
Creșterea valorilor înseamnă o optimizare mai agresivă, făcând timpul de compilare
crește cu o performanță probabil ceva mai bună. Valoarea implicită este 500.

reordonare-blocuri-duplicare
reordonare-blocuri-duplicare-feedback
Folosit de trecerea de reordonare a blocurilor de bază pentru a decide dacă se utilizează necondiționat
ramificați sau duplicați codul la destinație. Codul este duplicat atunci când este
dimensiunea estimată este mai mică decât această valoare înmulțită cu dimensiunea estimată a
salt necondiționat în punctele fierbinți ale programului.

reordonare-blocare-duplicare-feedback este utilizat numai atunci când feedbackul de profil este
disponibil. Poate fi setat la valori mai mari decât reordonare-bloc-duplicare întrucât
informațiile despre punctele fierbinți sunt mai precise.

max-sched-ready-insns
Numărul maxim de instrucțiuni gata de a fi emise trebuie să fie programat
luați în considerare în orice moment în timpul primei treceri de programare. Creșterea valorilor
înseamnă căutări mai amănunțite, ceea ce face ca timpul de compilare să crească cu probabil
putin beneficiu. Valoarea implicită este 100.

blocuri-regionale-programate-max
Numărul maxim de blocuri dintr-o regiune care trebuie luate în considerare pentru interblocare
programare. Valoarea implicită este 10.

max-pipeline-region-blocks
Numărul maxim de blocuri dintr-o regiune care trebuie luate în considerare pentru conducte în
programator selectiv. Valoarea implicită este 15.

max-sched-region-insns
Numărul maxim de insns dintr-o regiune care trebuie luate în considerare pentru interblocare
programare. Valoarea implicită este 100.

max-pipeline-region-insns
Numărul maxim de insns dintr-o regiune care trebuie luat în considerare pentru conducte în
programator selectiv. Valoarea implicită este 200.

min-spec-prob
Probabilitatea minimă (în procente) de a ajunge la un bloc sursă pentru interblocare
programare speculativă. Valoarea implicită este 40.

max-sched-extend-regions-iters
Numărul maxim de iterații prin CFG pentru extinderea regiunilor. O valoare de 0 (
implicit) dezactivează extensiile de regiune.

max-sched-insn-conflict-delay
Întârzierea maximă a conflictului pentru ca un insn să fie luat în considerare pentru mișcarea speculativă.
Valoarea implicită este 3.

sched-spec-prob-cutoff
Probabilitatea minimă de succes a speculațiilor (în procente), deci speculativă
insn-urile sunt programate. Valoarea implicită este 40.

sched-spec-state-edge-prob-cutoff
Probabilitatea minimă pe care trebuie să o aibă o margine pentru ca programatorul să-și salveze starea
peste ea. Valoarea implicită este 10.

sched-mem-true-dep-cost
Distanța minimă (în cicluri CPU) între stocare și încărcare care vizează aceeași memorie
locatii. Valoarea implicită este 1.

selsched-max-lookahead
Dimensiunea maximă a ferestrei de anticipare a programării selective. Este o adâncime
de căutare a instrucțiunilor disponibile. Valoarea implicită este 50.

selsched-max-sched-times
Numărul maxim de ori în care o instrucțiune este programată în timpul selectivului
programare. Aceasta este limita numărului de iterații prin care
instrucțiunile pot fi canalizate. Valoarea implicită este 2.

selsched-max-insns-to-redenumire
Numărul maxim de cele mai bune instrucțiuni din lista pregătită pentru care sunt luate în considerare
redenumirea în planificatorul selectiv. Valoarea implicită este 2.

sms-min-sc
Valoarea minimă a numărului de etape pe care o generează programatorul swing modulo. The
valoarea implicită este 2.

max-ultima-valoare-rtl
Dimensiunea maximă măsurată ca număr de RTL-uri care pot fi înregistrate într-o expresie
în combinator pentru un pseudoregistru ca ultima valoare cunoscută a acelui registru. The
implicit este 10000.

limita-cota-întreg
Constantele întregi mici pot folosi o structură de date partajată, reducând cea a compilatorului
utilizarea memoriei și creșterea vitezei acesteia. Aceasta setează valoarea maximă a unui shared
constantă întreagă. Valoarea implicită este 256.

ssp-buffer-size
Dimensiunea minimă a bufferelor (adică matrice) care primesc protecție împotriva distrugerii stivei
cand -fstack-protection este folosit.

Această implicită înainte de Ubuntu 10.10 era „8”. În prezent este „4”, pentru a crește
numărul de funcții protejate de protectorul stivei.

dimensiune minimă pentru partajarea stivei
Dimensiunea minimă a variabilelor care participă la partajarea sloturilor stivei atunci când nu
optimizare. Valoarea implicită este 32.

max-jump-thread-duplicare-stmts
Numărul maxim de instrucțiuni permise într-un bloc care trebuie duplicat când
salturi de filet.

maxim-câmpuri-pentru-câmp-sensibil
Numărul maxim de câmpuri dintr-o structură tratate într-o manieră sensibilă la câmp în timpul
analiza pointerului. Valoarea implicită este zero pentru -O0 și -O1și 100 pentru -Os, -O2, și
-O3.

prefetch-latency
Estimați numărul mediu de instrucțiuni care sunt executate înainte de preluare preliminară
finisaje. Distanța preprelevată înainte este proporțională cu această constantă.
Creșterea acestui număr poate duce, de asemenea, la preluarea prealabilă a mai puține fluxuri (vezi
simultane-prefetches).

simultane-prefetches
Număr maxim de preluări care pot rula în același timp.

l1-cache-line-size
Dimensiunea liniei de cache din memoria cache L1, în octeți.

l1-cache-size
Dimensiunea cache-ului L1, în kiloocteți.

l2-cache-size
Dimensiunea cache-ului L2, în kiloocteți.

raportul-min-insn-la-preluare
Raportul minim dintre numărul de instrucțiuni și numărul de preluări
pentru a activa preîncărcarea într-o buclă.

prefetch-min-insn-la-mem-raport
Raportul minim dintre numărul de instrucțiuni și numărul de memorie
referințe pentru a activa preîncărcarea într-o buclă.

folosire-tipuri-canonice
Dacă compilatorul ar trebui să folosească sistemul de tip „canonic”. Implicit, aceasta
ar trebui să fie întotdeauna 1, care utilizează un mecanism intern mai eficient pentru comparare
tipuri în C++ și Objective-C++. Cu toate acestea, dacă erori în sistemul de tip canonic sunt
provocând erori de compilare, setați această valoare la 0 pentru a dezactiva tipurile canonice.

comutator-conversie-max-raport-ramură
Conversia de inițializare a comutatorului refuză să creeze matrice care sunt mai mari decât
comutator-conversie-max-raport-ramură ori numărul de ramuri din comutator.

max-partial-antic-lungime
Lungimea maximă a setului antic parțial calculat în timpul parțialului arborelui
optimizarea eliminării redundanței (-fttree-pre) la optimizarea la -O3 Si mai sus.
Pentru unele tipuri de cod sursă, eliminarea redundanței parțiale îmbunătățite
optimizarea poate fugi, consumând toată memoria disponibilă pe gazdă
mașinărie. Acest parametru stabilește o limită pentru lungimea seturilor care sunt calculate,
care previne comportamentul de fuga. Setarea unei valori de 0 pentru acest parametru
permite o lungime nelimitată.

sccvn-max-scc-size
Dimensiunea maximă a unei componente puternic conectate (SCC) în timpul procesării SCCVN. Dacă
această limită este atinsă, procesarea SCCVN pentru întreaga funcție nu este realizată și
optimizările în funcție de ele sunt dezactivate. Dimensiunea SCC maximă implicită este
10000.

sccvn-max-alias-queries-per-access
Numărul maxim de interogări alias-oracle pe care le efectuăm atunci când căutăm redundanțe
pentru încărcături și depozite. Dacă această limită este atinsă, căutarea este anulată și încărcarea sau
magazinul nu este considerat redundant. Numărul de interogări este algoritmic
limitat la numărul de magazine pe toate căile de la încărcare la intrarea funcției.
Numărul maxim implicit de interogări este 1000.

ira-max-bucle-num
IRA utilizează implicit alocarea registrului regional. Dacă o funcție conține mai multe
bucle decât numărul dat de acest parametru, doar cel mult numărul dat de
buclele cel mai frecvent executate formează regiuni pentru alocarea registrului regional.
Valoarea implicită a parametrului este 100.

ira-max-conflict-table-size
Deși IRA folosește un algoritm sofisticat pentru a comprima tabelul de conflict,
tabelul poate încă necesita cantități excesive de memorie pentru funcții uriașe. Dacă
tabelul de conflict pentru o funcție ar putea fi mai mare decât dimensiunea în MB dată de aceasta
parametrul, alocatorul de registru folosește în schimb un parametru mai rapid, mai simplu și mai mic.
algoritm de calitate care nu necesită construirea unui tabel de conflict pseudo-registru.
Valoarea implicită a parametrului este 2000.

ira-bucla-rezervat-regs
IRA poate fi utilizat pentru a evalua presiunea mai precisă a registrului în bucle pentru decizii
pentru a muta invarianții buclei (vezi -O3). Numărul de registre disponibile rezervat pentru
alte scopuri sunt date de acest parametru. Valoarea implicită a
parametrul este 2, care este numărul minim de registre necesare pentru tipic
instrucțiuni. Această valoare este cea mai bună găsită din numeroase experimente.

buclă-invariant-max-bbs-în-buclă
Mișcarea invariantă în buclă poate fi foarte costisitoare, atât în ​​timpul de compilare, cât și în
cantitatea necesară de memorie în timp de compilare, cu bucle foarte mari. Bucle cu mai multe
blocurile de bază decât acest parametru nu vor avea optimizare a mișcării invariante în buclă
efectuate asupra lor. Valoarea implicită a parametrului este 1000 pentru -O1 și 10000
pentru -O2 Si mai sus.

loop-max-datarefs-for-datadeps
Construirea dependențelor de date este costisitoare pentru bucle foarte mari. Acest parametru
limitează numărul de referințe de date în bucle care sunt luate în considerare pentru date
analiza dependenței. Aceste bucle mari nu sunt gestionate de optimizările care utilizează
dependențe de date în buclă. Valoarea implicită este 1000.

max-vartrack-size
Setează un număr maxim de sloturi de tabel hash de utilizat în timpul fluxului de date de urmărire variabilă
analiza oricărei funcții. Dacă această limită este depășită cu urmărirea variabilă la
atribuiri activate, analiza pentru funcția respectivă este reîncercată fără aceasta, după
eliminând toate insn-urile de depanare din funcție. Dacă limita este depăşită chiar şi fără
depanare insns, analiza de urmărire var este complet dezactivată pentru funcție.
Setarea parametrului la zero îl face nelimitat.

max-vartrack-expr-depth
Setează un număr maxim de niveluri de recursivitate atunci când se încearcă maparea numelor de variabile sau
depanați temporare pentru a valorifica expresiile. Acest lucru schimbă timpul de compilare pentru mai mult
informații complete de depanare. Dacă acest lucru este setat prea mic, valorează expresiile care sunt
disponibil și ar putea fi reprezentat în informațiile de depanare poate ajunge să nu fie utilizat;
setarea mai mare poate permite compilatorului să găsească o depanare mai complexă
expresii, dar timpul de compilare și utilizarea memoriei pot crește. Valoarea implicită este 12.

min-nondebug-insn-uid
Utilizați uid-uri începând cu acest parametru pentru insns nondebug. Intervalul de sub
parametrul este rezervat exclusiv pentru insn-urile de depanare create de
-fvar-tracking-assignments, dar insn-urile de depanare pot obține uid-uri (nesuprapuse) mai sus
aceasta dacă intervalul rezervat este epuizat.

ipa-sra-ptr-factor-de-creștere
IPA-SRA înlocuiește un pointer către un agregat numai cu unul sau mai mulți parametri noi
când dimensiunea lor cumulativă este mai mică sau egală cu ipa-sra-ptr-factor-de-creștere ori de
dimensiunea parametrului pointerului original.

tm-max-agregate-size
Când se fac copii ale variabilelor locale de fir într-o tranzacție, acest parametru
specifică dimensiunea în octeți după care variabilele sunt salvate cu înregistrarea în jurnal
funcţionează spre deosebire de perechile de secvenţe de cod de salvare/restaurare. Doar această opțiune
se aplică la utilizare -fgnu-tm.

grafit-max-nb-scop-params
Pentru a evita efectele exponențiale în transformările buclei de grafit, numărul de
parametrii dintr-o parte de control static (SCoP) este mărginit. Valoarea implicită este 10
parametrii. O variabilă a cărei valoare este necunoscută la momentul compilării și definită
în afara unui SCoP este un parametru al SCoP.

grafit-max-bbs-pe-funcție
Pentru a evita efectele exponențiale în detectarea SCoP, dimensiunea funcțiilor
analizat de Grafit este mărginit. Valoarea implicită este de 100 de blocuri de bază.

bucla-bloc-tigla-dimensiune
Blocarea buclei sau transformările de extragere în bandă, activate cu -floop-bloc or
-floop-strip-mina, strip mine fiecare buclă din cuibul buclei cu un număr dat de
iterații. Lungimea benzii poate fi modificată folosind bucla-bloc-tigla-dimensiune
parametru. Valoarea implicită este de 51 de iterații.

ipa-cp-value-list-size
IPA-CP încearcă să urmărească toate valorile și tipurile posibile transmise unei funcții
parametru pentru a le propaga și a efectua devirtualizarea. ipa-cp-valoare-
dimensiunea listei este numărul maxim de valori și tipuri pe care le stochează pentru un formal
parametrul unei funcții.

ipa-cp-eval-threshold
IPA-CP își calculează propriul punctaj de euristică a rentabilității clonării și performanțe
acele oportunități de clonare cu scoruri care depășesc ipa-cp-eval-threshold.

ipa-max-agg-items
IPA-CP este, de asemenea, capabil să propage un număr de valori scalare transmise într-un
agregat. ipa-max-agg-items controlează numărul maxim de astfel de valori pe unul
parametru.

ipa-cp-buclă-hint-bonus
Când IPA-CP determină că un candidat la clonare ar face numărul de
iterații ale unei bucle cunoscute, adaugă un bonus de ipa-cp-buclă-hint-bonus bonus la
scorul de profitabilitate al candidatului.

ipa-cp-array-index-hint-bonus
Când IPA-CP determină că un candidat de clonare ar face indexul unui tablou
acces cunoscut, adaugă un bonus de ipa-cp-array-index-hint-bonus bonus la
scorul de profitabilitate al candidatului.

lto-partitii
Specificați numărul dorit de partiții produse în timpul compilării WHOPR. The
numărul de partiții ar trebui să depășească numărul de procesoare utilizate pentru compilare. The
valoarea implicită este 32.

lto-minpartition
Dimensiunea partiției minime pentru WHOPR (în instrucțiuni estimate). Acest lucru previne
cheltuielile de împărțire a programelor foarte mici în prea multe partiții.

cxx-max-namespaces-for-diagnostic-help
Numărul maxim de spații de nume de consultat pentru sugestii la căutarea numelui C++
eșuează pentru un identificator. Valoarea implicită este 1000.

prag-frecvență-scădere
Frecvența maximă de execuție relativă (în procente) a blocului țintă
relativ la blocul inițial al unei instrucțiuni pentru a permite scufundarea instrucțiunii a
afirmație. Cifrele mai mari au ca rezultat o scufundare mai agresivă a declarațiilor. The
valoarea implicită este 75. Se aplică o mică ajustare pozitivă pentru declarațiile cu
operanzi de memorie, deoarece aceștia sunt și mai profitabili, așa că se scufundă.

max-magazine-la-chiuvetă
Numărul maxim de perechi de magazine condiționate care pot fi scufundate. Setați la 0 dacă
fie vectorizare (-fttree-vectoriza) sau if-conversie (-ftree-loop-dacă-conversie)
este dezactivat. Valoarea implicită este 2.

permite-încărcare-date-curse
Permiteți optimizatorilor să introducă noi curse de date pe încărcări. Setați la 1 pentru a permite,
în caz contrar, la 0. Această opțiune este activată implicit, cu excepția cazului în care este setată implicit de către
-fmemory-model= opțiune.

permite-stocare-date-curse
Permiteți optimizatorilor să introducă noi curse de date în magazine. Setați la 1 pentru a permite,
în caz contrar, la 0. Această opțiune este activată implicit, cu excepția cazului în care este setată implicit de către
-fmemory-model= opțiune.

permit-ambalate-încărcare-date-curse
Permiteți optimizatorilor să introducă noi curse de date pe încărcările de date împachetate. Setați la 1 la
permit, în caz contrar la 0. Această opțiune este activată implicit, dacă nu este setată implicit de
il -fmemory-model= opțiune.

permit-ambalate-magazin-date-curse
Permiteți optimizatorilor să introducă noi curse de date în depozitele de date pline. Setați la 1 la
permit, în caz contrar la 0. Această opțiune este activată implicit, dacă nu este setată implicit de
il -fmemory-model= opțiune.

prag-valoare-caz
Cel mai mic număr de valori diferite pentru care este cel mai bine să utilizați un jump-table
în locul unui arbore de ramuri condiționate. Dacă valoarea este 0, utilizați valoarea implicită pentru
Mașina. Valoarea implicită este 0.

tree-reassoc-width
Setați numărul maxim de instrucțiuni executate în paralel în arborele reasociat.
Acest parametru înlocuiește euristicile dependente de țintă utilizate în mod implicit dacă nu are
valoare zero.

algoritmul-presiunii-sched
Alegeți dintre cele două implementări disponibile ale -fsched-presiune. Algoritmul 1
este implementarea originală și este mai probabil să împiedice instrucțiunile de la
fiind reordonată. Algoritmul 2 a fost conceput pentru a fi un compromis între
abordarea relativ conservatoare adoptată de algoritmul 1 și cea mai degrabă agresivă
abordare adoptată de planificatorul implicit. Se bazează mai mult pe a avea un
fișier registru obișnuit și clase precise de presiune a registrului. Vedea haifa-sched.c
în sursele GCC pentru mai multe detalii.

Alegerea implicită depinde de țintă.

max-slsr-cand-scan
Setați numărul maxim de candidați existenți care vor fi luați în considerare la căutare
o bază pentru un nou candidat pentru reducerea rezistenței în linie dreaptă.

asan-globali
Activați detectarea depășirii tamponului pentru obiectele globale. Acest tip de protecție este
activat în mod implicit dacă utilizați -fsanitize=adresa opțiune. Pentru a dezactiva global
utilizarea protectiei obiectelor --param asan-globals=0.

asan-stivă
Activați detectarea depășirii tamponului pentru obiectele stive. Acest tip de protecție este
activat în mod implicit la utilizare-fsanitize=adresa. Pentru a dezactiva utilizarea protecției stivei
--param asan-stack=0 opțiune.

asan-instrument-citeşte
Activați detectarea depășirii tamponului pentru citirile din memorie. Acest tip de protecție este
activat în mod implicit la utilizare -fsanitize=adresa. Pentru a dezactiva citirile din memorie
utilizarea protectiei --param asan-instrument-reads=0.

asan-instrument-scrie
Activați detectarea depășirii tamponului pentru scrierile în memorie. Acest tip de protecție este
activat în mod implicit la utilizare -fsanitize=adresa. Pentru a dezactiva scrierea în memorie
utilizarea protectiei --param asan-instrument-writes=0 opțiune.

asan-memintrin
Activați detectarea pentru funcțiile încorporate. Acest tip de protecție este activat de
implicit la utilizare -fsanitize=adresa. Pentru a dezactiva protecția funcțiilor încorporate
utilizare --param asan-memintrin=0.

asan-utilizare-după-întoarcere
Activați detectarea utilizării după returnare. Acest tip de protecție este activat de
implicit la utilizare -fsanitize=adresa opțiune. Pentru a dezactiva utilizarea după returnare
utilizarea de detectare --param asan-utilizare-după-retur=0.

asan-instrumentație-cu-apel-prag
Dacă numărul de accesări la memorie în funcția instrumentată este mai mare sau egal cu
acest număr, utilizați apeluri inverse în loc de verificări inline. De exemplu, pentru a dezactiva codul inline
utilizare --param asan-instrumentation-with-call-threshold=0.

Opţiuni Controlul il Preprocesor
Aceste opțiuni controlează preprocesorul C, care este rulat pe fiecare fișier sursă C înainte de efectiv
compilare.

Dacă utilizați -E opțiunea, nu se face nimic în afară de preprocesare. Unele dintre aceste opțiuni
au sens numai împreună cu -E deoarece fac ca ieșirea preprocesorului să fie
nepotrivit pentru compilarea propriu-zisă.

-Wp,opțiune
Poți să folosești -Wp,opțiune pentru a ocoli driverul compilatorului și a trece opțiune direct prin
la preprocesor. Dacă opțiune conține virgule, este împărțit în mai multe opțiuni la
virgulele. Cu toate acestea, multe opțiuni sunt modificate, traduse sau interpretate de către
driverul compilatorului înainte de a fi transmis preprocesorului și -Wp ocolește forțat
această fază. Interfața directă a preprocesorului este nedocumentată și supusă
schimbare, așa că, ori de câte ori este posibil, ar trebui să evitați utilizarea -Wp și lăsați șoferul să se ocupe de
opțiuni în schimb.

-Xpreprocesor opțiune
Trece opțiune ca opțiune pentru preprocesor. Puteți folosi acest lucru pentru a furniza sistem-
opțiuni specifice de preprocesor pe care GCC nu le recunoaște.

Dacă doriți să treceți o opțiune care preia un argument, trebuie să utilizați -Xpreprocesor
de două ori, o dată pentru opțiune și o dată pentru argument.

-fără-integrat-cpp
Efectuați preprocesarea ca o trecere separată înainte de compilare. În mod implicit, GCC funcționează
preprocesarea ca parte integrată a tokenizării și analizei de intrare. Dacă această opțiune
este furnizat, front-end-ul pentru limba corespunzătoare (cc1, cc1plus, Sau cc1obj pentru C, C++,
și, respectiv, Objective-C) este în schimb invocat de două ori, o dată doar pentru preprocesare
și o dată pentru compilarea efectivă a intrării preprocesate. Această opțiune poate fi utilă
în colaborare cu -B or -invelis opțiuni pentru a specifica un preprocesor alternativ sau
efectuează procesări suplimentare ale sursei programului între preprocesarea normală și
compilare.

-D nume
Predefinit nume ca macro, cu definiția 1.

-D nume=definiție
Conținutul definiție sunt tokenizate și procesate ca și cum ar fi apărut în timpul
faza de traducere trei în a #defini directivă. În special, definiția va fi
trunchiată de caractere încorporate în noua linie.

Dacă invocați preprocesorul dintr-un shell sau un program asemănător shell-ului de care aveți nevoie
pentru a utiliza sintaxa de ghilimele shell-ului pentru a proteja caractere precum spațiile care au a
sens în sintaxa shell.

Dacă doriți să definiți o macrocomandă asemănătoare unei funcții pe linia de comandă, scrieți argumentul acesteia
listă cu paranteze înconjurătoare înainte de semnul egal (dacă există). Parantezele sunt
semnificativ pentru majoritatea shell-urilor, așa că va trebui să citați opțiunea. Cu sh și csh,
-D'nume(argumente...)=definiție' funcționează.

-D și -U opțiunile sunt procesate în ordinea în care sunt date pe linia de comandă. Toate
-imacros fişier și -include fişier opțiunile sunt procesate până la urmă -D și -U opțiuni.

-U nume
Anulați orice definiție anterioară a nume, fie încorporat, fie prevăzut cu a -D opțiune.

-undef
Nu predefiniți macrocomenzi specifice sistemului sau specifice GCC. Standardul predefinit
macrourile rămân definite.

-I dir
Adăugați directorul dir la lista directoarelor de căutat pentru fișierele antet.
Directoare numite de -I sunt căutate înainte ca sistemul standard să includă directoare.
Dacă directorul dir este un director standard de includere a sistemului, opțiunea este ignorată
asigurați-vă că ordinea implicită de căutare pentru directoarele de sistem și tratamentul special
din anteturile sistemului nu sunt învinse. Dacă dir începe cu „=", apoi „=" va fi
înlocuit cu prefixul sysroot; vedea --sysroot și -isysroot.

-o fişier
Scrie ieșire în fişier. Aceasta este la fel cu specificarea fişier ca a doua non-opțiune
argument pentru cpp. gcc are o interpretare diferită a unui al doilea argument fără opțiune,
deci trebuie sa folosesti -o pentru a specifica fișierul de ieșire.

-Perete
Activează toate avertismentele opționale care sunt de dorit pentru codul normal. În prezent aceasta
is -Wcomentează, - Trigrafii, -Wmultichar și un avertisment despre promovarea numărului întreg care provoacă a
schimbarea semnului în expresiile „#if”. Rețineți că multe dintre avertismentele preprocesorului
sunt activate în mod implicit și nu au opțiuni pentru a le controla.

-Wcomentează
-Wcomentarii
Avertizați de fiecare dată când începe o secvență de comentarii /* apare într-o /* comentariu sau ori de câte ori a
backslash-newline apare într-un // cometariu. (Ambele forme au același efect.)

- Trigrafii
Majoritatea trigrafelor din comentarii nu pot afecta sensul programului. Cu toate acestea, a
trigraf care ar forma o linie nouă scăpată (??/ la capătul unei linii) poate, de
schimbând locul în care începe sau se termină comentariul. Prin urmare, doar trigrafe care s-ar forma
liniile noi scăpate produc avertismente în interiorul unui comentariu.

Această opțiune este implicată de -Perete. Dacă -Perete nu este dat, această opțiune este încă activată
cu excepția cazului în care trigrafurile sunt activate. Pentru a obține conversia trigraf fără avertismente, dar obțineți
celălalt -Perete avertismente, utilizare -trigrafe -Perete -Wno-trigrafe.

- Tradițional
Avertizați asupra anumitor constructe care se comportă diferit în tradițional și ISO C. De asemenea
avertizează despre constructele ISO C care nu au echivalent C tradițional și problematice
constructe care ar trebui evitate.

-Wundef
Avertizați de fiecare dată când un identificator care nu este o macrocomandă este întâlnit într-un #dacă directivă,
in afara de definit. Astfel de identificatori sunt înlocuiți cu zero.

-Wunused-macro-uri
Avertizați despre macrocomenzile definite în fișierul principal care nu sunt utilizate. O macro este utilizat dacă este
extins sau testat pentru existență cel puțin o dată. Preprocesorul va avertiza, de asemenea, dacă
macrocomanda nu a fost utilizată în momentul în care este redefinită sau nedefinită.

Macrocomenzi încorporate, macrocomenzi definite pe linia de comandă și macrocomenzi definite în include
fișierele nu sunt avertizate.

Notă: Dacă o macrocomandă este de fapt utilizată, dar este folosită numai în blocurile condiționale ignorate, atunci
CPP îl va raporta ca neutilizat. Pentru a evita avertismentul într-un astfel de caz, s-ar putea să vă îmbunătățiți
domeniul de aplicare al definiției macrocomenzii, de exemplu, mutându-l în primul omis
bloc. Alternativ, puteți oferi o utilizare inactivă cu ceva de genul:

#dacă este definită_macro_causing_the_warning
#endif

-Wendif-etichete
Avertizați ori de câte ori un #altfel sau un #endif sunt urmate de text. Acest lucru se întâmplă de obicei în
codul formularului

#dacă FOO
...
#altfel FOO
...
#endif FOO

Al doilea și al treilea „FOO” ar trebui să fie în comentarii, dar adesea nu sunt în programe mai vechi.
Acest avertisment este activat în mod implicit.

-Eroare
Transformă toate avertismentele în erori grele. Codul sursă care declanșează avertismente va fi
respins.

-Wsystem-anteturi
Emiteți avertismente pentru codul din anteturile sistemului. Acestea sunt în mod normal inutile pentru a găsi
erori în propriul cod, prin urmare suprimate. Dacă sunteți responsabil pentru sistem
bibliotecă, poate doriți să le vedeți.

-w Suprimați toate avertismentele, inclusiv cele pe care GNU CPP le emite în mod implicit.

-pedant
Emiteți toate diagnosticele obligatorii enumerate în standardul C. Unii dintre ei au rămas
în mod implicit, deoarece se declanșează frecvent pe cod inofensiv.

-pedant-erori
Emiteți toate diagnosticele obligatorii și transformați toate diagnosticele obligatorii în erori.
Aceasta include diagnostice obligatorii fără care GCC emite -pedant dar tratează ca
Avertizări.

-M În loc să scoateți rezultatul preprocesării, scoateți o regulă potrivită pentru face
descriind dependențele fișierului sursă principal. Preprocesorul scoate unul
face regula care conține numele fișierului obiect pentru acel fișier sursă, două puncte și numele
dintre toate fișierele incluse, inclusiv cele care provin din -include or -imacros comandă
opțiuni de linie.

Dacă nu este specificat în mod explicit (cu -MT or -MQ), numele fișierului obiect este format din
numele fișierului sursă cu orice sufix înlocuit cu sufixul fișierului obiect și cu oricare
părțile directorului principal eliminate. Dacă sunt multe fișiere incluse, atunci regula este
împărțit în mai multe linii folosind \-linie nouă. Regula nu are comenzi.

Această opțiune nu suprimă ieșirea de depanare a preprocesorului, cum ar fi -dM. A evita
amestecând astfel de rezultate de depanare cu regulile de dependență, ar trebui să specificați în mod explicit
fișier de ieșire a dependenței cu -MF, sau utilizați o variabilă de mediu precum
DEPENDENCE_OUTPUT. Ieșirea de depanare va fi trimisă în continuare către fluxul de ieșire obișnuit ca
normale.

Care trece -M către șofer implică -E, și suprimă avertismentele cu un implicit -w.

-MM Aprecieri -M dar nu menționați fișierele antet care se găsesc în directoarele antet de sistem,
nici fișierele de antet care sunt incluse, direct sau indirect, dintr-un astfel de antet.

Aceasta implică faptul că alegerea parantezelor unghiulare sau ghilimele duble într-un #include
directiva nu determină în sine dacă acel antet va apărea în -MM
ieșire de dependență. Aceasta este o ușoară schimbare în semantică față de GCC versiunile 3.0 și
mai devreme.

-MF fişier
Când este utilizat cu -M or -MM, specifică un fișier în care să scrieți dependențele. Daca nu -MF
comutatorul este dat, preprocesorul trimite regulile în același loc în care ar fi trimis
ieșire preprocesată.

Când este utilizat cu opțiunile de driver -MD or -MMD, -MF suprascrie dependența implicită
fisier de iesire.

-MG În combinație cu o opțiune precum -M solicitând generarea de dependență, -MG presupune
fișierele de antet lipsă sunt fișiere generate și le adaugă la lista de dependențe fără
ridicând o eroare. Numele fișierului dependenței este preluat direct din „#include”
directivă fără a preda vreo cale. -MG de asemenea, suprimă ieșirea preprocesată, ca a
lipsa fișierului antet face acest lucru inutil.

Această caracteristică este utilizată în actualizarea automată a fișierelor make.

-MP Această opțiune îi cere CPP să adauge o țintă falsă pentru fiecare dependență, alta decât cea
fișierul principal, făcându-i pe fiecare să nu depindă de nimic. Aceste reguli false funcționează în jurul erorilor
face oferă dacă eliminați fișierele antet fără a actualiza makefile a se potrivi.

Aceasta este ieșirea tipică:

test.o: test.c test.h

test.h:

-MT ţintă
Schimbați ținta regulii emisă de generarea dependenței. În mod implicit, CPP ia
numele fișierului de intrare principal, șterge orice componente de director și orice sufix de fișier
precum .cși adaugă sufixul obiect obișnuit al platformei. Rezultatul este ținta.

An -MT opțiunea va seta ținta să fie exact șirul pe care îl specificați. Daca vrei
ținte multiple, le puteți specifica ca un singur argument pentru -MT, sau folosiți mai multe
-MT opțiuni.

De exemplu, -MT „$(objpfx)foo.o” ar putea da

$(objpfx)foo.o: foo.c

-MQ ţintă
La fel ca -MT, dar citează orice caractere care sunt speciale pentru a crea.
-MQ „$(objpfx)foo.o” oferă

$$(objpfx)foo.o: foo.c

Ținta implicită este cotată automat, ca și cum ar fi fost dată cu -MQ.

-MD -MD este echivalent cu -M -MF fişier, cu excepția asta -E nu este subînțeles. Soferul
determină fişier pe baza faptului că an -o este dată opțiunea. Dacă este, șoferul îl folosește
argument dar cu un sufix de .d, altfel ia numele fișierului de intrare,
elimină orice componente și sufix de director și aplică a .d sufix.

If -MD este folosit împreună cu -E, orice -o comutatorul este înțeles pentru a specifica
fișier de ieșire al dependenței, dar dacă este folosit fără -E, fiecare -o se înțelege că specifică a
fișier obiect țintă.

Întrucât -E nu este subînțeles, -MD poate fi folosit pentru a genera un fișier de ieșire de dependență ca a
efect secundar al procesului de compilare.

-MMD
Aprecieri -MD cu excepția menționării numai a fișierelor antet utilizator, nu a fișierelor antet de sistem.

-fpch-deps
Când utilizați anteturi precompilate, acest flag va determina semnalizatoarele de ieșire a dependenței
listează, de asemenea, fișierele din dependențele antetului precompilat. Dacă nu este specificat doar
ar fi listat antetul precompilat și nu fișierele care au fost folosite pentru a-l crea
deoarece acele fișiere nu sunt consultate atunci când se folosește un antet precompilat.

-fpch-preproces
Această opțiune permite utilizarea unui antet precompilat împreună cu -E. Inserează o specială
„#pragma”, „#pragma GCC pch_preprocess”nume de fișier"" în ieșire pentru a marca locul
unde a fost găsit antetul precompilat și acesta nume de fișier. Când -fpreprocesate este in
utilizare, GCC recunoaște acest „#pragma” și încarcă PCH.

Această opțiune este dezactivată în mod implicit, deoarece rezultatul preprocesat este numai
într-adevăr potrivit ca intrare în GCC. Este pornit de -save-temps.

Nu ar trebui să scrieți acest „#pragma” în propriul cod, dar este sigur să editați
nume de fișier dacă fișierul PCH este disponibil într-o locație diferită. Numele fișierului poate fi
absolut sau poate fi relativ la directorul curent al GCC.

-x c
-x c ++
-x obiectiv-c
-x asamblator-cu-cpp
Specificați limba sursă: C, C++, Objective-C sau asamblare. Asta nu are nimic de-a face
cu conformitatea standardelor sau extinderi; doar selectează ce sintaxă de bază
aştepta. Dacă nu oferi niciuna dintre aceste opțiuni, cpp va deduce limba din
extensia fișierului sursă: .c, . Cc, .m, Sau .S. Alte extensii comune pentru
C++ și asamblarea sunt, de asemenea, recunoscute. Dacă cpp nu recunoaște extensia, aceasta
va trata fișierul ca C; acesta este modul cel mai generic.

Notă: Versiunile anterioare de cpp au acceptat a -Long opțiunea care a selectat atât
limba și nivelul de conformitate cu standardele. Această opțiune a fost eliminată, deoarece
intră în conflict cu -l opțiune.

-std=standard
-ansi
Specificați standardul la care trebuie să se conformeze codul. În prezent, CPP știe despre C
și standardele C++; altele pot fi adăugate în viitor.

standard poate fi unul dintre:

"c90"
"c89"
„iso9899:1990”
Standardul ISO C din 1990. c90 este prescurtarea obișnuită pentru această versiune a
standardul.

-ansi opțiunea este echivalentă cu -std=c90.

„iso9899:199409”
Standardul C din 1990, modificat în 1994.

„iso9899:1999”
"c99"
„iso9899:199x”
"c9x"
Standardul ISO C revizuit, publicat în decembrie 1999. Înainte de publicare, acesta
a fost cunoscut sub numele de C9X.

„iso9899:2011”
"c11"
"c1x"
Standardul ISO C revizuit, publicat în decembrie 2011. Înainte de publicare, acesta
a fost cunoscut sub numele de C1X.

"gnu90"
"gnu89"
Standardul C din 1990 plus extensii GNU. Aceasta este valoarea implicită.

"gnu99"
"gnu9x"
Standardul C din 1999 plus extensii GNU.

"gnu11"
"gnu1x"
Standardul C din 2011 plus extensii GNU.

"c++98"
Standardul ISO C++ din 1998 plus amendamente.

"gnu++98"
La fel ca -std=c++98 plus extensii GNU. Aceasta este valoarea implicită pentru codul C++.

-eu- Împărțiți calea de includere. Orice directoare specificate cu -I opțiuni înainte -eu- sunt
a căutat numai antetele solicitate cu „#include”fişier""; nu sunt căutați
"#includefisier>". Dacă sunt specificate directoare suplimentare cu -I opțiuni după
-eu-, acele directoare sunt căutate pentru toate #include directivelor.

În plus, -eu- inhibă utilizarea directorului directorului de fișiere curent ca
primul director de căutare pentru „#include”fişier"". Această opțiune a fost retrasă.

-nostdinc
Nu căutați fișierele antet în directoarele standard de sistem. Doar directoarele
ai specificat cu -I opțiuni (și directorul fișierului curent, dacă
adecvate) sunt căutate.

-nostdinc++
Nu căutați fișiere de antet în directoarele standard specifice C++, dar faceți totuși
căutați în celelalte directoare standard. (Această opțiune este folosită la construirea C++
bibliotecă.)

-include fişier
Proces fişier ca și cum „#include „fișier”” a apărut ca prima linie a sursei primare
fişier. Cu toate acestea, primul director căutat fişier funcționează preprocesorul
director in schimb of directorul care conține fișierul sursă principal. Dacă nu este găsit
acolo, este căutat în restul lanțului de căutare „#include „...”” ca
normale.

Dacă este multiplu -include sunt date opțiuni, fișierele sunt incluse în ordinea în care acestea
apar pe linia de comandă.

-imacros fişier
Exact ca -include, cu excepția faptului că orice rezultat produs prin scanare fişier este aruncat
departe. Macro-urile pe care le definește rămân definite. Acest lucru vă permite să achiziționați toate macrocomenzile
dintr-un antet fără a procesa și declarațiile acestuia.

Toate fișierele specificate de -imacros sunt procesate înaintea tuturor fișierelor specificate de -include.

-idirafter dir
Caută dir pentru fișierele antet, dar fă-o după toate directoarele specificate cu -I si
directoarele de sistem standard au fost epuizate. dir este tratat ca un sistem include
director. Dacă dir începe cu „=", apoi „=" va fi înlocuit cu sysroot
prefix; vedea --sysroot și -isysroot.

-iprefix prefix
Specifica prefix ca prefix pentru ulterioare -icuprefix Opțiuni. Dacă prefixul
reprezintă un director, ar trebui să includeți finalul /.

-icuprefix dir
-iwithprefixbefore dir
Adăuga dir la prefixul specificat anterior cu -iprefix, și adăugați rezultatul
director la calea de căutare include. -iwithprefixbefore îl pune în același loc -I
ar fi; -icuprefix o pune unde -idirafter ar fi.

-isysroot dir
Această opțiune este ca --sysroot opțiunea, dar se aplică numai fișierelor antet (cu excepția
ținte Darwin, unde se aplică atât fișierelor antet, cât și bibliotecilor). Vezi
--sysroot opțiune pentru mai multe informații.

-imultilib dir
Utilizare dir ca subdirector al directorului care conține anteturi C++ specifice țintei.

-isistem dir
Caută dir pentru fișierele antet, după toate directoarele specificate de -I dar înainte de
directoare standard de sistem. Marcați-l ca director de sistem, astfel încât să devină același
tratament special aplicat directoarelor de sistem standard. Dacă dir începe
cu „=", apoi „=" va fi înlocuit cu prefixul sysroot; vedea --sysroot și
-isysroot.

-citez dir
Caută dir numai pentru fișierele antet solicitate cu „#include”fişier""; ei nu sunt
a căutat „#includefisier>", înaintea tuturor directoarelor specificate de -I și înainte de
directoare standard de sistem. Dacă dir începe cu „=", apoi „=" va fi înlocuit cu
prefixul sysroot; vedea --sysroot și -isysroot.

-fdirectives-doar
Când preprocesați, gestionați directivele, dar nu extindeți macrocomenzi.

Comportamentul opțiunii depinde de -E și -fpreprocesate opțiuni.

Cu -E, preprocesarea este limitată la gestionarea directivelor precum „#define”,
„#ifdef” și „#error”. Alte operațiuni de preprocesor, cum ar fi extinderea macro și
conversia trigraf nu sunt efectuate. In plus -dD opțiunea este implicit
activat.

Cu -fpreprocesate, predefinirea liniei de comandă și a majorității macrocomenzilor încorporate este
dezactivat. Macro-urile precum „__LINE__”, care sunt dependente de context, sunt gestionate
în mod normal. Aceasta permite compilarea fișierelor preprocesate anterior cu „-E
-doar fdirective".

Cu amândoi -E și -fpreprocesate, regulile pentru -fpreprocesate a avea prioritate. Acest
permite preprocesarea completă a fișierelor preprocesate anterior cu „-E
-doar fdirective".

-fdolari-în-identificatori
Accept $ în identificatori.

-identificatori-extinși
Acceptați numele de caractere universale în identificatori. Această opțiune este experimentală; într-o
versiunea viitoare a GCC, va fi activată implicit pentru C99 și C++.

-anteturi-sistem-fno-canonice
Când preprocesați, nu scurtați căile antetului sistemului cu canonizare.

-fpreprocesate
Indicați preprocesorului că fișierul de intrare a fost deja preprocesat. Acest
suprimă lucruri precum extinderea macro, conversia trigrafului, îmbinarea nou-linii scăpată,
și procesarea majorității directivelor. Preprocesorul încă recunoaște și elimină
comentarii, astfel încât să puteți transmite un fișier preprocesat cu -C la compilator fără
Probleme. În acest mod, preprocesorul integrat este puțin mai mult decât un tokenizer
pentru capete frontale.

-fpreprocesate este implicit dacă fișierul de intrare are una dintre extensii .i, .ii or .mi.
Acestea sunt extensiile pe care GCC le folosește pentru fișierele preprocesate create de -save-temps.

-ftabstop=lățime
Setați distanța dintre punctele de tabulatură. Acest lucru ajută preprocesorul să raporteze coloana corectă
numere în avertismente sau erori, chiar dacă pe linie apar file. Dacă valoarea este mai mică
mai mare de 1 sau mai mare de 100, opțiunea este ignorată. Valoarea implicită este 8.

-fdebug-cpp
Această opțiune este utilă numai pentru depanarea GCC. Când este folosit cu -E, depanarea depozitelor
informații despre hărți de locație. Fiecare token din ieșire este precedat de dump of
harta căreia îi aparține locația. Depozitul hărții care conține locația unui jeton
va fi:

{"P":F ;"F":F ;"L": ;"C": ;"S": ;"M": ;"E": ,"loc": }

Când este folosit fără -E, această opțiune nu are efect.

-ftrack-macro-expansiune[=nivel]
Urmăriți locațiile jetoanelor în extinderile macro. Acest lucru permite compilatorului să emită
diagnostic despre stiva actuală de extindere a macrocomenzii atunci când apare o eroare de compilare în
o extindere macro. Folosirea acestei opțiuni face ca preprocesorul și compilatorul să consume
mai multa memorie. The nivel parametrul poate fi folosit pentru a alege nivelul de precizie al jetonului
urmărirea locației scăzând astfel consumul de memorie dacă este necesar. Valoare 0 of
nivel dezactivează această opțiune ca și cum nu -ftrack-macro-expansiune a fost prezent pe
linia de comandă. Valoare 1 urmărește locațiile jetoanelor într-un mod degradat de dragul
suprasarcina minimă de memorie. În acest mod toate jetoanele rezultate din extinderea unui
argumentul unei macro-funcții au aceeași locație. Valoare 2 urmărește jetoanele
locații complet. Această valoare este cea mai înfometată de memorie. Când este dată această opțiune
nici un argument, valoarea implicită a parametrului este 2.

Rețineți că -ftrack-macro-expansion=2 este activat implicit.

-fexec-charset=set de caractere
Setați setul de caractere de execuție, utilizat pentru constantele șir și caractere. Implicit
este UTF-8. set de caractere poate fi orice codificare acceptată de biblioteca „iconv” a sistemului
rutină.

-fwide-exec-charset=set de caractere
Setați setul larg de caractere de execuție, utilizat pentru șiruri largi și constante de caractere.
Valoarea implicită este UTF-32 sau UTF-16, oricare dintre acestea corespunde lățimii lui „wchar_t”. La fel de
cu -fexec-charset, set de caractere poate fi orice codificare acceptată de „iconv” a sistemului
rutina bibliotecii; cu toate acestea, veți avea probleme cu codificările care nu se potrivesc
exact în „wchar_t”.

-finput-charset=set de caractere
Setați setul de caractere de intrare, utilizat pentru traducere din setul de caractere de intrare
fișier la setul de caractere sursă utilizat de GCC. Dacă localitatea nu specifică, sau GCC
nu pot obține aceste informații din local, implicit este UTF-8. Acesta poate fi
suprascris fie de localitatea, fie de această opțiune de linie de comandă. Momentan comanda
opțiunea de linie are prioritate dacă există un conflict. set de caractere poate fi orice codificare
susținut de rutina bibliotecii „iconv” a sistemului.

-fworking-director
Activați generarea de marcatori de linie în ieșirea preprocesorului care va permite compilatorului
cunoașteți directorul de lucru curent în momentul preprocesării. Când această opțiune este
activat, preprocesorul va emite, după marcatorul de linie inițial, un al doilea marcator de linie
cu directorul de lucru curent urmat de două bare oblice. GCC va folosi acest lucru
director, când este prezent în intrarea preprocesată, ca directorul emis ca
directorul de lucru curent în unele formate de informații de depanare. Această opțiune este
activat implicit dacă informațiile de depanare sunt activate, dar acest lucru poate fi inhibat cu
forma negata -fno-director-de-lucru. Dacă -P steag este prezent în comandă
linie, această opțiune nu are niciun efect, deoarece nu sunt emise directive „#line”.

-fno-arata-coloana
Nu tipăriți numerele coloanelor în diagnosticare. Acest lucru poate fi necesar dacă sunt diagnosticate
fiind scanat de un program care nu înțelege numerele coloanelor, cum ar fi
dejagnu.

-A predicat=răspunde
Faceți o afirmație cu predicatul predicat si raspunsul răspunde. Această formă este
preferat formei mai vechi -A predicat(răspunde), care este încă susținut, pentru că
nu folosește caractere speciale shell.

-A -predicat=răspunde
Anulează o aserțiune cu predicatul predicat si raspunsul răspunde.

-dCHARS
CHARS este o secvență de unul sau mai multe dintre următoarele caractere și nu trebuie să fie
precedat de un spațiu. Alte caractere sunt interpretate de compilatorul propriu-zis, sau
rezervat pentru versiunile viitoare ale GCC și, prin urmare, sunt ignorate în tăcere. Daca specificati
personaje al căror comportament este în conflict, rezultatul este nedefinit.

M În loc de ieșirea normală, generați o listă de #defini directive pentru toate
macrocomenzi definite în timpul execuției preprocesorului, inclusiv predefinite
macro-uri. Acest lucru vă oferă o modalitate de a afla ce este predefinit în versiunea dvs. de
preprocesorul. Presupunând că nu aveți niciun fișier foo.h, comanda

atinge foo.h; cpp -dM foo.h

va afișa toate macrocomenzile predefinite.

Dacă utilizați -dM fara -E opțiune, -dM este interpretat ca sinonim pentru
-fdump-rtl-mach.

D Aprecieri M cu excepția a două privințe: o face nu include macrocomenzile predefinite și acesta
iesiri atât il #defini directivele și rezultatul preprocesării. Ambele feluri
de ieșire mergeți la fișierul de ieșire standard.

N Aprecieri D, dar emit doar numele macro, nu expansiunile acestora.

I producție #include directive pe lângă rezultatul preprocesării.

U Aprecieri D cu excepția faptului că numai macrocomenzile care sunt extinse sau a căror definiție este testată
în directivele de preprocesor, sunt ieșite; ieșirea este întârziată până la utilizare sau
testarea macro-ului; și #undef directivele sunt, de asemenea, ieșite pentru macro-urile testate, dar
nedefinit la momentul respectiv.

-P Inhibați generarea de marcatori de linie în ieșirea de la preprocesor. Acest lucru ar putea fi
util atunci când rulați preprocesorul pe ceva care nu este cod C și va fi trimis
la un program care ar putea fi confundat de marcatori de linie.

-C Nu aruncați comentarii. Toate comentariile sunt transmise în fișierul de ieșire, cu excepția
pentru comentariile din directivele procesate, care sunt șterse împreună cu directiva.

Ar trebui să fiți pregătit pentru efecte secundare atunci când utilizați -C; determină preprocesorul să
tratează comentariile ca semne în sine. De exemplu, comentariile care apar la
începutul a ceea ce ar fi o linie directivă are ca efect transformarea acelei linii într-un
linie sursă obișnuită, deoarece primul jeton de pe linie nu mai este a #.

-CC Nu aruncați comentarii, inclusiv în timpul extinderii macrocomenzilor. Acesta este ca -C, cu exceptia
că comentariile conținute în macrocomenzi sunt, de asemenea, transmise în fișierul de ieșire unde
macro-ul este extins.

Pe lângă efectele secundare ale -C opțiune, -CC opțiunea cauzează tot stilul C++
comentariile dintr-o macrocomandă pentru a fi convertite în comentarii în stil C. Acest lucru este pentru a preveni mai târziu
utilizarea acelei macrocomenzi de la comentarea din neatenție a restului liniei sursă.

-CC opțiunea este în general utilizată pentru a susține comentariile la scame.

-traditional-cpp
Încercați să imiteți comportamentul preprocesoarelor C de modă veche, spre deosebire de ISO C
preprocesoare.

-trigrafe
Procesează secvențe trigrafice. Acestea sunt secvențe de trei caractere, toate începând cu
??, care sunt definite de ISO C pentru a reprezenta un singur caracter. De exemplu, ??/ Standuri
pentru \, asa de '??/n' este o constantă de caractere pentru o linie nouă. În mod implicit, GCC ignoră
trigrafe, dar în moduri conforme cu standardul le convertește. Vezi -std și -ansi
opțiuni.

Cele nouă trigrafe și înlocuitorii lor sunt

Trigraf: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
Înlocuire: [ ] { } # \ ^ | ~

-remapa
Activați codul special pentru a funcționa în jurul sistemelor de fișiere care permit doar fișiere foarte scurte
nume, cum ar fi MS-DOS.

--Ajutor
--ţintă-ajutor
Tipăriți text care descrie toate opțiunile liniei de comandă în loc să preprocesați nimic.

-v Modul verbos. Tipăriți numărul versiunii GNU CPP la începutul execuției și
raportați forma finală a căii de includere.

-H Tipăriți numele fiecărui fișier antet utilizat, pe lângă alte activități normale. Fiecare
numele este indentat pentru a arăta cât de adânc în #include stiva este. Antet precompilat
fișierele sunt, de asemenea, tipărite, chiar dacă sunt considerate invalide; un precompilat invalid
fișierul antet este tipărit cu ...X si unul valabil cu ...! .

-versiune
--versiune
Imprimați numărul versiunii GNU CPP. Cu o liniuță, treceți la preprocesare ca de obicei.
Cu două liniuțe, ieșiți imediat.

Care trece Opţiuni la il Montator
Puteți transmite opțiuni la asamblator.

-Wa,opțiune
Trece opțiune ca opțiune pentru asamblator. Dacă opțiune conține virgule, este împărțit
în mai multe opțiuni la virgule.

-Xassembler opțiune
Trece opțiune ca opțiune pentru asamblator. Puteți utiliza acest lucru pentru a furniza sisteme specifice
opțiuni de asamblare pe care GCC nu le recunoaște.

Dacă doriți să treceți o opțiune care preia un argument, trebuie să utilizați -Xassembler de două ori,
o dată pentru opțiune și o dată pentru argument.

Opţiuni pentru Legarea
Aceste opțiuni intră în joc atunci când compilatorul leagă fișierele obiect într-un executabil
fisier de iesire. Ele sunt lipsite de sens dacă compilatorul nu face un pas de legătură.

nume-fișier-obiect
Un nume de fișier care nu se termină cu un sufix special recunoscut este considerat a denumi an
fișier obiect sau bibliotecă. (Fișierele obiect se disting de biblioteci prin linker
în funcție de conținutul fișierului.) Dacă se face legătura, aceste fișiere obiect sunt folosite ca
intrare în linker.

-c
-S
-E Dacă oricare dintre aceste opțiuni este utilizată, atunci linker-ul nu este rulat și numele fișierelor obiect
nu trebuie folosite ca argumente.

-lbibliotecă
-l bibliotecă
Căutați în biblioteca numită bibliotecă la conectarea. (A doua alternativă cu
biblioteca ca argument separat este doar pentru conformitatea POSIX și nu este recomandată.)

Face o diferență unde în comandă scrieți această opțiune; linker-ul caută
și procesează bibliotecile și fișierele obiect în ordinea în care sunt specificate. Prin urmare, foo.o
-lz bar.o caută în bibliotecă z după dosar foo.o dar înainte bar.o. Dacă bar.o se referă la
funcții în z, este posibil ca aceste funcții să nu fie încărcate.

Linker-ul caută o listă standard de directoare pentru bibliotecă, care este de fapt
un fișier numit bibliotecă.a. Linkerul folosește apoi acest fișier ca și cum ar fi fost specificat
tocmai după nume.

Directoarele căutate includ mai multe directoare standard de sistem plus orice pe care le aveți
specifica cu -L.

În mod normal, fișierele găsite în acest fel sunt fișiere de bibliotecă --- fișiere de arhivă ai căror membri sunt
fișiere obiect. Linker-ul gestionează un fișier arhivă prin scanarea acestuia pentru membri
care definesc simboluri care au fost până acum referite, dar nedefinite. Dar dacă
fișierul care este găsit este un fișier obiect obișnuit, este legat în mod obișnuit. The
singura diferență între utilizarea unui -l opțiunea și specificarea unui nume de fișier este aceea -l
înconjoară bibliotecă cu lib și .a și caută în mai multe directoare.

-lobjc
Ai nevoie de acest caz special al -l opțiune pentru a lega un Objective-C sau
Programul Objective-C++.

-nostartfiles
Nu utilizați fișierele standard de pornire a sistemului atunci când conectați. Sistemul standard
bibliotecile sunt utilizate în mod normal, cu excepția cazului în care -nostdlib or -nodefaultlibs este folosit.

-nodefaultlibs
Nu utilizați bibliotecile standard de sistem atunci când conectați. Doar bibliotecile pe care le specificați
sunt transmise linkerului și opțiunile care specifică legătura bibliotecilor de sistem, cum ar fi
ca „-static-libgcc” sau „-shared-libgcc”, sunt ignorate. Fișierele standard de pornire sunt
folosit în mod normal, cu excepția cazului în care -nostartfiles este folosit.

Compilatorul poate genera apeluri la „memcmp”, „memset”, „memcpy” și „memmove”. Aceste
intrările sunt de obicei rezolvate de intrări în libc. Aceste puncte de intrare ar trebui să fie
furnizate printr-un alt mecanism atunci când această opțiune este specificată.

-nostdlib
Nu utilizați fișierele sau bibliotecile standard de pornire a sistemului atunci când conectați. Fără pornire
fișierele și numai bibliotecile pe care le specificați sunt transmise linkerului și opțiunilor
specificarea legăturii bibliotecilor de sistem, cum ar fi „-static-libgcc” sau
„-shared-libgcc”, sunt ignorate.

Compilatorul poate genera apeluri la „memcmp”, „memset”, „memcpy” și „memmove”. Aceste
intrările sunt de obicei rezolvate de intrări în libc. Aceste puncte de intrare ar trebui să fie
furnizate printr-un alt mecanism atunci când această opțiune este specificată.

Una dintre bibliotecile standard ocolite de -nostdlib și -nodefaultlibs is libgcc.a, A
biblioteca de subrutine interne pe care GCC o folosește pentru a depăși neajunsurile specifice
mașini sau nevoi speciale pentru unele limbi.

În cele mai multe cazuri, aveți nevoie libgcc.a chiar și atunci când doriți să evitați alte biblioteci standard.
Cu alte cuvinte, când specificați -nostdlib or -nodefaultlibs ar trebui de obicei
specifica -lgcc de asemenea. Acest lucru vă asigură că nu aveți referințe nerezolvate la
subrutinele bibliotecii interne GCC. (Un exemplu de astfel de subrutină internă este
__principal, folosit pentru a asigura apelarea constructorilor C++.)

-plăcintă
Produceți un executabil independent de poziție pe ținte care îl acceptă. Pentru previzibil
rezultate, trebuie, de asemenea, să specificați același set de opțiuni utilizate pentru compilare (-fpie,
-fPIE, sau subopțiuni de model) când specificați această opțiune de linker.

-rdinamic
Treci steagul -export-dinamic către linkerul ELF, pe ținte care îl susțin. Acest
instruiește linkerul să adauge toate simbolurile, nu numai cele utilizate, la simbolul dinamic
masa. Această opțiune este necesară pentru unele utilizări ale „dlopen” sau pentru a permite obținerea
backtraces din interiorul unui program.

-s Eliminați toate tabelele de simboluri și informațiile de relocare din executabil.

-static
Pe sistemele care acceptă conectarea dinamică, acest lucru împiedică conectarea cu partajarea
biblioteci. Pe alte sisteme, această opțiune nu are efect.

-impartit
Produceți un obiect partajat care poate fi apoi legat de alte obiecte pentru a forma un
executabil. Nu toate sistemele acceptă această opțiune. Pentru rezultate previzibile, trebuie
de asemenea, specificați același set de opțiuni utilizate pentru compilare (-fpic, -fPIC, sau model
subopțiuni) când specificați această opțiune de linker.[1]

-shared-libgcc
-static-libgcc
Pe sistemele care oferă libgcc ca bibliotecă partajată, aceste opțiuni forțează utilizarea
fie versiunea partajată sau, respectiv, statică. Dacă nu există o versiune partajată a libgcc a fost
construite când compilatorul a fost configurat, aceste opțiuni nu au niciun efect.

Există mai multe situații în care o aplicație ar trebui să folosească partajarea libgcc
în loc de versiunea statică. Cel mai frecvent dintre acestea este atunci când aplicația
dorește să arunce și să prindă excepții în diferite biblioteci partajate. In acest caz,
fiecare dintre biblioteci, precum și aplicația în sine ar trebui să utilizeze partajarea libgcc.

Prin urmare, driverele G++ și GCJ se adaugă automat -shared-libgcc ori de câte ori construiești
o bibliotecă partajată sau un executabil principal, deoarece programele C++ și Java folosesc de obicei
excepții, așa că acesta este lucrul corect de făcut.

Dacă, în schimb, utilizați driverul GCC pentru a crea biblioteci partajate, este posibil să descoperiți că acestea
nu sunt întotdeauna legate de partajate libgcc. Dacă GCC găsește, la configurația sa
timp, că aveți un linker non-GNU sau un linker GNU care nu acceptă opțiunea
--eh-frame-hdr, leagă versiunea partajată a libgcc în biblioteci partajate de
Mod implicit. În caz contrar, profită de linker și optimizează link-ul
cu versiunea partajată a libgcc, conectând cu versiunea statică a libgcc by
Mod implicit. Acest lucru permite propagarea excepțiilor prin astfel de biblioteci partajate, fără
suportând costuri de relocare la momentul încărcării bibliotecii.

Cu toate acestea, dacă o bibliotecă sau un executabil principal ar trebui să arunce sau să prindă excepții, tu
trebuie să-l conecteze folosind driverul G++ sau GCJ, după caz ​​pentru limbile utilizate în
program sau folosind opțiunea -shared-libgcc, astfel încât să fie legat de partajat
libgcc.

-static-libasan
Cand -fsanitize=adresa opțiunea este utilizată pentru a lega un program, driverul GCC
se leagă automat împotriva libasan. Dacă libasan este disponibil ca bibliotecă partajată și
il -static opțiunea nu este utilizată, atunci aceasta face legătura cu versiunea partajată a libasan.
-static-libasan opțiunea direcționează driverul GCC să se conecteze libasan static, fără
legând în mod static alte biblioteci.

-static-libtsan
Cand -fsanitize=thread opțiunea este utilizată pentru a lega un program, driverul GCC
se leagă automat împotriva libtsan. Dacă libtsan este disponibil ca bibliotecă partajată și
il -static opțiunea nu este utilizată, atunci aceasta face legătura cu versiunea partajată a libtsan.
-static-libtsan opțiunea direcționează driverul GCC să se conecteze libtsan static, fără
legând în mod static alte biblioteci.

-static-liblsan
Cand -fsanitize=scurgere opțiunea este utilizată pentru a lega un program, driverul GCC
se leagă automat împotriva liblsan. Dacă liblsan este disponibil ca bibliotecă partajată și
il -static opțiunea nu este utilizată, atunci aceasta face legătura cu versiunea partajată a liblsan.
-static-liblsan opțiunea direcționează driverul GCC să se conecteze liblsan static, fără
legând în mod static alte biblioteci.

-static-libubsan
Cand -fsanitize=nedefinit opțiunea este utilizată pentru a lega un program, driverul GCC
se leagă automat împotriva libubsan. Dacă libubsan este disponibil ca o bibliotecă partajată,
si -static opțiunea nu este utilizată, atunci aceasta face legătura cu versiunea partajată a
libubsan. -static-libubsan opțiunea direcționează driverul GCC să se conecteze libubsan
static, fără a lega neapărat alte biblioteci static.

-static-libstdc++
Cand g ++ programul este folosit pentru a lega un program C++, în mod normal se leagă automat
împotriva libstdc++. Dacă libstdc++ este disponibil ca o bibliotecă partajată, iar -static
opțiunea nu este utilizată, atunci aceasta face legătura cu versiunea partajată a libstdc++. Acesta este
normal bine. Cu toate acestea, uneori este util să înghețați versiunea libstdc++
utilizat de program fără a merge până la o legătură complet statică. The
-static-libstdc++ opțiunea direcționează g ++ driver pentru a conecta libstdc++ static, fără
legând în mod static alte biblioteci.

-simbolic
Legați referințe la simboluri globale atunci când construiți un obiect partajat. Avertizați despre orice
referințe nerezolvate (dacă nu sunt suprascrise de opțiunea editorului de linkuri -Xlinker -z
-Xlinker def). Doar câteva sisteme acceptă această opțiune.

-T scenariu
Utilizare scenariu ca script linker. Această opțiune este acceptată de majoritatea sistemelor care utilizează
Linker GNU. Pe unele ținte, cum ar fi ținte bare-board fără sistem de operare,
il -T opțiunea poate fi necesară la conectarea pentru a evita referințele la simboluri nedefinite.

-Xlinker opțiune
Trece opțiune ca opțiune pentru linker. Puteți utiliza acest lucru pentru a furniza sisteme specifice
opțiuni de linker pe care GCC nu le recunoaște.

Dacă doriți să treceți o opțiune care ia un argument separat, trebuie să utilizați -Xlinker
de două ori, o dată pentru opțiune și o dată pentru argument. De exemplu, a trece -afirma
Definitii, trebuie sa scrii -Xlinker -afirma -Xlinker Definitii. Aceasta nu funcționează
pentru a scrie -Xlinker "-afirma definiții", deoarece aceasta trece întregul șir ca a
un singur argument, care nu este ceea ce se așteaptă linkerul.

Când utilizați linkerul GNU, este de obicei mai convenabil să transmiteți argumente către linker
opțiuni folosind opțiune=valoare sintaxă decât ca argumente separate. De exemplu, tu
poate specifica -Xlinker -Hartă=ieșire.hartă mai degrabă decât -Xlinker -Hartă -Xlinker ieșire.hartă.
Este posibil ca alte linkeri să nu accepte această sintaxă pentru opțiunile din linia de comandă.

-Wl,opțiune
Trece opțiune ca opțiune pentru linker. Dacă opțiune conține virgule, este împărțit în
mai multe opțiuni la virgule. Puteți folosi această sintaxă pentru a transmite un argument către
opțiune. De exemplu, -Wl,-Hartă,ieșire.hartă trece -Hartă ieșire.hartă către linker. Cand
folosind linkerul GNU, puteți obține și același efect cu -Wl,-Map=output.map.

NOTĂ: În Ubuntu 8.10 și versiunile ulterioare, pentru LDFLAGS, opțiunea -Wl,-z,relro este folosit.
Pentru a dezactiva, utilizați -Wl,-z,norelro.

-u simbol
Prefă-te simbolul simbol este nedefinit, pentru a forța definirea conexiunii modulelor bibliotecii
aceasta. Poți să folosești -u de mai multe ori cu simboluri diferite pentru a forța încărcarea
module suplimentare de bibliotecă.

Opţiuni pentru director Caută
Aceste opțiuni specifică directoare pentru a căuta fișiere antet, biblioteci și părți
a compilatorului:

-Idir
Adăugați directorul dir la capul listei de directoare de căutat antet
fișiere. Acesta poate fi folosit pentru a înlocui un fișier antet de sistem, înlocuindu-l pe al dvs
versiune, deoarece aceste directoare sunt căutate înainte de fișierul antet al sistemului
directoare. Cu toate acestea, nu ar trebui să utilizați această opțiune pentru a adăuga directoare care conțin
Fișierele antet de sistem furnizate de furnizor (utilizați -isistem pentru asta). Dacă utilizați mai mult de unul
-I opțiunea, directoarele sunt scanate în ordine de la stânga la dreapta; sistemul standard
directoarele vin după.

Dacă un sistem standard include director, sau un director specificat cu -isistem, Este
specificat de asemenea cu -I, -I opțiunea este ignorată. Directorul este încă căutat dar
ca director de sistem în poziția sa normală în sistem include lanț. Asta este
asigurați-vă că procedura GCC pentru a remedia anteturile de sistem cu erori și comanda pentru
Directiva „include_next” nu sunt modificate din greșeală. Dacă chiar trebuie să te schimbi
ordinea de căutare a directoarelor de sistem, utilizați -nostdinc şi / sau -isistem opțiuni.

-iplugindir=dir
Setați directorul pentru a căuta pluginuri care sunt trecute -fplugin=nume în loc de
-fplugin=cale/nume.asa de. Această opțiune nu este menită să fie folosită de utilizator, ci numai
trecut de șofer.

-citezdir
Adăugați directorul dir la capul listei de directoare de căutat antet
dosare numai pentru cazul de #include "fişier"; nu sunt căutați #include <fişier>,
altfel la fel ca -I.

-Ldir
Adăugați directorul dir la lista directoarelor care trebuie căutate -l.

-Bprefix
Această opțiune specifică unde să găsiți executabilele, bibliotecile, fișierele incluse și
fișierele de date ale compilatorului însuși.

Programul driver al compilatorului rulează unul sau mai multe subprograme cpp, cc1, as și ld.
Încearcă prefix ca prefix pentru fiecare program pe care încearcă să îl ruleze, atât cu cât și fără
maşină/versiune/.

Pentru fiecare subprogram care urmează să fie rulat, driverul compilatorului încearcă mai întâi -B prefix, dacă există.
Dacă acel nume nu este găsit, sau dacă -B nu este specificat, șoferul încearcă două standard
prefixe, /usr/lib/gcc/ și /usr/local/lib/gcc/. Dacă niciuna dintre acestea nu duce la a
numele fișierului care este găsit, numele programului nemodificat este căutat folosind
directoarele specificate în dvs PATH variabilă de mediu.

Compilatorul verifică dacă calea furnizată de -B se referă la un director și
dacă este necesar, adaugă un caracter separator de director la sfârșitul căii.

-B prefixele care specifică efectiv nume de directoare se aplică și bibliotecilor din
linker, deoarece compilatorul traduce aceste opțiuni în -L opțiuni pentru linker.
Se aplică și pentru a include fișiere în preprocesor, deoarece compilatorul traduce
aceste opțiuni în -isistem opțiuni pentru preprocesor. În acest caz, compilatorul
anexează include la prefix.

Fișierul de suport pentru runtime libgcc.a poate fi căutat și folosind -B prefix, dacă
Necesar. Dacă nu se găsește acolo, se încearcă cele două prefixe standard de mai sus și asta
este totul. Fișierul este lăsat în afara linkului dacă nu este găsit prin aceste mijloace.

O altă modalitate de a specifica un prefix asemănător celui -B prefixul este folosirea mediului
variabil GCC_EXEC_PREFIX.

Ca un kludge special, dacă calea oferită de -B is [dir/]stageN/, În cazul în care N este un număr
în intervalul 0 la 9, apoi este înlocuit cu [dir/]include. Asta pentru a ajuta la boot-
legarea compilatorului.

-specificații=fişier
Proces fişier după ce compilatorul citește standardul Specificatii fișier, pentru a suprascrie
valorile implicite pe care gcc programul driver folosește atunci când determină ce comută să treacă
la cc1, cc1plus, as, ld, etc. Mai mult de unul -specificații=fişier poate fi specificat pe
linie de comandă și sunt procesate în ordine, de la stânga la dreapta.

--sysroot=dir
Utilizare dir ca director rădăcină logic pentru anteturi și biblioteci. De exemplu, dacă
compilatorul caută în mod normal antete în / usr / include și biblioteci în / Usr / lib, Aceasta
în schimb căutări dir/usr/include și dir/usr/lib.

Dacă utilizați atât această opțiune, cât și -isysroot opțiunea, apoi --sysroot opțiune
se aplică bibliotecilor, dar -isysroot opțiunea se aplică fișierelor antet.

Linkerul GNU (începând cu versiunea 2.16) are suportul necesar pentru aceasta
opțiune. Dacă linkerul dvs. nu acceptă această opțiune, aspectul fișierului antet al
--sysroot încă funcționează, dar aspectul bibliotecii nu.

--fără-sysroot-sufix
Pentru unele ținte, un sufix este adăugat la directorul rădăcină specificat cu --sysroot,
în funcție de celelalte opțiuni utilizate, astfel încât anteturile pot fi găsite, de exemplu, în
dir/sufix/usr/include în loc de dir/usr/include. Această opțiune dezactivează adăugarea
a unui asemenea sufix.

-eu- Această opțiune a fost retrasă. Vă rugăm să utilizați -citez în schimb pentru -I directoare înainte
il -eu- și scoateți -eu-. Orice directoare cu care specificați -I opțiuni înainte de
-eu- opțiunea sunt căutate numai pentru cazul #include "fişier"; nu sunt căutați
pentru #include <fişier>.

Dacă sunt specificate directoare suplimentare cu -I opțiuni după -eu-Acestea
directoarele sunt căutate pentru toate #include directive. (De obicei toate -I directoare
sunt folosite în acest fel.)

În plus, -eu- opțiunea inhibă utilizarea directorului curent (unde
fișierul de intrare curent a venit de la) ca primul director de căutare pentru #include "fişier".
Nu există nicio modalitate de a trece peste acest efect de -eu-. Cu -Eu. puteți specifica căutarea
directorul care este curent când este invocat compilatorul. Asta nu este tocmai
la fel ca ceea ce face preprocesorul în mod implicit, dar este adesea satisfăcător.

-eu- nu inhibă utilizarea directoarelor standard de sistem pentru fișierele antet.
Prin urmare, -eu- și -nostdinc sunt independente.

specificarea Ţintă Mașină și compilator Versiune
Modul obișnuit de a rula GCC este să rulați executabilul numit gcc, Sau maşină-gcc cand cruce-
compilare, sau maşină-gcc-versiune pentru a rula o altă versiune decât cea care a fost instalată
ultimul.

hardware-ul modele și Configurații
Fiecare tip de mașină țintă poate avea propriile opțiuni speciale, începând cu -m, a alege
dintre diferite modele sau configurații hardware --- de exemplu, 68010 vs 68020, flotant
coprocesor sau niciunul. O singură versiune instalată a compilatorului se poate compila pentru orice model
sau configurație, conform opțiunilor specificate.

Unele configurații ale compilatorului acceptă și opțiuni speciale suplimentare, de obicei pentru
compatibilitate cu alte compilatoare de pe aceeași platformă.

AAArch64 Opţiuni

Aceste opțiuni sunt definite pentru implementările AArch64:

-mabi=nume
Generați codul pentru modelul de date specificat. Valorile permise sunt ilp32 pentru SysV-
ca modelul de date unde int, long int și pointer sunt pe 32 de biți și lp64 pentru SysV-like
model de date unde int este de 32 de biți, dar long int și pointer sunt de 64 de biți.

Valoarea implicită depinde de configurația specifică a țintei. Rețineți că LP64 și
ABI-urile ILP32 nu sunt compatibile cu link-uri; trebuie să compilați întregul program cu același
ABI și leagă cu un set compatibil de biblioteci.

-mbig-endian
Generați cod big-endian. Aceasta este valoarea implicită când GCC este configurat pentru un
aarch64_be-*-* țintă.

-mgeneral-regs-only
Generați cod care utilizează numai registrele generale.

-mlittle-endian
Generați cod little-endian. Aceasta este valoarea implicită când GCC este configurat pentru un
aarch64-*-* dar nu un aarch64_be-*-* țintă.

-mcmodel=minuscul
Generați cod pentru modelul de cod mic. Programul și simbolurile sale definite static
trebuie să fie la 1 GB unul de celălalt. Pointerii au 64 de biți. Programele pot fi statice
sau legate dinamic. Acest model nu este implementat pe deplin și în mare parte tratat ca
mic.

-mcmodel=mic
Generați cod pentru modelul de cod mic. Programul și este definit static
simbolurile trebuie să fie la 4 GB unul de celălalt. Pointerii au 64 de biți. Programele pot fi
legate static sau dinamic. Acesta este modelul de cod implicit.

-mcmodel=mare
Generați cod pentru modelul de cod mare. Acest lucru nu face presupuneri despre adrese și
dimensiunile secțiunilor. Pointerii au 64 de biți. Programele pot fi legate numai static.

-mstrict-align
Nu presupuneți că referințele de memorie nealiniate vor fi gestionate de sistem.

-momit-leaf-frame-pointer
-mno-omite-leaf-frame-pointer
Omiteți sau păstrați indicatorul de cadru în funcțiile frunze. Primul comportament este
Mod implicit.

-mtls-dialect=desc
Utilizați descriptori TLS ca mecanism de stocare local al firului pentru accesele dinamice ale TLS
variabile. Aceasta este valoarea implicită.

-mtls-dialect=tradițional
Folosiți TLS tradițional ca mecanism de stocare local al firelor pentru accesele dinamice ale TLS
variabile.

-mfix-cortex-a53-835769
-mno-fix-cortex-a53-835769
Activați sau dezactivați soluția pentru problema ARM Cortex-A53 cu numărul 835769.
va implica inserarea unei instrucțiuni NOP între instrucțiunile de memorie și pe 64 de biți
instrucțiuni de înmulțire-acumulare întregi.

-mfix-cortex-a53-843419
-mno-fix-cortex-a53-843419
Activați sau dezactivați soluția pentru problema ARM Cortex-A53 cu numărul 843419.
o soluție de eroare este făcută în momentul conexiunii și aceasta va trece doar semnalul corespunzător
către linker.

-martie=nume
Specificați numele arhitecturii țintă, opțional sufixat cu unul sau mai multe
modificatori de caracteristici. Această opțiune are forma -martie=arc{+[Nu.]trăsătură}*, unde
numai valoarea admisibilă pentru arc is armv8-a. Valorile admise pentru trăsătură sunt
documentate în sub-secțiunea de mai jos.

Acolo unde sunt specificați modificatori de caracteristici conflictuale, este utilizată caracteristica cea mai din dreapta.

GCC folosește acest nume pentru a determina ce fel de instrucțiuni poate emite la generare
cod de asamblare.

Unde -Martie este specificat fără niciunul dintre -mtune or -mcpu fiind de asemenea precizat, cel
codul va fi reglat pentru a funcționa bine într-o serie de procesoare țintă implementate
arhitectura tinta.

-mtune=nume
Specificați numele procesorului țintă pentru care GCC ar trebui să ajusteze performanța
Codul. Valorile permise pentru această opțiune sunt: generic, cortex-a53, cortex-a57.

În plus, această opțiune poate specifica că GCC ar trebui să ajusteze performanța codului
pentru un sistem mare.MIC. Singura valoare admisă este cortex-a57.cortex-a53.

Unde niciunul dintre -mtune=, -mcpu= or -martie= sunt specificate, codul va fi reglat
performează bine într-o gamă de procesoare țintă.

Această opțiune nu poate fi sufixată de modificatorii de caracteristici.

-mcpu=nume
Specificați numele procesorului țintă, opțional sufixat de una sau mai multe caracteristici
modificatori. Această opțiune are forma -mcpu=cpu{+[Nu.]trăsătură}*, acolo unde este permis
valori pentru cpu sunt aceleași cu cele disponibile pentru -mtune.

Valorile admise pentru trăsătură sunt documentate în sub-secțiunea de mai jos.

Acolo unde sunt specificați modificatori de caracteristici conflictuale, este utilizată caracteristica cea mai din dreapta.

GCC folosește acest nume pentru a determina ce fel de instrucțiuni poate emite la generare
cod de asamblare (parcă de -Martie) și pentru a determina procesorul țintă pentru care să
acordați performanță (parcă de -mtune). Acolo unde această opțiune este utilizată împreună cu
-Martie or -mtune, aceste opțiuni au prioritate față de partea corespunzătoare a acesteia
opțiune.

-Martie și -mcpu modificatori de caracteristici

Modificatori de caracteristici utilizați cu -Martie și -mcpu poate fi unul dintre următoarele:

crc Activați extensia CRC.

cripto
Activați extensia Crypto. Aceasta înseamnă că SIMD avansat este activat.

fp Activați instrucțiunile în virgulă mobilă.

simd
Activați instrucțiuni SIMD avansate. Aceasta înseamnă că instrucțiunile în virgulă mobilă sunt
activat. Aceasta este valoarea implicită pentru toate valorile curente posibile pentru opțiuni -Martie și
-mcpu=.

Adapteva Bobotează Opţiuni

Acestea -m opțiunile sunt definite pentru Adapteva Epiphany:

-mhalf-reg-file
Nu alocați niciun registru în intervalul „r32”...r63”. Asta permite codul să ruleze
variantele hardware cărora le lipsesc aceste registre.

-mprefer-short-insn-regs
Alocați de preferință registre care permit generarea de instrucțiuni scurte. Acesta poate
duce la creșterea numărului de instrucțiuni, astfel încât acest lucru se poate reduce sau crește în general
dimensiunea codului.

-mbranch-cost=o
Setați costul sucursalelor la aproximativ o instrucțiuni „simple”. Acest cost este doar a
euristic și nu se garantează că va produce rezultate consistente între versiuni.

-mcmove
Activați generarea de mișcări condiționate.

-mnops=o
Emite o NOP-uri înaintea oricărei alte instrucțiuni generate.

-mno-soft-cmpsf
Pentru comparații cu o singură precizie în virgulă mobilă, emiteți o instrucțiune „fsub” și testați
steagurile. Aceasta este mai rapidă decât o comparație de software, dar poate obține rezultate incorecte
în prezența NaN, sau când două numere mici diferite sunt comparate astfel încât
diferența lor este calculată ca zero. Valoarea implicită este -msoft-cmpsf, Care utilizări
comparații software mai lente, dar compatibile cu IEEE.

-mstack-offset=o
Setați decalajul dintre partea de sus a stivei și indicatorul stivei. De exemplu, o valoare de 8
înseamnă că cei opt octeți din intervalul „sp+0...sp+7” pot fi utilizați de funcțiile frunză
fără alocarea stivei. Alte valori decât 8 or 16 sunt netestate și puțin probabil
muncă. De asemenea, rețineți că această opțiune modifică ABI; compilarea unui program cu a
offset de stivă diferit de cel cu care au fost compilate bibliotecile, în general, nu
muncă. Această opțiune poate fi utilă dacă doriți să evaluați dacă o stivă diferită este compensată
v-ar oferi un cod mai bun, dar să utilizați de fapt un offset de stivă diferit pentru a construi
programe de lucru, se recomandă configurarea lanțului de instrumente cu aplicația corespunzătoare
--with-stack-offset=o opțiune.

-mno-rotunda-cel mai apropiat
Faceți planificatorul să presupună că modul de rotunjire a fost setat la trunchiere. The
implicit este -mround-cea mai apropiată.

-mlong-apeluri
Dacă nu este specificat altfel de un atribut, presupunem că toate apelurile ar putea fi dincolo de
compensați intervalul instrucțiunilor „b” / „bl” și, prin urmare, încărcați adresa funcției
într-un registru înainte de a efectua un apel (altfel direct). Aceasta este valoarea implicită.

-mshort-calls
Dacă nu este specificat altfel de un atribut, presupuneți că toate apelurile directe sunt în interval
din instrucțiunile „b” / „bl”, deci utilizați aceste instrucțiuni pentru apelurile directe. The
implicit este -mlong-apeluri.

-msmall16
Să presupunem că adresele pot fi încărcate ca valori nesemnate pe 16 biți. Acest lucru nu se aplică
adrese de funcţii pentru care -mlong-apeluri semantica este în vigoare.

-mfp-mode=mod
Setați modul predominant al unității în virgulă mobilă. Aceasta determină plutirea-
mod punct care este furnizat și așteptat la apelul funcției și la ora de întoarcere. Făcând
acest mod se potrivește cu modul de care aveți nevoie preponderent la pornirea funcției
programe mai mici și mai rapide prin evitarea comutărilor de mod inutile.

mod poate fi setat la una dintre următoarele valori:

apelantului
Orice mod la introducerea funcției este valid și reținut sau restaurat atunci când funcția
revine și când apelează alte funcții. Acest mod este util pentru compilare
biblioteci sau alte unități de compilare pe care ați putea dori să le încorporați în diferite
programe cu diferite moduri FPU predominante și confortul de a putea
utilizarea unui singur fișier obiect depășește dimensiunea și viteza de suprasarcină pentru orice mod suplimentar
schimbarea care ar putea fi necesară, în comparație cu ceea ce ar fi necesar cu un mai mult
alegerea specifică a modului FPU predominant.

trunchia
Acesta este modul folosit pentru calculele în virgulă mobilă cu trunchiere (adică rotunjire
spre zero) modul de rotunjire. Aceasta include conversia de la virgulă mobilă la
întreg.

rotund-cel mai apropiat
Acesta este modul utilizat pentru calculele în virgulă mobilă cu rotunjire la cel mai apropiat sau
mod uniform de rotunjire.

int Acesta este modul folosit pentru a efectua calcule întregi în FPU, de exemplu, întreg
înmulțire sau înmulțire-și-acumulare întregi.

Valoarea implicită este -mfp-mode=apelant

-mnosplit-lohi
-mno-postinc
-mno-postmodify
Modificări de generare de cod care dezactivează, respectiv, împărțirea încărcărilor pe 32 de biți,
generarea de adrese post-incrementare și generarea de adrese post-modificare. The
valorile implicite sunt msplit-lohi, -mpost-inc, și -mpost-modify.

-mnovect-dublu
Schimbați modul SIMD preferat în SImode. Valoarea implicită este -mvect-dublu, Care utilizări
DImode ca mod SIMD preferat.

-max-vect-align=o
Alinierea maximă pentru tipurile de mod vector SIMD. o poate fi 4 sau 8. Valoarea implicită este
8. Rețineți că aceasta este o modificare ABI, chiar dacă multe interfețe de funcții de bibliotecă sunt
neafectate dacă nu folosesc moduri vectoriale SIMD în locuri care afectează dimensiunea și/sau
alinierea tipurilor relevante.

-msplit-vecmove-devreme
Împărțirea vectorului se mută în mișcări de un singur cuvânt înainte de reîncărcare. În teorie acest lucru poate da
o alocare mai bună a registrelor, dar până acum pare să fie în general cazul invers.

-m1reg-reg
Specificați un registru care să mențină constanta -1, ceea ce face ca încărcarea să fie mică negativă
constante și anumite măști de biți mai rapid. Valori admise pentru reg sunt r43 și r63,
care specifică utilizarea acelui registru ca registru fix și nici unul, ceea ce înseamnă că nu
registrul este utilizat în acest scop. Valoarea implicită este -m1reg-niciuna.

ARC Opţiuni

Următoarele opțiuni controlează varianta de arhitectură pentru care codul este compilat:

-barrel-shifter
Generați instrucțiuni susținute de comutatorul de butoi. Aceasta este valoarea implicită, dacă nu
-mcpu=ARC601 este în vigoare.

-mcpu=cpu
Setați tipul de arhitectură, utilizarea înregistrării și parametrii de programare a instrucțiunilor pentru cpu.
Există, de asemenea, opțiuni de alias de comandă rapidă disponibile pentru compatibilitate inversă și
comoditatea. Valori acceptate pentru cpu sunt

ARC600
Compilați pentru ARC600. Aliasuri: -mA6, -mARC600.

ARC601
Compilați pentru ARC601. Alias: -mARC601.

ARC700
Compilați pentru ARC700. Aliasuri: -mA7, -mARC700. Acesta este implicit atunci când este configurat
cu --with-cpu=arc700.

-mdpfp
-mdpfp-compact
FPX: Generați instrucțiuni FPX Double Precision, reglate pentru implementarea compactă.

-mdpfp-rapid
FPX: Generați instrucțiuni FPX Double Precision, reglate pentru implementare rapidă.

-mno-dpfp-lrsr
Dezactivați instrucțiunile LR și SR de la utilizarea registrelor auxiliare de extensie FPX.

-mea
Generați instrucțiuni aritmetice extinse. Momentan doar „divaw”, „adds”, „subs”,
și „sat16” sunt acceptate. Acest lucru este întotdeauna activat pentru -mcpu=ARC700.

-mno-mpy
Nu generați instrucțiuni mpy pentru ARC700.

-mmul32x16
Generați instrucțiuni de înmulțire pe 32x16 biți și mac.

-mmul64
Generați instrucțiuni mul64 și mulu64. Valabil doar pentru -mcpu=ARC600.

-norma
Generați instrucțiuni de normă. Aceasta este valoarea implicită dacă -mcpu=ARC700 este în vigoare.

-mspfp
-mspfp-compact
FPX: Generați instrucțiuni FPX Single Precision, reglate pentru implementarea compactă.

-mspfp-rapid
FPX: Generați instrucțiuni FPX Single Precision, reglate pentru implementare rapidă.

-msimd
Activați generarea de instrucțiuni ARC SIMD prin intermediul elementelor integrate specifice țintei. Numai valabil
pentru -mcpu=ARC700.

-msoft-float
Această opțiune a fost ignorată; este furnizat numai în scopuri de compatibilitate. Software
Codul în virgulă mobilă este emis în mod implicit, iar această implicită poate fi înlocuită de FPX
Opțiuni; mspfp, mspfp-compact, Sau mspfp-rapid pentru precizie unică și mdpfp, mdpfp-
compact, Sau mdpfp-rapid pentru dublă precizie.

-mswap
Generați instrucțiuni de schimb.

Următoarele opțiuni sunt transmise asamblatorului și, de asemenea, definesc preprocesorul
simboluri macro.

-mdsp-packa
Transmis la asamblator pentru a activa extensiile DSP Pack A. De asemenea, stabilește
simbolul preprocesorului „__Xdsp_packa”.

-mdvbf
Transmis la asamblator pentru a activa extensia dublă Viterbi fluture. De asemenea
setează simbolul preprocesorului „__Xdvbf”.

-mlock
Transmis la asamblator pentru a activa extensia Condițională de încărcare/stocare blocată.
Setează, de asemenea, simbolul preprocesorului „__Xlock”.

-mmac-d16
Transmis la asamblator. Setează, de asemenea, simbolul preprocesorului „__Xxmac_d16”.

-mmac-24
Transmis la asamblator. Setează, de asemenea, simbolul preprocesorului „__Xxmac_24”.

-mrtsc
Transmis la asamblator pentru a activa extensia Time-Stamp Counter pe 64 de biți
instrucție. Setează, de asemenea, simbolul preprocesorului „__Xrtsc”.

-mswape
Transmis la asamblator pentru a activa instrucțiunea de extensie pentru comandarea de octeți de schimb.
Setează, de asemenea, simbolul preprocesorului „__Xswape”.

-mtelefonie
Transmis la asamblator pentru a permite instrucțiuni cu operand dublu și unic pentru
telefonie. Setează, de asemenea, simbolul preprocesorului „__Xtelephony”.

-mxy
Transmis la asamblator pentru a activa extensia de memorie XY. De asemenea, stabilește
simbolul preprocesorului „__Xxy”.

Următoarele opțiuni controlează modul în care este adnotat codul de asamblare:

- misize
Adnotați instrucțiunile de asamblare cu adrese estimate.

-manotate-aliniere
Explicați ce considerente de aliniere duc la decizia de a face o instrucțiune
scurte sau lungi.

Următoarele opțiuni sunt transmise linkerului:

-marclinux
Transmis la linker, pentru a specifica utilizarea emulației „arclinux”. Această opțiune
este activat implicit în lanțurile de instrumente construite pentru „arc-linux-uclibc” și
ținte „arceb-linux-uclibc” atunci când nu este solicitată profilarea.

-marclinux_prof
Transmis la linker, pentru a specifica utilizarea emulației „arclinux_prof”. Acest
opțiunea este activată implicit în lanțurile de instrumente construite pentru „arc-linux-uclibc” și
ținte „arceb-linux-uclibc” atunci când se solicită profilarea.

Următoarele opțiuni controlează semantica codului generat:

-mepilog-cfi
Activați generarea de informații privind cadrul de apel pentru epiloguri.

-mno-epilog-cfi
Dezactivați generarea de informații privind cadrul de apel pentru epiloguri.

-mlong-apeluri
Generați apeluri insns ca înregistrarea apelurilor indirecte, oferind astfel acces la maximum
Interval de adrese pe 32 de biți.

-medium-apeluri
Nu utilizați un interval de adresare mai mic de 25 de biți pentru apeluri, care este decalajul disponibil
pentru o instrucțiune necondiționată de ramificare și legătură. Executarea condiționată a funcției
apelurile sunt suprimate, pentru a permite utilizarea intervalului de 25 de biți, mai degrabă decât a intervalului de 21 de biți
cu ramură și legătură condiționată. Aceasta este valoarea implicită pentru lanțurile de scule create pentru
ținte „arc-linux-uclibc” și „arceb-linux-uclibc”.

-mno-sdata
Nu generați referințe sdata. Aceasta este valoarea implicită pentru lanțurile de scule create pentru
ținte „arc-linux-uclibc” și „arceb-linux-uclibc”.

-mucb-mcount
Instrument cu apeluri mcount așa cum este utilizat în codul UCB. Adică faceți numărătoarea în apelat,
nu apelantul. În mod implicit, instrumentația ARC contează în apelant.

-mvolatile-cache
Utilizați accesul de memorie cache în mod obișnuit pentru referințe volatile. Aceasta este valoarea implicită.

-mno-volatil-cache
Activați ocolirea memoriei cache pentru referințe volatile.

Următoarele opțiuni ajustează fin generarea codului:

-malign-call
Faceți optimizări de aliniere pentru instrucțiunile de apel.

-mauto-modify-reg
Activați utilizarea pre/post modificare cu deplasarea registrului.

-mbbit-vizor
Activați bbit peephole2.

-mno-brcc
Această opțiune dezactivează o trecere specifică țintei arc_reorg pentru a genera „BRcc”
instrucțiuni. Nu are niciun efect asupra generației „BRcc” condusă de trecerea combinatorului.

-mcase-vector-pcrel
Folosiți tabele de carcasă pentru comutatoare legate de computer - acest lucru permite scurtarea tabelului de carcasă. Acesta este
implicit pentru -Os.

-mcompact-casesi
Activați modelul casei compact. Aceasta este valoarea implicită pentru -Os.

-mno-cond-exec
Dezactivați trecerea specifică ARCompact pentru a genera instrucțiuni de execuție condiționată. Datorită
pentru a întârzia programarea sloturilor și interacțiunile dintre numerele de operanzi, dimensiunile literale,
lungimile instrucțiunilor și suportul pentru execuția condiționată, independent de țintă
pass pentru a genera execuția condiționată lipsește adesea, așa că portul ARC a păstrat a
trecere specială în jurul valorii de care încearcă să găsească execuție mai condiționată generatoare
oportunități după alocarea registrului, scurtarea ramurilor și programarea întârzierii sloturilor
a fost făcut. Această trecere în general, dar nu întotdeauna, îmbunătățește performanța și codul
dimensiune, cu costul unui timp suplimentar de compilare, motiv pentru care există o opțiune de comutare
se stinge. Dacă aveți o problemă cu instrucțiunile de apel care depășesc offset-ul permis
pentru că sunt condiționate, ar trebui să luați în considerare utilizarea -medium-apeluri
in schimb.

-mearly-cbranchsi
Activați utilizarea de pre-reîncărcare a modelului cbranchsi.

-mexpand-adddi
Extindeți „adddi3” și „subdi3” la momentul generarii rtl în „add.f”, „adc” etc.

-încărcări-mindexate
Activați utilizarea sarcinilor indexate. Acest lucru poate fi problematic, deoarece unii optimizatori o vor face
apoi presupunem că există magazine indexate, ceea ce nu este cazul.

-mlra
Activați alocarea registrului local. Acest lucru este încă experimental pentru ARC, deci implicit
compilatorul folosește reîncărcarea standard (de ex -mno-lra).

-mlra-prioritate-niciuna
Nu indicați nicio prioritate pentru registrele țintă.

-mlra-prioritate-compact
Indicați prioritatea registrului țintă pentru r0..r3 / r12..r15.

-mlra-prioritate-necompact
Reduceți prioritatea registrului țintă pentru r0..r3 / r12..r15.

-mno-millicode
Când optimizați pentru dimensiune (folosind -Os), proloage și epiloguri care trebuie să salveze sau
restaurarea unui număr mare de registre sunt adesea scurtate prin utilizarea apelului la un special
funcția în libgcc; aceasta este denumită a milicod apel. Deoarece aceste apeluri pot prezenta
probleme de performanță și/sau cauzează probleme de conectare atunci când se conectează într-un mod nestandard,
această opțiune este furnizată pentru a dezactiva generarea de apeluri milicod.

-cod mixt
Modificați alocarea registrului pentru a ajuta la generarea de instrucțiuni pe 16 biți. Acest lucru are în general
efectul scăderii dimensiunii medii a instrucțiunii în timp ce crește instrucțiunea
conta.

-mq-clasa
Activați alternativele de instrucțiuni „q”. Aceasta este valoarea implicită pentru -Os.

-mRcq
Activați gestionarea constrângerii Rcq - cea mai mare parte a generării de coduri scurte depinde de aceasta. Aceasta este
implicit.

-mRcw
Activați gestionarea constrângerii Rcw - ccfsm condexec depinde în mare parte de acest lucru. Acesta este
Mod implicit.

-msize-level=nivel
Ajustați optimizarea dimensiunilor în ceea ce privește lungimea instrucțiunilor și alinierea. The
valori recunoscute pentru nivel sunt:

0 Fără optimizare a dimensiunii. Acest nivel este depreciat și tratat ca 1.

1 Instrucțiunile scurte sunt folosite oportunist.

2 În plus, alinierea buclelor și a codului după eliminarea barierelor.

3 În plus, alinierea opțională a datelor este abandonată și opțiunea Os este activat.

Aceasta este implicită 3 cand -Os este în vigoare. În caz contrar, comportamentul atunci când acest lucru nu este
set este echivalent cu nivel 1.

-mtune=cpu
Setați parametrii de programare a instrucțiunilor pentru cpu, suprascriind orice implicat de -mcpu=.

Valori acceptate pentru cpu sunt

ARC600
Ajustați pentru procesorul ARC600.

ARC601
Ajustați pentru procesorul ARC601.

ARC700
Reglați pentru procesorul ARC700 cu bloc multiplicator standard.

ARC700-xmac
Ajustați pentru procesor ARC700 cu bloc XMAC.

ARC725D
Ajustați pentru procesorul ARC725D.

ARC750D
Ajustați pentru procesorul ARC750D.

-mmultcost=o
Costul de asumat pentru o instrucțiune de multiplicare, cu 4 fiind egală cu o instrucţiune normală.

-munalign-prob-threshold=probabilitate
Setați pragul de probabilitate pentru dezalinierea ramurilor. Când reglați pentru ARC700 și
optimizând pentru viteza, ramurile fără slot de întârziere umplut sunt de preferință emise
nealiniat și lung, cu excepția cazului în care profilarea indică faptul că probabilitatea ca ramura să
fi luat este mai jos probabilitate. Valoarea implicită este (REG_BR_PROB_BASE/2), adică 5000.

Următoarele opțiuni sunt menținute pentru compatibilitate cu versiunea anterioară, dar acum sunt depreciate
și va fi eliminat într-o versiune viitoare:

-margonaut
FPX învechit.

-mbig-endian
-EB Compilați cod pentru ținte Big Endian. Utilizarea acestor opțiuni este acum depreciată. Utilizatori
dorind cod big-endian, ar trebui să utilizeze țintele „arceb-elf32” și „arceb-linux-uclibc”
la construirea lanțului de scule, pentru care big-endian este implicit.

-mlittle-endian
-CE Compilați codul pentru ținte Little Endian. Utilizarea acestor opțiuni este acum depreciată.
Utilizatorii care doresc cod little-endian ar trebui să folosească „arc-elf32” și „arc-linux-uclibc”
ținte la construirea lanțului de scule, pentru care little-endian este implicit.

-mbarrel_shifter
Inlocuit de -barrel-shifter

-mdpfp_compact
Inlocuit de -mdpfp-compact

-mdpfp_rapid
Inlocuit de -mdpfp-rapid

-mdsp_packa
Inlocuit de -mdsp-packa

-mEA
Inlocuit de -mea

-mmac_24
Inlocuit de -mmac-24

-mmac_d16
Inlocuit de -mmac-d16

-mspfp_compact
Inlocuit de -mspfp-compact

-mspfp_rapid
Inlocuit de -mspfp-rapid

-mtune=cpu
Valori arc600, arc601, arc700 și arc700-xmac pentru cpu sunt înlocuite cu ARC600, ARC601,
ARC700 și ARC700-xmac respectiv

-multcost=o
Inlocuit de -multcost.

ARM Opţiuni

Acestea -m opțiunile sunt definite pentru arhitecturile Advanced RISC Machines (ARM):

-mabi=nume
Generați codul pentru ABI specificat. Valorile permise sunt: apcs-gnu, atbuc, aapcs,
aapcs-linux și iwmmxt.

-mapcs-cadru
Generați un cadru de stivă care este compatibil cu standardul de apel de procedură ARM pentru toți
funcții, chiar dacă acest lucru nu este strict necesar pentru executarea corectă a codului.
specificarea -fomit-cadru-pointer cu această opțiune face ca cadrele stivei să nu fie
generate pentru funcțiile frunzelor. Valoarea implicită este -mno-apcs-frame.

-mapcs
Acesta este un sinonim pentru -mapcs-cadru.

-mthub-interwork
Generați cod care acceptă apelurile între seturile de instrucțiuni ARM și Thumb.
Fără această opțiune, pe arhitecturile anterioare v5, cele două seturi de instrucțiuni nu pot fi
utilizat în mod fiabil într-un singur program. Valoarea implicită este -mno-degetul mare-interwork, din moment ce usor
cod mai mare este generat când -mthub-interwork este specificat. În configurațiile AAPCS
această opțiune este lipsită de sens.

-mno-sched-prolog
Preveniți reordonarea instrucțiunilor din prologul funcției sau îmbinarea
acele instrucțiuni cu instrucțiunile din corpul funcției. Aceasta înseamnă că toate
funcțiile încep cu un set de instrucțiuni recunoscut (sau, de fapt, unul de alegere
dintr-un set mic de prologuri de funcții diferite), iar aceste informații pot fi folosite pentru
localizați începutul funcțiilor într-o bucată de cod executabilă. Valoarea implicită este
-msched-prolog.

-mfloat-abi=nume
Specifică ce ABI în virgulă mobilă să folosească. Valorile permise sunt: moale, softfp și
greu.

specificarea moale determină GCC să genereze rezultate care conțin apeluri de bibliotecă pentru flotare
operații cu puncte. softfp permite generarea de cod folosind virgulă mobilă hardware
instrucțiuni, dar folosește totuși convențiile de apelare soft-float. greu permite
generarea de instrucțiuni în virgulă mobilă și utilizează convențiile de apelare specifice FPU.

Valoarea implicită depinde de configurația specifică a țintei. Rețineți că hard-float
și ABI-urile soft-float nu sunt compatibile cu link-ul; trebuie să compilați întregul program cu
același ABI și se leagă cu un set compatibil de biblioteci.

-mlittle-endian
Generați cod pentru un procesor care rulează în modul little-endian. Aceasta este valoarea implicită pentru
toate configurațiile standard.

-mbig-endian
Generați cod pentru un procesor care rulează în modul big-endian; implicit este compilarea
cod pentru un procesor little-endian.

-mwords-little-endian
Această opțiune se aplică numai la generarea codului pentru procesoarele big-endian. Genera
cod pentru o ordine de cuvinte little-endian, dar o ordine de octeți big-endian. Adică un octet
ordinea formularului 32107654. Notă: această opțiune ar trebui utilizată numai dacă aveți nevoie
compatibilitate cu codul pentru procesoarele big-endian ARM generate de versiunile de
compilator înainte de 2.8. Această opțiune este acum depreciată.

-martie=nume
Acesta specifică numele arhitecturii ARM țintă. GCC folosește acest nume pentru
determinați ce fel de instrucțiuni poate emite la generarea codului de asamblare. Acest
opțiunea poate fi utilizată împreună cu sau în loc de -mcpu= opțiune. Permis
numele sunt: 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, armv7ve, armv8-a, armv8-a+crc, iwmmxt, iwmmxt2, ep9312.

-march=armv7ve este arhitectura armv7-a cu extensii de virtualizare.

-march=armv8-a+crc permite generarea de cod pentru arhitectura ARMv8-A împreună cu
extensiile opționale CRC32.

-martie=nativ determină compilatorul să detecteze automat arhitectura build-ului
calculator. În prezent, această caracteristică este acceptată numai pe GNU/Linux și nu pe toate
arhitecturile sunt recunoscute. Dacă detectarea automată nu reușește, opțiunea nu are
efect.

-mtune=nume
Această opțiune specifică numele procesorului ARM țintă pentru care ar trebui să se regleze GCC
performanța codului. Pentru unele implementări ARM, o performanță mai bună poate fi
obţinut prin utilizarea acestei opţiuni. Numele permise sunt: arm2, arm250, arm3, arm6,
arm60, arm600, arm610, arm620, arm7, brațul7m, brațul7d, brațul7dm, arm7di, arm7dmi, arm70,
arm700, arm700i, arm710, brațul710c, arm7100, arm720, arm7500, arm7500fe, arm7tdmi,
arm7tdmi-s, brațul710t, brațul720t, brațul740t, braț puternic, brațul puternic110, brațul puternic1100,
brațul puternic1110, arm8, arm810, arm9, arm9e, arm920, brațul920t, brațul922t, arm946e-s,
arm966e-s, arm968e-s, arm926ej-s, brațul940t, arm9tdmi, arm10tdmi, brațul1020t, arm1026ej-s,
arm10e, arm1020e, arm1022e, braț1136j-s, braț1136jf-s, mpcore, mpcorenovfp, braţ1156t2-s,
braț1156t2f-s, braț1176jz-s, braț1176jzf-s, cortex-a5, cortex-a7, cortex-a8, cortex-a9,
cortex-a12, cortex-a15, cortex-a53, cortex-a57, cortex-r4, cortex-r4f, cortex-r5,
cortex-r7, cortex-m4, cortex-m3, cortex-m1, cortex-m0, cortex-m0plus, maravell-pj4,
xscale, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626, fa726te.

În plus, această opțiune poate specifica că GCC ar trebui să ajusteze performanța codului
pentru un sistem mare.MIC. Numele permise sunt: cortex-a15.cortex-a7,
cortex-a57.cortex-a53.

-mtune=generic-arc specifică faptul că GCC ar trebui să ajusteze performanța pentru un amestec de
procesoare în cadrul arhitecturii arc. Scopul este de a genera cod care să ruleze bine pe
cele mai populare procesoare actuale, echilibrând între optimizările de care beneficiază unii
CPU-uri în gamă și evitând capcanele de performanță ale altor procesoare. Efectele
această opțiune se poate modifica în versiunile viitoare GCC pe măsură ce modelele CPU vin și pleacă.

-mtune=nativ determină compilatorul să detecteze automat CPU-ul computerului de construcție. La
prezent, această caracteristică este acceptată numai pe GNU/Linux și nu toate arhitecturile sunt
recunoscut. Dacă detectarea automată nu are succes, opțiunea nu are efect.

-mcpu=nume
Acesta specifică numele procesorului ARM țintă. GCC folosește acest nume pentru a deriva
numele arhitecturii ARM țintă (ca și cum ar fi specificat de -Martie) și procesorul ARM
tipul pentru care să reglați performanța (ca și cum ar fi specificat de -mtune). Unde această opțiune
este folosit împreună cu -Martie or -mtune, acele opțiuni au prioritate față de
parte adecvată a acestei opțiuni.

Numele permise pentru această opțiune sunt aceleași cu cele pentru -mtune.

-mcpu=generic-arc este, de asemenea, permis și este echivalent cu -martie=arc
-mtune=generic-arc. Vedea -mtune pentru mai multe informatii.

-mcpu=nativ determină compilatorul să detecteze automat CPU-ul computerului de construcție. La
prezent, această caracteristică este acceptată numai pe GNU/Linux și nu toate arhitecturile sunt
recunoscut. Dacă detectarea automată nu are succes, opțiunea nu are efect.

-mfpu=nume
Aceasta specifică pe ce hardware în virgulă mobilă (sau emulație hardware) este disponibilă
ținta. Numele permise sunt: vfp, vfpv3, vfpv3-fp16, vfpv3-d16, vfpv3-d16-fp16,
vfpv3xd, vfpv3xd-fp16, neon, neon-fp16, vfpv4, vfpv4-d16, fpv4-sp-d16, neon-vfpv4,
fp-armv8, neon-fp-armv8, și cripto-neon-fp-armv8.

If -msoft-float este specificat, acesta specifică formatul valorilor în virgulă mobilă.

Dacă hardware-ul în virgulă mobilă selectat include extensia NEON (de ex -mfpu=neon),
rețineți că operațiunile în virgulă mobilă nu sunt generate de trecerea de auto-vectorizare a GCC
dacă nu -optimizări-funsafe-matematice este de asemenea specificat. Acest lucru se datorează faptului că hardware-ul NEON
nu implementează pe deplin standardul IEEE 754 pentru aritmetica în virgulă mobilă (în
anumite valori denormale sunt tratate ca zero), astfel încât utilizarea instrucțiunilor NEON poate
duce la pierderea preciziei.

-mfp16-format=nume
Specificați formatul tipului de virgulă mobilă cu jumătate de precizie „__fp16”. Permis
numele sunt nici unul, ieee, și alternativă; implicit este nici unul, caz în care „__fp16”
tipul nu este definit.

-mstructure-size-boundary=n
Dimensiunile tuturor structurilor și uniunilor sunt rotunjite la un multiplu al numărului de
biți setați de această opțiune. Valorile permise sunt 8, 32 și 64. Valoarea implicită
variază pentru diferite lanțuri de instrumente. Pentru lanțul de instrumente vizat COFF, valoarea implicită este
8. O valoare de 64 este permisă numai dacă ABI-ul de bază o acceptă.

Specificarea unui număr mai mare poate produce un cod mai rapid și mai eficient, dar poate și
măriți dimensiunea programului. Diferite valori sunt potențial incompatibile.
Codul compilat cu o singură valoare nu se poate aștepta neapărat să funcționeze cu cod sau biblioteci
compilate cu o altă valoare, dacă fac schimb de informații folosind structuri sau uniuni.

-avort-la-noreturn
Generați un apel la funcția „abort” la sfârșitul unei funcții „noreturn”. Este
executat dacă funcția încearcă să revină.

-mlong-apeluri
-mno-lung-apeluri
Spune compilatorului să efectueze apeluri de funcții încărcând mai întâi adresa fișierului
funcția într-un registru și apoi efectuând un apel de subrutină pe acest registru. Acest
comutatorul este necesar dacă funcția țintă se află în afara adresei de 64 de megaocteți
intervalul versiunii bazate pe offset a instrucțiunii de apel de subrutină.

Chiar dacă acest comutator este activat, nu toate apelurile de funcții sunt transformate în apeluri lungi.
Euristica este că funcțiile statice, funcțiile care au apel scurt atribut,
funcții care sunt în sfera de aplicare a a #pragma nu_apeluri_prelungite directivă, și
funcții ale căror definiții au fost deja compilate în cadrul compilației curente
unitatea nu sunt transformate în apeluri lungi. Excepțiile de la această regulă sunt atât de slabe
definiții de funcții, funcții cu apel lung atributul sau cel secțiune atribut,
și funcții care intră în sfera de aplicare a a #pragma apeluri_lungite directive sunt întotdeauna
transformate în apeluri lungi.

Această caracteristică nu este activată în mod implicit. Precizând -mno-lung-apeluri restabilește
comportament implicit, la fel ca și plasarea apelurilor de funcție în sfera a #pragma
long_calls_off directivă. Rețineți că aceste comutatoare nu au niciun efect asupra modului în care compilatorul
generează cod pentru a gestiona apelurile de funcții prin indicatori de funcție.

-msingle-pic-base
Tratați registrul utilizat pentru adresarea PIC ca fiind doar pentru citire, în loc să îl încărcați în fișierul
prolog pentru fiecare funcție. Sistemul runtime este responsabil pentru inițializarea acestui lucru
înregistrați cu o valoare adecvată înainte de a începe execuția.

-mpic-registru=reg
Specificați registrul care va fi utilizat pentru adresarea PIC. Pentru cazul de bază PIC standard,
implicit va fi orice registru adecvat determinat de compilator. Pentru o singură bază PIC
caz, implicit este R9 dacă ținta se bazează pe EABI sau este activată verificarea stivei,
în caz contrar, implicit este R10.

-datele-mpic-sunt-relative-de-text
Să presupunem că fiecare segment de date este relativ la segmentul de text în momentul încărcării. Prin urmare,
permite adresarea datelor utilizând operațiuni legate de PC. Această opțiune este activată în mod implicit
pentru alte ținte decât VxWorks RTP.

-mpoke-nume-funcție
Scrieți numele fiecărei funcții în secțiunea de text, direct înaintea funcției
prolog. Codul generat este similar cu acesta:

t0
.ascii „nume_funcție_arm_poke”, 0
.alinia
t1
.cuvânt 0xff000000 + (t1 - t0)
arm_poke_function_name
mov ip, sp
stmfd sp!, {fp, ip, lr, pc}
sub fp, ip, #4

Când se efectuează o urmărire înapoi a stivei, codul poate inspecta valoarea „pc” stocată la „fp +
0". Dacă funcția de urmărire se uită atunci la locația „pc - 12” și primii 8 biți sunt
set, atunci știm că există un nume de funcție încorporat imediat înaintea acestuia
locație și are lungimea „((buc[-3]) și 0xff000000)”.

-degetul mare
-marm
Selectați între generarea de cod care se execută în stările ARM și Thumb. Valoarea implicită pentru
majoritatea configurațiilor este de a genera cod care se execută în stare ARM, dar implicit
poate fi schimbat prin configurarea GCC cu --cu-mod=de stat opțiunea de configurare.

-mtpcs-cadru
Generați un cadru de stivă care este compatibil cu Standardul de apel pentru procedura Thumb pentru
toate funcțiile non-frunze. (O funcție frunză este una care nu apelează nicio alta
funcții.) Valoarea implicită este -mno-tpcs-frame.

-mtpcs-leaf-frame
Generați un cadru de stivă care este compatibil cu Standardul de apel pentru procedura Thumb pentru
toate funcțiile frunzelor. (O funcție frunză este una care nu apelează nicio altă funcție.)
Valoarea implicită este -mno-apcs-cadru-frunză.

-mcallee-super-interfuncționare
Oferă tuturor funcțiilor vizibile extern din fișierul în curs de compilare o instrucțiune ARM
setați antetul care comută în modul Thumb înainte de a executa restul funcției.
Acest lucru permite ca aceste funcții să fie apelate din codul care nu interfuncționează. Această opțiune este
nu este valabil în configurațiile AAPCS, deoarece interfuncționarea este activată în mod implicit.

-mcaller-super-interfuncționare
Permite executarea corectă a apelurilor prin indicatori de funcție (inclusiv funcții virtuale).
indiferent dacă codul țintă a fost compilat pentru interfuncționare sau nu.
Există o mică suprasarcină în costul executării unui indicator de funcție dacă această opțiune
este activat. Această opțiune nu este validă în configurațiile AAPCS, deoarece interfuncționarea este
activat implicit.

-mtp=nume
Specificați modelul de acces pentru pointerul de stocare local de fir. Modelele valabile sunt
moale, care generează apeluri către „__aeabi_read_tp”, cp15, care preia firul
pointer de la „cp15” direct (suportat în arhitectura arm6k) și Auto, Care
folosește cea mai bună metodă disponibilă pentru procesorul selectat. Setarea implicită este
Auto.

-mtls-dialect=dialect
Specificați dialectul de utilizat pentru a accesa stocarea locală a firelor. Două dialectsunt
sprijinit---gnu și gnu2. gnu dialect selectează schema GNU originală pentru
sprijinirea modelelor TLS dinamice locale și globale. The gnu2 dialectul selectează GNU
schema de descriptor, care oferă performanțe mai bune pentru bibliotecile partajate. GNU
Schema de descriptor este compatibilă cu schema originală, dar necesită noi
suport pentru asamblare, linker și bibliotecă. Modelele TLS inițiale și locale sunt
neafectat de această opțiune și utilizați întotdeauna schema originală.

-mword-relocari
Generați numai relocari absolute pe valori de dimensiunea unui cuvânt (adică R_ARM_ABS32). Aceasta este
activat în mod implicit pe ținte (uClinux, SymbianOS) unde încărcătorul de rulare impune
această restricție și când -fpic or -fPIC este specificat.

-mfix-cortex-m3-ldrd
Unele nuclee Cortex-M3 pot provoca coruperea datelor atunci când instrucțiunile „ldrd” cu
sunt utilizate registre de destinație și bază care se suprapun. Această opțiune evită generarea
aceste instrucțiuni. Această opțiune este activată implicit când -mcpu=cortex-m3 is
specificat.

-munaligned-acces
-mno-unaligned-access
Activează (sau dezactivează) citirea și scrierea valorilor pe 16 și 32 de biți din adrese
care nu sunt aliniate pe 16 sau 32 de biți. În mod implicit, accesul nealiniat este dezactivat pentru toți
pre-ARMv6 și toate arhitecturile ARMv6-M și activate pentru toate celelalte arhitecturi. Dacă
accesul nealiniat nu este activat, atunci vor fi accesate cuvintele din structurile de date împachetate
câte un octet.

Atributul ARM „Tag_CPU_unaligned_access” va fi setat în fișierul obiect generat
fie adevărat, fie fals, în funcție de setarea acestei opțiuni. Dacă nu este aliniat
accesul este activat, atunci simbolul preprocesorului „__ARM_FEATURE_UNALIGNED” va fi de asemenea
definit.

-mneon-pentru-64 de biți
Permite utilizarea Neon pentru a gestiona operațiuni scalare pe 64 de biți. Aceasta este dezactivată implicit
deoarece costul mutarii datelor de la registrele de bază la Neon este mare.

-mslow-flash-data
Să presupunem că încărcarea datelor din flash este mai lentă decât preluarea instrucțiunilor. Prin urmare literal
sarcina este redusă la minimum pentru o performanță mai bună. Această opțiune este acceptată numai atunci când
compilarea pentru ARMv7 M-profile și dezactivată implicit.

-mrestrict-o
Restricționează generarea de blocuri IT pentru a se conforma regulilor ARMv8. Blocurile IT pot
conțin doar o singură instrucțiune pe 16 biți dintr-un set selectat de instrucțiuni. Acest
opțiunea este activată în mod implicit pentru modul Thumb ARMv8.

AVR Opţiuni

Aceste opțiuni sunt definite pentru implementările AVR:

-mmcu=mcu
Specificați arhitecturile setului de instrucțiuni Atmel AVR (ISA) sau tipul MCU.

Valoarea implicită pentru această opțiune este@tie{}„avr2”.

GCC acceptă următoarele dispozitive AVR și ISA:

"avr2"
Dispozitive „clasice” cu până la 8@tie{}KiB de memorie de program. mcu@tie{}= „attiny22”,
"attiny26", "at90c8534", "at90s2313", "at90s2323", "at90s2333", "at90s2343",
"at90s4414", "at90s4433", "at90s4434", "at90s8515", "at90s8535".

"avr25"
Dispozitive „clasice” cu până la 8@tie{}KiB de memorie de program și cu „MOVW”
instrucțiune. mcu@tie{}= „ata5272”, „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”.

"avr3"
Dispozitive „clasice” cu 16@tie{}KiB până la 64@tie{}KiB de memorie de program.
mcu@tie{}= „at43usb355”, „at76c711”.

"avr31"
Dispozitive „clasice” cu 128@tie{}KiB de memorie de program. mcu@tie{}= „atmega103”,
„at43usb320”.

"avr35"
Dispozitive „clasice” cu 16@tie{}KiB până la 64@tie{}KiB de memorie de program și cu
instrucțiunea „MOVW”. mcu@tie{}= „ata5505”, „atmega16u2”, „atmega32u2”,
„atmega8u2”, „attiny1634”, „attiny167”, „at90usb162”, „at90usb82”.

"avr4"
Dispozitive „îmbunătățite” cu până la 8@tie{}KiB de memorie de program. mcu@tie{}= "ata6285",
„ata6286”, „atmega48”, „atmega48a”, „atmega48p”, „atmega48pa”, „atmega8”,
„atmega8a”, „atmega8hva”, „atmega8515”, „atmega8535”, „atmega88”, „atmega88a”,
„atmega88p”, „atmega88pa”, „at90pwm1”, „at90pwm2”, „at90pwm2b”, „at90pwm3”,
„at90pwm3b”, „at90pwm81”.

"avr5"
Dispozitive „îmbunătățite” cu 16@tie{}KiB până la 64@tie{}KiB de memorie de program.
mcu@tie{}= „ata5790”, „ata5790n”, „ata5795”, „atmega16”, „atmega16a”,
„atmega16hva”, „atmega16hva2”, „atmega16hvb”, „atmega16hvbrevb”, „atmega16m1”,
„atmega16u4”, „atmega161”, „atmega162”, „atmega163”, „atmega164a”, „atmega164p”,
„atmega164pa”, „atmega165”, „atmega165a”, „atmega165p”, „atmega165pa”,
„atmega168”, „atmega168a”, „atmega168p”, „atmega168pa”, „atmega169”, „atmega169a”,
„atmega169p”, „atmega169pa”, „atmega26hvg”, „atmega32”, „atmega32a”, „atmega32c1”,
„atmega32hvb”, „atmega32hvbrevb”, „atmega32m1”, „atmega32u4”, „atmega32u6”,
„atmega323”, „atmega324a”, „atmega324p”, „atmega324pa”, „atmega325”, „atmega325a”,
„atmega325p”, „atmega3250”, „atmega3250a”, „atmega3250p”, „atmega3250pa”,
„atmega328”, „atmega328p”, „atmega329”, „atmega329a”, „atmega329p”, „atmega329pa”,
„atmega3290”, „atmega3290a”, „atmega3290p”, „atmega3290pa”, „atmega406”,
„atmega48hvf”, „atmega64”, „atmega64a”, „atmega64c1”, „atmega64hve”, „atmega64m1”,
„atmega64rfa2”, „atmega64rfr2”, „atmega640”, „atmega644”, „atmega644a”,
„atmega644p”, „atmega644pa”, „atmega645”, „atmega645a”, „atmega645p”,
„atmega6450”, „atmega6450a”, „atmega6450p”, „atmega649”, „atmega649a”,
„atmega649p”, „atmega6490”, „atmega6490a”, „atmega6490p”, „at90can32”,
"at90can64", "at90pwm161", "at90pwm216", "at90pwm316", "at90scr100", "at90usb646",
„at90usb647”, „at94k”, „m3000”.

"avr51"
Dispozitive „îmbunătățite” cu 128@tie{}KiB de memorie de program. mcu@tie{}= „atmega128”,
„atmega128a”, „atmega128rfa1”, „atmega1280”, „atmega1281”, „atmega1284”,
"atmega1284p", "at90can128", "at90usb1286", "at90usb1287".

"avr6"
Dispozitive „îmbunătățite” cu PC de 3 octeți, adică cu peste 128@tie{}KiB de program
memorie. mcu@tie{}= „atmega2560”, „atmega2561”.

"avrxmega2"
Dispozitive „XMEGA” cu mai mult de 8@tie{}KiB și până la 64@tie{}KiB de memorie de program.
mcu@tie{}= „atmxt112sl”, „atmxt224”, „atmxt224e”, „atmxt336s”, „atxmega16a4”,
"atxmega16a4u", "atxmega16c4", "atxmega16d4", "atxmega32a4", "atxmega32a4u",
"atxmega32c4", "atxmega32d4", "atxmega32e5", "atxmega32x1".

"avrxmega4"
Dispozitive „XMEGA” cu peste 64@tie{}KiB și până la 128@tie{}KiB de program
memorie. mcu@tie{}= „atxmega64a3”, „atxmega64a3u”, „atxmega64a4u”, „atxmega64b1”,
"atxmega64b3", "atxmega64c3", "atxmega64d3", "atxmega64d4".

"avrxmega5"
Dispozitive „XMEGA” cu peste 64@tie{}KiB și până la 128@tie{}KiB de program
memorie și mai mult de 64@tie{}KiB de RAM. mcu@tie{}= "atxmega64a1",
„atxmega64a1u”.

"avrxmega6"
Dispozitive „XMEGA” cu mai mult de 128@tie{}KiB de memorie de program. mcu@tie{}=
„atmxt540s”, „atmxt540sreva”, „atxmega128a3”, „atxmega128a3u”, „atxmega128b1”,
"atxmega128b3", "atxmega128c3", "atxmega128d3", "atxmega128d4", "atxmega192a3",
"atxmega192a3u", "atxmega192c3", "atxmega192d3", "atxmega256a3", "atxmega256a3b",
"atxmega256a3bu", "atxmega256a3u", "atxmega256c3", "atxmega256d3", "atxmega384c3",
„atxmega384d3”.

"avrxmega7"
Dispozitive „XMEGA” cu peste 128@tie{}KiB de memorie de program și mai mult de
64@tie{}KiB de RAM. mcu@tie{}= "atxmega128a1", "atxmega128a1u", "atxmega128a4u".

"avr1"
Acest ISA este implementat de nucleul AVR minim și este acceptat numai pentru asamblare.
mcu@tie{}= „attiny11”, „attiny12”, „attiny15”, „attiny28”, „at90s1200”.

-maccumulate-args
Acumulați argumentele funcției de ieșire și achiziționați/eliberați spațiul necesar pentru stiva
argumente de ieșire ale funcției o dată în prolog/epilog funcție. Fără această opțiune,
argumentele de ieșire sunt împinse înainte de a apela o funcție și apar după aceea.

Apăsarea argumentelor după apelul funcției poate fi costisitoare pe AVR, astfel încât
acumularea spațiului de stivă ar putea duce la executabile mai mici, deoarece argumentele au nevoie
să nu fie eliminate din stivă după un astfel de apel de funcție.

Această opțiune poate duce la o dimensiune redusă a codului pentru funcțiile care efectuează mai multe apeluri către
funcții care își obțin argumentele pe stivă, cum ar fi apeluri la funcții de tip printf.

-mbranch-cost=costa
Setați costurile de sucursală pentru instrucțiunile de sucursală condiționată la costa. Valori rezonabile
pentru costa sunt numere întregi mici, nenegative. Costul implicit al sucursalei este 0.

-mcall-proloage
Funcțiile proloage/epiloguri sunt extinse ca apeluri la subrutine corespunzătoare. Cod
dimensiunea este mai mică.

-mentă8
Să presupunem că „int” este un întreg pe 8 biți. Acest lucru afectează dimensiunile tuturor tipurilor: un „char” este 1
octet, un „int” este de 1 octet, un „long” este de 2 octeți și „long long” este de 4 octeți. Vă rog
rețineți că această opțiune nu este conformă cu standardele C, dar are ca rezultat mai mică
dimensiunea codului.

-mno-întreruperi
Codul generat nu este compatibil cu întreruperile hardware. Dimensiunea codului este mai mică.

-mrelaxează-te
Încercați să înlocuiți „CALL” resp. Instrucțiunea „JMP” de către cel mai scurt „RCALL” resp. "RJMP"
instructiuni daca este cazul. Setarea „-mrelax” adaugă doar opțiunea „--relax” la
linia de comandă a linkerului când linkerul este apelat.

Relaxarea săriturii este efectuată de către linker, deoarece compensațiile de sărituri nu sunt cunoscute înainte
codul este localizat. Prin urmare, codul de asamblare generat de compilator este același,
dar instrucțiunile din executabil pot diferi de instrucțiunile din asamblator
cod.

Relaxarea trebuie activată dacă sunt necesare stub-uri de linker, consultați secțiunea „EIND” și
linker stub-uri de mai jos.

-msp8
Tratați registrul pointerului stivei ca pe un registru de 8 biți, adică să presupuneți octetul mare al
indicatorul stivei este zero. În general, nu trebuie să setați această opțiune manual.

Această opțiune este utilizată intern de compilator pentru a selecta și a construi multilib-uri pentru
arhitecturile „avr2” și „avr25”. Aceste arhitecturi amestecă dispozitive cu și fără
„SPH”. Pentru orice altă setare decât „-mmcu=avr2” sau „-mmcu=avr25” driverul compilatorului
va adăuga sau elimina această opțiune din linia de comandă a compilatorului propriu-zis, deoarece
compilatorul știe atunci dacă dispozitivul sau arhitectura are un pointer de stivă de 8 biți și, prin urmare
nici un registru "SPH" sau nu.

-mstrict-X
Utilizați registrul de adrese „X” într-un mod propus de hardware. Aceasta înseamnă că „X” este
utilizat numai în adresare indirectă, post-increment sau pre-decrementare.

Fără această opțiune, registrul „X” poate fi utilizat în același mod ca „Y” sau „Z”, care
apoi este emulat de instrucțiuni suplimentare. De exemplu, încărcarea unei valori cu
Adresarea „X+const” cu un mic „const < 64” nenegativ la un registru Rn is
efectuat ca

adiw r26, const ; X += const
ld , X ; = *X
sbiw r26, const ; X -= const

-mtiny-stack
Schimbați doar cei 8@tie{}biți inferiori ai indicatorului de stivă.

-Waddr-conversie-spațiu
Avertizați despre conversiile dintre spațiile de adrese în cazul în care adresa rezultată
spațiul nu este conținut în spațiul de adresă de intrare.

„EIND” și Dispozitive cu mai mult de 128 Ki Bytes de Flash

Indicatorii din implementare au o lățime de 16@tie{}biți. Adresa unei funcții sau etichete
este reprezentată ca adresă de cuvânt, astfel încât săriturile indirecte și apelurile pot viza orice cod
adresa în intervalul 64@tie{}Ki cuvinte.

Pentru a facilita saltul indirect pe dispozitivele cu mai mult de 128@tie{}Ki bytes de
spațiu de memorie de program, există un registru de funcție special numit "EIND" care servește ca
cea mai semnificativă parte a adresei țintă atunci când instrucțiunile „EICALL” sau „EIJMP” sunt
folosit.

Salturile indirecte și apelurile pe aceste dispozitive sunt gestionate după cum urmează de către compilator și sunt
sub rezerva unor limitări:

· Compilatorul nu setează niciodată „EIND”.

· Compilatorul folosește „EIND” implicit în instrucțiunile „EICALL”/“EIJMP” sau poate citi
„EIND” direct pentru a emula un apel/sari indirect prin intermediul unui „RET”
instrucțiune.

· Compilatorul presupune că „EIND” nu se modifică niciodată în timpul codului de pornire sau în timpul
aplicarea. În special, „EIND” nu este salvat/restaurat în funcție sau întrerupere
rutină de serviciu prolog/epilog.

· Pentru apelurile indirecte la funcții și goto calculat, linker-ul generează cioturi. cioturi
sunt uneori numite și jump pads trambuline. Astfel, apelul indirect/săritul sare la
un astfel de ciot. Stub-ul conține un salt direct la adresa dorită.

· Relaxarea linkerului trebuie să fie activată, astfel încât linkerul să genereze stub-urile
corect o situație. Vezi opțiunea compilatorului „-mrelax” și opțiunea linler
"--Relaxați-vă". Există cazuri de colț în care linkerul ar trebui să genereze stub-uri, dar
se întrerupe fără relaxare și fără un mesaj de eroare util.

· Scriptul de linker implicit este aranjat pentru codul cu „EIND = 0”. Dacă se presupune cod
pentru a lucra pentru o configurare cu „EIND != 0”, trebuie folosit un script de linker personalizat în ordine
pentru a plasa secțiunile al căror nume începe cu „.trambuline” în segmentul în care
„EIND” indică către.

· Codul de pornire de la libgcc nu setează niciodată „EIND”. Observați că codul de pornire este un amestec
de cod de la libgcc și AVR-LibC. Pentru impactul AVR-LibC asupra „EIND”, consultați AVR-
Manual de utilizare LibC ("http://nongnu.org/avr-libc/user-manual/").

· Este legitim ca codul de pornire specific utilizatorului să configureze „EIND” mai devreme, de exemplu prin
mijloc de inițializare cod situat în secțiunea „.init3”. Un astfel de cod rulează înainte de
cod general de pornire care inițializează RAM și apelează constructori, dar după un pic de
cod de pornire de la AVR-LibC care setează „EIND” la segmentul în care se află tabelul vectorial
află.

#include

gol static
__attribute__((section(".init3"),naked,used,no_instrument_function))
init3_set_eind (void)
{
__asm ​​volatil ("ldi r24,pm_hh8(__trambuline_start)\n\t"
"out %i0,r24" :: "n" (&EIND): "r24","memorie");
}

Simbolul „__trampolines_start” este definit în scriptul linker.

· Stub-urile sunt generate automat de linker dacă sunt următoarele două condiții
întâlnit:

-
(scurt pentru genera cioturi) ca astfel:

LDI r24, lo8(gs( ))
LDI r25, hi8(gs( ))

-
exterior segmentul în care se află cioturile.

· Compilatorul emite astfel de modificatori „gs” pentru etichetele de cod în următoarele situații:

-
-
- -mcall-proloage>
opțiunea de linie de comandă.

-
tabelele pe care le puteți specifica -fno-sarituri-mesele opțiunea de linie de comandă.

-
-
· Săriți la adrese non-simbolice așa cum este nu sprijinit:

int main (void)
{
/* Funcția de apelare la adresa cuvântului 0x2 */
return ((int(*)(void)) 0x2)();
}

În schimb, trebuie configurat un stub, adică funcția trebuie apelată printr-un simbol
("func_4" în exemplu):

int main (void)
{
extern int func_4 (void);

/* Funcția de apelare la adresa octetului 0x4 */
return func_4();
}

iar aplicația să fie legată cu „-Wl,--defsym,func_4=0x4”. Alternativ, „func_4”
poate fi definit în script-ul linker.

Manipularea registrelor cu funcții speciale „RAMPD”, „RAMPX”, „RAMPY” și „RAMPZ”

Unele dispozitive AVR acceptă memorii mai mari decât gama 64@tie{}KiB care pot fi accesate
cu pointere de 16 biți. Pentru a accesa locații de memorie în afara acestui interval 64@tie{}KiB,
conținutul unui registru „RAMP” este folosit ca parte superioară a adresei: „X”, „Y”, „Z”
registrul de adrese este concatenat cu funcția specială „RAMPX”, „RAMPY”, „RAMPZ”.
înregistrează-te, respectiv, pentru a obține o adresă largă. În mod similar, „RAMPD” este folosit împreună cu
adresare directă.

· Codul de pornire inițializează registrele funcției speciale „RAMP” cu zero.

· În cazul în care o AVR Numit Adresă Spații, numite adresa spaţiu altele decât generice sau „__flash” este
folosit, apoi „RAMPZ” este setat după cum este necesar înainte de operație.

· Dacă dispozitivul acceptă RAM mai mare de 64@tie{}KiB și compilatorul trebuie schimbat
„RAMPZ” pentru a realiza o operație, „RAMPZ” este resetat la zero după operație.

· Dacă dispozitivul vine cu un registru „RAMP” specific, prologul/epilogul ISR
salvează/restaurează acel SFR și îl inițializează cu zero în cazul în care codul ISR ar putea
(implicit) folosește-l.

· RAM mai mare de 64@tie{}KiB nu este acceptată de GCC pentru ținte AVR. Dacă utilizați
asamblator inline pentru a citi din locații în afara intervalului de adrese de 16 biți și pentru a modifica
unul dintre registrele „RAMP”, trebuie să îl resetați la zero după acces.

Macro-uri AVR încorporate

GCC definește mai multe macrocomenzi încorporate, astfel încât codul utilizatorului să poată testa prezența sau
absența caracteristicilor. Aproape oricare dintre următoarele macrocomenzi încorporate sunt deduse din dispozitiv
capabilități și astfel declanșate de opțiunea de linie de comandă „-mmcu=".

Pentru și mai multe macrocomenzi încorporate specifice AVR, consultați AVR Numit Adresă Spatii și AVR Built-in
funcţii.

„__AVR_ARCH__”
Macrocomandă încorporată care se rezolvă la un număr zecimal care identifică arhitectura și
depinde de "-mmcu=mcu" opțiune. Valorile posibile sunt:

2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107

pentru mcu="avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",
„avrxmega2”, „avrxmega4”, „avrxmega5”, „avrxmega6”, „avrxmega7”, respectiv. Dacă mcu
specifică un dispozitiv, această macrocomandă încorporată este setată corespunzător. De exemplu, cu
„-mmcu=atmega8” macro-ul va fi definit la 4.

"__AVR_Dispozitiv__"
Setarea „-mmcu=dispozitiv" definește această macrocomandă încorporată care reflectă numele dispozitivului.
De exemplu, „-mmcu=atmega8” definește macro-ul încorporat „__AVR_ATmega8__”,
„-mmcu=attiny261a” definește „__AVR_ATtiny261A__”, etc.

Numele macrocomenzilor încorporate urmează schema „__AVR_Dispozitiv__" Unde Dispozitiv este
numele dispozitivului ca din manualul de utilizare AVR. Diferența dintre Dispozitiv în încorporat
macro și dispozitiv în „-mmcu=dispozitiv" este că acesta din urmă este întotdeauna litere mici.

If dispozitiv nu este un dispozitiv, ci doar o arhitectură de bază precum „avr51”, această macrocomandă va
să nu fie definite.

„__AVR_XMEGA__”
Dispozitivul/arhitectura aparține familiei de dispozitive XMEGA.

„__AVR_HAVE_ELPM__”
Dispozitivul are instrucțiunea „ELPM”.

„__AVR_HAVE_ELPMX__”
Dispozitivul are „ELPM Rn,Z" și „ELPM Rn,Z+" instructiuni.

„__AVR_HAVE_MOVW__”
Dispozitivul are instrucțiunea „MOVW” pentru a efectua mișcări registru-registru pe 16 biți.

„__AVR_HAVE_LPMX__”
Dispozitivul are „LPM Rn,Z" și „LPM Rn,Z+" instructiuni.

„__AVR_HAVE_MUL__”
Dispozitivul are un multiplicator hardware.

„__AVR_HAVE_JMP_CALL__”
Dispozitivul are instrucțiunile „JMP” și „CALL”. Acesta este cazul dispozitivelor cu
cel puțin 16@tie{}KiB de memorie de program.

„__AVR_HAVE_EIJMP_EICALL__”
„__AVR_3_BYTE_PC__”
Dispozitivul are instrucțiunile „EIJMP” și „EICALL”. Acesta este cazul dispozitivelor
cu mai mult de 128@tie{}KiB de memorie de program. Aceasta înseamnă, de asemenea, că programul
contorul (PC) are o lățime de 3@tie{}octeți.

„__AVR_2_BYTE_PC__”
Contorul de programe (PC) are o lățime de 2@tie{}octeți. Acesta este cazul dispozitivelor cu până la
128@tie{}KiB de memorie de program.

„__AVR_HAVE_8BIT_SP__”
„__AVR_HAVE_16BIT_SP__”
Registrul stack pointer (SP) este tratat ca registru de 8 biți, respectiv 16 biți de către
compilatorul. Definiția acestor macrocomenzi este afectată de „-mtiny-stack”.

„__AVR_HAVE_SPH__”
„__AVR_SP8__”
Dispozitivul are registrul de funcție specială SPH (partea înaltă a indicatorului stivei) sau are
un indicator de stivă de 8 biți, respectiv. Definiția acestor macrocomenzi este afectată de
„-mmcu=" iar în cazurile „-mmcu=avr2” și „-mmcu=avr25” tot prin „-msp8”.

„__AVR_HAVE_RAMPD__”
„__AVR_HAVE_RAMPX__”
„__AVR_HAVE_RAMPY__”
„__AVR_HAVE_RAMPZ__”
Dispozitivul are registrul de funcții speciale „RAMPD”, „RAMPX”, „RAMPY”, „RAMPZ”,
respectiv.

„__NO_INTERRUPȚI__”
Această macrocomandă reflectă opțiunea de linie de comandă „-mno-interrupts”.

„__AVR_ERRATA_SKIP__”
„__AVR_ERRATA_SKIP_JMP_CALL__”
Unele dispozitive AVR (AT90S8515, ATmega103) nu trebuie să omite instrucțiunile pe 32 de biți din cauza unei
eroare hardware. Instrucțiunile de ignorare sunt „SBRS”, „SBRC”, „SBIS”, „SBIC” și „CPSE”.
A doua macrocomandă este definită numai dacă „__AVR_HAVE_JMP_CALL__” este de asemenea setat.

„__AVR_ISA_RMW__”
Dispozitivul are instrucțiuni de citire-modificare-scriere (XCH, LAC, LAS și LAT).

„__AVR_SFR_OFFSET__=decalaj"
Instrucțiuni care pot adresa registre de funcții speciale I/O direct ca „IN”,
„OUT”, „SBI”, etc. pot folosi o adresă diferită ca și cum ar fi adresată printr-o instrucțiune către
accesați RAM ca „LD” sau „STS”. Acest offset depinde de arhitectura dispozitivului și are
pentru a fi scazut din adresa RAM pentru a obtine adresa I/O@tie{}respectiva.

„__WITH_AVRLIBC__”
Compilatorul este configurat pentru a fi utilizat împreună cu AVR-Libc. Vezi
Opțiunea de configurare „--with-avrlibc”.

Negru Opţiuni

-mcpu=cpu[-sirevision]
Specifică numele procesorului Blackfin țintă. În prezent, cpu poate fi unul dintre
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.

Opțional sirevision specifică revizuirea cu siliciu a țintei Blackfin
procesor. Orice soluție disponibilă pentru revizuirea de silicon vizată este activată.
If sirevision is nici unul, nu sunt activate soluții alternative. Dacă sirevision is Orice, toate
sunt activate soluții pentru procesorul vizat. Macrocomanda „__SILICON_REVISION__”.
este definită cu două cifre hexazecimale reprezentând numerele majore și minore din
revizuire siliciu. Dacă sirevision is nici unul, „__SILICON_REVISION__” nu este definit.
If sirevision is Orice, „__SILICON_REVISION__” este definit ca 0xffff. Dacă aceasta
facultativ sirevision nu este utilizat, GCC presupune cea mai recentă revizuire cunoscută de siliciu a
procesor Blackfin vizat.

GCC definește o macrocomandă de preprocesor pentru cea specificată cpu. Pentru bfin-elf lanț de instrumente,
această opțiune face ca BSP-ul hardware furnizat de libgloss să fie conectat în if -msim is
nu li se acordă.

Fără această opțiune, bf532 este folosit ca procesor în mod implicit.

Rețineți că suportul pentru bf561 este incomplet. Pentru bf561, doar macro-ul preprocesorului este
definit.

-msim
Specifică faptul că programul va fi rulat pe simulator. Acest lucru determină simulatorul
BSP furnizat de libgloss pentru a fi conectat. Această opțiune are efect numai pentru bfin-elf
lanțul de instrumente. Anumite alte opțiuni, cum ar fi -mid-shared-bibliotecă și -mfdpic, implică
-msim.

-momit-leaf-frame-pointer
Nu păstrați indicatorul de cadru într-un registru pentru funcțiile frunze. Acest lucru evită
instrucțiuni pentru a salva, configura și restaura pointerii cadru și face un registru suplimentar
disponibil în funcțiile frunzelor. Optiunea -fomit-cadru-pointer îndepărtează cadrul
pointer pentru toate funcțiile, ceea ce ar putea îngreuna depanarea.

-mspecld-anomalie
Când este activat, compilatorul se asigură că codul generat nu conține
încărcături speculative după instrucțiunile de salt. Dacă se folosește această opțiune,
„__WORKAROUND_SPECULATIVE_LOADS” este definit.

-mno-specld-anomalie
Nu generați cod suplimentar pentru a preveni încărcările speculative.

-mcsync-anomalie
Când este activat, compilatorul se asigură că codul generat nu conține CSYNC sau
Instrucțiuni SSYNC prea devreme după ramuri condiționate. Dacă se folosește această opțiune,
„__WORKAROUND_SPECULATIVE_SYNCS” este definit.

-mno-csync-anomalie
Nu generați cod suplimentar pentru a preveni și instrucțiunile CSYNC sau SSYNC să apară
la scurt timp după o ramură condiționată.

-mlow-64k
Când este activat, compilatorul este liber să profite de cunoștințele pe care întregul
programul se încadrează în memoria redusă de 64k.

-mno-low-64k
Să presupunem că programul este arbitrar de mare. Aceasta este valoarea implicită.

-mstack-check-l1
Efectuați verificarea stivei folosind informațiile plasate în memoria scratchpad L1 de către uClinux
nucleu.

-mid-shared-bibliotecă
Generați cod care acceptă biblioteci partajate prin metoda ID-ului bibliotecii. Asta permite
pentru biblioteci executate în loc și partajate într-un mediu fără memorie virtuală
management. Această opțiune implică -fPIC. Cu bfin-elf țintă, această opțiune implică
-msim.

-mno-id-biblioteca partajată
Generați cod care nu presupune că sunt folosite biblioteci partajate bazate pe ID. Aceasta este
implicit.

-mleaf-id-biblioteca partajată
Generați cod care acceptă biblioteci partajate prin metoda ID bibliotecii, dar presupune
că această bibliotecă sau executabil nu se va conecta cu nicio altă bibliotecă partajată cu ID.
Acest lucru permite compilatorului să folosească cod mai rapid pentru salturi și apeluri.

-mno-leaf-id-shared-library
Nu presupuneți că codul în curs de compilare nu se va conecta cu nicio bibliotecă partajată de ID.
Se generează un cod mai lent pentru insn-urile Jump and Call.

-mshared-library-id=n
Specifică numărul de identificare al bibliotecii partajate bazate pe ID care este compilată.
Specificarea unei valori de 0 generează un cod mai compact; precizând alte valori forţe
alocarea acelui număr bibliotecii curente, dar nu mai este spațiu sau timp
eficient decât omiterea acestei opțiuni.

-msep-data
Generați cod care permite ca segmentul de date să fie localizat într-o zonă diferită a memoriei
din segmentul de text. Acest lucru permite executarea pe loc într-un mediu fără
gestionarea memoriei virtuale prin eliminarea relocarilor fata de sectiunea de text.

-mno-sep-data
Generați cod care presupune că segmentul de date urmează segmentul de text. Aceasta este
implicit.

-mlong-apeluri
-mno-lung-apeluri
Spune compilatorului să efectueze apeluri de funcții încărcând mai întâi adresa fișierului
funcția într-un registru și apoi efectuând un apel de subrutină pe acest registru. Acest
comutatorul este necesar dacă funcția țintă se află în afara intervalului de adresare de 24 de biți al
versiunea bazată pe offset a instrucțiunii de apel de subrutine.

Această caracteristică nu este activată în mod implicit. Precizând -mno-lung-apeluri restabilește
comportament implicit. Rețineți că aceste comutatoare nu au niciun efect asupra modului în care compilatorul generează
cod pentru a gestiona apelurile de funcții prin indicatori de funcție.

-mfast-fp
Legătură cu biblioteca rapidă în virgulă mobilă. Această bibliotecă relaxează o parte din IEEE
regulile standardului în virgulă mobilă pentru verificarea intrărilor în raport cu Not-a-Number (NAN), în
interesul de performanţă.

-minline-plt
Activați integrarea intrărilor PLT în apelurile de funcții către funcții care nu sunt cunoscute
se leagă local. Nu are efect fără -mfdpic.

-multicore
Creați o aplicație de sine stătătoare pentru procesoarele multicore Blackfin. Această opțiune provoacă
fișierele de pornire adecvate și scripturile de legătură care acceptă multicore care urmează să fie utilizate și definește
macrocomanda „__BFIN_MULTICORE”. Poate fi folosit doar cu -mcpu=bf561[-sirevision].

Această opțiune poate fi folosită cu -mcorea or -mcoreb, care selectează o singură aplicație-
model de programare per-core. Fără -mcorea or -mcoreb,
este utilizat modelul de programare cu o singură aplicație/dual-core. În acest model, principalul
funcția Core B ar trebui să fie numită „coreb_main”.

Dacă această opțiune nu este utilizată, este utilizat modelul de programare a aplicației cu un singur nucleu.

-mcorea
Creați o aplicație de sine stătătoare pentru Core A din BF561 atunci când utilizați o aplicație-per-
model de programare de bază. Fișierele de pornire adecvate și scripturile de legătură sunt utilizate pentru a sprijini Core
A, iar macro-ul „__BFIN_COREA” este definită. Această opțiune poate fi utilizată numai în
coroborat cu -multicore.

-mcoreb
Creați o aplicație de sine stătătoare pentru Core B din BF561 atunci când utilizați o aplicație-per-
model de programare de bază. Fișierele de pornire adecvate și scripturile de legătură sunt utilizate pentru a sprijini Core
B și macro-ul „__BFIN_COREB” este definită. Când se utilizează această opțiune, „coreb_main”
ar trebui folosit în loc de „principal”. Această opțiune poate fi utilizată numai împreună cu
-multicore.

-msdram
Creați o aplicație autonomă pentru SDRAM. Sunt utilizate fișiere de pornire adecvate și scripturi de legătură
pentru a pune aplicația în SDRAM și este definită macro-ul „__BFIN_SDRAM”. The
încărcătorul ar trebui să inițializeze SDRAM înainte de a încărca aplicația.

-micplb
Să presupunem că ICPLB-urile sunt activate în timpul rulării. Acest lucru are un efect asupra anumitor anomalii
soluții alternative. Pentru ținte Linux, implicit este să presupunem că ICPLB-urile sunt activate; pentru
aplicații autonome, implicit este dezactivat.

C6X Opţiuni

-martie=nume
Acesta specifică numele arhitecturii țintă. GCC folosește acest nume pentru a determina
ce fel de instrucțiuni poate emite la generarea codului de asamblare. Permis
numele sunt: c62x, c64x, c64x+, c67x, c67x+, c674x.

-mbig-endian
Generați cod pentru o țintă big-endian.

-mlittle-endian
Generați cod pentru o țintă little-endian. Aceasta este valoarea implicită.

-msim
Alegeți fișierele de pornire și scriptul de linker potrivite pentru simulator.

-msdata=implicit
Puneți mici date globale și statice în .neardata secțiune, care este indicată de
înregistrarea „B14”. Puneți mici date globale și statice neinițializate în fișierul .bss secțiune,
care este adiacent cu .neardata secțiune. Puneți date mici doar pentru citire în .rodata
secțiune. Secțiunile corespunzătoare utilizate pentru bucăți mari de date sunt .fardata, .departe
și .const.

-msdata=toate
Pune toate datele, nu doar obiectele mici, în secțiunile rezervate pentru date mici și
utilizați adresarea relativă la registrul „B14” pentru a le accesa.

-msdata=niciuna
Nu folosiți secțiunile rezervate pentru date mici și folosiți adrese absolute pentru
accesează toate datele. Puneți toate datele globale și statice inițializate în fișierul .fardata secțiune,
și toate datele neinițializate din .departe secțiune. Pune toate datele constante în .const
secţiune.

CRIS Opţiuni

Aceste opțiuni sunt definite special pentru porturile CRIS.

-martie=de tip arhitectură
-mcpu=de tip arhitectură
Generați cod pentru arhitectura specificată. Alegerile pentru de tip arhitectură sunt
v3, v8 și v10 pentru ETRAX 4, ETRAX 100, respectiv ETRAX 100 LX. Implicit este v0
cu excepția cris-axis-linux-gnu, unde este implicit v10.

-mtune=de tip arhitectură
Acordați-vă de tip arhitectură totul aplicabil despre codul generat, cu excepția
ABI și setul de instrucțiuni disponibile. Alegerile pentru de tip arhitectură sunt
la fel ca pentru -martie=de tip arhitectură.

-mmax-stack-frame=n
Avertizați când cadrul stivei unei funcții depășește n octeți.

-metrax4
-metrax100
Opțiunile -metrax4 și -metrax100 sunt sinonime pentru -martie=v3 și -martie=v8
respectiv.

-mmul-bug-soluție
-mno-mul-bug-workaround
Soluționați o eroare din instrucțiunile „muls” și „mulu” pentru modelele CPU în care acesta
se aplică. Această opțiune este activă implicit.

-mpdebug
Activați informațiile detaliate despre depanare specifice CRIS în codul de asamblare. Acest
opțiunea are și efectul de a opri #NO_APP indicator de cod formatat la
asamblator la începutul dosarului de asamblare.

-mcc-init
Nu utilizați rezultatele codului de condiție din instrucțiunile anterioare; emit întotdeauna compara și
instrucțiuni de testare înainte de utilizarea codurilor de stare.

-mno-efecte secundare
Nu emite instrucțiuni cu efecte secundare în alte moduri de abordare decât post-
creştere.

-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
Aceste opțiuni (nO- opțiuni) aranjați (eliminați aranjamentele) pentru cadrul stivei,
datele individuale și constantele să fie aliniate pentru dimensiunea maximă de acces la date unice
pentru modelul de procesor ales. Implicit este aranjarea pentru alinierea pe 32 de biți. ABI
detalii precum aspectul structurii nu sunt afectate de aceste opțiuni.

-m32-bit
-m16-bit
-m8-bit
Similar cu opțiunile stack-data- și const-align de mai sus, aceste opțiuni sunt aranjate pentru
cadru de stivă, datele inscriptibile și constantele să fie toate aliniate pe 32 de biți, 16 biți sau 8 biți.
Valoarea implicită este alinierea pe 32 de biți.

-mno-prolog-epilog
-mprolog-epilog
Cu -mno-prolog-epilog, funcția normală de prolog și epilog care a creat
cadrele stivei sunt omise și nu există instrucțiuni de returnare sau secvențe de returnare
generate în cod. Utilizați această opțiune numai împreună cu inspecția vizuală a
cod compilat: nu sunt generate avertismente sau erori atunci când registrele salvate pentru apeluri trebuie să fie
salvate sau stocarea pentru variabilele locale trebuie alocată.

-mno-gotplt
-mgotplt
Cu -fpic și -fPIC, nu generați (generează) secvențe de instrucțiuni care se încarcă
adrese pentru funcții din partea PLT a GOT, mai degrabă decât (tradițională pe alte
arhitecturi) apeluri către PLT. Valoarea implicită este -mgotplt.

-melf
Opțiunea moștenită fără operațiuni recunoscută numai cu cris-axis-elf și cris-axis-linux-gnu
ținte.

-mlinux
Opțiunea moștenită fără operațiuni recunoscută numai cu ținta cris-axis-linux-gnu.

-sim
Această opțiune, recunoscută pentru cris-axis-elf, aranjează să se conecteze cu intrare-ieșire
funcții dintr-o bibliotecă de simulatoare. Cod, date inițializate și date zero-inițializate
sunt alocate consecutiv.

-sim2
Aprecieri -sim, dar treceți opțiuni de linker pentru a localiza datele inițializate la 0x40000000 și zero-
date initializate la 0x80000000.

CR16 Opţiuni

Aceste opțiuni sunt definite special pentru porturile CR16.

- mmac
Activați utilizarea instrucțiunilor de multiplicare-acumulare. Dezactivat implicit.

-mcr16cplus
-mcr16c
Generați cod pentru arhitectura CR16C sau CR16C+. Arhitectura CR16C+ este implicită.

-msim
Conectează biblioteca libsim.a care este compatibilă cu simulatorul. Aplicabil pentru ELF
numai compilator.

-mentă32
Alegeți tipul întreg ca lățime de 32 de biți.

-mbit-ops
Generează instrucțiuni "sbit"/"cbit" pentru manipulări de biți.

-mdata-model=model
Alegeți un model de date. Alegerile pentru model sunt aproape, departe or mediu. mediu este implicit.
"Dar daca departe nu este valabil cu -mcr16c, deoarece arhitectura CR16C nu acceptă
model de date departe.

Darwin Opţiuni

Aceste opțiuni sunt definite pentru toate arhitecturile care rulează sistemul de operare Darwin.

FSF GCC pe Darwin nu creează fișiere obiect „grase”; creează un fișier obiect pentru
arhitectura unică pe care GCC a fost creat pentru a viza. GCC-ul Apple pe Darwin creează „grăsime”
fișiere dacă sunt multiple -arc sunt utilizate opțiuni; face acest lucru rulând compilatorul sau linkerul
de mai multe ori și unind rezultatele împreună cu Lipo.

Subtipul fișierului creat (cum ar fi ppc7400 or ppc970 or i686) este determinată de
indicatori care specifică ISA pe care GCC îl vizează, cum ar fi -mcpu or -Martie.
-force_cpusubtype_ALL opțiunea poate fi folosită pentru a înlocui acest lucru.

Instrumentele Darwin variază în comportamentul lor atunci când sunt prezentate cu o nepotrivire ISA. The
asamblator, as, permite utilizarea numai instrucțiunilor care sunt valabile pentru subtipul de
fișierul pe care îl generează, deci nu puteți pune instrucțiuni pe 64 de biți într-un ppc750 fișier obiect. The
linker pentru biblioteci partajate, /usr/bin/libtool, eșuează și tipărește o eroare dacă i se cere
creați o bibliotecă partajată cu un subtip mai puțin restrictiv decât fișierele sale de intrare (pentru
de exemplu, încercarea de a pune a ppc970 fișier obiect într-un ppc7400 bibliotecă). Linkerul pentru
executabile, ld, oferă în liniște executabilului cel mai restrictiv subtip dintre oricare dintre ele
fișiere de intrare.

-Fdir
Adăugați directorul cadru dir la capul listei directoarelor de căutat
pentru fișierele antet. Aceste directoare sunt intercalate cu cele specificate de -I
opțiuni și sunt scanate într-o ordine de la stânga la dreapta.

Un director cadru este un director cu cadre în el. Un cadru este un
director cu a Anteturi şi / sau PrivateHeaders director continut direct în el care
se termină în .cadru. Numele unui cadru este numele acestui director excluzând
il .cadru. Anteturile asociate cadrului se găsesc în unul dintre cele două
directoare, cu Anteturi fiind căutat mai întâi. Un subcadru este un cadru
director care se află într-un cadru cadrele director. Include subcadru
anteturile pot apărea numai într-un antet al unui cadru care conține subcadru sau
într-un antet subcadru fratelui. Două subcadre sunt frați dacă apar în
același cadru. Un subcadru nu trebuie să aibă același nume ca un cadru; A
se emite un avertisment dacă aceasta este încălcată. În prezent un subcadru nu poate avea
subcadre; în viitor, mecanismul poate fi extins pentru a sprijini acest lucru. The
cadrele standard pot fi găsite în / Sistem / Bibliotecă / Cadruri și
/ Library / Cadre. Un exemplu include arată ca „#include ",
Unde Cadru denotă denumirea cadrului și antet.h se găsește în
PrivateHeaders or Anteturi director.

-icadrudir
Aprecieri -F cu excepția că directorul este tratat ca un director de sistem. Principala diferență
intre aceasta -icadru și -F este că cu -icadru compilatorul nu avertizează
despre constructele conținute în fișierele antet găsite prin dir. Această opțiune este valabilă
numai pentru familia C de limbi.

- a presupus
Emiteți informații de depanare pentru simbolurile care sunt utilizate. Pentru formatul de depanare a înjunghiilor,
aceasta permite -elimină-neutilizate-debug-simboluri. Aceasta este activată implicit.

-gfull
Emiteți informații de depanare pentru toate simbolurile și tipurile.

-mmacosx-version-min=versiune
Cea mai veche versiune de MacOS X pe care va rula acest executabil este versiune. Tipic
valori ale versiune includ 10.1, 10.2 și 10.3.9.

Dacă compilatorul a fost construit pentru a utiliza anteturile sistemului în mod implicit, atunci implicit pentru
această opțiune este versiunea de sistem pe care rulează compilatorul, în caz contrar
implicit este de a face alegeri care sunt compatibile cu tot atâtea sisteme și baze de cod
posibil.

-mkernel
Activați modul de dezvoltare a nucleului. The -mkernel seturi de opțiuni -static, -fno-comună,
-fno-use-cxa-atexit, -fno-excepții, -fno-non-call-exceptions, -fapple-kext,
-fno-slab și -fno-rtti acolo unde este cazul. Se setează și acest mod -mno-altivec,
-msoft-float, -fno-builtin și -mlong-ramură pentru ținte PowerPC.

-mone-byte-bool
Ignorați valorile implicite pentru bool astfel încât sizeof(bool)==1. În mod implicit dimensiunea (bool) is 4
la compilarea pentru Darwin/PowerPC și 1 la compilare pentru Darwin/x86, deci această opțiune
nu are efect asupra x86.

Avertisment: -mone-byte-bool comutatorul face ca GCC să genereze cod care nu este binar
compatibil cu codul generat fără comutatorul respectiv. Utilizarea acestui comutator poate necesita
recompilarea tuturor celorlalte module dintr-un program, inclusiv bibliotecile de sistem. Foloseste asta
comutați pentru a se conforma unui model de date care nu este implicit.

-mfix-și-continuați
-fix-and-continuare
-findirect-date
Generați cod adecvat pentru dezvoltarea rapidă, cum ar fi pentru a permite GDB
încărcați dinamic fișierele „.o” în programe care rulează deja. -findirect-date și
-fix-and-continuare sunt furnizate pentru compatibilitate inversă.

-toate_încărcare
Încarcă toți membrii bibliotecilor de arhive statice. Vezi omule ld(1) pentru mai multe informații.

-arch_errors_fatal
Caută erorile care au de-a face cu fișierele care au arhitectura greșită să fie fatale.

-bind_at_load
Determină ca fișierul de ieșire să fie marcat astfel încât linkerul dinamic să le lege pe toate
referințe nedefinite când fișierul este încărcat sau lansat.

-pachet
Produceți un fișier în format pachet Mach-o. Vezi omule ld(1) pentru mai multe informații.

-bundle_loader executabil
Această opțiune specifică executabil care va încărca fișierul de ieșire al construirii fiind
legat. Vezi omule ld(1) pentru mai multe informații.

-dinamiclib
Când trece această opțiune, GCC produce o bibliotecă dinamică în loc de un executabil când
conectarea, folosind Darwin libtool comanda.

-force_cpusubtype_ALL
Acest lucru face ca fișierul de ieșire al GCC să aibă Toate colectiile subtip, în loc de unul controlat de
il -mcpu or -Martie opțiune.

-client_permis numele clientului
-numele clientului
-compatibility_version
-Versiune curentă
-dead_strip
-fisier-dependenta
-dylib_file
-dylinker_install_name
-dinamic
-lista_simbolurilor_exportate
-filelist
-flat_namespace
-force_flat_namespace
-headerpad_max_install_names
-bază_imagine
-init
-nume_instalare
-ţine_privaţi_externi
-multi_module
-multiplicat_definite
-multiply_defined_unused
-noall_load
-no_dead_strip_inits_and_terms
-nofixprebinding
-nomultidefs
-nuprelegare
-noseglinkedit
-pagezero_size
-prelegare
-prebind_all_twolevel_modules
-private_bundle
-read_only_relocs
-sectalign
-sectoobiecte simboluri
-de ce încărcătură
-seg1addr
-sectcreate
-sectoobiecte simboluri
-sector
-segaddr
-segs_read_only_addr
-segs_read_write_addr
-seg_adr_table
-seg_addr_table_filename
-seglinkedit
-segprot
-segs_read_only_addr
-segs_read_write_addr
-modul_unic
-static
-sub_bibliotecă
-sub_umbrelă
-spațiu de nume_două_niveluri
-umbrelă
-nedefinit
-listă_simboluri_neexportate
-nepotriviri_de_referințe_slabe
-ce încărcat
Aceste opțiuni sunt transmise linker-ului Darwin. Pagina de manual pentru linkerul Darwin descrie
ei în detaliu.

Decembrie Alfa Opţiuni

Acestea -m opțiunile sunt definite pentru implementările DEC Alpha:

-mno-soft-float
-msoft-float
Utilizați (nu utilizați) instrucțiunile hardware în virgulă mobilă pentru virgula mobilă
operațiuni. Cand -msoft-float este specificat, funcţionează în libgcc.a sunt folosite pentru a efectua
operații în virgulă mobilă. Cu excepția cazului în care sunt înlocuite cu rutine care emulează
operațiuni în virgulă mobilă sau compilate astfel încât să apeleze astfel de emulări
rutine, aceste rutine emit operații în virgulă mobilă. Dacă compilați pentru
un Alpha fără operații în virgulă mobilă, trebuie să vă asigurați că biblioteca este construită
pentru a nu-i chema.

Rețineți că implementările Alpha fără operațiuni în virgulă mobilă trebuie să aibă
registre în virgulă mobilă.

-mfp-reg
-mno-fp-regs
Generați cod care utilizează (nu utilizează) setul de registru în virgulă mobilă. -mno-fp-regs
implică -msoft-float. Dacă setul de registru în virgulă mobilă nu este utilizat, virgulă mobilă
operanzii sunt trecuți în registre întregi ca și cum ar fi numere întregi și virgulă mobilă
rezultatele sunt transmise în $0 în loc de $f0. Aceasta este o secvență de apeluri non-standard, deci
orice funcție cu un argument în virgulă mobilă sau o valoare returnată apelată de codul compilat
cu -mno-fp-regs trebuie compilat și cu această opțiune.

O utilizare tipică a acestei opțiuni este construirea unui nucleu care nu folosește și, prin urmare, are nevoie
nu salvați și restaurați orice registre în virgulă mobilă.

-mieee
Arhitectura Alpha implementează hardware în virgulă mobilă optimizat pentru maxim
performanţă. Este în mare parte compatibil cu standardul IEEE în virgulă mobilă. In orice caz,
pentru o conformitate deplină, este necesară asistența software. Această opțiune generează cod
cod complet compatibil IEEE cu excepția faptul că steag inexact nu este menținută (vezi mai jos).
Dacă această opțiune este activată, macrocomanda preprocesorului „_IEEE_FP” este definită în timpul
compilare. Codul rezultat este mai puțin eficient, dar este capabil să suporte corect
numere denormalizate și valori IEEE excepționale, cum ar fi not-a-number și plus/minus
infinit. Alți compilatoare Alpha apelează această opțiune -ieee_cu_nu_inexacte.

-mieee-cu-inexacte
Aceasta este ca. -mieee cu excepția codului generat menține și IEEE steag inexact.
Activarea acestei opțiuni face ca codul generat să implementeze IEEE complet compatibil
matematica. Pe lângă „_IEEE_FP”, „_IEEE_FP_EXACT” este definit ca o macrocomandă de preprocesor.
Pe unele implementări Alpha, codul rezultat se poate executa semnificativ mai lent decât
codul generat implicit. Deoarece există foarte puțin cod care depinde de
steag inexact, în mod normal nu ar trebui să specificați această opțiune. Alți compilatori Alpha apel
această opțiune -ieee_cu_ineexacte.

-mfp-trap-mode=modul capcană
Această opțiune controlează ce capcane legate de virgulă mobilă sunt activate. Alt Alfa
compilatorii apelează această opțiune -fptm modul capcană. Modul capcană poate fi setat la unul din patru
valori:

n Aceasta este setarea implicită (normală). Singurele capcane care sunt activate sunt
cele care nu pot fi dezactivate în software (de exemplu, împărțirea prin zero capcană).

u Pe lângă capcanele activate de n, sunt activate și capcanele de depășire.

su Aprecieri u, dar instrucțiunile sunt marcate pentru a fi sigure pentru finalizarea software-ului (vezi
manual de arhitectură alfa pentru detalii).

pe Aprecieri su, dar și capcanele inexacte sunt activate.

-mfp-rounding-mode=modul de rotunjire
Selectează modul de rotunjire IEEE. Alți compilatoare Alpha apelează această opțiune -fprm
modul de rotunjire. modul de rotunjire poate fi unul dintre:

n Mod normal de rotunjire IEEE. Numerele în virgulă mobilă sunt rotunjite spre cel mai apropiat
numărul de mașină sau către numărul par de mașină în caz de egalitate.

m Rotunzi spre minus infinit.

c Mod de rotunjire tăiată. Numerele în virgulă mobilă sunt rotunjite spre zero.

d Mod de rotunjire dinamică. Un câmp din registrul de control în virgulă mobilă (fpcr, A se vedea
Manual de referință pentru arhitectura alfa) controlează modul de rotunjire în vigoare. C
biblioteca inițializează acest registru pentru rotunjire spre plus infinit. Prin urmare,
cu excepția cazului în care programul dvs. modifică fpcr, d corespunde rotunjirii spre plus
infinit.

-mtrap-precision=precizie-capcană
În arhitectura Alpha, capcanele în virgulă mobilă sunt imprecise. Aceasta înseamnă fără
asistență software este imposibil de recuperat dintr-o capcană plutitoare și program
în mod normal, execuția trebuie încheiată. GCC poate genera cod care poate ajuta
gestionatorii capcanelor sistemului de operare în determinarea locației exacte care a cauzat a
capcană în virgulă flotantă. În funcție de cerințele unei aplicații, diferite
pot fi selectate niveluri de precizie:

p Precizia programului. Această opțiune este implicită și înseamnă că doar un handler de capcane poate
identificați ce program a cauzat o excepție în virgulă mobilă.

f Precizia funcției. Managerul capcanei poate determina funcția care a cauzat a
excepție în virgulă mobilă.

i Precizia instrucțiunilor. Operatorul de capcană poate determina instrucțiunea exactă care
a provocat o excepție în virgulă mobilă.

Alte compilatoare Alpha oferă opțiunile echivalente numite -scope_safe și
-reluare_sigură.

-mieee-conform
Această opțiune marchează codul generat ca fiind conform IEEE. Nu trebuie să utilizați această opțiune
cu excepția cazului în care specificați și dumneavoastră -mtrap-precision=i si nici -mfp-trap-mode=su or
-mfp-trap-mode=sui. Singurul său efect este de a emite linia .steagul 48 in functie
prolog al fișierului de asamblare generat.

-mbuild-constante
În mod normal, GCC examinează o constantă întreagă de 32 sau 64 de biți pentru a vedea dacă o poate construi
de la constante mai mici în două sau trei instrucțiuni. Dacă nu se poate, emite fișierul
constantă ca un literal și generează cod pentru a-l încărca din segmentul de date în timpul rulării.

Utilizați această opțiune pentru a solicita GCC să construiască toate constante întregi folosind cod, chiar dacă
este nevoie de mai multe instrucțiuni (maximum șase).

De obicei, utilizați această opțiune pentru a crea un încărcător dinamic de bibliotecă partajată. Însuși a
bibliotecă partajată, trebuie să se mute în memorie înainte de a putea găsi variabilele și
constante în propriul segment de date.

-mbwx
-mno-bwx
-mcix
-mno-cix
-mfix
-mno-fix
-mmax
-mno-max
Indicați dacă GCC ar trebui să genereze cod pentru a utiliza opționalele BWX, CIX, FIX și MAX
seturi de instrucțiuni. Implicit este să utilizați seturile de instrucțiuni acceptate de CPU
tip specificat prin -mcpu= opțiunea sau cea a procesorului pe care a fost construit GCC dacă niciuna nu este
specificat.

-mfloat-vax
-mfloat-ieee
Generați cod care utilizează (nu folosește) VAX F și G aritmetică în virgulă mobilă
de precizie simplă și dublă IEEE.

-mexplicit-relocs
-mno-explicite-relocs
Asamblerii Alpha mai vechi nu au oferit nicio modalitate de a genera relocari de simbol, cu excepția prin intermediul
macro-uri de asamblare. Utilizarea acestor macrocomenzi nu permite programarea optimă a instrucțiunilor.
GNU binutils începând cu versiunea 2.12 acceptă o nouă sintaxă care permite compilatorului
marcați în mod explicit ce relocari ar trebui să li se aplice instrucțiunilor. Această opțiune este
mai ales util pentru depanare, deoarece GCC detectează capacitățile asamblatorului atunci când acesta
este construit și setează implicit în consecință.

-msmall-data
-mlarge-data
Cand -mexplicit-relocs este în vigoare, datele statice sunt accesate prin gp-relativ
relocari. Cand -msmall-data este utilizat, sunt plasate obiecte lungi de 8 octeți sau mai mici
a mic de date zonă (secțiunile „.sdata” și „.sbss”) și sunt accesate pe 16 biți
relocari in afara registrului $gp. Acest lucru limitează dimensiunea zonei mici de date la
64KB, dar permite accesarea directă a variabilelor printr-o singură instrucțiune.

Valoarea implicită este -mlarge-data. Cu această opțiune, zona de date este limitată chiar mai jos
2 GB. Programele care necesită mai mult de 2 GB de date trebuie să folosească „malloc” sau „mmap” pentru
alocați datele în heap în loc de în segmentul de date al programului.

Când se generează cod pentru bibliotecile partajate, -fpic implică -msmall-data și -fPIC
implică -mlarge-data.

-msmall-text
-mlarg-text
Cand -msmall-text este utilizat, compilatorul presupune că codul întregului program
(sau bibliotecă partajată) se încadrează în 4MB și, prin urmare, este accesibilă cu o instrucțiune de ramură.
Cand -msmall-data este utilizat, compilatorul poate presupune că toate simbolurile locale partajează
aceeași valoare $gp și astfel reduceți numărul de instrucțiuni necesare pentru o funcție
sunați de la 4 la 1.

Valoarea implicită este -mlarg-text.

-mcpu=tip_cpu
Setați setul de instrucțiuni și parametrii de programare a instrucțiunilor pentru tipul de mașină
tip_cpu. Puteți specifica fie EV numele stilului sau numărul de cip corespunzător.
GCC acceptă parametrii de programare pentru familia de procesoare EV4, EV5 și EV6 și
alege valorile implicite pentru setul de instrucțiuni din procesorul pe care îl specificați. Dacă
nu specificați un tip de procesor, GCC este implicit la procesorul pe care
compilatorul a fost construit.

Valori acceptate pentru tip_cpu sunt

ev4
ev45
21064
Programează ca EV4 și nu are extensii de set de instrucțiuni.

ev5
21164
Programează ca EV5 și nu are extensii de set de instrucțiuni.

ev56
21164a
Programează ca EV5 și acceptă extensia BWX.

pca56
21164pc
21164PC
Programează ca EV5 și acceptă extensiile BWX și MAX.

ev6
21264
Programează ca EV6 și acceptă extensiile BWX, FIX și MAX.

ev67
21264a
Programează ca EV6 și acceptă extensiile BWX, CIX, FIX și MAX.

Lanțurile de instrumente native susțin, de asemenea, valoarea nativ, care selectează cea mai bună arhitectură
opțiune pentru procesorul gazdă. -mcpu=nativ nu are efect dacă GCC nu recunoaște
procesorul.

-mtune=tip_cpu
Setați numai parametrii de programare a instrucțiunilor pentru tipul de mașină tip_cpu.
setul de instrucțiuni nu este schimbat.

Lanțurile de instrumente native susțin, de asemenea, valoarea nativ, care selectează cea mai bună arhitectură
opțiune pentru procesorul gazdă. -mtune=nativ nu are efect dacă GCC nu recunoaște
procesorul.

-memorie-latenta=timp
Setează latența pe care planificatorul ar trebui să o asume pentru referințele tipice de memorie așa cum este văzut de
aplicația. Acest număr depinde în mare măsură de modelele de acces la memorie utilizate
de aplicație și dimensiunea cache-ului extern de pe mașină.

Opțiuni valide pentru timp sunt

număr
Un număr zecimal care reprezintă ciclurile de ceas.

L1
L2
L3
principal
Compilatorul conține estimări ale numărului de cicluri de ceas pentru EV4 și „tipic”
Hardware EV5 pentru cache-urile de nivel 1, 2 și 3 (numite și Dcache, Scache și
Bcache), precum și în memoria principală. Rețineți că L3 este valabil numai pentru EV5.

FR30 Opţiuni

Aceste opțiuni sunt definite special pentru portul FR30.

-msmall-model
Utilizați modelul cu spațiu de adrese mici. Acest lucru poate produce cod mai mic, dar presupune
că toate valorile și adresele simbolice se încadrează într-un interval de 20 de biți.

-mno-lsim
Să presupunem că a fost furnizat suportul de rulare și, prin urmare, nu este nevoie să includeți
biblioteca de simulatoare (libsim.a) pe linia de comandă a linkerului.

FRV Opţiuni

-mgpr-32
Utilizați numai primele 32 de registre de uz general.

-mgpr-64
Utilizați toate cele 64 de registre de uz general.

-mfpr-32
Utilizați numai primele 32 de registre în virgulă mobilă.

-mfpr-64
Utilizați toate cele 64 de registre în virgulă mobilă.

-mhard-float
Utilizați instrucțiuni hardware pentru operațiuni în virgulă mobilă.

-msoft-float
Utilizați rutine de bibliotecă pentru operațiuni în virgulă mobilă.

-malloc-cc
Alocați în mod dinamic registrele de coduri de condiție.

-mfixed-cc
Nu încercați să alocați în mod dinamic registrele de coduri de condiție, utilizați doar „icc0” și
„fcc0”.

-mdword
Schimbați ABI pentru a utiliza insns cu două cuvinte.

-mno-dword
Nu folosiți instrucțiuni cu cuvinte duble.

-mdublu
Folosiți instrucțiuni duble în virgulă mobilă.

-mno-dublu
Nu utilizați instrucțiuni duble în virgulă mobilă.

-mmedia
Folosiți instrucțiuni media.

-mno-media
Nu folosiți instrucțiuni media.

-mmuladd
Folosiți instrucțiuni de înmulțire și adunare/scădere.

-mno-muladd
Nu utilizați instrucțiuni de înmulțire și adunare/scădere.

-mfdpic
Selectați FDPIC ABI, care utilizează descriptori de funcție pentru a reprezenta indicatorii către
funcții. Fără opțiuni legate de PIC/PIE, implică -fPIE. Cu -fpic or
-fpie, se presupune că intrările GOT și datele mici sunt într-un interval de 12 biți față de GOT
adresa de bază; cu -fPIC or -fPIE, decalajele GOT sunt calculate cu 32 de biți. Cu
bfin-elf țintă, această opțiune implică -msim.

-minline-plt
Activați integrarea intrărilor PLT în apelurile de funcții către funcții care nu sunt cunoscute
se leagă local. Nu are efect fără -mfdpic. Este activat implicit dacă
optimizarea pentru viteză și compilarea pentru biblioteci partajate (de exemplu, -fPIC or -fpic), sau
când o opțiune de optimizare precum -O3 sau mai sus este prezent în linia de comandă.

-mTLS
Presupuneți un segment TLS mare atunci când generați cod local fir.

-mtls
Nu presupuneți un segment TLS mare atunci când generați cod local de fir.

-mgprel-ro
Activați utilizarea relocațiilor „GPREL” în FDPIC ABI pentru datele despre care se știe că sunt în
secțiuni numai în citire. Este activat implicit, cu excepția -fpic or -fpie: Chiar dacă
poate ajuta la micșorarea tabelului global de compensare, schimbă 1 instrucțiune cu 4. Cu
-fPIC or -fPIE, schimbă 3 instrucțiuni pentru 4, dintre care una poate fi partajată de mai multe
simboluri și evită necesitatea unei intrări GOT pentru simbolul referit, așa că este
mai probabil să fie o victorie. Daca nu este, -mno-gprel-ro poate fi folosit pentru a-l dezactiva.

-multilib-library-pic
Link cu bibliotecile de imagini (biblioteca, nu FD). Este subînțeles de -mlibrary-pic, de asemenea
ca pe atunci -fPIC și -fpic fără -mfdpic. Nu ar trebui să-l folosești niciodată în mod explicit.

-mlinked-fp
Urmați cerința EABI de a crea întotdeauna un indicator de cadru de fiecare dată când un cadru de stivă
este alocat. Această opțiune este activată implicit și poate fi dezactivată cu
-mno-linked-fp.

-mlong-apeluri
Utilizați adresarea indirectă pentru a apela funcții din afara unității de compilare curente. Acest
permite ca funcțiile să fie plasate oriunde în spațiul de adrese de 32 de biți.

-etichete-maligne
Încercați să aliniați etichetele la o limită de 8 octeți inserând NOP-uri în pachetul anterior.
Această opțiune are efect numai atunci când împachetarea VLIW este activată. Nu creează noi
pachete; doar adaugă NOP-uri la cele existente.

-mlibrary-pic
Generați cod EABI independent de poziție.

-macc-4
Utilizați numai primele patru registre de acumulator media.

-macc-8
Utilizați toate cele opt registre de acumulator media.

-mpack
Ambalați instrucțiunile VLIW.

-mno-pack
Nu împachetați instrucțiunile VLIW.

-mno-eflaguri
Nu marcați comutatoarele ABI în e_flags.

-mcond-move
Activați utilizarea instrucțiunilor de mutare condiționată (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-cond-move
Dezactivați utilizarea instrucțiunilor de mutare condiționată.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mscc
Activați utilizarea instrucțiunilor setului condiționat (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-scc
Dezactivați utilizarea instrucțiunilor setului condiționat.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mcond-exec
Activați utilizarea execuției condiționate (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-cond-exec
Dezactivați utilizarea execuției condiționate.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mvliw-ramură
Rulați o trecere pentru a împacheta ramurile în instrucțiunile VLIW (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-vliw-ramură
Nu rulați o trecere pentru a împacheta ramuri în instrucțiunile VLIW.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mmulti-cond-exec
Activați optimizarea „&&” și „||” în execuție condiționată (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-multi-cond-exec
Dezactivați optimizarea „&&” și „||” în execuție condiționată.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mnested-cond-exec
Activați optimizările de execuție condiționate imbricate (implicit).

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-mno-imbricat-cond-exec
Dezactivați optimizările de execuție condiționată imbricate.

Acest comutator este în principal pentru depanarea compilatorului și va fi probabil eliminat într-un
versiune viitoare.

-moptimize-membar
Acest comutator elimină instrucțiunile „membar” redundante din codul generat de compilator.
Este activat în mod implicit.

-mno-optimize-membar
Acest comutator dezactivează eliminarea automată a instrucțiunilor redundante „membar” din
codul generat.

-mtomcat-stats
Determină gazul să imprime statistici despre tomcat.

-mcpu=cpu
Selectați tipul de procesor pentru care să generați codul. Valorile posibile sunt frv, fr550,
motan, fr500, fr450, fr405, fr400, fr300 și simplu.

GNU / Linux Opţiuni

Acestea -m opțiunile sunt definite pentru ținte GNU/Linux:

-mglibc
Utilizați biblioteca GNU C. Aceasta este valoarea implicită, cu excepția activată *-*-linux-*uclibc* și
*-*-linux-*android* ținte.

-muclibc
Utilizați biblioteca uClibc C. Aceasta este activarea implicită *-*-linux-*uclibc* ținte.

-mbionic
Utilizați biblioteca Bionic C. Aceasta este activarea implicită *-*-linux-*android* ținte.

-mandroid
Compilați cod compatibil cu platforma Android. Aceasta este activarea implicită
*-*-linux-*android* ținte.

La compilare, această opțiune se activează -mbionic, -fPIC, -fno-excepții și -fno-rtti by
Mod implicit. Când se conectează, această opțiune face ca driverul GCC să treacă opțiuni specifice Android
către linker. În cele din urmă, această opțiune face ca macrocomanda preprocesorului „__ANDROID__” să fie
definit.

-tno-android-cc
Dezactivați efectele de compilare ale -mandroid, adică nu activați -mbionic, -fPIC,
-fno-excepții și -fno-rtti în mod implicit.

-tno-android-ld
Dezactivați efectele de conectare ale -mandroid, adică, treceți opțiunile standard de conectare Linux la
linker.

H8 / 300 Opţiuni

Acestea -m opțiunile sunt definite pentru implementările H8/300:

-mrelaxează-te
Scurtați unele referințe de adrese la momentul link-ului, atunci când este posibil; folosește opțiunea de linker
-Relaxați-vă.

-mh Generați codul pentru H8/300H.

-Domnișoară Generați codul pentru H8S.

-mn Generați codul pentru H8S și H8/300H în modul normal. Acest comutator trebuie folosit
fie cu -mh or -Domnișoară.

-ms2600
Generați codul pentru H8S/2600. Acest comutator trebuie folosit cu -Domnișoară.

-mexr
Registrele extinse sunt stocate pe stivă înainte de executarea funcției cu monitor
atribut. Opțiunea implicită este -mexr. Această opțiune este valabilă numai pentru ținte H8S.

-mno-exr
Registrele extinse nu sunt stocate pe stivă înainte de executarea funcției cu monitor
atribut. Opțiunea implicită este -mno-exr. Această opțiune este valabilă numai pentru ținte H8S.

-mentă32
Faceți datele „int” la 32 de biți în mod implicit.

-malign-300
Pe H8/300H și H8S, utilizați aceleași reguli de aliniere ca și pentru H8/300. Implicit
pentru H8/300H și H8S este de a alinia lungi și float pe granițele de 4 octeți.
-malign-300 face ca acestea să fie aliniate pe granițele de 2 octeți. Această opțiune nu are efect
pe H8/300.

HPPA Opţiuni

Acestea -m opțiunile sunt definite pentru familia de calculatoare HPPA:

-martie=de tip arhitectură
Generați cod pentru arhitectura specificată. Alegerile pentru de tip arhitectură sunt
1.0 pentru PA 1.0, 1.1 pentru PA 1.1 și 2.0 pentru procesoare PA 2.0. A se referi la
/usr/lib/sched.models pe un sistem HP-UX pentru a determina opțiunea de arhitectură adecvată
pentru mașina dvs. Codul compilat pentru arhitecturi cu numere mai mici rulează pe mai mare
arhitecturi numerotate, dar nu invers.

-mpa-risc-1-0
-mpa-risc-1-1
-mpa-risc-2-0
Sinonime pentru -martie=1.0, -martie=1.1, și -martie=2.0 respectiv.

-mjump-in-delay
Umpleți intervalele de întârziere ale apelurilor de funcție cu instrucțiuni de salt necondiționat prin modificare
indicatorul de întoarcere pentru apelul de funcție să fie ținta saltului condiționat.

-mdisable-fpregs
Împiedicați utilizarea registrelor în virgulă mobilă în orice mod. Acest lucru este necesar pentru
compilarea nucleelor ​​care efectuează comutarea leneșă de context a registrelor în virgulă mobilă. Dacă
utilizați această opțiune și încercați să efectuați operații în virgulă mobilă, compilatorul
avortează.

-mdisable-indexing
Împiedicați compilatorul să folosească moduri de adrese de indexare. Acest lucru evită mai degrabă unele
probleme obscure la compilarea codului generat MIG sub MACH.

-mno-spațiu-regs
Generați cod care presupune că ținta nu are registre de spațiu. Acest lucru permite GCC să
generați apeluri indirecte mai rapide și utilizați moduri de adrese index nescalate.

Un astfel de cod este potrivit pentru sistemele și nucleele PA de nivel 0.

-mfast-indirect-calls
Generați cod care presupune că apelurile nu traversează niciodată granițele spațiului. Acest lucru permite GCC să
emit cod care efectuează apeluri indirecte mai rapide.

Această opțiune nu funcționează în prezența bibliotecilor partajate sau a funcțiilor imbricate.

-mfixed-range=registru-gamă
Generați codul tratând intervalul de registre dat ca registre fixe. Un registru fix
este unul pe care alocatorul de registru nu îl poate folosi. Acest lucru este util la compilarea nucleului
cod. Un interval de registre este specificat ca două registre separate printr-o liniuță. Multiplu
intervalele de registru pot fi specificate separate prin virgulă.

-mlong-load-store
Generați 3 instrucțiuni de încărcare și stocați secvențe așa cum este cerut uneori de HP-UX 10
linker. Aceasta este echivalentă cu +k opțiune pentru compilatoarele HP.

-portable-runtime
Utilizați convențiile de apelare portabile propuse de HP pentru sistemele ELF.

-mgas
Activați utilizarea directivelor de asamblare pe care numai GAS le înțelege.

-mschedule=tip CPU
Cod de programare în funcție de constrângerile pentru tipul de mașină tip CPU. Alegerile
pentru tip CPU sunt 700 7100, 7100LC, 7200, 7300 și 8000. A se referi la
/usr/lib/sched.models pe un sistem HP-UX pentru a determina opțiunea de programare adecvată pentru
mașina dvs. Programarea implicită este 8000.

-mlinker-opt
Activați trecerea de optimizare în linkerul HP-UX. Rețineți că acest lucru face depanare simbolică
imposibil. De asemenea, declanșează o eroare în linkerii HP-UX 8 și HP-UX 9 în care acestea
dați mesaje de eroare false atunci când conectați unele programe.

-msoft-float
Generați rezultate care conțin apeluri de bibliotecă pentru virgulă mobilă. Avertisment: necesarul
bibliotecile nu sunt disponibile pentru toate obiectivele HPPA. În mod normal, facilitățile de la
se utilizează compilatorul C obișnuit al mașinii, dar acest lucru nu se poate face direct în cross-
compilare. Trebuie să vă faceți propriile aranjamente pentru a oferi o bibliotecă adecvată
funcții pentru compilare încrucișată.

-msoft-float modifică convenția de apelare în fișierul de ieșire; prin urmare, este numai
util dacă compilați toate a unui program cu această opțiune. În special, trebuie
compila libgcc.a, biblioteca care vine cu GCC, cu -msoft-float pentru aceasta
la locul de muncă.

-msio
Generați predefinitul, „_SIO”, pentru server IO. Valoarea implicită este -mwsio. Acest lucru generează
predefinitele, „__hp9000s700”, „__hp9000s700__” și „_WSIO”, pentru stația de lucru IO.
Aceste opțiuni sunt disponibile sub HP-UX și HI-UX.

-mgnu-ld
Utilizați opțiuni specifice pentru GNU ld. Aceasta trece -impartit la ld la construirea unui comun
bibliotecă. Este implicit atunci când GCC este configurat, explicit sau implicit, cu
Linker GNU. Această opțiune nu afectează care ld se numește; schimbă doar ce
parametrii îi sunt trecuți ld. ld care este numit este determinat de
--cu-ld opțiunea de configurare, calea de căutare a programului GCC și, în final, de către utilizator PATH.
Linker-ul folosit de GCC poate fi imprimat folosind care `gcc -print-prog-name=ld`. Acest
opțiunea este disponibilă numai pe HP-UX GCC pe 64 de biți, adică configurată cu
hppa*64*-*-hpux*.

-mhp-ld
Utilizați opțiuni specifice pentru HP ld. Aceasta trece -b la ld la construirea unei biblioteci partajate
și trece +Accept Nepotrivire de tip la ld pe toate linkurile. Este valoarea implicită când este GCC
configurat, explicit sau implicit, cu linkerul HP. Această opțiune nu afectează
care ld se numește; schimbă doar ce parametri îi sunt trecuți ld. ld
care este numit este determinat de --cu-ld opțiunea de configurare, căutarea programului GCC
calea și, în final, de către utilizator PATH. Linker-ul folosit de GCC poate fi imprimat folosind
care `gcc -print-prog-name=ld`. Această opțiune este disponibilă numai pe HP-UX pe 64 de biți
GCC, adică configurat cu hppa*64*-*-hpux*.

-mlong-apeluri
Generați cod care utilizează secvențe lungi de apeluri. Acest lucru asigură că un apel este întotdeauna capabil
pentru a ajunge la stub-urile generate de linker. Implicit este generarea de apeluri lungi numai atunci când
distanța de la locul apelului până la începutul funcției sau al unității de traducere, ca
cazul poate fi, depășește o limită predefinită stabilită de tipul de ramură utilizat. The
limitele pentru apelurile normale sunt 7,600,000 și, respectiv, 240,000 de octeți, pentru PA 2.0
și arhitecturi PA 1.X. Apelurile secundare sunt întotdeauna limitate la 240,000 de octeți.

Distanțele sunt măsurate de la începutul funcțiilor atunci când se utilizează
-secţiuni-funcţii opțiunea, sau când utilizați -mgas și -mno-portable-runtime Opțiuni
împreună sub HP-UX cu linkerul SOM.

În mod normal, nu este de dorit să utilizați această opțiune, deoarece degradează performanța. In orice caz,
poate fi util în aplicații mari, în special atunci când se obișnuiește conectarea parțială
construiți aplicația.

Tipurile de apeluri lungi utilizate depind de capacitățile asamblatorului și linkerului,
și tipul de cod generat. Impactul asupra sistemelor care suportă mult timp
apeluri absolute și apeluri lungi simbol-diferență sau PC-uri ar trebui să fie
relativ mic. Cu toate acestea, un apel indirect este utilizat pe sistemele ELF pe 32 de biți în cod pic
si este destul de lunga.

-munix=unix-std
Generați predefinite ale compilatorului și selectați un fișier de pornire pentru standardul UNIX specificat.
Alegerile pentru unix-std sunt 93, 95 și 98. 93 este acceptat pe toate versiunile HP-UX.
95 este disponibil pe HP-UX 10.10 și versiuni ulterioare. 98 este disponibil pe HP-UX 11.11 și versiuni ulterioare.
Valorile implicite sunt 93 pentru HP-UX 10.00, 95 pentru HP-UX 10.10 totuși până la 11.00 și 98
pentru HP-UX 11.11 și versiuni ulterioare.

-munix=93 oferă aceleași predefinite ca și GCC 3.3 și 3.4. -munix=95 furnizează
predefinite suplimentare pentru „XOPEN_UNIX” și „_XOPEN_SOURCE_EXTENDED” și fișierul de pornire
unix95.o. -munix=98 oferă predefinite suplimentare pentru „_XOPEN_UNIX”,
„_XOPEN_SOURCE_EXTENDED”, „_INCLUDE__STDC_A1_SOURCE” și „_INCLUDE_XOPEN_SOURCE_500”,
și fișierul de pornire unix98.o.

Acesta este important să rețineți că această opțiune modifică interfețele pentru diferite biblioteci
rutine. De asemenea, afectează comportamentul operațional al bibliotecii C. Prin urmare, extremă
este nevoie de grijă în utilizarea acestei opțiuni.

Codul de bibliotecă care este destinat să funcționeze cu mai mult de un standard UNIX trebuie testat,
setați și restaurați variabila __xpg4_extended_mask Asa Potrivit. Majoritatea programelor GNU
nu oferă această capacitate.

-nolibdld
Suprimați generarea de opțiuni de link pentru a căuta libdld.sl atunci când -static opțiunea este
specificat pe HP-UX 10 și versiuni ulterioare.

-static
Implementarea HP-UX a setlocale în libc are o dependență de libdld.sl. Acolo
nu este o versiune de arhivă a libdld.sl. Astfel, atunci când -static este specificată opțiunea,
sunt necesare opțiuni speciale de link pentru a rezolva această dependență.

Pe HP-UX 10 și versiuni ulterioare, driverul GCC adaugă opțiunile necesare pentru a se conecta
libdld.sl atunci când -static este specificată opțiunea. Acest lucru face ca binarul rezultat să
fii dinamic. Pe portul pe 64 de biți, linkerii generează binare dinamice în mod implicit în
orice caz. The -nolibdld opțiunea poate fi utilizată pentru a preveni adăugarea driverului GCC
aceste opțiuni de link.

- fire
Adăugați suport pentru multithreading cu dce fir bibliotecă sub HP-UX. Această opțiune
setează steaguri atât pentru preprocesor, cât și pentru linker.

Intel 386 și AMD x86-64 Opţiuni

Acestea -m opțiunile sunt definite pentru familia de computere i386 și x86-64:

-martie=tip CPU
Generați instrucțiuni pentru tipul de mașină tip CPU. In contrast cu -mtune=tip CPU,
care doar reglează codul generat pentru ceea ce este specificat tip CPU, -martie=tip CPU
permite GCC să genereze cod care ar putea să nu ruleze deloc pe alte procesoare decât cel
indicat. Precizând -martie=tip CPU implică -mtune=tip CPU.

Alegerile pentru tip CPU sunt:

nativ
Aceasta selectează CPU pentru a genera codul în momentul compilării, determinând
tipul de procesor al mașinii de compilare. Folosind -martie=nativ permite tuturor
subseturi de instrucțiuni acceptate de mașina locală (prin urmare, rezultatul ar putea să nu ruleze
pe diferite mașini). Folosind -mtune=nativ produce cod optimizat pentru local
mașină sub constrângerile setului de instrucțiuni selectat.

i386
CPU original Intel i386.

i486
CPU Intel i486. (Nu este implementată nicio programare pentru acest cip.)

i586
pentium
CPU Intel Pentium fără suport MMX.

pentium-mmx
CPU Intel Pentium MMX, bazat pe nucleu Pentium cu suport pentru set de instrucțiuni MMX.

pentiumpro
CPU Intel Pentium Pro.

i686
Când este utilizat cu -Martie, se folosește setul de instrucțiuni Pentium Pro, astfel încât codul rulează
pe toate cipurile din familia i686. Când este folosit cu -mtune, are același sens ca
generic.

pentium2
CPU Intel Pentium II, bazat pe nucleul Pentium Pro cu suport pentru set de instrucțiuni MMX.

pentium3
pentium3m
CPU Intel Pentium III, bazat pe nucleul Pentium Pro cu set de instrucțiuni MMX și SSE
sprijini.

pentium-m
Intel Pentium M; versiune de putere redusă a procesorului Intel Pentium III cu MMX, SSE și SSE2
suport pentru set de instrucțiuni. Folosit de caietele Centrino.

pentium4
pentium4m
CPU Intel Pentium 4 cu suport pentru set de instrucțiuni MMX, SSE și SSE2.

prescott
Versiune îmbunătățită a procesorului Intel Pentium 4 cu instrucțiuni MMX, SSE, SSE2 și SSE3
setați suportul.

nocona
Versiune îmbunătățită a procesorului Intel Pentium 4 cu extensii pe 64 de biți, MMX, SSE, SSE2 și
Suport pentru set de instrucțiuni SSE3.

miez2
CPU Intel Core 2 cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3 și SSSE3
suport pentru set de instrucțiuni.

nehalem
CPU Intel Nehalem cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suport pentru setul de instrucțiuni SSE4.2 și POPCNT.

westmere
CPU Intel Westmere cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suport pentru setul de instrucțiuni SSE4.2, POPCNT, AES și PCLMUL.

sandybridge
CPU Intel Sandy Bridge cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3,
Suport pentru setul de instrucțiuni SSE4.1, SSE4.2, POPCNT, AVX, AES și PCLMUL.

ivybridge
CPU Intel Ivy Bridge cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Set de instrucțiuni SSE4.2, POPCNT, AVX, AES, PCLMUL, FSGSBASE, RDRND și F16C
sprijini.

haswell
CPU Intel Haswell cu extensii pe 64 de biți, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, IMC, IMC2
și suport pentru set de instrucțiuni F16C.

Broadwell
CPU Intel Broadwell cu extensii pe 64 de biți, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, IMC, IMC2,
Suport pentru setul de instrucțiuni F16C, RDSEED, ADCX și PREFETCHW.

bonnell
CPU Intel Bonnell cu extensii pe 64 de biți, MOVBE, MMX, SSE, SSE2, SSE3 și SSSE3
suport pentru set de instrucțiuni.

silvermont
CPU Intel Silvermont cu extensii pe 64 de biți, MOVBE, MMX, SSE, SSE2, SSE3, SSSE3,
Suport pentru setul de instrucțiuni SSE4.1, SSE4.2, POPCNT, AES, PCLMUL și RDRND.

k6 CPU AMD K6 cu suport pentru set de instrucțiuni MMX.

k6-2
k6-3
Versiuni îmbunătățite ale procesorului AMD K6 cu MMX și 3DNow! suport pentru set de instrucțiuni.

Athlon
athlon-tbird
CPU AMD Athlon cu MMX, 3dNOW!, 3DNow îmbunătățit! și instrucțiuni de preluare prealabilă SSE
sprijini.

atlon-4
athlon-xp
athlon-mp
Procesor AMD Athlon îmbunătățit cu MMX, 3DNow!, 3DNow îmbunătățit! și instruire SSE completă
setați suportul.

k8
opteron
athlon64
athlon-fx
Procesoare bazate pe nucleul AMD K8 cu suport pentru set de instrucțiuni x86-64, inclusiv
procesoarele AMD Opteron, Athlon 64 și Athlon 64 FX. (Aceasta supraseturi MMX,
SSE, SSE2, 3DNow!, 3DNow îmbunătățit! și extensii de set de instrucțiuni pe 64 de biți.)

k8-sse3
opteron-sse3
athlon64-sse3
Versiuni îmbunătățite de nuclee AMD K8 cu suport pentru setul de instrucțiuni SSE3.

amdfam10
Barcelona
Procesoare bazate pe nuclee AMD Family 10h cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi MMX, SSE, SSE2, SSE3, SSE4A, 3DNow!, 3DNow îmbunătățit!, ABM și 64 de biți
extensii setului de instrucțiuni.)

bdver1
Procesoare bazate pe nuclee AMD Family 15h cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A,
SSSE3, SSE4.1, SSE4.2, ABM și extensii de set de instrucțiuni pe 64 de biți.)

bdver2
Procesoare bazate pe nuclee de 15 ore din familia AMD cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi BMI, TBM, F16C, FMA, FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE,
SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM și set de instrucțiuni pe 64 de biți
extensii.)

bdver3
Procesoare bazate pe nuclee de 15 ore din familia AMD cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi IMC, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, XOP, LWP, AES, PCL_MUL, CX16,
MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM și set de instrucțiuni pe 64 de biți
extensii.

bdver4
Procesoare bazate pe nuclee de 15 ore din familia AMD cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi IMC, BMI2, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, AVX2, XOP, LWP, AES,
PCL_MUL, CX16, MOVBE, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM și
Extensii de set de instrucțiuni pe 64 de biți.

btver1
Procesoare bazate pe nuclee AMD Family 14h cu suport pentru set de instrucțiuni x86-64. (Acest
superseturi MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM și set de instrucțiuni pe 64 de biți
extensii.)

btver2
Procesoare bazate pe nuclee AMD Family 16h cu suport pentru set de instrucțiuni x86-64. Acest
include MOVBE, F16C, BMI, AVX, PCL_MUL, AES, SSE4.2, SSE4.1, CX16, ABM, SSE4A,
SSSE3, SSE3, SSE2, SSE, MMX și extensii de set de instrucțiuni pe 64 de biți.

winchip-c6
CPU IDT WinChip C6, tratat în același mod ca i486 cu un set de instrucțiuni MMX suplimentar
sprijini.

winchip2
CPU IDT WinChip 2, tratat în același mod ca i486 cu MMX și 3DNow suplimentar!
suport pentru set de instrucțiuni.

c3 VIA C3 CPU cu MMX și 3DNow! suport pentru set de instrucțiuni. (Nu există nicio programare
implementat pentru acest cip.)

c3-2
CPU VIA C3-2 (Nehemiah/C5XL) cu suport pentru set de instrucțiuni MMX și SSE. (Nu
programarea este implementată pentru acest cip.)

Geode
Procesor încorporat AMD Geode cu MMX și 3DNow! suport pentru set de instrucțiuni.

-mtune=tip CPU
Acordați-vă tip CPU totul aplicabil despre codul generat, cu excepția ABI
și setul de instrucțiuni disponibile. În timp ce alegeți un anumit tip CPU orare
lucruri adecvate pentru acel cip anume, compilatorul nu generează niciun cod
care nu poate rula pe tipul implicit de mașină decât dacă utilizați a -martie=tip CPU opțiune.
De exemplu, dacă GCC este configurat pentru i686-pc-linux-gnu, atunci -mtune=pentium4 generează
cod care este reglat pentru Pentium 4, dar încă rulează pe mașini i686.

Alegerile pentru tip CPU sunt la fel ca pentru -Martie. În plus, -mtune suportă 2
opțiuni suplimentare pentru tip CPU:

generic
Produceți cod optimizat pentru cele mai comune procesoare IA32/AMD64/EM64T. daca tu
știți CPU pe care va rula codul dvs., atunci ar trebui să utilizați cel corespunzător
-mtune or -Martie în loc de -mtune=generic. Dar, dacă nu știi
exact ce vor avea utilizatorii CPU ai aplicației dvs., atunci ar trebui să utilizați acest lucru
opțiune.

Pe măsură ce noi procesoare sunt implementate pe piață, comportamentul acestei opțiuni
se va schimba. Prin urmare, dacă faceți upgrade la o versiune mai nouă a GCC, generarea codului
controlat de această opțiune se va modifica pentru a reflecta procesoarele care sunt cele mai multe
comună la momentul lansării acelei versiuni de GCC.

Nu este -mars=generic opțiune pentru că -Martie indică setul de instrucțiuni
compilatorul poate folosi și nu există un set de instrucțiuni generice aplicabil tuturor
procesoare. În contrast, -mtune indică procesorul (sau, în acest caz,
colecție de procesoare) pentru care codul este optimizat.

Intel
Produceți cod optimizat pentru cele mai recente procesoare Intel, care sunt Haswell
și Silvermont pentru această versiune a GCC. Dacă știți CPU pe care aveți codul
va rula, atunci ar trebui să utilizați cea corespunzătoare -mtune or -Martie în loc de
-mtune=intel. Dar, dacă doriți ca aplicația dvs. să aibă performanțe mai bune atât pe Haswell
și Silvermont, atunci ar trebui să utilizați această opțiune.

Pe măsură ce noi procesoare Intel sunt implementate pe piață, comportamentul acestuia
opțiunea se va schimba. Prin urmare, dacă faceți upgrade la o versiune mai nouă a GCC, codați
generația controlată de această opțiune se va modifica pentru a reflecta cel mai actual Intel
procesoare la momentul lansării acelei versiuni de GCC.

Nu este -march=intel opțiune pentru că -Martie indică setul de instrucțiuni
compilatorul poate folosi și nu există un set comun de instrucțiuni aplicabil tuturor
procesoare. În contrast, -mtune indică procesorul (sau, în acest caz,
colecție de procesoare) pentru care codul este optimizat.

-mcpu=tip CPU
Un sinonim depreciat pentru -mtune.

-mfpmath=unitate
Generați aritmetică în virgulă mobilă pentru unitatea selectată unitate. Alegerile pentru unitate sunt:

387 Utilizați coprocesorul standard 387 în virgulă mobilă prezent pe majoritatea cipurilor
și emulat altfel. Codul compilat cu această opțiune rulează aproape peste tot.
Rezultatele temporare sunt calculate cu precizie de 80 de biți în loc de precizie
specificate în funcție de tip, rezultând rezultate ușor diferite față de majoritatea
alte chips-uri. Vedea -float-magazin pentru o descriere mai detaliata.

Aceasta este alegerea implicită pentru compilatorul i386.

sse Utilizați instrucțiuni scalare în virgulă mobilă prezente în setul de instrucțiuni SSE. Acest
setul de instrucțiuni este acceptat de cipuri Pentium III și mai noi și în linia AMD
prin cipurile Athlon-4, Athlon XP și Athlon MP. Versiunea anterioară a SSE
setul de instrucțiuni acceptă doar aritmetica cu precizie simplă, deci dubla și
aritmetica cu precizie extinsă se fac încă folosind 387. O versiune ulterioară, prezentă
numai în cipurile Pentium 4 și AMD x86-64, acceptă și aritmetica cu precizie dublă.

Pentru compilatorul i386, trebuie să utilizați -martie=tip CPU, -msse or -msse2 trece la
activați extensiile SSE și faceți eficientă această opțiune. Pentru compilatorul x86-64,
aceste extensii sunt activate implicit.

Codul rezultat ar trebui să fie considerabil mai rapid în majoritatea cazurilor și
evitați problemele de instabilitate numerică ale codului 387, dar pot rupe unele existente
cod care se așteaptă ca temporare să fie de 80 de biți.

Aceasta este alegerea implicită pentru compilatorul x86-64.

sse,387
sse+387
atât
Încercați să utilizați ambele seturi de instrucțiuni simultan. Acest lucru dublează efectiv
cantitatea de registre disponibile și pe jetoane cu unități de execuție separate pentru 387
și SSE resursele de execuție. Utilizați această opțiune cu grijă, așa cum este încă
experimental, deoarece alocatorul de registru GCC nu modelează separat
unități funcționale bine, rezultând performanțe instabile.

-masm=dialect
Ieșire instrucțiuni de asamblare folosind selectat dialect. Alegerile acceptate sunt Intel or
la (implicit). Darwin nu suportă Intel.

-mieee-fp
-mno-ieee-fp
Controlați dacă compilatorul utilizează sau nu comparații în virgulă mobilă IEEE. Aceste
tratați corect cazul în care rezultatul unei comparații este neordonat.

-msoft-float
Generați rezultate care conțin apeluri de bibliotecă pentru virgulă mobilă.

Avertisment: bibliotecile necesare nu fac parte din GCC. În mod normal, facilitățile de la
se utilizează compilatorul C obișnuit al mașinii, dar acest lucru nu se poate face direct în cross-
compilare. Trebuie să vă faceți propriile aranjamente pentru a oferi o bibliotecă adecvată
funcții pentru compilare încrucișată.

Pe mașinile în care o funcție returnează rezultate în virgulă mobilă în registrul 80387
stiva, unele coduri operaționale în virgulă mobilă pot fi emise chiar dacă -msoft-float este folosit.

-mno-fp-ret-in-387
Nu utilizați registrele FPU pentru valorile returnate ale funcțiilor.

Convenția obișnuită de apelare are funcții care returnează valori de tipurile „float” și „double”
într-un registru FPU, chiar dacă nu există FPU. Ideea este că sistemul de operare
ar trebui să emuleze un FPU.

Optiunea -mno-fp-ret-in-387 face ca astfel de valori să fie returnate în CPU obișnuit
înregistrează în schimb.

-mno-fancy-math-387
Unele 387 de emulatori nu acceptă instrucțiunile „sin”, „cos” și „sqrt” pentru
387. Specificați această opțiune pentru a evita generarea acelor instrucțiuni. Această opțiune este
implicit pe FreeBSD, OpenBSD și NetBSD. Această opțiune este anulată când -Martie
indică faptul că CPU-ul țintă are întotdeauna un FPU și deci instrucțiunea nu are nevoie
emulare. Aceste instrucțiuni nu sunt generate decât dacă utilizați și
-optimizări-funsafe-matematice intrerupator.

-malign-dublu
-mno-align-double
Controlați dacă GCC aliniază variabilele „double”, „long double” și „long long” pe a
delimitare de două cuvinte sau delimitare de un cuvânt. Alinierea variabilelor „duble” pe un cuvânt cu două cuvinte
boundary produce cod care rulează ceva mai rapid pe un Pentium în detrimentul a mai mult
memorie.

Pe x86-64, -malign-dublu este activat implicit.

Avertisment: dacă utilizați -malign-dublu comutator, structuri care conțin tipurile de mai sus
sunt aliniate diferit față de specificațiile interfeței binare ale aplicației publicate
pentru 386 și nu sunt compatibile binare cu structurile din codul compilat fără
acel comutator.

-m96bit-long-dublu
-m128bit-long-dublu
Aceste comutatoare controlează dimensiunea tipului „dublu lung”. Binarul aplicației i386
interfața specifică dimensiunea să fie de 96 de biți, deci -m96bit-long-dublu este implicit în
modul pe 32 de biți.

Arhitecturile moderne (Pentium și mai noi) preferă ca „long double” să fie aliniat la un 8-
sau limita de 16 octeți. În matrice sau structuri conforme cu ABI, acest lucru nu este
posibil. Deci specificând -m128bit-long-dublu aliniază „long double” la 16 octeți
limită prin completarea „dublu lung” cu un zero suplimentar pe 32 de biți.

În compilatorul x86-64, -m128bit-long-dublu este alegerea implicită ca ABI
specifică faptul că „long double” este aliniat pe granița de 16 octeți.

Observați că niciuna dintre aceste opțiuni nu permite nicio precizie suplimentară față de standardul x87
de 80 de biți pentru un „dublu lung”.

Avertisment: dacă înlocuiți valoarea implicită pentru ABI țintă, aceasta va modifica dimensiunea
de structuri și matrice care conțin variabile „long double”, precum și modificarea
convenție de apelare a funcției pentru funcțiile care au „long double”. Prin urmare, nu sunt
compatibil binar cu codul compilat fără comutatorul respectiv.

-mlong-dublu-64
-mlong-dublu-80
-mlong-dublu-128
Aceste comutatoare controlează dimensiunea tipului „dublu lung”. O dimensiune de 64 de biți face ca
tipul „dublu lung” echivalent cu tipul „dublu”. Aceasta este valoarea implicită pentru 32 de biți
Biblioteca Bionic C. O dimensiune de 128 de biți face ca tipul „long double” să fie echivalent cu
tipul „__float128”. Aceasta este valoarea implicită pentru biblioteca Bionic C pe 64 de biți.

Avertisment: dacă înlocuiți valoarea implicită pentru ABI țintă, aceasta va modifica dimensiunea
de structuri și matrice care conțin variabile „long double”, precum și modificarea
convenție de apelare a funcției pentru funcțiile care au „long double”. Prin urmare, nu sunt
compatibil binar cu codul compilat fără comutatorul respectiv.

-mlarge-data-threshold=prag
Cand -mcmodel=mediu este specificat, obiectele de date mai mari decât prag sunt plasate în
secțiunea mare de date. Această valoare trebuie să fie aceeași pentru toate obiectele conectate la
binarul și implicit este 65535.

-mrtd
Utilizați o convenție diferită de apelare a funcției, în care funcțiile care au un fix
numărul de argumente se întoarce cu „ret num" instrucțiuni, care le expun argumentele
în timp ce se întorcea. Acest lucru salvează o instrucțiune în apelant, deoarece nu este nevoie
pune argumentele acolo.

Puteți specifica că o funcție individuală este apelată cu această secvență de apelare cu
atributul funcției stdcall. De asemenea, puteți trece peste -mrtd opțiunea utilizând
atributul funcției cdecl.

Avertisment: această convenție de apelare este incompatibilă cu cea folosită în mod normal pe Unix,
deci nu îl puteți folosi dacă trebuie să apelați biblioteci compilate cu compilatorul Unix.

De asemenea, trebuie să furnizați prototipuri de funcție pentru toate funcțiile care acceptă variabile
numărul de argumente (inclusiv „printf”); altfel este generat cod incorect pt
apeluri la aceste funcții.

În plus, rezultă un cod grav incorect dacă apelați o funcție cu prea multe
argumente. (În mod normal, argumentele suplimentare sunt ignorate în mod inofensiv.)

-mregparm=o
Controlați câte registre sunt folosite pentru a transmite argumente întregi. Implicit, nu
registrele sunt folosite pentru a transmite argumente și pot fi folosite cel mult 3 registre. Poti
controlați acest comportament pentru o anumită funcție utilizând atributul funcție regparm.

Avertisment: dacă utilizați acest comutator și o este diferit de zero, atunci trebuie să construiți toate modulele
cu aceeași valoare, inclusiv orice biblioteci. Aceasta include bibliotecile de sistem și
module de pornire.

-msseregparm
Utilizați convențiile de transmitere a registrului SSE pentru argumentele float și duble și valorile returnate.
Puteți controla acest comportament pentru o anumită funcție utilizând atributul funcție
sseregparm.

Avertisment: dacă utilizați acest comutator, atunci trebuie să construiți toate modulele cu aceeași valoare,
inclusiv orice biblioteci. Aceasta include bibliotecile de sistem și modulele de pornire.

-mvect8-ret-in-mem
Returnează vectori de 8 octeți în memorie în loc de registre MMX. Aceasta este activarea implicită
Solaris@tie{}8 și 9 și VxWorks pentru a se potrivi cu ABI al compilatoarelor Sun Studio până
versiunea 12. Urmează versiunile ulterioare ale compilatorului (începând cu Studio 12 Update@tie{}1).
ABI utilizat de alte ținte x86, care este implicit pe Solaris@tie{}10 ​​și mai târziu.
Numai utilizați această opțiune dacă trebuie să rămâneți compatibil cu codul existent produs de
acele versiuni anterioare ale compilatorului sau versiuni mai vechi ale GCC.

-mpc32
-mpc64
-mpc80
Setați precizia în virgulă mobilă 80387 la 32, 64 sau 80 de biți. Cand -mpc32 este specificat,
semnificațiile rezultatelor operațiilor în virgulă mobilă sunt rotunjite la 24 de biți
(precizie unică); -mpc64 rotunjește semnificațiile rezultatelor în virgulă mobilă
operații la 53 de biți (precizie dublă) și -mpc80 rotunjește semnificațiile rezultatelor
a operațiunilor în virgulă mobilă la 64 de biți (precizie dublă extinsă), care este
Mod implicit. Când se utilizează această opțiune, operațiunile în virgulă mobilă cu precizie mai mare sunt
nu este disponibil pentru programator fără a seta în mod explicit cuvântul de control FPU.

Setarea rotunjirii operațiunilor în virgulă mobilă la mai puțin decât se poate face implicit pe 80 de biți
accelera unele programe cu 2% sau mai mult. Rețineți că unele biblioteci matematice presupun asta
operațiunile în virgulă mobilă cu precizie extinsă (80 de biți) sunt activate implicit; rutine
în astfel de biblioteci ar putea suferi pierderi semnificative de precizie, de obicei prin
numită „anulare catastrofală”, când această opțiune este utilizată pentru a seta precizia la
precizie mai mică decât extinsă.

-mstackrealign
Realliniază stiva la intrare. Pe Intel x86, -mstackrealign opțiunea generează un
prolog și epilog alternativ care realinează stiva de rulare, dacă este necesar. Acest
acceptă amestecarea codurilor vechi care păstrează alinierea stivei de 4 octeți cu codurile moderne care
păstrați alinierea stivei de 16 octeți pentru compatibilitatea SSE. Vezi și atributul
„force_align_arg_pointer”, aplicabil funcțiilor individuale.

-mpreferred-stack-boundary=o
Încercați să mențineți limita stivei aliniată la un 2 ridicat la o limita octetului. Dacă
-limită-stivă-mprefered nu este specificat, valoarea implicită este 4 (16 octeți sau 128 biți).

Avertisment: Când se generează cod pentru arhitectura x86-64 cu extensii SSE
dezactivat, -mpreferred-stack-boundary=3 poate fi folosit pentru a menține aliniat limita stivei
până la limita de 8 octeți. Deoarece x86-64 ABI necesită o aliniere a stivei de 16 octeți, acesta este ABI
incompatibil și destinat a fi utilizat într-un mediu controlat în care se află spațiul de stivă
limitare importantă. Această opțiune va duce la cod greșit atunci când funcțiile sunt compilate
cu alinierea stivei de 16 octeți (cum ar fi funcțiile dintr-o bibliotecă standard) sunt apelate
cu stiva nealiniată. În acest caz, instrucțiunile SSE pot duce la o memorie nealiniată
capcane de acces. În plus, argumentele variabilelor vor fi tratate incorect pentru 16 octeți
obiecte aliniate (inclusiv x87 long double și __int128), ducând la rezultate greșite.
Trebuie să construiți toate modulele cu -mpreferred-stack-boundary=3, inclusiv orice biblioteci.
Aceasta include bibliotecile de sistem și modulele de pornire.

-mincoming-stack-boundary=o
Să presupunem că stiva de intrare este aliniată la un 2 ridicat la o limita octetului. Dacă
-mincoming-stack-boundary nu este specificat, cel specificat de
-limită-stivă-mprefered este folosit.

Pe Pentium și Pentium Pro, valorile „dublu” și „dublu lung” ar trebui aliniate la un
Granița de 8 octeți (vezi -malign-dublu) sau suferă performanțe semnificative în timpul de rulare
pedepsele. Pe Pentium III, tipul de date Streaming SIMD Extension (SSE) „__m128” poate
nu funcționează corect dacă nu este aliniat pe 16 octeți.

Pentru a asigura alinierea corectă a acestor valori pe stivă, limita stivei trebuie să fie ca
aliniat ca cel cerut de orice valoare stocată pe stivă. În plus, fiecare funcție
trebuie generat astfel încât să mențină stiva aliniată. Apelând astfel o funcție
compilat cu o limită de stivă preferată mai mare dintr-o funcție compilată cu o limită mai mică
limita preferată a stivei, cel mai probabil, nu aliniază stiva. Este recomandat ca
bibliotecile care folosesc apeluri inverse folosesc întotdeauna setarea implicită.

Această aliniere suplimentară consumă spațiu suplimentar în stivă și, în general, crește codul
mărimea. Cod care este sensibil la utilizarea spațiului de stivă, cum ar fi sistemele încorporate și
nucleele sistemului de operare, poate dori să reducă alinierea preferată la
-mpreferred-stack-boundary=2.

-mmmx
-mno-mmx
-msse
-mno-sse
-msse2
-mno-sse2
-msse3
-mno-sse3
-mssse3
-mno-ssse3
-msse4.1
-mno-sse4.1
-msse4.2
-mno-sse4.2
-msse4
-mno-sse4
-mavx
-mno-avx
-mavx2
-mno-avx2
-mavx512f
-mno-avx512f
-mavx512pf
-mno-avx512pf
-mavx512er
-mno-avx512er
-mavx512cd
-mno-avx512cd
-msha
-mno-sha
-maes
-mno-aes
-mpclmul
-mno-pclmul
-mfsgsbase
-mno-fsgsbase
-mrdrnd
-mno-rdrnd
-mf16c
-mno-f16c
-mfma
-mno-fma
-mprefetchwt1
-mno-prefetchwt1
-msse4a
-mno-sse4a
-mfma4
-mno-fma4
-mxop
-mno-xop
-mlwp
-mno-lwp
-m3dnow
-mno-3dnow
-mpopcnt
-mno-popcnt
-mabm
-mno-abm
-mbmi
-mbmi2
-mno-bmi
-mno-bmi2
-mlzcnt
-mno-lzcnt
-mfxsr
-mxsave
-mxsaveopt
-mrtm
-mtbm
-mno-tbm
Aceste comutatoare permit sau dezactivează utilizarea instrucțiunilor în MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AVX512F, AVX512PF, AVX512ER, AVX512CD, SHA, AES, PCLMUL,
FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP, LWP, ABM, IMC, BMI2, FXSR, XSAVE,
XSAVEOPT, LZCNT, RTM sau 3DNow! seturi de instrucțiuni extinse. Aceste extensii sunt de asemenea
disponibile ca funcții încorporate: vezi X86 Built-in funcţii, pentru detalii despre
funcții activate și dezactivate de aceste comutatoare.

Pentru a genera automat instrucțiuni SSE/SSE2 din codul în virgulă mobilă (spre deosebire de
la 387 instrucțiuni), vezi -mfpmath=sse.

GCC deprimă instrucțiunile SSEx când -mavx este folosit. În schimb, generează un AVX nou
instrucțiuni sau echivalență AVX pentru toate instrucțiunile SSEx atunci când este necesar.

Aceste opțiuni permit GCC să folosească aceste instrucțiuni extinse chiar și în codul generat
fără -mfpmath=sse. Aplicațiile care efectuează detectarea CPU în timpul rulării trebuie să fie compilate
fișiere separate pentru fiecare arhitectură acceptată, folosind steagurile corespunzătoare. În
în special, fișierul care conține codul de detectare a CPU ar trebui compilat fără
aceste opțiuni.

-mdump-tune-caracteristici
Această opțiune indică GCC să elimine numele caracteristicilor de reglare a performanței x86 și
setări implicite. Numele pot fi folosite în -mtune-ctrl=listă de caracteristici.

-mtune-ctrl=listă de caracteristici
Această opțiune este folosită pentru a efectua un control fin al caracteristicilor de generare a codului x86.
listă de caracteristici este o listă separată prin virgulă trăsătură nume. Vezi si
-mdump-tune-caracteristici. Când este specificat, trăsătură va fi pornit dacă nu este
precedat de „^”, în caz contrar, va fi dezactivat. -mtune-ctrl=listă de caracteristici is
destinat a fi utilizat de dezvoltatorii GCC. Utilizarea acestuia poate duce la căi de cod care nu sunt acoperite de
testare și poate duce la ICE-uri ale compilatorului sau erori de rulare.

-mno-implicit
Această opțiune indică GCC să dezactiveze toate funcțiile reglabile. Vezi si
-mtune-ctrl=listă de caracteristici și -mdump-tune-caracteristici.

-mcld
Această opțiune indică GCC să emită o instrucțiune „cld” în prologul funcțiilor
care folosesc instrucțiuni cu șir. Instrucțiunile șirurilor depind de marcajul DF de selectat
între modul autoincrement sau autodecrement. În timp ce ABI specifică indicatorul DF pentru
să fie șters la introducerea funcției, unele sisteme de operare încalcă această specificație prin nu
ștergerea steagului DF în dispeceratele lor de excepții. Managerul de excepții poate fi
invocat cu steag-ul DF setat, ceea ce duce la un mod de direcție greșită atunci când este string
sunt folosite instructiuni. Această opțiune poate fi activată în mod implicit pe ținte x32 pe 86 de biți până la
configurarea GCC cu --enable-cld opțiunea de configurare. Generația „cld”
instrucțiunile pot fi suprimate cu -mno-cld opțiunea compilatorului în acest caz.

-mvzeroupper
Această opțiune indică GCC să emită o instrucțiune „vzeroupper” înainte de un transfer de
controlați fluxul în afara funcției pentru a minimiza și penalitatea de tranziție AVX la SSE
ca să elimini elementele intrinseci „zeroupper” inutile.

-mprefer-avx128
Această opțiune indică GCC să folosească instrucțiuni AVX pe 128 de biți în loc de AVX pe 256 biți
instrucțiuni în auto-vectorizatorul.

-mcx16
Această opțiune permite GCC să genereze instrucțiuni „CMPXCHG16B”. „CMPXCHG16B” permite
pentru operațiuni atomice pe tipuri de date dublu quadword (sau oword) de 128 de biți. Aceasta este
util pentru contoare de înaltă rezoluție care pot fi actualizate de mai multe procesoare (sau
miezuri). Această instrucțiune este generată ca parte a funcțiilor încorporate atomice: vezi
__sincronizare Construcții or __atomic Construcții pentru detalii.

-msahf
Această opțiune permite generarea de instrucțiuni „SAHF” în cod pe 64 de biți. Intel timpuriu
Procesoare Pentium 4 cu suport Intel 64, înainte de introducerea pasului Pentium 4 G1
în decembrie 2005, nu aveau instrucțiunile „LAHF” și „SAHF” care erau susținute de
AMD64. Acestea sunt instrucțiuni de încărcare și, respectiv, de stocare pentru anumite steaguri de stare.
În modul pe 64 de biți, instrucțiunea „SAHF” este utilizată pentru a optimiza „fmod”, „drem” și
funcții încorporate „restul”; vedea Altele Construcții pentru detalii.

-mmovbe
Această opțiune permite utilizarea instrucțiunii „movbe” pentru a implementa „__builtin_bswap32”
și „__builtin_bswap64”.

-mcrc32
Această opțiune activează funcțiile încorporate „__builtin_ia32_crc32qi”,
„__builtin_ia32_crc32hi”, „__builtin_ia32_crc32si” și „__builtin_ia32_crc32di” pentru
generați instrucțiunea de mașină „crc32”.

-mrecip
Această opțiune permite utilizarea instrucțiunilor „RCPSS” și „RSQRTSS” (și vectorizate ale acestora
variantele „RCPPS” și „RSQRTPS”) cu un pas suplimentar Newton-Raphson de crescut
precizie în loc de „DIVSS” și „SQRTSS” (și variantele lor vectorizate) pentru
argumente de precizie în virgulă mobilă. Aceste instrucțiuni sunt generate numai atunci când
-optimizări-funsafe-matematice este activat împreună cu -numai-finit-matematică și
-fno-capcană-matematică. Rețineți că, în timp ce debitul secvenței este mai mare decât
debitul instrucțiunii non-reciproce, precizia secvenței poate fi
a scăzut cu până la 2 ulp (adică inversul lui 1.0 este egal cu 0.99999994).

Rețineți că GCC implementează „1.0f/sqrtf(X)" în termeni de „RSQRTSS” (sau „RSQRTPS”) deja
cu -ffast-matematică (sau combinația de opțiuni de mai sus) și nu are nevoie -mrecip.

De asemenea, rețineți că GCC emite secvența de mai sus cu pas suplimentar Newton-Raphson pentru
diviziune vectorizată cu un singur flotant și „sqrtf(X)" deja cu -ffast-matematică
(sau combinația de opțiuni de mai sus) și nu are nevoie -mrecip.

-mrecip=opta
Această opțiune controlează ce instrucțiuni de estimare reciprocă pot fi utilizate. opta este
listă de opțiuni separate prin virgulă, care poate fi precedată de a ! pentru a inversa opțiunea:

toate Activați toate instrucțiunile de estimare.

lipsă
Activați instrucțiunile implicite, echivalente cu -mrecip.

nici unul
Dezactivați toate instrucțiunile de estimare, echivalent cu -mno-recip.

div Activați aproximarea pentru diviziunea scalară.

vec-div
Activați aproximarea pentru diviziunea vectorizată.

sqrt
Activați aproximarea pentru rădăcina pătrată scalară.

vec-sqrt
Activați aproximarea pentru rădăcina pătrată vectorizată.

Deci, de exemplu, -mrecip=toate,!sqrt permite toate aproximările reciproce,
cu excepția rădăcinii pătrate.

-mveclibabi=tip
Specifică tipul ABI de utilizat pentru vectorizarea intrinseci utilizând o bibliotecă externă.
Valori acceptate pentru tip sunt svml pentru biblioteca de matematică vectorială scurtă Intel și acml
pentru biblioteca de bază matematică AMD. Pentru a utiliza această opțiune, ambele -fttree-vectoriza și
-optimizări-funsafe-matematice trebuie să fie activat și un SVML sau ACML compatibil ABI
bibliotecă trebuie specificată la momentul link-ului.

GCC emite în prezent apeluri către „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” și „vmlsAcos4” pentru tipul de funcție corespunzător când -mveclibabi=svml is
folosit și „__vrd2_sin”, „__vrd2_cos”, „__vrd2_exp”, „__vrd2_log”, „__vrd2_log2”,
„__vrd2_log10”, „__vrs4_sinf”, „__vrs4_cosf”, „__vrs4_expf”, „__vrs4_logf”,
„__vrs4_log2f”, „__vrs4_log10f” și „__vrs4_powf” pentru tipul de funcție corespunzător
cand -mveclibabi=acml este folosit.

-mabi=nume
Generați codul pentru convenția de apelare specificată. Valorile permise sunt sysv pentru
ABI folosit pe GNU/Linux și alte sisteme și ms pentru Microsoft ABI. The
implicit este să utilizați Microsoft ABI atunci când vizați Microsoft Windows și SysV ABI
pe toate celelalte sisteme. Puteți controla acest comportament pentru o anumită funcție utilizând
atributul funcției ms_abi/sysv_abi.

-mtls-dialect=tip
Generați codul pentru a accesa stocarea locală a firului folosind gnu or gnu2 convenții. gnu
este valoarea implicită conservatoare; gnu2 este mai eficient, dar poate adăuga compilare și rulare
cerințe de timp care nu pot fi satisfăcute pe toate sistemele.

-mpush-args
-mno-push-args
Utilizați operațiunile PUSH pentru a stoca parametrii de ieșire. Această metodă este mai scurtă și de obicei
la fel de rapidă ca metoda care utilizează operațiuni SUB/MOV și este activată implicit. În unele
cazurile care îl dezactivează pot îmbunătăți performanța datorită programării îmbunătățite și reduse
dependențe.

-maccumulate-outgoing-args
Dacă este activată, este calculată cantitatea maximă de spațiu necesară pentru argumentele de ieșire
prologul funcţiei. Acest lucru este mai rapid pe majoritatea procesoarelor moderne din cauza reducerii
dependențe, planificare îmbunătățită și utilizare redusă a stivei atunci când stiva preferată
limita nu este egală cu 2. Dezavantajul este o creștere notabilă a dimensiunii codului. Acest
comutator implică -mno-push-args.

-mthreads
Acceptă gestionarea excepțiilor thread-safe pe MinGW. Programe care se bazează pe thread-safe
gestionarea excepțiilor trebuie să compileze și să lege tot codul cu -mthreads opțiune. Cand
compilare, -mthreads definește „-D_MT”; atunci când se leagă, se leagă într-un thread special
biblioteca de ajutor -lmingwthrd care curăță datele de gestionare a excepțiilor pe fir.

-mno-align-stringops
Nu aliniați destinația operațiilor cu șiruri aliniate. Acest comutator reduce codul
mărimea și îmbunătățește performanța în cazul în care destinația este deja aliniată, dar GCC
nu știe despre asta.

-minline-all-stringops
În mod implicit, GCC inline operații cu șir numai atunci când se știe că destinația este
aliniat la o limită de cel puțin 4 octeți. Acest lucru permite mai multă integrare și crește codul
dimensiune, dar poate îmbunătăți performanța codului care depinde de rapid „memcpy”, „strlen” și
„memset” pentru lungimi scurte.

-minline-stringops-dinamic
Pentru operațiuni cu șir de dimensiune necunoscută, utilizați verificări în timpul execuției cu cod inline pentru mici
blocuri și o bibliotecă solicită blocuri mari.

-mstringop-strategy=ALG
Ignorați euristica de decizie internă pentru algoritmul particular pentru care să îl utilizați
operații cu șiruri de aliniere. Valorile permise pentru ALG sunt:

rep_byte
rep_4byte
rep_8byte
Extindeți folosind prefixul i386 „rep” de dimensiunea specificată.

bucla_octeți
buclă
bucla_desfăşurată
Extindeți într-o buclă inline.

libcall
Utilizați întotdeauna un apel de bibliotecă.

-mmemcpy-strategy=strategie
Ignorați euristica de decizie internă pentru a decide dacă „__builtin_memcpy” ar trebui să fie
inline și ce algoritm inline să folosească atunci când dimensiunea așteptată a operației de copiere
este cunoscut. strategie este o listă separată prin virgulă de ALG:dimensiune_max:dest_align tripleti. ALG
este specificat în -mstringop-strategie, dimensiune_max specifică dimensiunea maximă de octeți cu care
algoritm inline ALG este permis. Pentru ultimul triplet, cel dimensiune_max trebuie să fie „-1”. The
dimensiune_max a tripleților din listă trebuie specificate în ordine crescătoare. The
dimensiune minimă de octeți pentru ALG este 0 pentru primul triplet și "dimensiune_max + 1" a
intervalul precedent.

-mmemset-strategy=strategie
Opțiunea este similară cu -mmemcpy-strategy= cu excepția faptului că este de a controla
Expansiunea „__builtin_memset”.

-momit-leaf-frame-pointer
Nu păstrați indicatorul de cadru într-un registru pentru funcțiile frunze. Acest lucru evită
instrucțiuni pentru salvarea, configurarea și restaurarea indicatorilor de cadru și face un registru suplimentar
disponibil în funcțiile frunzelor. Optiunea -fomit-leaf-frame-pointer îndepărtează cadrul
pointer pentru funcțiile frunzelor, ceea ce ar putea îngreuna depanarea.

-mtls-direct-seg-refs
-mno-tls-direct-seg-refs
Controlează dacă variabilele TLS pot fi accesate cu compensații din segmentul TLS
registru (%gs pentru 32 de biți, %fs pentru 64 de biți) sau dacă indicatorul de bază al firului trebuie să fie
adăugat. Dacă acest lucru este valid sau nu, depinde de sistemul de operare și dacă acesta
cartografiază segmentul pentru a acoperi întreaga zonă TLS.

Pentru sistemele care folosesc Biblioteca GNU C, implicit este activată.

-msse2avx
-mno-sse2avx
Specificați că asamblatorul trebuie să codifice instrucțiunile SSE cu prefixul VEX. Optiunea
-mavx activează acest lucru în mod implicit.

-mfentry
-mno-fentry
Dacă profilarea este activă (-pag), puneți apelul contor de profilare înaintea prologului.
Notă: Pe arhitecturile x86, atributul „ms_hook_prologue” nu este posibil la
moment pentru -mfentry și -pag.

-m8bit-idiv
-mno-8bit-idiv
Pe unele procesoare, cum ar fi Intel Atom, diviziunea întregului nesemnat pe 8 biți este mult mai rapidă decât
Împărțire întregi pe 32 de biți/64 de biți. Această opțiune generează o verificare în timpul execuției. Dacă ambele
dividendul și divizorul sunt în intervalul de la 0 la 255, împărțirea întregului fără semn pe 8 biți este
folosit în locul împărțirii întregi pe 32 de biți/64 de biți.

-mavx256-split-unaligned-load
-mavx256-split-unaligned-store
Încărcați și stocați AVX nealiniat pe 32 de octeți.

-mstack-protector-guard=pază
Generați codul de protecție a stivei folosind canary la pază. Locațiile acceptate sunt global
pentru canar global sau tls pentru canary per-thread în blocul TLS (implicit). Acest
opțiunea are efect numai atunci când -festack-protector or -fstack-protector-all este specificat.

Acestea -m switch-urile sunt acceptate în plus față de cele de mai sus pe procesoarele x86-64 pe 64 de biți
medii.

-m32
-m64
-mx32
-m16
Generați cod pentru un mediu pe 16 biți, 32 biți sau 64 biți. The -m32 seturi de opțiuni „int”,
„lung”, iar pointerul tipează la 32 de biți și generează cod care rulează pe orice sistem i386.

-m64 opțiunea setează „int” la 32 de biți și „long” și tipurile de pointer la 64 de biți și
generează cod pentru arhitectura x86-64. Pentru Darwin doar -m64 opțiune, de asemenea
oprește -fno-pic și -mdynamic-no-pic opțiuni.

-mx32 opțiunea setează tipurile „int”, „long” și pointer la 32 de biți și generează cod
pentru arhitectura x86-64.

-m16 opțiunea este aceeași ca -m32, cu excepția faptului că emite „.code16gcc”
directivă de asamblare la începutul ieșirii de asamblare, astfel încât binarul să poată rula
în modul pe 16 biți.

-mno-zona-rosie
Nu utilizați așa-numita „zonă roșie” pentru codul x86-64. Zona roșie este impusă de
x86-64 ABI; este o zonă de 128 de octeți dincolo de locația pointerului stivei care nu este
modificate de manipulatorii de semnale sau întreruperi și, prin urmare, pot fi utilizate pentru date temporare
fără a regla indicatorul de stivă. Steagul -mno-zona-rosie dezactivează această zonă roșie.

-mcmodel=mic
Generați cod pentru modelul de cod mic: programul și simbolurile sale trebuie să fie conectate
cei 2 GB inferiori ai spațiului de adrese. Pointerii au 64 de biți. Programele pot fi
legate static sau dinamic. Acesta este modelul de cod implicit.

-mcmodel=kernel
Generați cod pentru modelul de cod de kernel. Nucleul rulează în negativul de 2 GB al
spatiu de adresare. Acest model trebuie utilizat pentru codul kernel-ului Linux.

-mcmodel=mediu
Generați cod pentru modelul mediu: programul este conectat în 2 GB inferioare ale
spatiu de adresare. Acolo sunt plasate și simboluri mici. Simboluri cu dimensiuni mai mari decât
-mlarge-data-threshold sunt introduse în secțiuni mari de date sau BSS și pot fi localizate
peste 2 GB. Programele pot fi legate static sau dinamic.

-mcmodel=mare
Generați cod pentru modelul mare. Acest model nu face ipoteze despre adrese
și dimensiunile secțiunilor.

-maddress-mode=lung
Generați codul pentru modul de adresă lungă. Acest lucru este acceptat numai pentru 64 de biți și x32
medii. Este modul implicit de adresă pentru mediile pe 64 de biți.

-maddress-mode=scurt
Generați codul pentru modul de adresă scurtă. Acest lucru este acceptat numai pentru 32 de biți și x32
medii. Este modul implicit de adresă pentru mediile pe 32 de biți și x32.

i386 și x86-64 ferestre din Opţiuni

Aceste opțiuni suplimentare sunt disponibile pentru ținte Microsoft Windows:

-mconsole
Această opțiune specifică că o aplicație consolă urmează să fie generată, prin instruire
linkerul pentru a seta tipul de subsistem antet PE necesar pentru aplicațiile de consolă.
Această opțiune este disponibilă pentru ținte Cygwin și MinGW și este activată implicit
acele tinte.

-mdll
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Specifică că un DLL---a
biblioteca de legături dinamice --- urmează să fie generată, permițând selectarea celor necesare
obiect de pornire runtime și punctul de intrare.

-mnop-fun-dllimport
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Se precizează că
Atributul „dllimport” trebuie ignorat.

-mthread
Această opțiune este disponibilă pentru ținte MinGW. Specifică acel fir specific MinGW
trebuie folosit suport.

-municode
Această opțiune este disponibilă pentru ținte MinGW-w64. Determină preprocesorul „UNICODE”.
macro să fie predefinită și alege codul de pornire compatibil Unicode.

-mwin32
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Se precizează că tipicul
Macrocomenzile predefinite Microsoft Windows trebuie setate în pre-procesor, dar nu
influențează alegerea bibliotecii de rulare/codului de pornire.

-mwindows
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Specifică că o interfață grafică
aplicația trebuie să fie generată prin instruirea linkerului să seteze antetul PE
tipul de subsistem corespunzător.

-fno-set-stack-executable
Această opțiune este disponibilă pentru ținte MinGW. Specifică faptul că flagul executabil pentru
stiva utilizată de funcțiile imbricate nu este setată. Acest lucru este necesar pentru rularea binarelor
în modul kernel al Microsoft Windows, așa cum există User32 API, care este folosit pentru a seta
privilegii executabile, nu este disponibil.

-fwritable-relocated-rdata
Această opțiune este disponibilă pentru țintele MinGW și Cygwin. Se precizează că relocată-
datele din secțiunea numai în citire sunt introduse în secțiunea .data. Acesta este necesar pentru bătrâni
runtimes care nu acceptă modificarea secțiunilor .rdata pentru pseudo-relocare.

-mpe-aligned-commons
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Acesta specifică faptul că GNU
extensie la formatul de fișier PE care permite alinierea corectă a variabilelor COMUNE
ar trebui utilizat la generarea codului. Este activat în mod implicit dacă GCC detectează că
Asamblatorul țintă găsit în timpul configurării acceptă caracteristica.

Vezi și sub i386 și x86-64 Opţiuni pentru opțiunile standard.

IA-64 Opţiuni

Acestea sunt -m opțiunile definite pentru arhitectura Intel IA-64.

-mbig-endian
Generați cod pentru o țintă big-endian. Aceasta este valoarea implicită pentru HP-UX.

-mlittle-endian
Generați cod pentru o țintă little-endian. Aceasta este valoarea implicită pentru AIX5 și GNU/Linux.

-mgnu-as
-mno-gnu-as
Generați (sau nu) cod pentru asamblatorul GNU. Aceasta este valoarea implicită.

-mgnu-ld
-mno-gnu-ld
Generați (sau nu) cod pentru linkerul GNU. Aceasta este valoarea implicită.

-mno-pic
Generați cod care nu utilizează un registru de pointer global. Rezultatul nu este pozitia
cod independent și încalcă IA-64 ABI.

-mvolatile-asm-stop
-mno-volatil-asm-stop
Generați (sau nu) un pic de oprire imediat înainte și după declarațiile asm volatile.

-mregister-names
-mno-registru-nume
Generați (sau nu) in, loc, și afară înregistrează nume pentru registrele stivuite. Acest
poate face rezultatul asamblatorului mai lizibil.

-mno-sdata
-msdata
Dezactivați (sau activați) optimizările care utilizează secțiunea de date mici. Acest lucru poate fi util
pentru a rezolva erorile de optimizare.

-mconstant-gp
Generați cod care utilizează o singură valoare constantă a indicatorului global. Acest lucru este util atunci când
compilarea codului kernelului.

-mauto-pic
Generați cod care poate fi auto-relocabil. Asta implică -mconstant-gp. Acest lucru este util
la compilarea codului firmware-ului.

-minline-float-divide-min-latency
Generați cod pentru împărțirile în linie ale valorilor în virgulă mobilă folosind latența minimă
algoritm.

-minline-float-divide-max-throughput
Generați cod pentru împărțirile în linie ale valorilor în virgulă mobilă folosind debitul maxim
algoritm.

-mno-inline-float-divide
Nu generați cod inline pentru împărțirea valorilor în virgulă mobilă.

-minline-int-divide-min-latency
Generați cod pentru împărțiri în linie a valorilor întregi folosind latența minimă
algoritm.

-minline-int-divide-max-throughput
Generați cod pentru împărțiri în linie a valorilor întregi folosind debitul maxim
algoritm.

-mno-inline-int-divide
Nu generați cod inline pentru împărțiri ale valorilor întregi.

-minline-sqrt-min-latency
Generați cod pentru rădăcini pătrate inline folosind algoritmul de latență minimă.

-minline-sqrt-max-throughput
Generați cod pentru rădăcini pătrate inline folosind algoritmul de debit maxim.

-mno-inline-sqrt
Nu generați cod inline pentru „sqrt”.

-mfused-madd
-mno-fuzionat-madd
Nu generați (nu) codul care utilizează înmulțirea/adunarea sau înmulțirea/scăderea fuzionate
instrucțiuni. Implicit este utilizarea acestor instrucțiuni.

-mno-pitic2-asm
-mdwarf2-asm
Nu generați (sau nu generați) cod de asamblare pentru informațiile de depanare a numărului de linie DWARF 2.
Acest lucru poate fi util atunci când nu utilizați asamblatorul GNU.

-biți-stop-meriți
-mno-biți-de-oprire-timpurii
Permiteți ca biții de oprire să fie plasați mai devreme decât imediat înaintea instrucțiunii care
a declanșat bitul de oprire. Acest lucru poate îmbunătăți programarea instrucțiunilor, dar nu întotdeauna
face acest lucru.

-mfixed-range=registru-gamă
Generați codul tratând intervalul de registre dat ca registre fixe. Un registru fix
este unul pe care alocatorul de registru nu îl poate folosi. Acest lucru este util la compilarea nucleului
cod. Un interval de registre este specificat ca două registre separate printr-o liniuță. Multiplu
intervalele de registru pot fi specificate separate prin virgulă.

-mtls-size=dimensiunea tls
Specificați dimensiunea de biți a decalajelor TLS imediate. Valorile valide sunt 14, 22 și 64.

-mtune=tip CPU
Ajustați programarea instrucțiunilor pentru un anumit CPU, Valorile valide sunt itaniu,
itan 1, milostiv, itan 2, și McKinley.

-milp32
-mlp64
Generați cod pentru un mediu pe 32 de biți sau 64 de biți. Mediul pe 32 de biți setează int,
lung și indicator la 32 de biți. Mediul pe 64 de biți setează int la 32 de biți și lung și
pointer la 64 de biți. Acestea sunt semnalizatoare specifice HP-UX.

-mno-sched-br-data-spec
-msched-br-data-spec
(Dezactivați/Activați) programarea speculativă a datelor înainte de reîncărcare. Aceasta are ca rezultat generarea de
instrucțiunile „ld.a” și instrucțiunile de verificare corespunzătoare („ld.c” / „chk.a”). The
implicit este „dezactivare”.

-msched-ar-data-spec
-mno-sched-ar-data-spec
(En/Dis)activați programarea speculativă a datelor după reîncărcare. Aceasta are ca rezultat generarea de
instrucțiunile „ld.a” și instrucțiunile de verificare corespunzătoare („ld.c” / „chk.a”). The
implicit este „activare”.

-mno-sched-control-spec
-msched-control-spec
(Dis/En)able controla programarea speculativă. Această caracteristică este disponibilă numai în timpul
programarea regiunii (adică înainte de reîncărcare). Aceasta are ca rezultat generarea „ld.s”
instrucțiunile și instrucțiunile de verificare corespunzătoare „chk.s”. Valoarea implicită este
'dezactivare'.

-msched-br-in-data-spec
-mno-sched-br-in-data-spec
(En/Dis)activați programarea speculativă a instrucțiunilor care depind de date
sarcini speculative înainte de reîncărcare. Acest lucru este eficient doar cu -msched-br-data-spec
activat. Valoarea implicită este „activare”.

-msched-ar-in-data-spec
-mno-sched-ar-in-data-spec
(En/Dis)activați programarea speculativă a instrucțiunilor care depind de date
sarcini speculative după reîncărcare. Acest lucru este eficient doar cu -msched-ar-data-spec
activat. Valoarea implicită este „activare”.

-msched-in-control-spec
-mno-sched-in-control-spec
(En/Dis)activați programarea speculativă a instrucțiunilor care depind de
controlează sarcinile speculative. Acest lucru este eficient doar cu -msched-control-spec activat.
Valoarea implicită este „activare”.

-mno-sched-prefer-non-data-spec-insns
-msched-prefer-non-data-spec-insns
Dacă este activată, instrucțiunile speculative de date sunt alese pentru programare numai dacă nu există
alte alegeri momentan. Acest lucru face ca utilizarea speculațiilor de date să fie mult mai mare
conservator. Valoarea implicită este „dezactivare”.

-mno-sched-prefer-non-control-spec-insns
-msched-prefer-non-control-spec-insns
Dacă sunt activate, instrucțiunile de control-speculare sunt alese pentru programare numai dacă există
nu există alte alegeri momentan. Acest lucru face ca utilizarea speculațiilor de control să fie mult mai mare
mai conservatoare. Valoarea implicită este „dezactivare”.

-mno-sched-count-spec-in-critical-path
-msched-count-spec-in-critical-path
Dacă este activată, dependențele speculative sunt luate în considerare în timpul calculării
prioritățile instrucțiunilor. Acest lucru face ca utilizarea speculației să fie puțin mai mare
conservator. Valoarea implicită este „dezactivare”.

-msched-spec-ldc
Utilizați o simplă verificare a speculațiilor de date. Această opțiune este activată în mod implicit.

-msched-control-spec-ldc
Utilizați o verificare simplă pentru speculații de control. Această opțiune este activată în mod implicit.

-msched-stop-bits-după-fiecare-ciclu
Puneți un pic de oprire după fiecare ciclu când programați. Această opțiune este activată în mod implicit.

-msched-fp-mem-deps-zero-cost
Să presupunem că stocurile și încărcările în virgulă mobilă nu sunt susceptibile de a provoca un conflict atunci când
plasate în același grup de instrucțiuni. Această opțiune este dezactivată implicit.

-msel-sched-dont-check-control-spec
Generați verificări pentru speculații de control în programarea selectivă. Acest steag este
dezactivat implicit.

-msched-max-memory-insns=max-insns
Limitarea numărului de insns de memorie per grup de instrucțiuni, acordând prioritate mai mică
insns de memorie ulterioare care încearcă să programeze în același grup de instrucțiuni.
Frecvent util pentru a preveni conflictele bancare cache. Valoarea implicită este 1.

-msched-max-memory-insns-hard-limit
Face limita specificată de msched-max-memory-insns o limită dură, interzicând mai mult
decât acel număr dintr-un grup de instrucțiuni. În caz contrar, limita este „soft”, adică
că operațiunile non-memorie sunt de preferat când se atinge limita, dar memoria
operațiunile pot fi încă programate.

LM32 Opţiuni

Acestea -m opțiunile sunt definite pentru arhitectura LatticeMico32:

-barrel-shift-activat
Activați instrucțiunile de schimbare a butoiului.

-mdivide-activat
Activați instrucțiunile de împărțire și modul.

-multiplicare-activat
Activați instrucțiunile de înmulțire.

-msign-extend-activat
Activați instrucțiunile de extindere a semnelor.

-activat pentru muzică
Activați instrucțiunile definite de utilizator.

M32C Opţiuni

-mcpu=nume
Selectați CPU pentru care este generat codul. nume poate fi unul dintre r8c pentru R8C/Tiny
serie, m16c pentru seria M16C (până la /60), m32cm pentru seria M16C/80 sau m32c
pentru seria M32C/80.

-msim
Specifică faptul că programul va fi rulat pe simulator. Acest lucru determină o alternativă
biblioteca runtime care urmează să fie conectată în care acceptă, de exemplu, fișiere I/O. Trebuie să nu
utilizați această opțiune când generați programe care vor rula pe hardware real; trebuie să vă
furnizați propria bibliotecă de rulare pentru orice funcții I/O sunt necesare.

-memregs=număr
Specifică numărul de pseudo-registruri bazate pe memorie pe care GCC le utilizează în timpul generării codului.
Aceste pseudo-registre sunt folosite ca registre reale, deci există un compromis între
Capacitatea GCC de a încadra codul în registrele disponibile și penalizarea de performanță a
folosind memoria în loc de registre. Rețineți că toate modulele dintr-un program trebuie să fie
compilat cu aceeași valoare pentru această opțiune. Din această cauză, nu trebuie să utilizați acest lucru
opțiunea cu bibliotecile de rulare implicite ale GCC.

M32R/D Opţiuni

Acestea -m opțiunile sunt definite pentru arhitecturile Renesas M32R/D:

-m32r2
Generați codul pentru M32R/2.

-m32rx
Generați codul pentru M32R/X.

-m32r
Generați codul pentru M32R. Aceasta este valoarea implicită.

-mmodel=mic
Să presupunem că toate obiectele trăiesc în memoria inferioară de 16 MB (astfel încât adresele lor să poată fi
încărcat cu instrucțiunea "ld24") și să presupunem că toate subrutinele sunt accesibile cu
instrucțiunea „bl”. Aceasta este valoarea implicită.

Adresabilitatea unui anumit obiect poate fi setată cu atributul „model”.

-mmodel=mediu
Să presupunem că obiectele pot fi oriunde în spațiul de adrese de 32 de biți (compilatorul generează
instrucțiunile „seth/add3” pentru a-și încărca adresele) și presupunem că toate subrutinele sunt
accesibil cu instrucțiunea „bl”.

-mmodel=mare
Să presupunem că obiectele pot fi oriunde în spațiul de adrese de 32 de biți (compilatorul generează
instrucțiunile „seth/add3” pentru a-și încărca adresele) și presupunem că subrutinele ar putea să nu fie
accesibil cu instrucțiunea „bl” (compilatorul generează mult mai lent
secvența de instrucțiuni „seth/add3/jl”.

-msdata=niciuna
Dezactivați utilizarea zonei mici de date. Variabilele sunt introduse într-unul dintre .date, .bss, Sau
.rodata (cu excepția cazului în care a fost specificat atributul „secțiune”). Aceasta este valoarea implicită.

Zona mică de date este formată din secțiuni .sdata și .sbss. Obiectele pot fi explicit
puneți în zona mică de date cu atributul „secțiune” folosind una dintre aceste secțiuni.

-msdata=sdata
Puneți date mici globale și statice în zona de date mici, dar nu generați speciale
cod pentru a le face referire.

-msdata=utilizare
Puneți date mici globale și statice în zona de date mici și generați speciale
instrucțiuni pentru a le referi.

-G o
Puneți obiecte globale și statice mai mici sau egale cu o octeți în datele mici sau
Secțiuni BSS în loc de secțiunile normale de date sau BSS. Valoarea implicită a o is
8. -msdata opțiunea trebuie să fie setată la una dintre sdata or utilizare pentru ca această opțiune să aibă vreunul
efect.

Toate modulele ar trebui să fie compilate cu același -G o valoare. Compilarea cu diferite
valori ale o poate sau nu să funcționeze; dacă nu, linkerul dă o eroare
mesaj --- codul incorect nu este generat.

-mdebug
Face ca codul specific M32R din compilator să afișeze câteva statistici care ar putea ajuta
în programele de depanare.

-bucle-maligne
Aliniați toate buclele la o limită de 32 de octeți.

-mno-align-loops
Nu aplicați o aliniere de 32 de octeți pentru bucle. Aceasta este valoarea implicită.

-rata-eșec=număr
Emisiune număr instrucțiuni pe ciclu. număr poate fi doar 1 sau 2.

-mbranch-cost=număr
număr poate fi doar 1 sau 2. Dacă este 1, atunci ramurile sunt preferate în detrimentul condiționat
cod, dacă este 2, atunci se aplică inversul.

-mflush-trap=număr
Specifică numărul capcanei de utilizat pentru a goli memoria cache. Valoarea implicită este 12. Valabil
numerele sunt cuprinse între 0 și 15 inclusiv.

-mno-flush-trap
Specifică faptul că memoria cache nu poate fi golită folosind o capcană.

-mflush-func=nume
Specifică numele funcției sistemului de operare de apelat pentru a goli memoria cache. The
implicit este _flush_cache, dar un apel de funcție este utilizat numai dacă o capcană nu este disponibilă.

-mno-flush-func
Indică faptul că nu există nicio funcție OS pentru golirea memoriei cache.

M680x0 Opţiuni

Acestea sunt -m opțiunile definite pentru procesoarele M680x0 și ColdFire. Setările implicite
depinde de ce arhitectură a fost selectată când a fost configurat compilatorul; valorile implicite
pentru cele mai frecvente alegeri sunt prezentate mai jos.

-martie=arc
Generați cod pentru o anumită arhitectură de set de instrucțiuni M680x0 sau ColdFire.
Valorile admisibile ale arc pentru arhitecturile M680x0 sunt: 68000, 68010, 68020, 68030,
68040, 68060 și cpu32. Arhitecturile ColdFire sunt selectate în funcție de Freescale
Clasificarea ISA și valorile admise sunt: isaah, isaaplus, ISAB și Isaac.

GCC definește o macrocomandă __mcfarc__ ori de câte ori generează cod pentru o țintă ColdFire.
arc în acest macro este unul dintre -Martie argumentele prezentate mai sus.

Când sunt utilizate împreună, -Martie și -mtune selectați codul care rulează pe o familie de similare
procesoare, dar care este optimizat pentru o anumită microarhitectură.

-mcpu=cpu
Generați cod pentru un anumit procesor M680x0 sau ColdFire. M680x0 cpusunt:
68000, 68010, 68020, 68030, 68040, 68060, 68302, 68332 și cpu32. The ColdFire cpus
sunt date de tabelul de mai jos, care clasifică, de asemenea, CPU-urile în familii:

Familie : -mcpu argumente
51 : 51 51ac 51ag 51CN 51em 51JE 51jf 51jg 51jm 51mm 51qe 51qm
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 suprascrie -martie=arc if arc este compatibil cu cpu. Alte combinații de
-mcpu și -Martie sunt respinse.

GCC definește macro-ul __mcf_cpu_cpu când ținta ColdFire cpu este selectat. De asemenea
definește __mcf_family_familie, unde valoarea de familie este dat de tabelul de mai sus.

-mtune=ton
Ajustați codul pentru o anumită microarhitectură în limitele stabilite de -Martie
și -mcpu. Microarhitecturile M680x0 sunt: 68000, 68010, 68020, 68030, 68040,
68060 și cpu32. Microarhitecturile ColdFire sunt: cfv1, cfv2, cfv3, cfv4 și
cfv4e.

De asemenea, puteți utiliza -mtune=68020-40 pentru codul care trebuie să ruleze relativ bine pe 68020,
ținte 68030 și 68040. -mtune=68020-60 este similar, dar include 68060 ținte ca
bine. Aceste două opțiuni selectează aceleași decizii de reglare ca -m68020-40 și -m68020-60
respectiv.

GCC definește macrocomenzi __mcarc și __mcarc__ la reglarea pentru arhitectura 680x0
arc. De asemenea, definește mcarc decât dacă fie -ansi sau un non-GNU -std este folosită opțiunea.
Dacă GCC se reglează pentru o serie de arhitecturi, așa cum este selectat de -mtune=68020-40 or
-mtune=68020-60, definește macrocomenzile pentru fiecare arhitectură din gamă.

GCC definește și macro-ul __muarh__ atunci când reglați microarhitectura ColdFire
uarh, În cazul în care uarh este unul dintre argumentele prezentate mai sus.

-m68000
-mc68000
Generați ieșire pentru un 68000. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68000. Este echivalent cu -martie=68000.

Utilizați această opțiune pentru microcontrolere cu un nucleu 68000 sau EC000, inclusiv 68008,
68302, 68306, 68307, 68322, 68328 și 68356.

-m68010
Generați ieșire pentru un 68010. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68010. Este echivalent cu -martie=68010.

-m68020
-mc68020
Generați ieșire pentru un 68020. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68020. Este echivalent cu -martie=68020.

-m68030
Generați ieșire pentru un 68030. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68030. Este echivalent cu -martie=68030.

-m68040
Generați ieșire pentru un 68040. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68040. Este echivalent cu -martie=68040.

Această opțiune inhibă utilizarea instrucțiunilor 68881/68882 care trebuie să fie emulate de către
software-ul pe 68040. Utilizați această opțiune dacă 68040-ul dvs. nu are cod de emulat
acele instrucțiuni.

-m68060
Generați ieșire pentru un 68060. Aceasta este valoarea implicită când compilatorul este configurat pentru
sisteme bazate pe 68060. Este echivalent cu -martie=68060.

Această opțiune inhibă utilizarea instrucțiunilor 68020 și 68881/68882 care trebuie să fie
emulat de software pe 68060. Utilizați această opțiune dacă 68060-ul dvs. nu are cod
pentru a imita acele instrucțiuni.

-mcpu32
Generați ieșire pentru un CPU32. Aceasta este valoarea implicită când compilatorul este configurat
Sisteme bazate pe CPU32. Este echivalent cu -march=cpu32.

Utilizați această opțiune pentru microcontrolere cu un nucleu CPU32 sau CPU32+, inclusiv 68330,
68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 și 68360.

-m5200
Generați ieșire pentru un procesor ColdFire 520X. Aceasta este valoarea implicită când este compilatorul
configurat pentru sisteme bazate pe 520X. Este echivalent cu -mcpu=5206, și este acum
depreciat în favoarea acestei opțiuni.

Utilizați această opțiune pentru microcontroler cu un nucleu 5200, inclusiv MCF5202, MCF5203,
MCF5204 și MCF5206.

-m5206e
Generați ieșire pentru un procesor ColdFire 5206e. Opțiunea este acum retrasă în favoarea
echivalentul -mcpu=5206e.

-m528x
Generați rezultate pentru un membru al familiei ColdFire 528X. Opțiunea este acum
depreciat în favoarea echivalentului -mcpu=528x.

-m5307
Generați ieșire pentru un procesor ColdFire 5307. Opțiunea este acum retrasă în favoarea
echivalent -mcpu=5307.

-m5407
Generați ieșire pentru un procesor ColdFire 5407. Opțiunea este acum retrasă în favoarea
echivalent -mcpu=5407.

-mcfv4e
Generați ieșire pentru un procesor al familiei ColdFire V4e (de ex. 547x/548x). Aceasta include utilizarea
instrucțiuni hardware în virgulă mobilă. Opțiunea este echivalentă cu -mcpu=547x, si este
acum depreciat în favoarea acestei opțiuni.

-m68020-40
Generați ieșire pentru un 68040, fără a utiliza niciuna dintre instrucțiunile noi. Aceasta rezultă
în cod care poate rula relativ eficient fie pe un 68020/68881, fie pe un 68030 sau pe un
68040. Codul generat folosește instrucțiunile 68881 care sunt emulate pe
68040.

Opțiunea este echivalentă cu -martie=68020 -mtune=68020-40.

-m68020-60
Generați ieșire pentru un 68060, fără a utiliza niciuna dintre instrucțiunile noi. Aceasta rezultă
în cod care poate rula relativ eficient fie pe un 68020/68881, fie pe un 68030 sau pe un
68040. Codul generat folosește instrucțiunile 68881 care sunt emulate pe
68060.

Opțiunea este echivalentă cu -martie=68020 -mtune=68020-60.

-mhard-float
-m68881
Generați instrucțiuni în virgulă mobilă. Aceasta este valoarea implicită pentru 68020 și mai sus și
pentru dispozitivele ColdFire care au un FPU. Acesta definește macro-ul __HAVE_68881__ pe M680x0
ţinte şi __mcffpu__ pe ținte ColdFire.

-msoft-float
Nu generați instrucțiuni în virgulă mobilă; folosiți în schimb apelurile de bibliotecă. Acesta este
implicit pentru ținte 68000, 68010 și 68832. Este, de asemenea, implicit pentru ColdFire
dispozitive care nu au FPU.

-mdiv
-mno-div
Generați (nu generați) instrucțiuni de împărțire și restul hardware ColdFire. Dacă
-Martie se folosește fără -mcpu, implicit este „pornit” pentru arhitecturile ColdFire și „dezactivat”
pentru arhitecturi M680x0. În caz contrar, valoarea implicită este preluată de la CPU țintă (fie
procesorul implicit sau cel specificat de -mcpu). De exemplu, valoarea implicită este „off”
pentru -mcpu=5206 și „pornit” pentru -mcpu=5206e.

GCC definește macro-ul __mcfhwdiv__ când această opțiune este activată.

-mscurt
Considerați că tipul „int” are o lățime de 16 biți, cum ar fi „short int”. În plus, parametrii
transmise pe stivă sunt, de asemenea, aliniate la o limită de 16 biți chiar și pe ținte al căror API
impune promovarea la 32 de biți.

-mno-scurt
Nu considerați că tipul „int” are o lățime de 16 biți. Aceasta este valoarea implicită.

-mnobitfield
-mno-câmp de biți
Nu utilizați instrucțiunile câmpului de biți. The -m68000, -mcpu32 și -m5200 opțiunile implică
-mnobitfield.

-mbitfield
Folosiți instrucțiunile câmpului de biți. The -m68020 opțiunea implică -mbitfield. Acest lucru este
implicit dacă utilizați o configurație proiectată pentru un 68020.

-mrtd
Utilizați o convenție diferită de apelare a funcției, în care funcțiile care au un fix
numărul de argumente se întoarce cu instrucțiunea „rtd”, care le afișează argumentele
în timp ce se întorcea. Acest lucru salvează o instrucțiune în apelant, deoarece nu este nevoie
pune argumentele acolo.

Această convenție de apelare este incompatibilă cu cea folosită în mod normal pe Unix, deci tu
nu îl puteți folosi dacă trebuie să apelați biblioteci compilate cu compilatorul Unix.

De asemenea, trebuie să furnizați prototipuri de funcție pentru toate funcțiile care acceptă variabile
numărul de argumente (inclusiv „printf”); altfel este generat cod incorect pt
apeluri la aceste funcții.

În plus, rezultă un cod grav incorect dacă apelați o funcție cu prea multe
argumente. (În mod normal, argumentele suplimentare sunt ignorate în mod inofensiv.)

Instrucțiunea „rtd” este acceptată de 68010, 68020, 68030, 68040, 68060 și CPU32
procesoare, dar nu de la 68000 sau 5200.

-mno-rtd
Nu utilizați convențiile de apelare selectate de -mrtd. Aceasta este valoarea implicită.

-malign-int
-mno-align-int
Controlați dacă GCC aliniază „int”, „long”, „long long”, „float”, „double” și „long
variabile duble pe o limită de 32 de biți (-malign-int) sau o limită de 16 biți
(-mno-align-int). Alinierea variabilelor pe granițele de 32 de biți produce cod care rulează
ceva mai rapid la procesoarele cu magistrale pe 32 de biți în detrimentul unei mai multe memorie.

Avertisment: dacă utilizați -malign-int comutator, GCC aliniază structurile care conțin cele de mai sus
tipează diferit față de majoritatea specificațiilor de interfață binară ale aplicației publicate pentru
m68k.

-mpcrel
Utilizați modul de adresare relativ la computer al 68000 direct, în loc să utilizați un global
tabel de compensare. În prezent, această opțiune implică -fpic, permițând cel mult un offset de 16 biți
pentru adresare relativă la pc. -fPIC nu este suportat în prezent cu -mpcrel, Deşi
acest lucru ar putea fi acceptat pentru procesoare 68020 și mai mari.

-mno-strict-align
-mstrict-align
Nu presupuneți (faceți) că referințele de memorie nealiniate sunt gestionate de sistem.

-msep-data
Generați cod care permite ca segmentul de date să fie localizat într-o zonă diferită a memoriei
din segmentul de text. Acest lucru permite executarea pe loc într-un mediu fără
managementul memoriei virtuale. Această opțiune implică -fPIC.

-mno-sep-data
Generați cod care presupune că segmentul de date urmează segmentul de text. Aceasta este
implicit.

-mid-shared-bibliotecă
Generați cod care acceptă biblioteci partajate prin metoda ID-ului bibliotecii. Asta permite
pentru biblioteci executate in loc și partajate într-un mediu fără memorie virtuală
management. Această opțiune implică -fPIC.

-mno-id-biblioteca partajată
Generați cod care nu presupune că sunt folosite biblioteci partajate bazate pe ID. Aceasta este
implicit.

-mshared-library-id=n
Specifică numărul de identificare al bibliotecii partajate bazate pe ID care este compilată.
Specificarea unei valori de 0 generează un cod mai compact; precizând alte valori forţe
alocarea acelui număr bibliotecii curente, dar nu mai este spațiu sau timp
eficient decât omiterea acestei opțiuni.

-mxgot
-mno-xgot
Când generați cod independent de poziție pentru ColdFire, generați cod care funcționează dacă
GOT are mai mult de 8192 de intrări. Acest cod este mai mare și mai lent decât codul
generat fără această opțiune. Pe procesoarele M680x0, această opțiune nu este necesară; -fPIC
este suficient.

GCC utilizează în mod normal o singură instrucțiune pentru a încărca valori din GOT. În timp ce aceasta este
relativ eficient, funcționează doar dacă GOT-ul este mai mic de aproximativ 64k. Orice
mai mare determină linker-ul să raporteze o eroare, cum ar fi:

relocare trunchiată pentru a se potrivi: R_68K_GOT16O foobar

Dacă se întâmplă acest lucru, ar trebui să recompilați codul cu -mxgot. Apoi ar trebui să funcționeze cu
GOT-uri foarte mari. Cu toate acestea, codul generat cu -mxgot este mai puțin eficient, deoarece
necesită 4 instrucțiuni pentru a prelua valoarea unui simbol global.

Rețineți că unele linkere, inclusiv versiuni mai noi ale linkerului GNU, pot crea
GOT-uri multiple și sortați intrările GOT. Dacă aveți un astfel de linker, ar trebui doar să aveți nevoie
să utilizeze -mxgot la compilarea unui singur fișier obiect care accesează mai mult de 8192 GOT
intrări. Foarte puțini fac.

Aceste opțiuni nu au efect decât dacă GCC generează cod independent de poziție.

MCore Opţiuni

Acestea sunt -m opțiunile definite pentru procesoarele Motorola M*Core.

-mhardlit
-mno-luminat greu
Constante inline în fluxul de cod dacă se poate face în două instrucțiuni sau mai puțin.

-mdiv
-mno-div
Utilizați instrucțiunea de împărțire. (Activat implicit).

-mrelax-imediat
-mno-relax-imediat
Permiteți imediate de dimensiuni arbitrare în operațiuni pe biți.

-mwide-bitfields
-mno-wide-bitfields
Tratează întotdeauna câmpurile de biți ca de dimensiune „int”.

-m4byte-funcții
-mno-4byte-funcții
Forțați toate funcțiile să fie aliniate la o limită de 4 octeți.

-mcallgraph-date
-mno-callgraph-date
Emiteți informații despre callgraph.

-mslow-bytes
-mno-slow-bytes
Preferați accesul la cuvinte când citiți cantitățile de octeți.

-mlittle-endian
-mbig-endian
Generați cod pentru o țintă little-endian.

-m210
-m340
Generați codul pentru procesorul 210.

-mno-lsim
Să presupunem că a fost furnizat suport de rulare și, prin urmare, omiteți biblioteca simulatorului
(libsim.a) din linia de comandă a linkerului.

-mstack-increment=mărimea
Setați suma maximă pentru o singură operație de creștere a stivei. Valorile mari pot
crește viteza programelor care conțin funcții care necesită o cantitate mare de
spațiu de stivă, dar pot declanșa și o eroare de segmentare dacă stiva este extinsă
prea mult. Valoarea implicită este 0x1000.

MeP Opţiuni

-mabsdiff
Activează instrucțiunea „abs”, care este diferența absolută dintre două registre.

-mall-opts
Activează toate instrucțiunile opționale --- operațiuni de medie, înmulțire, împărțire, biți,
zero înainte, diferență absolută, min/max, clip și saturație.

-maverage
Activează instrucțiunea „ave”, care calculează media a două registre.

-mbased=n
Variabile de dimensiune n octeții sau mai mici sunt plasați în mod implicit în secțiunea „.based”.
Variabilele bazate folosesc registrul $tp ca registru de bază și există o limită de 128 de octeți
la secțiunea „.based”.

-mbitops
Activează instrucțiunile de operare a biților --- test de biți ("btstm"), set ("bsetm"), șterge
("bclrm"), inversare ("bnotm") și test-and-set ("tas").

-mc=nume
Selectează în ce secțiune sunt plasate datele constante. nume poate fi „mici”, „aproape” sau
"departe".

-mclip
Activează instrucțiunea „clip”. Rețineți că „-mclip” nu este util decât dacă și dvs
furnizați „-mminmax”.

-mconfig=nume
Selectează una dintre configurațiile de bază încorporate. Fiecare cip MeP are unul sau mai multe
module din el; fiecare modul are un CPU de bază și o varietate de coprocesoare, opționale
instrucțiuni și periferice. Instrumentul „MeP-Integrator”, care nu face parte din GCC, oferă
aceste configurații prin această opțiune; utilizarea acestei opțiuni este la fel cu utilizarea tuturor
opțiunile corespunzătoare din linia de comandă. Configurația implicită este „implicit”.

-mcop
Activează instrucțiunile coprocesorului. În mod implicit, acesta este un coprocesor pe 32 de biți. Notă
că coprocesorul este în mod normal activat prin opțiunea „-mconfig=".

-mcop32
Activează instrucțiunile coprocesorului pe 32 de biți.

-mcop64
Activează instrucțiunile coprocesorului pe 64 de biți.

-mivc2
Activează programarea IVC2. IVC2 este un coprocesor VLIW pe 64 de biți.

-mdc
Face ca variabilele constante să fie plasate în secțiunea „.near”.

-mdiv
Activează instrucțiunile „div” și „divu”.

-meb
Generați cod big-endian.

-mel
Generați cod little-endian.

-mio-volatil
Spune compilatorului că orice variabilă marcată cu atributul „io” trebuie să fie
considerat volatil.

-ml Determină ca variabilele să fie atribuite implicit secțiunii „.far”.

-mleadz
Activează instrucțiunea „leadz” (zero inițial).

-mm Determină ca variabilele să fie atribuite implicit secțiunii „.near”.

-mminmax
Activează instrucțiunile „min” și „max”.

-mult
Activează instrucțiunile de înmulțire și înmulțire-acumulare.

-mno-opts
Dezactivează toate instrucțiunile opționale activate de „-mall-opts”.

-mrepeat
Activează instrucțiunile „repeat” și „erepeat”, utilizate pentru bucla cu supraîncărcare redusă.

-Domnișoară Determină ca toate variabilele să fie implicit la secțiunea „.tiny”. Rețineți că există o
Limită de 65536 de octeți pentru această secțiune. Accesurile la aceste variabile folosesc baza %gp
inregistreaza-te.

-msatur
Activează instrucțiunile de saturație. Rețineți că compilatorul nu este în prezent
generați-le în sine, dar această opțiune este inclusă pentru compatibilitate cu alte instrumente,
ca și".

-msdram
Conectați timpul de rulare bazat pe SDRAM în loc de timpul de rulare implicit bazat pe ROM.

-msim
Conectați bibliotecile de rulare a simulatorului.

-msimnovec
Conectați bibliotecile de rulare a simulatorului, excluzând suportul încorporat pentru resetare și
vectori de excepție și tabele.

-mtf
Determină ca toate funcțiile să fie implicite în secțiunea „.far”. Fără această opțiune, funcționează
implicit la secțiunea „.near”.

-mtiny=n
Variabile care sunt n octeții sau mai mici sunt alocați secțiunii „.tiny”. Aceste
variabilele folosesc registrul de bază $gp. Valoarea implicită pentru această opțiune este 4, dar rețineți că
există o limită de 65536 de octeți pentru secțiunea „.tiny”.

MicroBlaze Opţiuni

-msoft-float
Utilizați emularea software pentru virgulă mobilă (implicit).

-mhard-float
Utilizați instrucțiuni hardware în virgulă mobilă.

-mmemcpy
Nu optimizați mișcările blocurilor, folosiți „memcpy”.

-mno-clearbss
Această opțiune este depreciată. Utilizare -fno-zero-inițializat-în-bss in schimb.

-mcpu=tip CPU
Utilizați caracteristicile și codul de programare pentru procesorul dat. Valorile acceptate sunt în
format vX.YY.Z, În cazul în care X este o versiune majoră, YY este versiunea minoră și Z is
cod de compatibilitate. Exemple de valori sunt v3.00.a, v4.00.b, v5.00.a, v5.00.b, v5.00.b,
v6.00.a.

-mxl-soft-mul
Utilizați emularea software de multiplicare (implicit).

-mxl-soft-div
Utilizați emularea software pentru împărțiri (implicit).

-mxl-baril-shift
Utilizați schimbătorul de viteze.

-mxl-pattern-compara
Utilizați instrucțiuni de comparare a modelelor.

-msmall-divides
Utilizați optimizarea căutării în tabel pentru diviziunile întregi cu semne mici.

-mxl-stack-check
Această opțiune este depreciată. Utilizare -fstack-check in schimb.

-mxl-gp-opt
Utilizați secțiunile „.sdata”/.sbss referitoare la GP.

-mxl-multiplicare-mare
Utilizați instrucțiuni de înmulțire înaltă pentru partea înaltă a înmulțirii de 32x32.

-mxl-float-convertire
Utilizați instrucțiuni hardware de conversie în virgulă mobilă.

-mxl-float-sqrt
Utilizați instrucțiuni hardware cu virgulă mobilă rădăcină pătrată.

-mbig-endian
Generați cod pentru o țintă big-endian.

-mlittle-endian
Generați cod pentru o țintă little-endian.

-mxl-reordonare
Folosiți instrucțiuni de reordonare (încărcare/stocare inversată de schimb și octet).

-mxl-mode-modelul aplicației
Selectați modelul de aplicație modelul aplicației. Modelele valabile sunt

executabil
executabil normal (implicit), folosește codul de pornire crt0.o.

xmdstub
pentru utilizare cu Xilinx Microprocessor Debugger (XMD) software de depanare intruzivă
agent numit xmdstub. Acesta folosește fișierul de pornire crt1.o și setează adresa de început a
programul la 0x800.

bootstrap
pentru aplicațiile care sunt încărcate folosind un bootloader. Acest model folosește fișierul de pornire
crt2.o care nu conține un handler de vector de resetare a procesorului. Acest lucru este potrivit
pentru a transfera controlul asupra unui procesor resetat la bootloader, mai degrabă decât la
aplicație.

novectori
pentru aplicații care nu necesită niciun vector MicroBlaze. Această opțiune
poate fi util pentru aplicațiile care rulează într-o aplicație de monitorizare. Acest model
utilizări crt3.o ca fișier de pornire.

Opțiune -modul-xl-modelul aplicației este un alias depreciat pentru -mxl-mode-modelul aplicației.

MIPS Opţiuni

-EB Generați cod big-endian.

-CE Generați cod little-endian. Aceasta este valoarea implicită pentru mips*el-*-* configurații.

-martie=arc
Generați codul care rulează arc, care poate fi numele unui MIPS ISA generic sau
numele unui anumit procesor. Numele ISA sunt: mips1, mips2, mips3, mips4,
mips32, mips32r2, mips64 și mips64r2. Numele procesorului sunt: 4kc, 4km, 4kp, 4ksc,
4kec, 4kem, 4kep, 4ksd, 5kc, 5kf, 20kc, 24kc, 24kf2_1, 24kf1_1, 24kec, 24kef2_1,
24kef1_1, 34kc, 34kf2_1, 34kf1_1, 34kn, 74kc, 74kf2_1, 74kf1_1, 74kf3_2, 1004kc,
1004kf2_1, 1004kf1_1, loongson2e, loongson2f, loongson3a, M4K, M14K, m14kc, m14ke,
m14kec, octeon, octeon+, octeon2, orion, r2000, r3000, r3900, r4000, r4400, r4600,
r4650, r4700, r6000, r8000, rm7000, rm9000, r10000, r12000, r14000, r16000, sb1,
sr71000, vr4100, vr4111, vr4120, vr4130, vr4300, vr5000, vr5400, vr5500, xlr și XLP.
Valoarea specială din-abi selectează cea mai compatibilă arhitectură pentru cea selectată
ABI (adică mips1 pentru ABI-uri pe 32 de biți și mips3 pentru ABI-uri pe 64 de biți).

Lanțul de instrumente nativ Linux/GNU acceptă, de asemenea, valoarea nativ, care selectează cel mai bun
opțiune de arhitectură pentru procesorul gazdă. -martie=nativ nu are niciun efect dacă GCC are
nu recunosc procesorul.

În numele procesoarelor, o finală 000 poate fi prescurtat ca k (de exemplu, -martie=r2k).
Prefixele sunt opționale și vr poate fi scris r.

Numele formularului nf2_1 referiți-vă la procesoare cu FPU tactate la jumătate din rata
nucleu, nume ale formei nf1_1 referiți-vă la procesoare cu FPU tactate la aceeași rată
ca nucleu și numele formei nf3_2 referiți-vă la procesoare cu FPU-uri tactate la un raport
de 3:2 în raport cu miezul. Din motive de compatibilitate, nf este acceptat ca a
sinonim pentru nf2_1 în timp ce nx și bfx sunt acceptate ca sinonime pentru nf1_1.

GCC definește două macrocomenzi pe baza valorii acestei opțiuni. Primul este _MIPS_ARCH,
care dă numele arhitecturii țintă, ca șir. Al doilea are forma
_MIPS_ARCH_foo, În cazul în care foo este valoarea capitalizată a _MIPS_ARCH. De exemplu,
-martie=r2000 seturi _MIPS_ARCH la "r2000" și definește macro-ul _MIPS_ARCH_R2000.

Rețineți că _MIPS_ARCH macro folosește numele de procesor date mai sus. Cu alte cuvinte,
are prefixul complet și nu abreviază 000 as k. În cazul în care din-abi,
macro denumește arhitectura rezolvată (fie "mips1" or "mips3"). Îl numește pe
arhitectura implicită când nu -Martie este dată opțiunea.

-mtune=arc
Optimizați pentru arc. Printre altele, această opțiune controlează modul în care sunt instrucțiunile
programate și costul perceput al operațiilor aritmetice. Lista de arc Valorile
este la fel ca pentru -Martie.

Când această opțiune nu este utilizată, GCC se optimizează pentru procesorul specificat de -Martie. De
folosind -Martie și -mtune împreună, este posibil să generați cod care rulează pe a
familie de procesoare, dar optimizați codul pentru un anumit membru al acelei familii.

-mtune definește macro-urile _MIPS_TUNE și _MIPS_TUNE_foo, care funcționează în același mod ca
il -Martie cele descrise mai sus.

-mips1
Echivalentă cu -march=mips1.

-mips2
Echivalentă cu -march=mips2.

-mips3
Echivalentă cu -march=mips3.

-mips4
Echivalentă cu -march=mips4.

-mips32
Echivalentă cu -march=mips32.

-mips32r2
Echivalentă cu -march=mips32r2.

-mips64
Echivalentă cu -march=mips64.

-mips64r2
Echivalentă cu -march=mips64r2.

-mips16
-mno-mips16
Generați (nu generați) codul MIPS16. Dacă GCC vizează un MIPS32 sau MIPS64
arhitectură, folosește MIPS16e ASE.

Generarea codului MIPS16 poate fi, de asemenea, controlată pe bază de funcție prin intermediul
atributele „mips16” și „nomips16”.

-mflip-mips16
Generați cod MIPS16 pe funcții alternative. Această opțiune este oferită pentru regresie
testarea generării mixte de cod MIPS16/non-MIPS16 și nu este destinată pentru obișnuit
utilizat la compilarea codului utilizatorului.

-minterlink-comprimat
-mno-interlink-comprimat
Solicitați (nu necesită) ca codul folosind standardul (necomprimat) MIPS ISA să fie conectat-
compatibil cu codul MIPS16 și microMIPS și invers.

De exemplu, codul care utilizează codarea standard ISA nu poate sări direct la MIPS16 sau
cod microMIPS; trebuie să folosească fie un apel, fie un salt indirect. -minterlink-comprimat
prin urmare, dezactivează săriturile directe, cu excepția cazului în care GCC știe că ținta săriturii nu este
comprimat.

-minterlink-mips16
-mno-interlink-mips16
Pseudintele de -minterlink-comprimat și -mno-interlink-comprimat. Aceste opțiuni
preced microMIPS ASE și sunt păstrate pentru compatibilitate inversă.

-mabi=32
-mabi=o64
-mabi=n32
-mabi=64
-mabi=eabi
Generați codul pentru ABI-ul dat.

Rețineți că EABI are o variantă pe 32 de biți și una pe 64 de biți. GCC generează în mod normal 64 de biți
cod atunci când selectați o arhitectură pe 64 de biți, dar puteți utiliza -mgp32 pentru a obține codul pe 32 de biți
in schimb.

Pentru informații despre O64 ABI, consultațihttp://gcc.gnu.org/projects/mipso64-abi.html>.

GCC acceptă o variantă a ABI o32 în care registrele în virgulă mobilă sunt mai degrabă 64
lățime de peste 32 de biți. Puteți selecta această combinație cu -mabi=32 -mfp64. Acest ABI
se bazează pe instrucțiunile „mthc1” și „mfhc1” și, prin urmare, este acceptat numai pentru
procesoare MIPS32R2.

Atribuțiile de registru pentru argumente și valorile returnate rămân aceleași, dar fiecare
Valoarea scalară este transmisă într-un singur registru de 64 de biți, mai degrabă decât într-o pereche de 32 de biți
registre. De exemplu, valorile scalare în virgulă mobilă sunt returnate în $f0 numai, nu a
$f0/$f1 pereche. Setul de registre salvate pentru apeluri rămâne, de asemenea, același, dar toți cei 64 de biți
sunt salvati.

-mabicals
-mno-abicalls
Generați (nu generați) cod care este potrivit pentru obiectele dinamice în stil SVR4.
-mabicals este valoarea implicită pentru sistemele bazate pe SVR4.

-mshared
-mno-shared
Generați (nu generați) cod care este complet independent de poziție și care poate
prin urmare, să fie conectate la biblioteci partajate. Această opțiune afectează doar -mabicals.

Toate -mabicals codul a fost în mod tradițional independent de poziție, indiferent de opțiuni
ca -fPIC și -fpic. Cu toate acestea, ca extensie, lanțul de instrumente GNU permite executabile
pentru a utiliza accesuri absolute pentru simboluri obligatorii la nivel local. De asemenea, poate folosi GP mai scurt
secvențe de inițializare și generează apeluri directe către funcții definite local. Acest
modul este selectat de -mno-shared.

-mno-shared depinde de binutils 2.16 sau mai mare și generează obiecte care pot fi doar
legat de linkerul GNU. Totuși, opțiunea nu afectează ABI-ul finalei
executabil; afectează doar ABI-ul obiectelor relocabile. Folosind -mno-shared
în general, face executabilele atât mai mici, cât și mai rapide.

-mshared este implicit.

-mplt
-mno-plt
Să presupunem (nu să presupunem) că linkerii statici și dinamici acceptă PLT-uri și copiere
relocari. Această opțiune afectează doar -mno-shared -mabicals. Pentru n64 ABI, aceasta
opțiunea nu are efect fără -msym32.

Puteți face -mplt implicit prin configurarea GCC cu --cu-mips-plt. Implicit
is -mno-plt in caz contrar.

-mxgot
-mno-xgot
Ridicați (nu ridicați) restricțiile obișnuite privind dimensiunea tabelului global de compensare.

GCC utilizează în mod normal o singură instrucțiune pentru a încărca valori din GOT. În timp ce aceasta este
relativ eficient, funcționează doar dacă GOT-ul este mai mic de aproximativ 64k. Orice
mai mare determină linker-ul să raporteze o eroare, cum ar fi:

relocare trunchiată pentru a se potrivi: R_MIPS_GOT16 foobar

Dacă se întâmplă acest lucru, ar trebui să recompilați codul cu -mxgot. Acest lucru funcționează cu foarte
GOT-uri mari, deși codul este și mai puțin eficient, deoarece este nevoie de trei
instrucțiuni pentru a prelua valoarea unui simbol global.

Rețineți că unele linkere pot crea mai multe GOT-uri. Dacă ai un astfel de linker, tu
ar trebui doar să fie utilizat -mxgot când un singur fișier obiect accesează mai mult de 64k
în valoare de intrări GOT. Foarte puțini fac.

Aceste opțiuni nu au efect decât dacă GCC generează cod independent de poziție.

-mgp32
Să presupunem că registrele de uz general au o lățime de 32 de biți.

-mgp64
Să presupunem că registrele de uz general au o lățime de 64 de biți.

-mfp32
Să presupunem că registrele în virgulă mobilă au o lățime de 32 de biți.

-mfp64
Să presupunem că registrele în virgulă mobilă au o lățime de 64 de biți.

-mhard-float
Utilizați instrucțiuni pentru coprocesor în virgulă mobilă.

-msoft-float
Nu utilizați instrucțiuni pentru coprocesor în virgulă mobilă. Implementați virgulă mobilă
calcule folosind în schimb apeluri de bibliotecă.

-mno-float
Echivalentă cu -msoft-float, dar în plus afirmă că programul este compilat
nu efectuează operații în virgulă mobilă. Această opțiune este acceptată în prezent
numai prin unele configurații MIPS bare-metal, unde poate selecta un set special de
bibliotecile cărora le lipsește tot suportul pentru virgulă mobilă (inclusiv, de exemplu,
formate „printf” de puncte). Dacă codul compilat cu „-mno-float” conține accidental
operațiuni în virgulă mobilă, este probabil să sufere o eroare de legătură sau de rulare.

-msingle-float
Să presupunem că coprocesorul în virgulă mobilă acceptă numai operații cu precizie unică.

-mdouble-float
Să presupunem că coprocesorul în virgulă mobilă acceptă operații cu precizie dublă. Acest
este implicit.

-mabs=2008
-mabs=moştenire
Aceste opțiuni controlează tratamentul IEEE 754 special not-a-number (NaN).
date în virgulă mobilă cu „abs.fmt" și „neg.fmt" instrucțiunile mașinii.

Implicit sau când -mabs=moştenire este utilizat tratamentul moștenire este selectat. In acest
în cazul în care aceste instrucțiuni sunt considerate aritmetice și evitate atunci când sunt operate corect
este necesar și operandul de intrare ar putea fi un NaN. O secvență mai lungă de instrucțiuni
care manipulează manual bitul de semn al datei în virgulă mobilă este folosit în schimb, cu excepția cazului în care
il -finit-doar matematică a fost specificată și opțiunea.

-mabs=2008 opțiunea selectează tratamentul IEEE 754-2008. În acest caz acestea
instrucțiunile sunt considerate non-aritmetice și, prin urmare, funcționează corect în toate
cazuri, inclusiv în special în cazul în care operandul de intrare este un NaN. Aceste instrucțiuni
sunt deci întotdeauna folosite pentru operațiunile respective.

-mnan=2008
-mnan=moștenire
Aceste opțiuni controlează codificarea IEEE 754 special not-a-number (NaN).
date în virgulă mobilă.

-mnan=moștenire opțiunea selectează codificarea moștenită. În acest caz, NaN liniștiți (qNaN)
sunt notate cu primul bit al câmpului lor semnificant final fiind 0, în timp ce
NaN-urile de semnalizare (sNaNs) sunt notate cu primul bit al semnificației lor finale
câmpul fiind 1.

-mnan=2008 opțiunea selectează codificarea IEEE 754-2008. În acest caz, qNaN-urile sunt
notat cu primul bit al câmpului lor semnificativ de final fiind 1, în timp ce sNaNs
sunt notate cu primul bit al câmpului lor semnificant final fiind 0.

Valoarea implicită este -mnan=moștenire cu excepția cazului în care GCC a fost configurat cu --with-nan=2008.

-mllsc
-mno-llsc
Utilizați (nu folosiți) ll, sc, și sincronizaţi instrucțiuni pentru implementarea memoriei atomice încorporate
funcții. Când nicio opțiune nu este specificată, GCC folosește instrucțiunile dacă țintă
arhitectura le susține.

-mllsc este util dacă mediul de rulare poate emula instrucțiunile și -mno-llsc
poate fi util la compilarea pentru ISA-uri nestandard. Puteți face oricare dintre opțiunile
implicit prin configurarea GCC cu --cu-llsc și --fără-llsc respectiv.
--cu-llsc este implicit pentru unele configurații; consultați documentația de instalare
pentru detalii.

-mdsp
-mno-dsp
Utilizați (nu utilizați) versiunea 1 a MIPS DSP ASE.
Această opțiune definește macrocomanda preprocesorului __mips_dsp. De asemenea, definește
__mips_dsp_rev la 1.

-mdspr2
-mno-dspr2
Utilizați (nu utilizați) versiunea 2 a MIPS DSP ASE.
Această opțiune definește macrocomenzile preprocesorului __mips_dsp și __mips_dspr2. De asemenea
definește __mips_dsp_rev la 2.

-msmartmips
-mno-smartmips
Utilizați (nu utilizați) MIPS SmartMIPS ASE.

-persoană-singure
-mno-pereche-singure
Folosiți (nu utilizați) instrucțiuni în virgulă mobilă pereche.
Această opțiune necesită ca suportul hardware în virgulă mobilă să fie activat.

-mdmx
-mno-mdmx
Utilizați (nu utilizați) instrucțiunile MIPS Digital Media Extension. Această opțiune poate fi doar
utilizat la generarea codului pe 64 de biți și necesită suport hardware în virgulă mobilă
activat.

-mips3d
-mno-mips3d
Utilizați (nu utilizați) MIPS-3D ASE. Optiunea -mips3d implică -persoană-singure.

-micromips
-mno-micromips
Generați (nu generați) cod microMIPS.

Generarea codului MicroMIPS poate fi, de asemenea, controlată pe bază de funcție prin intermediul
atributele „micromips” și „nomicromips”.

-mmt
-mno-mt
Folosiți (nu folosiți) instrucțiuni MT Multithreading.

-mmcu
-mno-mcu
Utilizați (nu utilizați) instrucțiunile MIPS MCU ASE.

-meva
-mno-eva
Utilizați (nu utilizați) instrucțiunile MIPS Enhanced Virtual Addressing.

-mvirt
-mno-virt
Utilizați (nu utilizați) instrucțiunile specifice aplicației de virtualizare MIPS.

-mlong64
Forțați tipurile „lungi” să aibă o lățime de 64 de biți. Vedea -mlong32 pentru o explicație a implicită
și modul în care este determinată dimensiunea indicatorului.

-mlong32
Forțați tipurile „long”, „int” și pointer să aibă o lățime de 32 de biți.

Mărimea implicită a „int”, „long” și pointers depinde de ABI. Toate
ABI-urile acceptate folosesc „int”-uri pe 32 de biți. N64 ABI folosește „lungi” pe 64 de biți, la fel ca și pe 64 de biți
EABI; ceilalți folosesc „lungi” de 32 de biți. Indicatoarele au aceeași dimensiune ca cele „lungi” sau
aceeași dimensiune ca registrele întregi, oricare dintre acestea este mai mică.

-msym32
-mno-sym32
Să presupunem (nu să presupunem) că toate simbolurile au valori de 32 de biți, indiferent de cele selectate
ABI. Această opțiune este utilă în combinație cu -mabi=64 și -mno-abicalls deoarece
permite GCC să genereze referințe mai scurte și mai rapide la adrese simbolice.

-G o
Puneți definițiile datelor vizibile extern într-o secțiune mică de date dacă datele respective sunt nu
mai mare ca o octeți. GCC poate genera apoi accesări mai eficiente la date; vedea
-mgpopt pentru detalii.

Valoarea implicită -G opțiunea depinde de configurație.

-mlocal-sdata
-mno-local-sdata
Extindeți (nu extindeți) -G comportament și la datele locale, cum ar fi variabilele statice
în C. -mlocal-sdata este implicit pentru toate configurațiile.

Dacă linkerul se plânge că o aplicație folosește prea multe date mici, s-ar putea
vrei să încerci să reconstruiești părțile mai puțin critice pentru performanță cu -mno-local-sdata. Tu
ar putea dori, de asemenea, să construiți biblioteci mari cu -mno-local-sdata, astfel încât bibliotecile
lăsați mai mult loc pentru programul principal.

-mextern-sdata
-mno-extern-sdata
Să presupunem (nu presupuneți) că datele definite extern sunt într-o secțiune mică de date dacă
dimensiunea acestor date este în -G limită. -mextern-sdata este implicit pentru toți
configurații.

Dacă compilați un modul Mod cu -mextern-sdata -G o -mgpopt, și Mod referințe a
variabil Fiecare care nu este mai mare decât o octeți, trebuie să vă asigurați că Fiecare este pus
într-o mică secțiune de date. Dacă Fiecare este definit de alt modul, trebuie fie să compilați
acel modul cu un suficient de mare -G setarea sau atașarea unui atribut „secțiune” la Fiecare's
definiție. Dacă Fiecare este obișnuit, trebuie să conectați aplicația cu un nivel suficient de mare -G
setare.

Cel mai simplu mod de a satisface aceste restricții este să compilați și să legați fiecare modul
cu aceeași -G opțiune. Cu toate acestea, poate doriți să construiți o bibliotecă care să accepte
mai multe limite diferite de date mici. Puteți face acest lucru compilând biblioteca cu
cel mai sus sprijinit -G setarea și utilizarea suplimentară -mno-extern-sdata pentru a opri
bibliotecă de a face ipoteze despre datele definite extern.

-mgpopt
-mno-gpopt
Folosiți (nu utilizați) accesări legate de GP pentru simboluri despre care se știe că sunt într-o date mică
secțiune; vedea -G, -mlocal-sdata și -mextern-sdata. -mgpopt este implicit pentru toți
configurații.

-mno-gpopt este util pentru cazurile în care registrul $gp ar putea să nu dețină valoarea
„_gp”. De exemplu, dacă codul face parte dintr-o bibliotecă care ar putea fi folosită într-un boot
monitor, programele care apelează rutine de monitorizare de pornire trec o valoare necunoscută în $gp. (În
astfel de situații, monitorul de pornire în sine este de obicei compilat -G0.)

-mno-gpopt implică -mno-local-sdata și -mno-extern-sdata.

-date-membrate
-mno-date-încorporate
Alocați mai întâi variabile secțiunii de date numai în citire, dacă este posibil, apoi apoi în
secțiune mică de date dacă este posibil, altfel în date. Acest lucru oferă un cod ușor mai lent
decât implicit, dar reduce cantitatea de RAM necesară la execuție și, prin urmare, poate
fi preferat pentru unele sisteme încorporate.

-muninit-const-in-rodata
-mno-uninit-const-in-rodata
Puneți variabile „const” neinițializate în secțiunea de date numai pentru citire. Această opțiune este
semnificativ numai în legătură cu -date-membrate.

-mcode-readable=instalare
Specificați dacă GCC poate genera cod care se citește din secțiuni executabile. Sunt
trei setari posibile:

-mcode-readable=da
Instrucțiunile pot accesa liber secțiuni executabile. Aceasta este setarea implicită.

-mcode-readable=pcrel
Instrucțiunile de încărcare MIPS16 referitoare la PC pot accesa secțiuni executabile, dar altele
instrucțiunile nu trebuie să facă acest lucru. Această opțiune este utilă pe procesoarele 4KSc și 4KSd
când codurile TLB au setat bitul de inhibare citire. Este util și pe procesoare
care poate fi configurat să aibă o interfață SRAM duală de instrucțiuni/date și că,
la fel ca M4K, redirecționează automat încărcările legate de PC către RAM de instrucțiuni.

-mcode-readable=nu
Instrucțiunile nu trebuie să acceseze secțiunile executabile. Această opțiune poate fi utilă pe
ținte care sunt configurate să aibă o interfață SRAM duală de instrucțiuni/date dar
care (spre deosebire de M4K) nu redirecționează automat încărcăturile legate de PC către
RAM de instrucțiuni.

-msplit-adrese
-mno-split-adrese
Activați (dezactivați) utilizarea operatorilor de relocare a asamblatorului „%hi()” și „%lo()”. Acest
opțiunea a fost înlocuită de -mexplicit-relocs dar este reținută pentru înapoi
compatibilitate.

-mexplicit-relocs
-mno-explicite-relocs
Folosiți (nu folosiți) operatori de relocare a asamblatorului atunci când aveți de-a face cu adrese simbolice.
Alternativa, selectată de -mno-explicite-relocs, este să folosiți în schimb macrocomenzi de asamblare.

-mexplicit-relocs este implicit dacă GCC a fost configurat să folosească un asamblator care
sprijină operatorii de relocare.

-mcheck-zero-diviziune
-mno-verificare-zero-diviziune
Capcană (nu captează) pe împărțirea întregului cu zero.

Valoarea implicită este -mcheck-zero-diviziune.

-mdivide-capcane
-mdivide-pauze
Sistemele MIPS verifică diviziunea la zero generând fie o capcană condiționată, fie a
instrucțiuni de pauză. Utilizarea capcanelor are ca rezultat un cod mai mic, dar este acceptat numai pe MIPS
II și mai târziu. De asemenea, unele versiuni ale nucleului Linux au o eroare care previne capcana
de la generarea semnalului adecvat ("SIGFPE"). Utilizare -mdivide-capcane pentru a permite condițional
capcane pe arhitecturi care le susțin și -mdivide-pauze a forţa folosirea
pauze.

Valoarea implicită este de obicei -mdivide-capcane, dar aceasta poate fi suprascrisă la momentul configurării
folosind --cu-divide=se întrerupe. Verificările împărțite la zero pot fi complet dezactivate folosind
-mno-verificare-zero-diviziune.

-mmemcpy
-mno-memcpy
Forțați (nu forțați) utilizarea lui „memcpy()” pentru mișcări de bloc non-triviale. Implicit
is -mno-memcpy, care permite GCC să integreze majoritatea copiilor de dimensiune constantă.

-mlong-apeluri
-mno-lung-apeluri
Dezactivați (nu dezactivați) utilizarea instrucțiunii „jal”. Apelarea funcțiilor folosind „jal”
este mai eficient, dar necesită ca apelantul și apelantul să fie în același 256 de megaocteți
segment.

Această opțiune nu are efect asupra codului abicals. Valoarea implicită este -mno-lung-apeluri.

-mmad
-mno-nebun
Activați (dezactivați) utilizarea instrucțiunilor „mad”, „madu” și „mul”, așa cum sunt furnizate de
R4650 ISA.

-mimadd
-mno-imadd
Activați (dezactivați) utilizarea instrucțiunilor întregi „madd” și „msub”. Valoarea implicită este
-mimadd pe arhitecturi care acceptă „madd” și „msub”, cu excepția celor 74k
arhitectura în care sa constatat că generează cod mai lent.

-mfused-madd
-mno-fuzionat-madd
Activați (dezactivați) utilizarea instrucțiunilor de multiplicare-acumulare în virgulă mobilă, atunci când acestea
Sunt disponibile. Valoarea implicită este -mfused-madd.

Pe CPU R8000, când sunt utilizate instrucțiuni de multiplicare-acumulare, intermediarul
produsul este calculat cu o precizie infinită și nu este supus la FCSR Flush to
Bit zero. Acest lucru poate fi nedorit în anumite circumstanțe. Pe alte procesoare
rezultatul este numeric identic cu calculul echivalent folosind înmulțirea separată,
adunați, scădeți și anulați instrucțiuni.

-nocpp
Spune-i asamblatorului MIPS să nu ruleze preprocesorul peste fișierele de asamblare utilizator (cu a
.s sufix) la asamblarea acestora.

-mfix-24k
-mno-fix-24k
Rezolvați errata 24K E48 (date pierdute în magazine în timpul reumplerii). Soluțiile alternative
sunt implementate de asamblator mai degrabă decât de GCC.

-mfix-r4000
-mno-fix-r4000
Soluționați anumite erori ale procesorului R4000:

- Un cuvânt dublu sau o schimbare variabilă poate da un rezultat incorect dacă este executat
imediat după începerea unei diviziuni întregi.

- Un cuvânt dublu sau o schimbare variabilă poate da un rezultat incorect dacă este executat în timp ce
o înmulțire a întregului este în curs.

- O diviziune întreagă poate da un rezultat incorect dacă este începută într-un interval de întârziere de a
luată ramură sau un salt.

-mfix-r4400
-mno-fix-r4400
Soluționați anumite erori ale procesorului R4400:

- Un cuvânt dublu sau o schimbare variabilă poate da un rezultat incorect dacă este executat
imediat după începerea unei diviziuni întregi.

-mfix-r10000
-mno-fix-r10000
Soluționați anumite erori R10000:

- Secvențele "ll"/"sc" pot să nu se comporte atomic la revizuirile anterioare 3.0. Ar putea
blocaj la versiunile 2.6 și anterioare.

Această opțiune poate fi utilizată numai dacă arhitectura țintă acceptă ramura probabilă
instructiuni. -mfix-r10000 este implicit când -martie=r10000 este folosit; -mno-fix-r10000
este implicit în caz contrar.

-mfix-rm7000
-mno-fix-rm7000
Lucrați în jurul erorii „dmult”/“dmultu” RM7000. Soluțiile sunt implementate de
asamblatorul mai degrabă decât de către GCC.

-mfix-vr4120
-mno-fix-vr4120
Soluționați anumite erori VR4120:

- „dmultu” nu produce întotdeauna rezultatul corect.

- „div” și „ddiv” nu produc întotdeauna rezultatul corect dacă unul dintre operanzi
este negativ.

Soluțiile pentru diviziunea errata se bazează pe funcții speciale în libgcc.a. La
prezente, aceste funcții sunt furnizate doar de configurațiile „mips64vr*-elf”.

Alte errate VR4120 necesită inserarea unui NOP între anumite perechi de
instrucțiuni. Aceste errate sunt gestionate de asamblator, nu de GCC în sine.

-mfix-vr4130
Lucrați cu errata VR4130 „mflo”/“mfhi”. Soluțiile sunt implementate de către
asamblator mai degrabă decât de către GCC, deși GCC evită utilizarea „mflo” și „mfhi” dacă
În schimb, sunt disponibile instrucțiuni VR4130 „macc”, „macchi”, „dmacc” și „dmacchi”.

-mfix-sb1
-mno-fix-sb1
Soluționați anumite erori de bază ale procesorului SB-1. (Acest steag funcționează în prezent în jurul SB-1
revizuirea 2 „F1” și „F2” errata în virgulă mobilă.)

-mr10k-cache-barrier=instalare
Specificați dacă GCC ar trebui să insereze bariere cache pentru a evita efectele secundare ale
speculații asupra procesoarelor R10K.

În comun cu multe procesoare, R10K încearcă să prezică rezultatul unui condițional
ramură și execută în mod speculativ instrucțiuni din ramura „luată”. Mai târziu
anulează aceste instrucțiuni dacă rezultatul prezis este greșit. Cu toate acestea, pe R10K,
chiar și instrucțiunile avortate pot avea efecte secundare.

Această problemă afectează doar depozitele de kernel și, în funcție de sistem, încărcările kernel-ului.
De exemplu, un magazin executat în mod speculativ poate încărca memoria țintă în cache
și marcați linia cache ca murdară, chiar dacă magazinul în sine este anulat ulterior. Dacă un DMA
operațiunea scrie în aceeași zonă de memorie înainte ca linia „murdară” să fie ștersă
datele din cache suprascrie datele DMA-ed. Consultați manualul procesorului R10K pentru o informație completă
descriere, inclusiv alte probleme potențiale.

O soluție este să inserați instrucțiuni de barieră cache înainte de fiecare acces la memorie
ar putea fi executat în mod speculativ și care ar putea avea efecte secundare chiar dacă este avortat.
-mr10k-cache-barrier=instalare controlează implementarea de către GCC a acestei soluții. Aceasta
presupune că accesul anulat la orice octet din următoarele regiuni nu are latură
efecte:

1. memoria ocupată de cadrul stivă al funcției curente;

2. memoria ocupată de un argument de stivă de intrare;

3. memoria ocupată de un obiect cu o adresă constantă în timp de legătură.

Este responsabilitatea nucleului să asigure accesul speculativ în aceste regiuni
sunt într-adevăr în siguranță.

Dacă programul de intrare conține o declarație de funcție, cum ar fi:

void foo (void);

atunci implementarea lui „foo” trebuie să permită executarea „j foo” și „jal foo”.
în mod speculativ. GCC respectă această restricție pentru funcțiile pe care le compilează singur. Aceasta
se așteaptă ca funcțiile non-GCC (cum ar fi codul de asamblare scris de mână) să facă același lucru.

Opțiunea are trei forme:

-mr10k-cache-barrier=magazin-încărcare
Introduceți o barieră de cache înainte de încărcare sau stocare care ar putea fi executată în mod speculativ
și asta ar putea avea efecte secundare chiar dacă este avortat.

-mr10k-cache-barrier=magazin
Introduceți o barieră cache înaintea unui magazin care ar putea fi executat în mod speculativ și
care ar putea avea efecte secundare chiar dacă este avortat.

-mr10k-cache-barrier=niciunul
Dezactivați inserarea barierelor cache. Aceasta este setarea implicită.

-mflush-func=FUNC
-mno-flush-func
Specifică funcția de apelat pentru a șterge cache-urile I și D sau pentru a nu apela niciuna dintre acestea
funcţie. Dacă este apelată, funcția trebuie să ia aceleași argumente ca și comuna
„_flush_func()”, adică adresa intervalului de memorie pentru care se află memoria cache
golite, dimensiunea intervalului de memorie și numărul 3 (pentru a goli ambele cache). The
implicit depinde de destinația GCC pentru care a fost configurat, dar de obicei este oricare
_flush_func or __cpu_flush.

mbranch-cost=o
Setați costul sucursalelor la aproximativ o instrucțiuni „simple”. Acest cost este doar a
euristic și nu se garantează că va produce rezultate consistente între versiuni. Un zero
cost selectează în mod redundant valoarea implicită, care se bazează pe -mtune setare.

-branch-probabil
-mno-ramură-probabilă
Activați sau dezactivați utilizarea instrucțiunilor Branch Likely, indiferent de valoarea implicită pentru
arhitectura selectata. În mod implicit, instrucțiunile Branch Likely pot fi generate dacă
sunt susținute de arhitectura selectată. O excepție este pentru MIPS32 și
arhitecturi MIPS64 și procesoare care implementează acele arhitecturi; pentru cei,
Instrucțiunile Branch Likely nu sunt generate implicit, deoarece MIPS32 și
Arhitecturile MIPS64 își depreciază în mod specific utilizarea.

-mfp-excepții
-mno-fp-excepții
Specifică dacă sunt activate excepțiile FP. Acest lucru afectează modul în care sunt instrucțiunile FP
programat pentru unele procesoare. Valoarea implicită este că excepțiile FP sunt activate.

De exemplu, pe SB-1, dacă excepțiile FP sunt dezactivate și emitem 64 de biți
cod, atunci putem folosi ambele conducte FP. În caz contrar, putem folosi doar o țeavă FP.

-mvr4130-align
-mno-vr4130-align
Conducta VR4130 este superscalar în două sensuri, dar poate emite doar două instrucțiuni
împreună dacă primul este aliniat pe 8 octeți. Când această opțiune este activată, GCC se aliniază
perechi de instrucțiuni despre care consideră că ar trebui să le execute în paralel.

Această opțiune are efect numai la optimizarea pentru VR4130. În mod normal, face cod
mai rapid, dar în detrimentul de a-l face mai mare. Este activat implicit la
nivelul de optimizare -O3.

-msynci
-mno-synci
Activați (dezactivați) generarea de instrucțiuni „synci” pe arhitecturile care o acceptă.
Instrucțiunile „synci” (dacă sunt activate) sunt generate când „__builtin___clear_cache()”
este compilat.

Această opțiune este implicită „-mno-synci”, dar implicit poate fi suprascrisă prin configurare
cu „--cu-synci”.

La compilarea codului pentru sisteme cu un singur procesor, este, în general, sigur să folosiți „synci”.
Cu toate acestea, pe multe sisteme multi-core (SMP), aceasta nu invalidează instrucțiunea
memorează cache pe toate nucleele și poate duce la un comportament nedefinit.

-mrelax-pic-calls
-mno-relax-pic-calls
Încercați să transformați apelurile PIC care sunt în mod normal trimise prin intermediul unui registru de 25 USD în apeluri directe.
Acest lucru este posibil numai dacă linkerul poate rezolva destinația la momentul link-ului și dacă
destinația se află în raza de acțiune pentru un apel direct.

-mrelax-pic-calls este valoarea implicită dacă GCC a fost configurat să utilizeze un asamblator și a
linkerul care acceptă directiva de asamblare „.reloc” și „-mexplicit-relocs” este în
efect. Cu „-mno-explicit-relocs”, această optimizare poate fi efectuată de către
asamblatorul și linkerul singuri, fără ajutorul compilatorului.

-mmcount-ra-adresă
-mno-mcount-ra-adresa
Emite (nu emite) cod care permite „_mcount” să modifice returnarea funcției de apelare
abordare. Când este activată, această opțiune extinde interfața obișnuită „_mcount” cu o interfață nouă
ra-adresa parametru, care are tipul „intptr_t *” și este trecut în registrul $12.
„_mcount” poate modifica apoi adresa de retur făcând ambele următoarele:

· Returnarea noii adrese în registru $31.

· Stocarea noii adrese în „*adresa-ra", dacă ra-adresa este nenulă.

Valoarea implicită este -mno-mcount-ra-adresa.

MMIX Opţiuni

Aceste opțiuni sunt definite pentru MMIX:

-mlibfuncs
-mno-libfuncs
Specificați că funcțiile intrinseci ale bibliotecii sunt compilate, trecând toate valorile
registre, indiferent de dimensiune.

-mepsilon
-mno-epsilon
Generați instrucțiuni de comparare în virgulă mobilă care se compară cu „rE”
registru epsilon.

-mabi=mmixware
-mabi=gnu
Generați cod care transmite parametrii funcției și returnează valori care (în fișierul apelat
funcția) sunt văzute ca registre $0 și mai sus, spre deosebire de GNU ABI care folosește global
înregistrează 231 USD și mai mult.

-mzero-extinde
-mno-zero-extinde
Când citiți date din memorie cu dimensiuni mai mici de 64 de biți, utilizați (nu utilizați) zero-
extinderea instrucțiunilor de încărcare în mod implicit, mai degrabă decât cele de extindere a semnelor.

-mknuthdiv
-mno-knuthdiv
Faceți ca rezultatul unei diviziuni care dă un rest să aibă același semn ca și divizorul.
Cu implicit, -mno-knuthdiv, semnul restului urmează semnul lui
dividend. Ambele metode sunt valabile din punct de vedere aritmetic, cea din urmă fiind aproape exclusivă
folosit.

-mtoplevel-simboluri
-mno-toplevel-simboluri
Adăugați (nu adăugați) a : la toate simbolurile globale, astfel încât codul de asamblare poate fi utilizat
cu directiva de asamblare „PREFIX”.

-melf
Generați un executabil în format ELF, mai degrabă decât implicit mmo format folosit de
il mmix simulator.

-mbranch-predic
-mno-ramură-predic
Folosiți (nu folosiți) instrucțiunile de ramură probabilă, atunci când predicția de ramură statică
indică o ramură probabilă.

-base-adrese
-adrese-mno-bază
Generați (nu generați) codul care utilizează de bază adrese. Folosind o adresă de bază
generează automat o cerere (tratată de asamblator și linker) pentru a
constantă pentru a fi înființată într-un registru global. Registrul este utilizat pentru una sau mai multe baze
adresa cererilor în intervalul 0 la 255 de la valoarea deținută în registru. The
în general duce la cod scurt și rapid, dar numărul de elemente de date diferite care
poate fi abordat este limitat. Aceasta înseamnă că un program care utilizează o mulțime de date statice
ar putea necesita -adrese-mno-bază.

-msingle-exit
-mno-single-exit
Forțați (nu forțați) codul generat să aibă un singur punct de ieșire în fiecare funcție.

MN10300 Opţiuni

Acestea -m opțiunile sunt definite pentru arhitecturile Matsushita MN10300:

-mult-bug
Generați cod pentru a evita erorile în instrucțiunile de multiplicare pentru procesoarele MN10300.
Aceasta este valoarea implicită.

-mno-mult-bug
Nu generați cod pentru a evita erorile în instrucțiunile de multiplicare pentru MN10300
procesoare.

-mam33
Generați cod folosind caracteristici specifice procesorului AM33.

-mno-am33
Nu generați cod folosind funcții specifice procesorului AM33. Acesta este
Mod implicit.

-mam33-2
Generați cod folosind caracteristici specifice procesorului AM33/2.0.

-mam34
Generați cod folosind caracteristici specifice procesorului AM34.

-mtune=tip CPU
Utilizați caracteristicile de sincronizare ale tipului de CPU indicat atunci când programați instrucțiuni.
Acest lucru nu schimbă tipul de procesor vizat. Tipul CPU trebuie să fie unul dintre
mn10300, am33, am33-2 or am34.

-mreturn-pointer-on-d0
Când generați o funcție care returnează un pointer, returnați indicatorul atât în ​​„a0” cât și în
„d0”. În caz contrar, indicatorul este returnat numai în „a0” și încearcă să apeleze astfel
funcțiile fără prototip au ca rezultat erori. Rețineți că această opțiune este activată până la
Mod implicit; utilizare -mno-return pointer-on-d0 pentru ao dezactiva.

-mno-crt0
Nu conectați în fișierul obiect de inițializare în timpul rulării C.

-mrelaxează-te
Indicați linkerului la care ar trebui să efectueze o trecere de optimizare a relaxării
scurtează ramurile, apelurile și adresele de memorie absolută. Această opțiune are doar efect
atunci când este utilizat pe linia de comandă pentru pasul final de legătură.

Această opțiune face imposibilă depanarea simbolică.

-mliw
Permite compilatorului să genereze Lung instrucție Cuvânt instrucțiuni dacă ținta este
AM33 sau mai târziu. Aceasta este valoarea implicită. Această opțiune definește macrocomanda preprocesorului
__LIW__.

-mnoliw
Nu permiteți compilatorului să genereze Lung instrucție Cuvânt instrucțiuni. Această opțiune
definește macro-ul preprocesorului __NU_LIW__.

-msetlb
Permite compilatorului să genereze fișierul SETLB și Lcc instrucțiuni dacă ținta este
AM33 sau mai târziu. Aceasta este valoarea implicită. Această opțiune definește macrocomanda preprocesorului
__SETLB__.

-mnosetlb
Nu permiteți compilatorului să genereze SETLB or Lcc instrucțiuni. Această opțiune definește
macro-ul preprocesorului __NO_SETLB__.

Moxie Opţiuni

-meb
Generați cod big-endian. Aceasta este valoarea implicită pentru moxie-*-* configurații.

-mel
Generați cod little-endian.

-mno-crt0
Nu conectați în fișierul obiect de inițializare în timpul rulării C.

MSP430 Opţiuni

Aceste opțiuni sunt definite pentru MSP430:

-masm-hex
Forțați ieșirea ansamblului să folosească întotdeauna constante hexadecimale. În mod normal, astfel de constante sunt semnate
zecimale, dar această opțiune este disponibilă pentru teste și/sau scopuri estetice.

-mmcu=
Selectați MCU de vizat. Acesta este folosit pentru a crea un simbol de preprocesor C bazat pe
numele MCU, convertit în majuscule și pre- și post-fixat cu „__”. Aceasta în
turn va fi folosit de fișierul antet „msp430.h” pentru a selecta un MCU specific
fișier antet suplimentar.

Opțiunea setează, de asemenea, ISA de utilizat. Dacă numele MCU este unul cunoscut numai de către
acceptă 430 ISA, atunci acesta este selectat, în caz contrar 430X ISA este selectat. A
numele generic MCU „msp430” poate fi folosit și pentru a selecta 430 ISA. În mod similar, cel
numele generic „msp430x” MCU va selecta 430X ISA.

În plus, un script de linker specific MCU va fi adăugat la linia de comandă a linkerului.
Numele scriptului este numele MCU cu „.ld” adăugat. Precizând astfel
-mmcu=xxx pe linia de comandă gcc va defini simbolul preprocesorului C „__XXX__” și
determina linkerul să caute un script numit xxx.ld.

Această opțiune este, de asemenea, transmisă asamblatorului.

-mcpu=
Specifică ISA de utilizat. Valorile acceptate sunt „msp430”, „msp430x” și „msp430xv2”.
Această opțiune este depreciată. The -mmcu= ar trebui folosită opțiunea pentru a selecta ISA.

-msim
Link către bibliotecile de rulare a simulatorului și scriptul de linker. Ignoră orice script care
ar fi selectat de către -mmcu= opțiune.

-m mare
Utilizați adresarea modelului mare (indicatori de 20 de biți, „size_t”) pe 32 de biți.

-mmic
Utilizați adresarea modelului mic (indicatori de 16 biți, „size_t”) pe 16 biți.

-mrelaxează-te
Această opțiune este transmisă asamblatorului și linkerului și permite linkerului să funcționeze
anumite optimizări care nu se pot face până la linkul final.

mhwmult=
Descrie tipul de multiplicare hardware acceptată de țintă. Valorile acceptate sunt
„niciunul” pentru nicio înmulțire hardware, „16 biți” pentru multiplicarea inițială doar pe 16 biți
susținut de MCU-urile timpurii. „32 de biți” pentru multiplicarea pe 16/32 de biți acceptată de MCU-urile ulterioare
și „f5series” pentru multiplicarea pe 16/32 de biți acceptată de MCU-urile din seria F5. O valoare de
poate fi dat și „auto”. Aceasta îi spune GCC să deducă suportul de multiplicare hardware
pe baza numelui MCU furnizat de -mmcu opțiune. Daca nu -mmcu este specificată opțiunea
apoi se presupune suportul de multiplicare hardware „32 de biți”. „auto” este setarea implicită.

Înmulțirile hardware sunt în mod normal efectuate prin apelarea unei rutine de bibliotecă. Acest lucru salvează
spațiu în codul generat. Când compilați la „-O3” sau mai mare, totuși, hardware-ul
multiplicatorul este invocat inline. Acest lucru face un cod mai mare, dar mai rapid.

Rutinele de multiplicare hardware dezactivează întreruperile în timpul rulării și restaurează
starea anterioară de întrerupere când se termină. Acest lucru le face să fie folosite în siguranță în interior
gestionatorii de întreruperi, precum și în codul normal.

-minrt
Activați utilizarea unui mediu de rulare minim - fără inițializatoare statice sau
constructorii. Acesta este destinat dispozitivelor cu memorie limitată. Compilatorul va
include simboluri speciale în unele obiecte care spun linker-ului și runtime-ului care cod
sunt necesare fragmente.

NDS32 Opţiuni

Aceste opțiuni sunt definite pentru implementările NDS32:

-mbig-endian
Generați cod în modul big-endian.

-mlittle-endian
Generați cod în modul little-endian.

-mreducere-reg
Utilizați registre cu set redus pentru alocarea registrelor.

-mfull-regs
Utilizați registre complete pentru alocarea registrelor.

-mcmov
Generați instrucțiuni de mutare condiționată.

-mno-cmov
Nu generați instrucțiuni de mutare condiționată.

-mperf-ext
Generați instrucțiuni de extensie de performanță.

-mno-perf-ext
Nu generați instrucțiuni de extensie de performanță.

-mv3push
Generați instrucțiuni push3/pop25 v25.

-mno-v3push
Nu generați instrucțiuni push3/pop25 v25.

-m16-bit
Generați instrucțiuni pe 16 biți.

-mno-16-bit
Nu generați instrucțiuni pe 16 biți.

-mgp-direct
Generați direct instrucțiuni de bază GP.

-mno-gp-direct
Nu generați direct instrucțiuni de bază GP.

-misr-vector-size=o
Specificați dimensiunea fiecărui vector de întrerupere, care trebuie să fie 4 sau 16.

-mcache-block-size=o
Specificați dimensiunea fiecărui bloc de cache, care trebuie să fie o putere de 2 între 4 și 512.

-martie=arc
Specificați numele arhitecturii țintă.

-mforce-fp-as-gp
Preveniți alocarea $fp în timpul alocării registrului, astfel încât compilatorul să poată face acest lucru
forță care efectuează optimizarea fp-as-gp.

-mforbid-fp-as-gp
Interziceți utilizarea $fp pentru a accesa variabile statice și globale. Această opțiune interzice cu strictețe
optimizarea fp-as-gp indiferent de -mforce-fp-as-gp.

-mex9
Utilizați directive speciale pentru a ghida linker-ul în optimizarea ex9.

-mctor-dtor
Activați caracteristica constructor/destructor.

-mrelaxează-te
Ghid linker pentru a relaxa instrucțiuni.

NIOS II Opţiuni

Acestea sunt opțiunile definite pentru procesorul Altera Nios II.

-G o
Puneți obiecte globale și statice mai mici sau egale cu o octeți în datele mici sau
Secțiuni BSS în loc de secțiunile normale de date sau BSS. Valoarea implicită a o is
8.

-mgpopt
-mno-gpopt
Generați (nu generați) accesări legate de GP pentru obiectele din datele mici sau BSS
secțiuni. Valoarea implicită este -mgpopt cu excepția cazului în care -fpic or -fPIC este specificat pentru a genera
cod independent de poziție. Rețineți că Nios II ABI nu permite GP-relative
accese din biblioteci partajate.

Poate fi necesar să specificați -mno-gpopt explicit atunci când construiesc programe care includ
cantități mari de date mici, inclusiv secțiuni mari de date GOT. În acest caz,
Offset-ul de 16 biți pentru adresarea relativă GP poate să nu fie suficient de mare pentru a permite accesul la
întreaga secțiune de date mici.

-mel
-meb
Generați cod little-endian (implicit) sau, respectiv, big-endian (experimental).

-mbypass-cache
-mno-bypass-cache
Forțați toate instrucțiunile de încărcare și stocare să ocolească întotdeauna memoria cache folosind variantele I/O ale
instructiunile. Valoarea implicită este să nu ocolească memoria cache.

-mno-cache-volatil
-mcache-volatil
Accesul la memorie volatilă ocolește memoria cache folosind variantele I/O ale încărcării și stocării
instrucțiuni. Valoarea implicită este să nu ocolească memoria cache.

-mno-rapid-sw-div
-mfast-sw-div
Nu utilizați împărțirea rapidă bazată pe tabel pentru numere mici. Implicit este folosirea rapidului
împărți la -O3 Si mai sus.

-mno-hw-mul
-mhw-mul
-mno-hw-mulx
-mhw-mulx
-mno-hw-div
-mhw-div
Activați sau dezactivați emiterea familiei de instrucțiuni „mul”, „mulx” și „div” de către
compilator. Implicit este să emită „mul” și nu „div” și „mulx”.

-mpersonalizat-insn=N
-mno-personalizat-insn
Fiecare -mpersonalizat-insn=N opțiunea permite utilizarea unei instrucțiuni personalizate cu codificare N cand
generarea codului care utilizează insn. De exemplu, „-mcustom-fadds=253” generează personalizare
instrucțiunea 253 pentru operații de adăugare în virgulă mobilă cu precizie unică în loc de
comportament implicit de utilizare a unui apel de bibliotecă.

Următoarele valori ale insn sunt suportate. Cu excepția cazului în care se menționează altfel, virgulă mobilă
operațiunile sunt de așteptat să fie implementate cu semantică normală IEEE 754 și
corespund direct operatorilor C sau funcțiilor încorporate GCC echivalente.

virgulă mobilă cu precizie unică:

mofte, fsubs, fdivs, fmuls
Operații aritmetice binare.

fnegs
Negație unară.

fabss
Valoare absolută unară.

fcmpeqs, fcmpges, fcmpgts, fcmples, fcmplts, fcmpnes
Operatii de comparatie.

fmins, fmaxs
Minimum și maxim în virgulă flotantă. Aceste instrucțiuni sunt generate numai dacă
-finit-doar matematică este specificat.

fsqrts
Operație cu rădăcină pătrată unară.

fcoss, fsins, ftans, fatanilor, fexps, biciuri
Funcții trigonometrice și exponențiale în virgulă mobilă. Aceste instrucțiuni sunt
generat numai dacă -optimizări-funsafe-matematice este de asemenea specificat.

virgulă mobilă dublă precizie:

fadd, fsubd, fdivd, fmuld
Operații aritmetice binare.

fnegd
Negație unară.

fabsd
Valoare absolută unară.

fcmpeqd, fcmpged, fcmpgtd, fcmpled, fcmpltd, fcmpned
Operatii de comparatie.

fmind, fmaxd
Dublă precizie minimă și maximă. Aceste instrucțiuni sunt generate numai dacă
-finit-doar matematică este specificat.

fsqrtd
Operație cu rădăcină pătrată unară.

fcosd, fsind, ftand, fatand, fexpd, flogd
Funcții trigonometrice și exponențiale cu precizie dublă. Aceste instrucțiuni sunt
generat numai dacă -optimizări-funsafe-matematice este de asemenea specificat.

Conversii:

fextsd
Conversie de la precizie simplă la precizie dublă.

ftruncds
Conversie de la precizie dublă la precizie simplă.

fixsi, fixsu, fixdi, fixdu
Conversie de la virgulă mobilă la tipuri de numere întregi semnate sau fără semn, cu
trunchierea spre zero.

floatis, float, plutitor, plutind
Conversia de la tipuri de numere întregi semnate sau nesemnate în tipuri în virgulă mobilă.

În plus, toate următoarele instrucțiuni de transfer pentru registrele interne X și Y
trebuie furnizate pentru a utiliza oricare dintre instrucțiunile în virgulă mobilă cu precizie dublă.
Instrucțiuni personalizate care iau doi operanzi sursă cu precizie dublă se așteaptă pe primul
operand în registrul de 64 de biți X. Celălalt operand (sau numai operand al unui operand unar
operație) este dată instrucțiunii de aritmetică personalizată cu cea mai puțin semnificativă
jumătate în registrul sursă src1 iar cea mai semnificativă jumătate în src2. Un obicei
instrucțiunea care returnează un rezultat cu precizie dublă returnează cel mai semnificativ 32
biți în registrul destinație și cealaltă jumătate în registrul de 32 de biți Y. GCC
generează automat secvențele de cod necesare pentru a scrie registrul X și/sau a citi
înregistrați Y când sunt utilizate instrucțiuni în virgulă mobilă cu precizie dublă.

fwrx
Scrie src1 în jumătatea cea mai puțin semnificativă a lui X și src2 în cele mai semnificative
jumătate din X.

fwry
Scrie src1 în Y.

frdxhi, frdxlo
Citiți cea mai mare sau mai puțin (respectiv) jumătate semnificativă din X și stocați-o destinaţie.

frdy
Citiți valoarea lui Y și stocați-o în destinaţie.

Rețineți că puteți obține mai mult control local asupra generării Nios II personalizate
instrucțiuni folosind „target(”custom-insn=N")" și „target(”no-custom-insn")"
atribute sau pragma ale funcției.

-mcustom-fpu-cfg=nume
Această opțiune permite un set predefinit, numit de codificări de instrucțiuni personalizate (vezi
-mpersonalizat-insn de mai sus). În prezent, sunt definite următoarele seturi:

-mcustom-fpu-cfg=60-1 este echivalent cu: -mcustom-fmuls=252 -mcustom-fadds=253
-mcustom-fsubs=254 -fsingura-precizie-constant

-mcustom-fpu-cfg=60-2 este echivalent cu: -mcustom-fmuls=252 -mcustom-fadds=253
-mcustom-fsubs=254 -mcustom-fdivs=255 -fsingura-precizie-constant

-mcustom-fpu-cfg=72-3 este echivalent cu: -mcustom-floatus=243 -mcustom-fixsi=244
-mcustom-floatis=245 -mcustom-fcmpgts=246 -mcustom-fcmples=249 -mcustom-fcmpeqs=250
-mcustom-fcmpnes=251 -mcustom-fmuls=252 -mcustom-fadds=253 -mcustom-fsubs=254
-mcustom-fdivs=255 -fsingura-precizie-constant

Sarcini de instruire personalizate oferite de individ -mpersonalizat-insn= opțiunile anulează
cele date de -mcustom-fpu-cfg=, indiferent de ordinea opțiunilor de pe
Linie de comanda.

Rețineți că puteți obține mai mult control local asupra selecției unei configurații FPU prin
folosind „target(”custom-fpu-cfg=Nume")" atribut de funcție sau pragma.

Aceste suplimentare -m sunt disponibile opțiuni pentru ținta Altera Nios II ELF (bare-metal):

-mhal
Legătură cu HAL BSP. Acest lucru suprimă legătura cu pornirea de rulare C furnizată de GCC
și codul de terminare și este utilizat în mod obișnuit împreună cu -msys-crt0= pentru a specifica
locația codului de pornire alternativ furnizat de HAL BSP.

-msmallc
Link cu o versiune limitată a bibliotecii C, -lsmallc, mai degrabă decât Newlib.

-msys-crt0=fişierul de pornire
fişierul de pornire este numele fișierului startfile (crt0) de utilizat la conectarea. Această opțiune
este utilă numai împreună cu -mhal.

-msys-lib=systemlib
systemlib este numele bibliotecii care furnizează apeluri de sistem de nivel scăzut
cerut de biblioteca C, de exemplu, „citește” și „scrie”. Această opțiune este de obicei folosită pentru
link cu o bibliotecă furnizată de un HAL BSP.

PDP-11 Opţiuni

Aceste opțiuni sunt definite pentru PDP-11:

-mfpu
Utilizați virgulă mobilă FPP hardware. Aceasta este valoarea implicită. (virgulă flotantă FIS pe
PDP-11/40 nu este acceptat.)

-msoft-float
Nu utilizați virgulă mobilă hardware.

-mac0
Returnează rezultatele în virgulă mobilă în ac0 (fr0 în sintaxa asamblatorului Unix).

-mno-ac0
Returnează rezultatele în virgulă mobilă în memorie. Aceasta este valoarea implicită.

-m40
Generați codul pentru un PDP-11/40.

-m45
Generați codul pentru un PDP-11/45. Aceasta este valoarea implicită.

-m10
Generați codul pentru un PDP-11/10.

-mbcopy-builtin
Utilizați modele „movmemhi” în linie pentru copierea memoriei. Aceasta este valoarea implicită.

-mbcopy
Nu utilizați modele „movmemhi” în linie pentru copierea memoriei.

-mentă16
-mno-int32
Utilizați „int” pe 16 biți. Aceasta este valoarea implicită.

-mentă32
-mno-int16
Utilizați „int” pe 32 de biți.

-mfloat64
-mno-float32
Utilizați „float” pe 64 de biți. Aceasta este valoarea implicită.

-mfloat32
-mno-float64
Utilizați „float” pe 32 de biți.

-mabshi
Utilizați modelul „abshi2”. Aceasta este valoarea implicită.

-mno-abshi
Nu utilizați modelul „abshi2”.

-branch-scump
Prefă-te că ramurile sunt scumpe. Acest lucru este pentru a experimenta cu generarea de cod
numai.

-branch-ieftin
Nu te preface că ramurile sunt scumpe. Aceasta este valoarea implicită.

-munix-asm
Utilizați sintaxa asamblatorului Unix. Acesta este implicit atunci când este configurat pentru pdp11-*-bsd.

-mdec-asm
Utilizați sintaxa asamblatorului DEC. Aceasta este valoarea implicită atunci când este configurată pentru orice țintă PDP-11
altele decât pdp11-*-bsd.

picoChip Opţiuni

Acestea -m opțiunile sunt definite pentru implementările picoChip:

-mae=ae_type
Setați setul de instrucțiuni, setul de registre și parametrii de programare a instrucțiunilor pentru matrice
tipul elementului ae_type. Valori acceptate pentru ae_type sunt orice, MUL, și MAC.

-mae=ORICE selectează un tip AE complet generic. Codul generat cu această opțiune rulează
pe oricare dintre celelalte tipuri de AE. Codul nu este la fel de eficient precum ar fi dacă ar fi compilat
pentru un anumit tip de AE, iar unele tipuri de operații (de exemplu, înmulțirea) nu funcționează
corect pe toate tipurile de AE.

-mae=MUL selectează un tip MUL AE. Acesta este cel mai util tip AE pentru codul compilat,
și este implicit.

-mae=MAC selectează un MAC AE în stil DSP. Codul compilat cu această opțiune poate avea de suferit
performanță slabă a manipulării octeților (car), deoarece DSP AE nu oferă
suport hardware pentru încărcare/magazine de octeți.

-msymbol-ca-adresă
Permiteți compilatorului să folosească direct un nume de simbol ca adresă într-o încărcare/magazin
instrucțiune, fără a o încărca mai întâi într-un registru. De obicei, utilizarea acestui
opțiunea generează programe mai mari, care rulează mai repede decât atunci când opțiunea nu este utilizată.
Cu toate acestea, rezultatele variază de la program la program, așa că este lăsat ca opțiune de utilizator,
mai degrabă decât să fie activat permanent.

-mno-ineficiente-avertismente
Dezactivează avertismentele despre generarea de cod ineficient. Aceste avertismente pot fi
generate, de exemplu, la compilarea codului care efectuează operații de memorie la nivel de octeți
pe tipul MAC AE. MAC AE nu are suport hardware pentru memoria la nivel de octet
operațiuni, astfel încât toate încărcările/stocarele de octeți trebuie sintetizate din încărcare/magazin de cuvinte
operațiuni. Acest lucru este ineficient și este generat un avertisment pentru a indica faptul că dvs
ar trebui să rescrie codul pentru a evita operațiunile de octeți sau pentru a viza un tip AE care are
suport hardware necesar. Această opțiune dezactivează aceste avertismente.

PowerPC Opţiuni

Acestea sunt enumerate sub

RL78 Opţiuni

-msim
Legături în biblioteci țintă suplimentare pentru a sprijini operarea într-un simulator.

-mmul=niciuna
-mmul=g13
-mmul=rl78
Specifică tipul de suport de multiplicare hardware care trebuie utilizat. Valoarea implicită este
„none”, care utilizează funcții de multiplicare software. Opțiunea „g13” este pentru
hardware-ul de multiplicare/divizare periferică numai pe țintele RL78/G13. Opțiunea „rl78”.
este pentru multiplicarea hardware standard definită în manualul software RL78.

IBM RS / 6000 și PowerPC Opţiuni

Acestea -m opțiunile sunt definite pentru IBM RS/6000 și PowerPC:

-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mpowerpc64
-mno-powerpc64
-mmfcrf
-mno-mfcrf
-mpopcntb
-mno-popcntb
-mpopcntd
-mno-popcntd
-mfprnd
-mno-fprnd
-mcmpb
-mno-cmpb
-mmfpgpr
-mno-mfpgpr
-mhard-dfp
-mno-hard-dfp
Folosiți aceste opțiuni pentru a specifica ce instrucțiuni sunt disponibile pe procesorul dvs
folosesc. Valoarea implicită a acestor opțiuni este determinată la configurarea GCC.
Specificând -mcpu=tip_cpu anulează specificarea acestor opțiuni. Noi
vă recomandăm să utilizați -mcpu=tip_cpu opțiune, mai degrabă decât opțiunile enumerate mai sus.

specificarea -mpowerpc-gpopt permite GCC să utilizeze arhitectura opțională PowerPC
instrucțiuni din grupul de uz general, inclusiv rădăcină pătrată în virgulă mobilă.
specificarea -mpowerpc-gfxopt permite GCC să utilizeze arhitectura opțională PowerPC
instrucțiuni din grupul Grafică, inclusiv selectarea în virgulă mobilă.

-mmfcrf opțiunea permite GCC să genereze mutarea din câmpul registrului de condiții
instrucțiuni implementate pe procesorul POWER4 și pe alte procesoare care acceptă
Arhitectura PowerPC V2.01. The -mpopcntb opțiunea permite GCC să genereze popcount
și instrucțiuni de estimare reciprocă FP cu precizie dublă implementate pe POWER5
procesor și alte procesoare care acceptă arhitectura PowerPC V2.02. The
-mpopcntd opțiunea permite GCC să genereze instrucțiunea popcount implementată pe
Procesor POWER7 și alte procesoare care acceptă arhitectura PowerPC V2.06.
-mfprnd opțiunea permite GCC să genereze instrucțiunile FP rotunjite la întregi
implementat pe procesorul POWER5+ și pe alte procesoare care acceptă PowerPC
Arhitectura V2.03. The -mcmpb opțiunea permite GCC să genereze octeții de comparare
instrucțiuni implementate pe procesorul POWER6 și pe alte procesoare care acceptă
Arhitectura PowerPC V2.05. The -mmfpgpr opțiunea permite GCC să genereze mutarea FP
la/de la instrucțiuni de registru de uz general implementate pe procesorul POWER6X și
alte procesoare care acceptă arhitectura extinsă PowerPC V2.05. The -mhard-dfp
opțiunea permite GCC să genereze instrucțiunile zecimale în virgulă mobilă implementate pe
unele procesoare POWER.

-mpowerpc64 opțiunea permite GCC să genereze instrucțiuni suplimentare pe 64 de biți care
se găsesc în arhitectura completă PowerPC64 și pentru a trata GPR-urile ca pe 64 de biți, cu cuvinte duble
cantități. GCC este implicit -mno-powerpc64.

-mcpu=tip_cpu
Setați tipul de arhitectură, utilizarea înregistrării și parametrii de programare a instrucțiunilor pentru
tip de mașină tip_cpu. Valori acceptate pentru tip_cpu sunt 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,
e5500, e6500, ec603e, G3, G4, G5, gigant, power3, power4, power5, putere5+, power6,
putere6x, power7, power8, putere pc, powerpc64, powerpc64le, și rs64.

-mcpu=powerpc, -mcpu=powerpc64, și -mcpu=powerpc64le specificați PowerPC pur pe 32 de biți
(fie endian), Big Endian PowerPC pe 64 de biți și Little Endian PowerPC pe 64 de biți
tipuri de mașini cu arhitectură, cu un model de procesor generic adecvat presupus pentru
scopuri de programare.

Celelalte opțiuni specifică un anumit procesor. Cod generat în cadrul acestor opțiuni
rulează cel mai bine pe acel procesor și este posibil să nu ruleze deloc pe alții.

-mcpu opțiunile activează sau dezactivează automat următoarele opțiuni:

-maltivec -mfprnd -mhard-float -mmfcrf -multiplu -mpopcntb -mpopcntd -mpowerpc64
-mpowerpc-gpopt -mpowerpc-gfxopt -msingle-float -mdouble-float -msimple-fpu -mstring
-mmulhw -mdlmzb -mmfpgpr -mvsx -mcrypto -mdirect-mutare -mpower8-fusion
-mpower8-vector -mquad-memory -mquad-memory-atomic

Opțiunile speciale setate pentru un anumit CPU variază între versiunile compilatorului,
în funcție de ce setare pare să producă cod optim pentru acel procesor; nu este
reflectă în mod necesar capabilitățile hardware-ului real. Dacă doriți să setați un
opțiune individuală la o anumită valoare, o puteți specifica după -mcpu opțiune,
ca -mcpu=970 -mno-altivec.

Pe AIX, -maltivec și -mpowerpc64 opțiunile nu sunt activate sau dezactivate de -mcpu
opțiune în prezent, deoarece AIX nu are suport complet pentru aceste opțiuni. Poți
activați sau dezactivați-le în continuare individual dacă sunteți sigur că va funcționa în dvs
mediu. (envrironment)

-mtune=tip_cpu
Setați parametrii de programare a instrucțiunilor pentru tipul de mașină tip_cpu, dar nu setați
tipul de arhitectură sau utilizarea registrului, ca -mcpu=tip_cpu face. Aceleași valori pentru
tip_cpu sunt utilizate pentru -mtune în ceea ce privește -mcpu. Dacă ambele sunt specificate, codul este generat
folosește arhitectura și registrele stabilite de -mcpu, dar parametrii de programare stabiliți de
-mtune.

-mcmodel=mic
Generați codul PowerPC64 pentru modelul mic: TOC este limitat la 64k.

-mcmodel=mediu
Generați codul PowerPC64 pentru modelul mediu: TOC și alte date statice pot fi actualizate
la o dimensiune totală de 4G.

-mcmodel=mare
Generați codul PowerPC64 pentru modelul mare: TOC poate avea o dimensiune de până la 4G. Alte
datele și codul sunt limitate doar de spațiul de adrese de 64 de biți.

-maltivec
-mno-altivec
Generați cod care utilizează (nu folosește) instrucțiunile AltiVec și, de asemenea, activați utilizarea
de funcții încorporate care permit acces mai direct la setul de instrucțiuni AltiVec.
De asemenea, poate fi necesar să setați -mabi=altivec pentru a ajusta ABI curent cu AltiVec ABI
îmbunătățiri.

Cand -maltivec este folosit, mai degrabă decât -maltivec=le or -maltivec=be, ordinea elementelor
pentru intrinseci Altivec, cum ar fi „vec_splat”, „vec_extract” și „vec_insert” se vor potrivi
Ordinea elementelor de matrice corespunzătoare îndianității țintei. Adică element
zero identifică elementul cel mai din stânga dintr-un registru vectorial atunci când vizează un big-endian
platformă și identifică elementul cel mai din dreapta într-un registru vectorial atunci când țintesc a
platformă little-endian.

-maltivec=be
Generați instrucțiuni Altivec folosind ordinea elementelor big-endian, indiferent dacă
ținta este big-sau little-endian. Aceasta este valoarea prestabilită atunci când vizați un big-endian
platformă.

Ordinea elementelor este folosită pentru a interpreta numerele de elemente în intrinseci Altivec, cum ar fi
„vec_splat”, „vec_extract” și „vec_insert”. În mod implicit, acestea se vor potrivi cu matricea
Ordinea elementelor corespunzătoare îndianității pentru țintă.

-maltivec=le
Generați instrucțiuni Altivec folosind ordinea elementelor little-endian, indiferent dacă
ținta este big-sau little-endian. Aceasta este valoarea prestabilită atunci când vizați un pic-
platforma endian. Această opțiune este în prezent ignorată atunci când vizați un big-endian
platformă.

Ordinea elementelor este folosită pentru a interpreta numerele de elemente în intrinseci Altivec, cum ar fi
„vec_splat”, „vec_extract” și „vec_insert”. În mod implicit, acestea se vor potrivi cu matricea
Ordinea elementelor corespunzătoare îndianității pentru țintă.

-mvrsave
-mno-vrsave
Generați instrucțiuni VRSAVE când generați codul AltiVec.

-mgen-celula-microcod
Generați instrucțiuni de microcod pentru celule.

-mwarn-celula-microcod
Avertizați când este emisă o instrucțiune de microcod Cell. Un exemplu de microcod celular
instruirea este o schimbare variabilă.

-msecure-plt
Generați cod care permite ld și ld.deci pentru a construi executabile și biblioteci partajate cu
secțiunile „.plt” și „.got” neexecutabile. Aceasta este o opțiune PowerPC SYSV ABI pe 32 de biți.

-mbss-plt
Generați cod care utilizează o secțiune BSS „.plt” care ld.deci completează și necesită „.plt”
și secțiunile „.got” care sunt atât inscriptibile, cât și executabile. Acesta este un PowerPC pe 32 de biți
Opțiunea SYSV ABI.

-misel
-mno-isel
Acest comutator activează sau dezactivează generarea de instrucțiuni ISEL.

-misel=da nu
Acest comutator a fost depreciat. Utilizare -misel și -mno-isel in schimb.

-mspe
-mno-spe
Acest comutator activează sau dezactivează generarea instrucțiunilor SPE simd.

-compare
-mno-pereche
Acest comutator activează sau dezactivează generarea de instrucțiuni SIMD PAIRED.

-mspe=da nu
Această opțiune a fost retrasă. Utilizare -mspe și -mno-spe in schimb.

-mvsx
-mno-vsx
Generați cod care utilizează (nu utilizează) instrucțiuni vectoriale/scalare (VSX) și, de asemenea
permite utilizarea funcțiilor încorporate care permit acces mai direct la VSX
set de instructiuni.

-mcrypto
-mno-cripto
Activați utilizarea (dezactivarea) funcțiilor încorporate care permit accesul direct la
instrucțiuni criptografice care au fost adăugate în versiunea 2.07 a PowerPC ISA.

-mdirect-mutare
-mno-direct-mutare
Generați cod care utilizează (nu folosește) instrucțiunile pentru a muta datele între
registrele de uz general și registrele vectoriale/scalare (VSX) care au fost adăugate în
versiunea 2.07 a PowerPC ISA.

-mpower8-fusion
-mno-power8-fusion
Generați cod care păstrează (nu păstrează) unele operații întregi adiacente, astfel încât
instrucțiunile pot fi combinate pe procesoarele power8 și ulterioare.

-mpower8-vector
-mno-power8-vector
Generați cod care folosește (nu folosește) instrucțiunile vectoriale și scalare care au fost
adăugat în versiunea 2.07 a PowerPC ISA. De asemenea, permiteți utilizarea funcțiilor încorporate
care permit un acces mai direct la instrucțiunile vectoriale.

-mquad-memory
-mno-quad-memorie
Generați cod care folosește (nu folosește) instrucțiunile de memorie cu patru cuvinte non-atomice.
-mquad-memory opțiunea necesită utilizarea modului pe 64 de biți.

-mquad-memory-atomic
-mno-quad-memorie-atomic
Generați cod care folosește (nu folosește) instrucțiunile de memorie atomic quad word. The
-mquad-memory-atomic opțiunea necesită utilizarea modului pe 64 de biți.

-mfloat-gprs=da/single/dublu/nu
-mfloat-gprs
Acest comutator activează sau dezactivează generarea de operațiuni în virgulă mobilă pe
registre de uz general pentru arhitecturile care îl suportă.

Argumentul da or singur permite utilizarea virgulei mobile cu precizie unică
operațiuni.

Argumentul dubla permite utilizarea virgulei mobile cu precizie simplă și dublă
operațiuni.

Argumentul Nu. dezactivează operațiile în virgulă mobilă pe registrele de uz general.

Această opțiune este disponibilă în prezent numai pe MPC854x.

-m32
-m64
Generați cod pentru medii pe 32 de biți sau 64 de biți ale țintelor Darwin și SVR4 (inclusiv
GNU/Linux). Mediul pe 32 de biți setează int, long și pointer la 32 de biți și
generează cod care rulează pe orice variantă PowerPC. Mediul pe 64 de biți setează int la
32 de biți și lung și pointer la 64 de biți și generează cod pentru PowerPC64, ca și pentru
-mpowerpc64.

-mfull-toc
-mno-fp-in-toc
-mno-sum-in-toc
-mminimal-toc
Modificați generarea TOC (Cuprins), care este creat pentru fiecare
fisier executabil. The -mfull-toc opțiunea este selectată implicit. În acest caz, GCC
alocă cel puțin o intrare TOC pentru fiecare referință unică a variabilei neautomate în
programul dvs. GCC plasează, de asemenea, constante în virgulă mobilă în TOC. Cu toate acestea, numai
16,384 de intrări sunt disponibile în TOC.

Dacă primiți un mesaj de eroare de linker care spune că ați depășit numărul disponibil
Spațiu TOC, puteți reduce cantitatea de spațiu TOC utilizată cu -mno-fp-in-toc și
-mno-sum-in-toc opțiuni. -mno-fp-in-toc împiedică GCC să pună virgulă mobilă
constante în TOC și -mno-sum-in-toc obligă GCC să genereze cod pentru a calcula
suma unei adrese și o constantă la timpul de execuție în loc să puneți acea sumă în TOC.
Puteți specifica una sau ambele dintre aceste opțiuni. Fiecare face ca GCC să producă foarte
cod puțin mai lent și mai mare în detrimentul conservării spațiului TOC.

Dacă încă rămâneți fără spațiu în cuprinsul TOC chiar și atunci când specificați ambele opțiuni,
specifica -mminimal-toc in schimb. Această opțiune face ca GCC să facă o singură intrare TOC pentru
fiecare dosar. Când specificați această opțiune, GCC produce cod care este mai lent și mai mare
dar care utilizează extrem de puțin spațiu TOC. Este posibil să doriți să utilizați această opțiune numai pe
fișiere care conțin cod executat mai rar.

-maix64
-maix32
Activați AIX ABI pe 64 de biți și convenția de apelare: pointeri pe 64 de biți, tip „lung” pe 64 de biți și
infrastructura necesară pentru a le susține. Precizând -maix64 implică -mpowerpc64,
în timp ce -maix32 dezactivează ABI pe 64 de biți și implică -mno-powerpc64. GCC este implicit
-maix32.

-mxl-compat
-mno-xl-compat
Produceți cod care se conformează mai strâns cu semantica compilatorului IBM XL atunci când utilizați AIX-
ABI compatibil. Transmite argumente în virgulă mobilă la funcțiile prototip dincolo de
înregistrați zona de salvare (RSA) pe stivă în plus față de argumentele FPR. Nu presupune
acea valoare dublă cea mai semnificativă din 128 de biți este rotunjită corect când
compararea valorilor și conversia în dublu. Utilizați nume de simbol XL pentru dublu lung
rutine de sprijin.

Convenția de apelare AIX a fost extinsă, dar nu a fost documentată inițial pentru a gestiona un
caz obscur K&R C de apelare a unei funcții care ia adresa argumentelor sale cu
mai puține argumente decât cele declarate. Compilatoarele IBM XL accesează argumente în virgulă mobilă care
nu se încadrează în RSA din stivă atunci când o subrutină este compilată fără
optimizare. Deoarece stocarea întotdeauna a argumentelor în virgulă mobilă pe stivă este
ineficientă și rar necesară, această opțiune nu este activată implicit și doar este
necesar la apelarea subrutinelor compilate de compilatoarele IBM XL fără optimizare.

-mpe
Suport IBM RS / 6000 SP Paralel Mediu inconjurator (PE). Conectați o aplicație scrisă pentru utilizare
mesajul care trece cu un cod special de pornire pentru a permite rularea aplicației. The
sistemul trebuie să aibă PE instalat în locația standard (/usr/lpp/ppe.poe/), sau
Specificatii fișierul trebuie înlocuit cu -specificații= opțiunea de a specifica cea corespunzătoare
locația directorului. Mediul paralel nu acceptă fire de execuție, deci -mpe
și opțiunea -pthread opțiunea sunt incompatibile.

-malign-natural
-putere-malignă
Pe AIX, Darwin pe 32 de biți și PowerPC GNU/Linux pe 64 de biți, opțiunea -malign-natural
suprascrie alinierea definită de ABI a tipurilor mai mari, cum ar fi dublele în virgulă mobilă,
pe limita lor bazată pe dimensiunea naturală. Optiunea -putere-malignă instruiește GCC să
urmați regulile de aliniere specificate de ABI. GCC este implicit la alinierea standard
definite în ABI.

Pe Darwin pe 64 de biți, alinierea naturală este implicită și -putere-malignă nu este
sprijinit.

-msoft-float
-mhard-float
Generați cod care nu utilizează (folosește) setul de registru în virgulă mobilă. Software
emularea în virgulă mobilă este furnizată dacă utilizați -msoft-float opțiunea și treceți
opțiunea către GCC la conectarea.

-msingle-float
-mdouble-float
Generați cod pentru operații cu virgulă mobilă cu precizie simplă sau dublă.
-mdouble-float implică -msingle-float.

-msimple-fpu
Nu generați instrucțiuni „sqrt” și „div” pentru unitatea hardware în virgulă mobilă.

-mfpu=nume
Specificați tipul de unitate în virgulă mobilă. Valori valabile pentru nume sunt sp_lite (echivalentă cu
-msingle-float -msimple-fpu), dp_lite (echivalentă cu -mdouble-float -msimple-fpu),
sp_full (echivalentă cu -msingle-float), Şi dp_full (echivalentă cu -mdouble-float).

-mxilinx-fpu
Efectuați optimizări pentru unitatea în virgulă mobilă pe Xilinx PPC 405/440.

-multiplu
-mno-multiplu
Generați cod care utilizează (nu folosește) instrucțiunile de încărcare cu mai multe cuvinte și
stocați mai multe instrucțiuni de cuvinte. Aceste instrucțiuni sunt generate implicit pe
sisteme POWER și nu sunt generate pe sisteme PowerPC. Nu folosi -multiplu pe mic-
sistemele endian PowerPC, deoarece acele instrucțiuni nu funcționează atunci când procesorul este conectat
modul little-endian. Excepțiile sunt PPC740 și PPC750 care le permit
instrucțiuni în modul little-endian.

-mstring
-mno-string
Generați cod care utilizează (nu folosește) instrucțiunile șirului de încărcare și magazinul
șir de instrucțiuni de cuvinte pentru a salva mai multe registre și a face mișcări mici în bloc. Aceste
instrucțiunile sunt generate implicit pe sistemele POWER și nu sunt generate pe PowerPC
sisteme. Nu folosi -mstring pe sistemele PowerPC little-endian, din moment ce acelea
instrucțiunile nu funcționează când procesorul este în modul little-endian. Excepțiile
sunt PPC740 și PPC750 care permit aceste instrucțiuni în modul little-endian.

-actualizare
-mno-update
Generați cod care utilizează (nu utilizează) instrucțiunile de încărcare sau stocare care actualizează
registrul de bază la adresa locației de memorie calculate. Aceste instrucțiuni
sunt generate implicit. Dacă utilizați -mno-update, există o mică fereastră între
momentul în care pointerul stivei este actualizat și adresa cadrului anterior este
stocat, ceea ce înseamnă cod care parcurge cadrul stivei prin întreruperi sau semnale pot
obține date corupte.

-adrese-mavoid-indexate
-mno-evitati-adresele-indexate
Generați cod care încearcă să evite (nu să evite) utilizarea încărcării sau stocării indexate
instrucțiuni. Aceste instrucțiuni pot genera o penalizare de performanță pentru procesoarele Power6
în anumite situații, cum ar fi atunci când treceți prin rețele mari care traversează un 16M
limite. Această opțiune este activată în mod prestabilit atunci când vizați Power6 și este dezactivată
in caz contrar.

-mfused-madd
-mno-fuzionat-madd
Generați cod care utilizează (nu utilizează) multiplicarea și acumularea în virgulă mobilă
instrucțiuni. Aceste instrucțiuni sunt generate implicit în cazul în virgulă mobilă hardware
este folosit. Dependent de mașină -mfused-madd opțiunea este acum mapată la mașină-
independent -ffp-contract=rapid opțiune și -mno-fuzionat-madd este mapat la
-ffp-contract=off.

-mmulhw
-mno-mulhw
Generați cod care folosește (nu folosește) jumătate de cuvânt multiplicare și multiplicare-acumulare
instrucțiuni despre procesoarele IBM 405, 440, 464 și 476. Aceste instrucțiuni sunt
generate în mod prestabilit atunci când vizați acele procesoare.

-mdlmzb
-mno-dlmzb
Generați cod care utilizează (nu utilizează) căutarea șirurilor dlmzb instrucțiuni despre IBM
procesoare 405, 440, 464 și 476. Această instrucțiune este generată implicit când
care vizează acele procesoare.

-mno-bit-align
-mbit-align
Pe System V.4 și sistemele PowerPC încorporate nu forțează structurile și uniunile
care conțin câmpuri de biți care trebuie aliniate la tipul de bază al câmpului de biți.

De exemplu, implicit o structură care nu conține decât 8 câmpuri de biți „nesemnate”.
lungimea 1 este aliniată la o limită de 4 octeți și are o dimensiune de 4 octeți. Prin utilizarea
-mno-bit-align, structura este aliniată la o limită de 1 octet și are dimensiunea de 1 octet.

-mno-strict-align
-mstrict-align
Pe System V.4 și sistemele PowerPC încorporate nu presupun (fac) acea memorie nealiniată
referințele sunt gestionate de sistem.

-mrelocabil
-mno-relocabil
Generați cod care permite (nu permite) mutarea unui executabil static în a
adresă diferită în timpul rulării. Un simplu încărcător de sistem PowerPC încorporat ar trebui
mutați întregul conținut al locațiilor „.got2” și pe 4 octeți enumerate în „.fixup”
secțiunea, un tabel cu adrese pe 32 de biți generate de această opțiune. Pentru ca asta să funcționeze, toate
obiectele legate între ele trebuie compilate cu -mrelocabil or -mrelocatable-lib.
-mrelocabil codul aliniază stiva la o limită de 8 octeți.

-mrelocatable-lib
-mno-relocabil-lib
Aprecieri -mrelocabil, -mrelocatable-lib generează o secțiune „.fixup” pentru a permite static
executabilele să fie relocate în timpul rulării, dar -mrelocatable-lib nu folosește
alinierea stivă mai mică de -mrelocabil. Obiecte compilate cu -mrelocatable-lib Mai
să fie legat de obiecte compilate cu orice combinație a -mrelocabil opțiuni.

-mno-toc
-mtoc
Pe System V.4 și sistemele PowerPC încorporate nu presupun că registrul 2 conține
un pointer către o zonă globală care indică către adresele utilizate în program.

- putin
-mlittle-endian
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru procesor în puțin-
modul endian. The -mlittle-endian opțiunea este aceeași ca - putin.

-mbig
-mbig-endian
Pe sistemul V.4 și sistemele PowerPC încorporate, compilați codul pentru procesor în format mare.
modul endian. The -mbig-endian opțiunea este aceeași ca -mbig.

-mdynamic-no-pic
Pe sistemele Darwin și Mac OS X, compilați codul astfel încât să nu fie relocabil, dar atât
referințele sale externe sunt relocabile. Codul rezultat este potrivit pentru
aplicații, dar nu biblioteci partajate.

-msingle-pic-base
Tratați registrul utilizat pentru adresarea PIC ca fiind doar pentru citire, în loc să îl încărcați în fișierul
prolog pentru fiecare funcție. Sistemul runtime este responsabil pentru inițializarea acestui lucru
înregistrați cu o valoare adecvată înainte de a începe execuția.

-mprioritize-restricted-insns=prioritate
Această opțiune controlează prioritatea care este atribuită slotului de expediere restricționat
instrucțiuni în timpul celei de-a doua treceri de programare. Argumentul prioritate ia valoarea
0, 1, Sau 2 pentru a atribui prioritate nu, cea mai mare sau a doua cea mai mare (respectiv).
instrucțiuni restricționate pentru intervalul de expediere.

-msched-costly-dep=tip_dependență
Această opțiune controlează ce dependențe sunt considerate costisitoare de către țintă în timpul
programarea instrucțiunilor. Argumentul tip_dependență ia una dintre următoarele
valori:

Nu. Nicio dependență nu este costisitoare.

toate Toate dependențele sunt costisitoare.

true_store_to_load
O adevărată dependență de la magazin la încărcare este costisitoare.

store_to_load
Orice dependență de la magazin la încărcare este costisitoare.

număr
Orice dependență pentru care latența este mai mare sau egală cu număr este costisitoare.

-minsert-sched-nops=schemă
Această opțiune controlează ce schemă de inserare NOP este utilizată în timpul celei de-a doua planificări
trece. Argumentul schemă ia una dintre următoarele valori:

Nu. Nu introduceți NOP-uri.

tampon Adăugați cu NOP orice grup de expediere care are spații de emisiune libere, conform
gruparea programatorului.

regrupare_exact
Introduceți NOP pentru a forța instituțiile costisitoare dependente în grupuri separate. Introduceți exact
câte NOP-uri sunt necesare pentru a forța un insn la un nou grup, conform estimărilor
gruparea procesoarelor.

număr
Introduceți NOP pentru a forța instituțiile costisitoare dependente în grupuri separate. Introduce număr
NOP pentru a forța un insn la un nou grup.

-mcall-sysv
Pe System V.4 și sistemele PowerPC încorporate compilați codul folosind convențiile de apelare care
să adere la proiectul din martie 1995 a interfeței binare a aplicației System V, PowerPC
supliment procesor. Aceasta este implicită, dacă nu ați configurat GCC folosind
powerpc-*-eabiaix.

-mcall-sysv-eabi
-mcall-eabi
Specificați ambele -mcall-sysv și -meabi opțiuni.

-mcall-sysv-noeabi
Specificați ambele -mcall-sysv și -mno-eabi opțiuni.

-mcall-aixdesc
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru sistemul de operare AIX.

-mcall-linux
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru GNU bazat pe Linux
sistemului.

-mcall-freebsd
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru funcționarea FreeBSD
sistemului.

-mcall-netbsd
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru funcționarea NetBSD
sistemului.

-mcall-openbsd
Pe sistemul V.4 și sistemele PowerPC încorporate compilați codul pentru operarea OpenBSD
sistemului.

-maix-struct-return
Returnează toate structurile în memorie (după cum este specificat de AIX ABI).

-msvr4-struct-return
Returnează structuri mai mici de 8 octeți în registre (așa cum este specificat de SVR4 ABI).

-mabi=abi-tip
Extindeți ABI curent cu o anumită extensie sau eliminați o astfel de extensie. Valabil
valorile sunt altivec, nu-altivec, spe, nu-spe, ibmlongdouble, ieeelongdouble, elfv1,
elfv2.

-mabi=spe
Extindeți actualul ABI cu extensiile SPE ABI. Acest lucru nu schimbă ABI implicit,
în schimb, adaugă extensiile SPE ABI la ABI actual.

-mabi=no-spe
Dezactivați extensiile ABI Book-E SPE pentru ABI curent.

-mabi=ibmlongdouble
Modificați ABI-ul curent pentru a utiliza IBM de precizie extinsă lung dublu. Acesta este un PowerPC
Opțiunea SYSV ABI pe 32 de biți.

-mabi=ieeelongdouble
Schimbați ABI-ul actual pentru a utiliza IEEE cu precizie extinsă dublu lung. Acesta este un PowerPC
Opțiune Linux ABI pe 32 de biți.

-mabi=elfv1
Modificați ABI-ul curent pentru a utiliza ABI-ul ELFv1. Acesta este ABI implicit pentru big-endian
PowerPC pe 64 de biți Linux. Suprascrierea ABI implicită necesită suport special de sistem și
este probabil să eșueze în moduri spectaculoase.

-mabi=elfv2
Modificați ABI-ul curent pentru a utiliza ABI-ul ELFv2. Acesta este ABI implicit pentru mici-
endian PowerPC Linux pe 64 de biți. Suprascrierea ABI implicită necesită un sistem special
sprijin și este probabil să eșueze în moduri spectaculoase.

-mprototip
-mno-prototip
Pe sistemul V.4 și sistemele PowerPC încorporate presupun că toate apelurile la argument variabil
funcțiile sunt corect prototipate. În caz contrar, compilatorul trebuie să insereze o instrucțiune
înainte de fiecare apel neprototipat pentru a seta sau a șterge bitul 6 din registrul codului de stare
(CR) pentru a indica dacă valorile în virgulă mobilă sunt transmise în virgulă mobilă
înregistrează în cazul în care funcția preia argumente variabile. Cu -mprototip, doar apeluri
la funcțiile de argumente variabile prototipate setați sau ștergeți bitul.

-msim
Pe sistemele PowerPC încorporate, presupuneți că modulul de pornire este apelat sim-crt0.o și
că bibliotecile standard C sunt libsim.a și libc.a. Aceasta este valoarea implicită pentru
powerpc-*-eabisim configurații.

-mmvme
Pe sistemele PowerPC încorporate, presupuneți că modulul de pornire este apelat crt0.o si
bibliotecile standard C sunt libmvme.a și libc.a.

-nebunii
Pe sistemele PowerPC încorporate, presupuneți că modulul de pornire este apelat crt0.o si
bibliotecile standard C sunt libads.a și libc.a.

-cuțit galben
Pe sistemele PowerPC încorporate, presupuneți că modulul de pornire este apelat crt0.o si
bibliotecile standard C sunt libyk.a și libc.a.

-mvxworks
Pe sistemul V.4 și sistemele PowerPC încorporate, specificați că compilați pentru a
Sistemul VxWorks.

-memb
Pe sistemele PowerPC încorporate, setați PPC_EMB bit în antetul steagurilor ELF pentru a indica
acea eabi sunt folosite relocari extinse.

-meabi
-mno-eabi
Pe System V.4 și sistemele PowerPC încorporate aderă (nu) la Embedded
Applications Binary Interface (EABI), care este un set de modificări aduse sistemului
V.4 specificații. Selectarea -meabi înseamnă că stiva este aliniată la 8 octeți
limită, o funcție „__eabi” este apelată din „main” pentru a configura mediul EABI,
si -msdata opțiunea poate folosi atât „r2” cât și „r13” pentru a indica două date mici separate
zone. Selectarea -mno-eabi înseamnă că stiva este aliniată la o limită de 16 octeți, nu
Funcția de inițializare EABI este apelată de la „main”, iar -msdata opțiunea folosește numai
„r13” pentru a indica o singură zonă mică de date. The -meabi opțiunea este activată în mod implicit dacă dvs
configurat GCC folosind unul dintre powerpc*-*-eabi* opțiuni.

-msdata=eabi
Pe sistemul V.4 și sistemele PowerPC încorporate, puneți „const” global mic inițializat și
date statice în .sdata2 secțiunea, care este indicată de registrul „r2”. Pune mic
date globale și statice non-"const" inițializate în .sdata secțiune, care este ascuțită
la prin registrul „r13”. Puneți mici date globale și statice neinițializate în fișierul .sbss
secțiunea, care este adiacentă .sdata secțiune. The -msdata=eabi opțiunea este
incompatibil cu -mrelocabil opțiune. -msdata=eabi opțiunea setează și
-memb opțiune.

-msdata=sysv
Pe sistemul V.4 și sistemele PowerPC încorporate, puneți mici date globale și statice în
.sdata secțiune, care este indicată de registrul „r13”. Pune mic global neinițializat
și date statice în .sbss secțiunea, care este adiacentă .sdata secțiune. The
-msdata=sysv opțiunea este incompatibilă cu -mrelocabil opțiune.

-msdata=implicit
-msdata
Pe sistemul V.4 și sistemele PowerPC încorporate, dacă -meabi este folosit, compilați codul la fel
as -msdata=eabi, altfel compilați codul la fel ca -msdata=sysv.

-msdata=date
Pe sistemul V.4 și sistemele PowerPC încorporate, puneți mici date globale în .sdata
secțiune. Puneți mici date globale neinițializate în .sbss secțiune. Nu folosi
înregistrați „r13” pentru a aborda date mici totuși. Acesta este comportamentul implicit, dacă nu
alte -msdata sunt utilizate opțiuni.

-msdata=niciuna
-mno-sdata
Pe sistemele PowerPC încorporate, puneți toate datele globale și statice inițializate în .date
secțiunea și toate datele neinițializate din .bss secţiune.

-mblock-move-inline-limit=o
Inline toate mișcările blocului (cum ar fi apelurile la „memcpy” sau copierea structurii) mai puțin de sau
egal cu o octeți. Valoarea minimă pentru o este de 32 de octeți pe ținte pe 32 de biți și 64
octeți pe ținte pe 64 de biți. Valoarea implicită este specifică țintei.

-G o
Pe sistemele PowerPC încorporate, puneți elemente globale și statice mai mici sau egale cu o
octeți în secțiunile mici de date sau BSS în loc de secțiunea normală de date sau BSS.
În mod implicit, o este 8. The -G o comutatorul este de asemenea transmis linker-ului. Toate modulele
ar trebui compilat cu același -G o valoare.

-mrenumele
-mno-renumeste
Pe System V.4 și sistemele PowerPC încorporate emit (nu) nume de registru în
ieșire în limbaj de asamblare folosind forme simbolice.

-mlongcall
-mno-longcall
În mod implicit presupuneți că toate apelurile sunt departe, astfel încât să fie mai lungi și mai scumpe
este necesară secvența de apelare. Acest lucru este necesar pentru apeluri mai mari de 32 de megaocteți
(33,554,432 octeți) din locația curentă. Un apel scurt este generat dacă
compilatorul știe că apelul nu poate fi atât de departe. Această setare poate fi înlocuită de
atributul funcției „shortcall” sau prin „#pragma apel lung(0) ".

Unele legături sunt capabile să detecteze apeluri în afara intervalului și să genereze codul de adeziv
Muscă. Pe aceste sisteme, apelurile lungi sunt inutile și generează cod mai lent. La fel de
din această scriere, linkerul AIX poate face acest lucru, la fel ca și linkerul GNU pentru PowerPC/64. Aceasta
este planificat să adauge această caracteristică la linker-ul GNU și pentru sistemele PowerPC pe 32 de biți.

Pe sistemele Darwin/PPC, „#pragma longcall” generează „jbsr callee, L42”, plus un ramură
insulă (cod lipici). Cele două adrese țintă reprezintă apelatul și sucursala
insulă. Linker-ul Darwin/PPC preferă prima adresă și generează un „bl apelat”
dacă instrucțiunea PPC „bl” ajunge direct la apelat; în caz contrar, linkerul
generează „bl L42” pentru a apela insula de ramificație. Insula ramură este atașată la
corpul funcției de apelare; calculează adresa completă de 32 de biți a apelantului și
sare la ea.

Pe sistemele Mach-O (Darwin), această opțiune direcționează compilatorul emite către lipici pentru
fiecare apel direct, iar linkerul Darwin decide dacă îl folosește sau îl renunță.

În viitor, GCC poate ignora toate specificațiile longcall atunci când linker-ul este cunoscut
generează lipici.

-mtls-markere
-mno-tls-markeri
Marcați (nu marcați) apelurile către „__tls_get_addr” cu o relocare care specifică funcția
argument. Relocarea permite linkerului să asocieze în mod fiabil apelul de funcție cu
instrucțiuni de configurare a argumentelor pentru optimizarea TLS, care, la rândul său, permite GCC să se îmbunătățească
programați secvența.

-pthread
Adaugă suport pentru multithreading cu pthreads bibliotecă. Această opțiune setează steaguri pentru
atât preprocesorul cât și linkerul.

-mrecip
-mno-recip
Această opțiune permite utilizarea estimării reciproce și a estimării rădăcinii pătrate reciproce
instrucțiuni cu pași suplimentari Newton-Raphson pentru a crește precizia în loc de
făcând o împărțire sau rădăcină pătrată și împărțire pentru argumente în virgulă mobilă. Ar trebui să folosești
il -ffast-matematică opțiune când se utilizează -mrecip (sau cel puțin -optimizări-funsafe-matematice,
-numai-finit-matematică, -freciprocal-matematică și -fno-capcană-matematică). Rețineți că, în timp ce
debitul secvenței este în general mai mare decât debitul non-
instrucție reciprocă, precizia secvenței poate fi scăzută cu până la 2 ulp
(adică, inversul lui 1.0 este egal cu 0.99999994) pentru rădăcini pătrate reciproce.

-mrecip=opta
Această opțiune controlează ce instrucțiuni de estimare reciprocă pot fi utilizate. opta este
listă de opțiuni separate prin virgulă, care poate fi precedată de un „!” pentru a inversa opțiunea:
„all”: activați toate instrucțiunile de estimare, „default”: activați instrucțiunile implicite,
echivalent cu -mrecip, „niciunul”: dezactivați toate instrucțiunile de estimare, echivalent cu
-mno-recip; „div”: activați instrucțiunile de aproximare reciprocă pentru ambele unice
și dublă precizie; "divf": permite aproximarea reciprocă cu precizie unică
instrucțiuni; "divd": activați aproximarea reciprocă cu dublă precizie
instrucțiuni; „rsqrt”: activați instrucțiunile de aproximare a rădăcinii pătrate reciproce
pentru precizie simplă și dublă; „rsqrtf”: activați reciproca cu precizie unică
instrucțiuni de aproximare a rădăcinii pătrate; „rsqrtd”: activați precizia dublă
instrucțiuni de aproximare a rădăcinii pătrate reciproce;

Deci, de exemplu, -mrecip=all,!rsqrtd permite toată estimarea reciprocă
instrucțiuni, cu excepția instrucțiunilor „FRSQRTE”, „XSRSQRTEDP” și „XVRSQRTEDP”
care se ocupă de calculele rădăcinii pătrate reciproce cu dublă precizie.

-mrecip-precizie
-mno-recip-precizie
Să presupunem (nu să presupunem) că instrucțiunile de estimare reciprocă oferă mai multe
estimări de precizie decât este impusă de PowerPC ABI. Selectarea -mcpu=putere6,
-mcpu=putere7 or -mcpu=putere8 selectează automat -mrecip-precizie. dublu-
instrucțiunile de estimare a rădăcinii pătrate de precizie nu sunt generate implicit pe
mașini de precizie, deoarece nu oferă o estimare care să convergă după trei
pași.

-mveclibabi=tip
Specifică tipul ABI de utilizat pentru vectorizarea intrinseci utilizând o bibliotecă externă.
Singurul tip suportat în prezent este „mass”, care specifică utilizarea IBM
Biblioteci Mathematical Acceleration Subsystem (MASS) pentru vectorizarea intrinseci folosind
biblioteci externe. GCC emite în prezent apeluri către „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” și „tanhf4” la generarea codului pentru power7. Ambii -fttree-vectoriza și
-optimizări-funsafe-matematice trebuie de asemenea activat. Bibliotecile MASS trebuie să fie
specificat la momentul linkului.

-mfriz
-mno-friz
Generați (nu generați) instrucțiunea „friz” atunci când -optimizări-funsafe-matematice
opțiunea este utilizată pentru a optimiza rotunjirea valorilor în virgulă mobilă la un întreg pe 64 de biți și
înapoi la virgulă mobilă. Instrucțiunea „friz” nu returnează aceeași valoare dacă
numărul în virgulă mobilă este prea mare pentru a se încadra într-un număr întreg.

-mpointers-to-imbricate-funcții
-mno-pointere-la-funcții-imbricate
Generați (nu generați) cod pentru a încărca registrul de lanț static (r11) cand
apelarea printr-un pointer pe sistemele AIX și Linux pe 64 de biți unde este un pointer de funcție
indică un descriptor de 3 cuvinte care oferă adresa funcției, valoarea TOC în care trebuie încărcată
Inregistreaza-te r2, și valoarea lanțului statică pentru a fi încărcate în registru r11.
-mpointers-to-imbricate-funcții este activat implicit. Nu puteți apela prin indicatori către
funcții imbricate sau pointeri către funcții compilate în alte limbi care utilizează
lanț static dacă utilizați -mno-pointere-la-funcții-imbricate.

-msave-toc-indirect
-mno-save-toc-indirect
Generați (nu generați) cod pentru a salva valoarea TOC în locația rezervată a stivei
în prologul funcției dacă funcția apelează printr-un pointer pe AIX și pe 64 de biți
sisteme Linux. Dacă valoarea TOC nu este salvată în prolog, aceasta este salvată chiar înainte
apelul prin indicator. The -mno-save-toc-indirect opțiunea este implicită.

-mcompat-align-parm
-mno-compat-align-parm
Generați (nu generați) cod pentru a trece parametrii de structură cu o aliniere maximă
de 64 de biți, pentru compatibilitate cu versiunile mai vechi de GCC.

Versiunile mai vechi de GCC (anterior versiunii 4.9.0) nu au aliniat incorect un parametru de structură
pe o graniță de 128 de biți când acea structură conținea un membru care necesită 128 de biți
aliniere. Acest lucru este corectat în versiunile mai recente ale GCC. Această opțiune poate fi utilizată
pentru a genera cod compatibil cu funcțiile compilate cu versiuni mai vechi ale
GCC.

-mno-compat-align-parm opțiunea este implicită.

RX Opţiuni

Aceste opțiuni de linie de comandă sunt definite pentru ținte RX:

-m64bit-duble
-m32bit-duble
Faceți ca tipul de date „dublu” să fie de 64 de biți (-m64bit-duble) sau 32 de biți (-m32bit-duble)
in marime. Valoarea implicită este -m32bit-duble. notițe Hardware-ul RX în virgulă mobilă funcționează numai
pe valori pe 32 de biți, motiv pentru care este implicit -m32bit-duble.

-fpu
-nofpu
Activează (-fpu) sau dezactivează (-nofpu) utilizarea hardware-ului RX în virgulă mobilă. The
implicit este activat pentru RX600 serie și dezactivat pentru RX200 serie.

Instrucțiunile în virgulă mobilă sunt generate numai pentru valori în virgulă mobilă pe 32 de biți,
totuși, deci hardware-ul FPU nu este folosit pentru duble dacă -m64bit-duble opțiunea este
folosit.

notițe În cazul în care -fpu opțiunea este activată atunci -optimizări-funsafe-matematice este de asemenea activat
automat. Acest lucru se datorează faptului că instrucțiunile RX FPU sunt ele însele nesigure.

-mcpu=nume
Selectează tipul de procesor RX care urmează să fie vizat. În prezent sunt acceptate trei tipuri, cel
generic RX600 și RX200 hardware de serie și specificul RX610 CPU. Valoarea implicită este
RX600.

Singura diferență între RX600 și RX610 est que le RX610 nu suportă
Instrucțiunea „MVTIPL”.

RX200 seria nu are o unitate hardware în virgulă mobilă și așadar -nofpu este activat
implicit atunci când acest tip este selectat.

-mbig-endian-date
-mlittle-endian-date
Stocați datele (dar nu codul) în format big-endian. Valoarea implicită este
-mlittle-endian-date, adică pentru a stoca date în formatul little-endian.

-msmall-data-limit=N
Specifică dimensiunea maximă în octeți a variabilelor globale și statice care pot fi plasate
în zona mică de date. Utilizarea unei zone mici de date poate duce la o dimensiune mai mică și mai rapidă
cod, dar dimensiunea zonei este limitată și este la latitudinea programatorului să se asigure că
zona nu se revarsă. De asemenea, atunci când zona mică de date este folosită unul dintre RX
registrele (de obicei „r13”) este rezervată pentru utilizare care indică această zonă, deci este nr
mai disponibil pentru utilizare de către compilator. Acest lucru ar putea duce la mai lent și/sau mai mare
cod dacă variabilele sunt împinse în stivă în loc să fie păstrate în acest registru.

Rețineți, variabilele comune (variabile care nu au fost inițializate) și constantele sunt
nu sunt plasate în zona mică de date, deoarece sunt alocate altor secțiuni din
executabil de ieșire.

Valoarea implicită este zero, ceea ce dezactivează această caracteristică. Rețineți că această caracteristică nu este
activat implicit cu niveluri de optimizare mai ridicate (-O2 etc) din cauza
efecte potenţial dăunătoare ale rezervării unui registru. Depinde de programator
să experimenteze și să descopere dacă această caracteristică este de folos programului lor. Vedea
descrierea -mpid opțiunea pentru o descriere a modului în care se înregistrează efectiv
țineți apăsat indicatorul pentru zona mică de date este ales.

-msim
-mno-sim
Utilizați timpul de rulare al simulatorului. Implicit este utilizarea timpului de rulare specific plăcii libgloss.

-mas100-sintaxă
-mno-as100-sintaxă
Când generați rezultatul asamblatorului, utilizați o sintaxă compatibilă cu AS100 de la Renesas
asamblator. Această sintaxă poate fi gestionată și de asamblatorul GAS, dar are unele
restricții, așa că nu este generat implicit.

-mmax-constant-size=N
Specifică dimensiunea maximă, în octeți, a unei constante care poate fi utilizată ca operand în
o instrucțiune RX. Deși setul de instrucțiuni RX permite constante de până la 4
octeți de lungime pentru a fi utilizați în instrucțiuni, o valoare mai lungă echivalează cu o valoare mai lungă
instrucție. Astfel, în anumite circumstanțe, poate fi benefic să restrângem dimensiunea
constante care sunt utilizate în instrucțiuni. În schimb, constantele prea mari sunt
plasat într-un pool constant și referit prin indirectarea registrului.

Valoarea N poate fi între 0 și 4. O valoare de 0 (implicit) sau 4 înseamnă că
sunt permise constante de orice dimensiune.

-mrelaxează-te
Activați relaxarea linkerului. Relaxarea linkerului este un proces prin care linkerul încearcă
pentru a reduce dimensiunea unui program prin găsirea unor versiuni mai scurte ale diverselor instrucțiuni.
Dezactivat în mod implicit.

-mint-registru=N
Specificați numărul de registre de rezervat pentru funcțiile de gestionare rapidă a întreruperilor. The
valoare N poate fi între 0 și 4. O valoare de 1 înseamnă că registrul „r13” este rezervat
pentru utilizarea exclusivă a gestionatorilor de întreruperi rapide. O valoare de 2 rezerve „r13” și
„r12”. O valoare de 3 rezerve „r13”, „r12” și „r11” și o valoare de 4 rezerve „r13”
prin „r10”. O valoare de 0, implicită, nu rezervă niciun registru.

-msave-acc-in-intreruperi
Specifică faptul că funcțiile de gestionare a întreruperii ar trebui să păstreze registrul acumulatorului.
Acest lucru este necesar numai dacă codul normal poate folosi registrul acumulatorului, de exemplu
deoarece efectuează înmulțiri pe 64 de biți. Implicit este ignorarea acumulatorului
deoarece acest lucru îi face pe cei care gestionează întreruperi mai rapid.

-mpid
-mno-pid
Permite generarea de date independente de poziție. Când este activat orice acces la
datele constante se realizează printr-un offset față de o adresă de bază păstrată într-un registru. Acest
permite ca locația datelor constante să fie determinată în timpul rulării fără a fi necesară
executabilul să fie relocat, ceea ce este un avantaj pentru aplicațiile încorporate cu tight
constrângeri de memorie. Datele care pot fi modificate nu sunt afectate de această opțiune.

Rețineți că utilizarea acestei caracteristici rezervă un registru, de obicei „r13”, pentru datele constante
adresa de bază. Acest lucru poate duce la un cod mai lent și/sau mai mare, în special în cazul complicat
funcții.

Registrul real ales pentru a păstra adresa constantă a bazei de date depinde dacă
il -msmall-data-limit și / sau -montarie-registru opțiunile din linia de comandă sunt activate.
Începând cu registrul „r13” și mergând în jos, registrele sunt alocate mai întâi
pentru a satisface cerinţele de -montarie-registru, Apoi -mpid și, în sfârșit
-msmall-data-limit. Astfel, este posibil ca registrul de date mici să fie „r8”
dacă ambele -mint-registru=4 și -mpid sunt specificate pe linia de comandă.

În mod implicit, această caracteristică nu este activată. Valoarea implicită poate fi restabilită prin intermediul -mno-pid
opțiunea de linie de comandă.

-mno-warn-multiple-rapid-întreruperi
-mwarn-multiple-întreruperi rapide
Împiedică GCC să emită un mesaj de avertizare dacă găsește mai mult de o întrerupere rapidă
handler atunci când compila un fișier. Implicit este emiterea unui avertisment pentru fiecare suplimentar
S-a găsit un handler de întrerupere rapid, deoarece RX acceptă doar o astfel de întrerupere.

Notă: Opțiunea generică de linie de comandă GCC -fixat-reg are o semnificație specială pentru RX
port atunci când este utilizat cu atributul funcției „întrerupere”. Acest atribut indică a
funcție menită să proceseze întreruperi rapide. GCC se asigură că utilizează numai registrele
„r10”, „r11”, „r12” și/sau „r13” și numai cu condiția ca utilizarea normală a
registrele corespunzătoare au fost restricționate prin intermediul -fixat-reg or -montarie-registru
opțiunile din linia de comandă.

S / 390 și zSeries Opţiuni

Acestea sunt -m opțiunile definite pentru arhitectura S/390 și zSeries.

-mhard-float
-msoft-float
Folosiți (nu utilizați) instrucțiunile și registrele hardware în virgulă mobilă pentru
operații cu puncte. Cand -msoft-float este specificat, funcţionează în libgcc.a sunt obisnuiti sa
efectuează operații în virgulă mobilă. Cand -mhard-float este specificat compilatorul
generează instrucțiuni IEEE în virgulă mobilă. Aceasta este valoarea implicită.

-mhard-dfp
-mno-hard-dfp
Utilizați (nu utilizați) instrucțiunile hardware cu virgulă mobilă zecimală pentru
operații în virgulă mobilă. Cand -mno-hard-dfp este specificat, funcţionează în libgcc.a sunt
folosit pentru a efectua operații zecimale cu virgulă mobilă. Cand -mhard-dfp este specificat, cel
compilatorul generează instrucțiuni hardware zecimale în virgulă mobilă. Aceasta este valoarea implicită
pentru -march=z9-ec sau mai mare.

-mlong-dublu-64
-mlong-dublu-128
Aceste comutatoare controlează dimensiunea tipului „dublu lung”. O dimensiune de 64 de biți face ca
tipul „dublu lung” echivalent cu tipul „dublu”. Aceasta este valoarea implicită.

-mbackchain
-mno-backchain
Stocați (nu stocați) adresa cadrului apelantului ca indicator backchain în
cadrul stivei apelatului. Poate fi necesar un backchain pentru a permite depanarea folosind instrumente care
nu înțeleg informațiile din cadrul apelului DWARF 2. Cand -mno-packed-stack este in
efect, indicatorul backchain este stocat în partea de jos a cadrului stivei; cand
-ambalat-stivă este de fapt, lanțul din spate este plasat în cuvântul cel mai de sus al
Zona de salvare a registrului de 96/160 octeți.

În general, cod compilat cu -mbackchain este compatibil cu apelurile cu codul compilat cu
-mmo-backchain; cu toate acestea, utilizarea backchain-ului în scopuri de depanare necesită de obicei
cu care este construit întregul binar -mbackchain. Rețineți că combinația de
-mbackchain, -ambalat-stivă și -mhard-float nu e suportat. Pentru a construi un
utilizarea nucleului linux -msoft-float.

Implicit este să nu mențineți backchain-ul.

-ambalat-stivă
-mno-packed-stack
Utilizați (nu utilizați) aspectul stivei ambalate. Cand -mno-packed-stack este specificat, cel
compilatorul folosește toate câmpurile zonei de salvare a registrului de 96/160 de octeți numai pentru acestea
scop implicit; câmpurile neutilizate încă ocupă spațiu în stivă. Cand -ambalat-stivă is
specificat, sloturile de salvare a registrului sunt împachetate dens în partea de sus a salvării registrului
zonă; Spațiul nefolosit este reutilizat în alte scopuri, permițând o utilizare mai eficientă a
spațiul de stivă disponibil. Cu toate acestea, când -mbackchain este, de asemenea, de fapt, cel mai de sus
Cuvântul zonei de salvare este întotdeauna folosit pentru a stoca backchain-ul și adresa de retur
registrul este întotdeauna salvat la două cuvinte mai jos de backchain.

Atâta timp cât backchain-ul cadru de stivă nu este utilizat, codul generat cu -ambalat-stivă
este compatibil cu apelurile cu codul generat cu -mno-packed-stack. Rețineți că unele non-FSF
versiuni ale GCC 2.95 pentru codul generat S/390 sau zSeries care utilizează cadrul de stivă
backchain în timpul rulării, nu doar în scopuri de depanare. Un astfel de cod nu este apel-
compatibil cu codul compilat cu -ambalat-stivă. De asemenea, rețineți că combinația de
-mbackchain, -ambalat-stivă și -mhard-float nu e suportat. Pentru a construi un
utilizarea nucleului linux -msoft-float.

Valoarea implicită este să nu utilizați aspectul stivei ambalate.

-msmall-exec
-mno-small-exec
Generați (sau nu generați) cod folosind instrucțiunea „sutien” pentru a face subrutina
apeluri. Acest lucru funcționează în mod fiabil numai dacă dimensiunea totală a executabilului nu depășește 64k.
Implicit este să folosiți în schimb instrucțiunea „basr”, care nu are acest lucru
prescripţie.

-m64
-m31
Cand -m31 este specificat, generați cod compatibil cu GNU/Linux pentru S/390 ABI. Cand
-m64 este specificat, generați cod compatibil cu GNU/Linux for zSeries ABI. Acest
permite GCC în special să genereze instrucțiuni pe 64 de biți. Pentru s390 ținte, cel
implicit este -m31, În timp ce s390x obiectivele implicite la -m64.

-mzarch
-mesa
Cand -mzarch este specificat, generați codul utilizând instrucțiunile disponibile pe
z/Arhitectură. Cand -mesa este specificat, generați codul utilizând instrucțiunile
disponibil pe ESA/390. Rețineți că -mesa nu este posibil cu -m64. La generare
cod compatibil cu GNU/Linux pentru S/390 ABI, implicit este -mesa. La generare
cod compatibil cu GNU/Linux pentru zSeries ABI, implicit este -mzarch.

-mmvcle
-mno-mvcle
Generați (sau nu generați) cod folosind instrucțiunea „mvcle” pentru a efectua blocarea
mișcări. Cand -mno-mvcle este specificat, utilizați în schimb o buclă „mvc”. Aceasta este valoarea implicită
cu excepția cazului în care se optimizează pentru dimensiune.

-mdebug
-mno-debug
Imprimați (sau nu imprimați) informații suplimentare de depanare la compilare. Valoarea implicită este
pentru a nu imprima informațiile de depanare.

-martie=tip CPU
Generați codul care rulează tip CPU, care este numele unui sistem care reprezintă a
anumit tip de procesor. Valori posibile pentru tip CPU sunt g5, g6, z900, z990, z9-109,
z9-ec, z10, z196, și zEC12. La generarea codului folosind instrucțiunile disponibile pe
z/Arhitecture, valoarea implicită este -martie=z900. În caz contrar, implicit este -martie=g5.

-mtune=tip CPU
Acordați-vă tip CPU totul aplicabil despre codul generat, cu excepția ABI
și setul de instrucțiuni disponibile. Lista de tip CPU valorile sunt aceleași ca pentru
-Martie. Valoarea implicită este valoarea utilizată pentru -Martie.

-mtpf-trace
-mno-tpf-trace
Generați cod care adaugă (nu adaugă) în ramuri specifice sistemului de operare TPF pentru a urmări rutinele
în sistemul de operare. Această opțiune este dezactivată în mod implicit, chiar și atunci când se compilează pentru
Sistemul de operare TPF.

-mfused-madd
-mno-fuzionat-madd
Generați cod care utilizează (nu utilizează) multiplicarea și acumularea în virgulă mobilă
instrucțiuni. Aceste instrucțiuni sunt generate implicit în cazul în virgulă mobilă hardware
este folosit.

-mwarn-framesize=Marimea ramei
Emiteți un avertisment dacă funcția curentă depășește dimensiunea de cadru dată. Pentru că aceasta este
o verificare în timp de compilare nu trebuie să fie o problemă reală atunci când programul rulează. Aceasta
este destinat să identifice funcțiile care cel mai probabil provoacă o depășire a stivei. Este
util pentru a fi folosit într-un mediu cu dimensiune limitată a stivei, de exemplu kernel-ul linux.

-mwarn-dynamicstack
Emiteți un avertisment dacă funcția apelează „alloca” sau folosește matrice de dimensiuni dinamice. Acest
este în general o idee proastă cu o dimensiune limitată a stivei.

-mstack-guard=paza-stiva
-mstack-size=dimensiunea stivei
Dacă aceste opțiuni sunt furnizate, back-end-ul S/390 emite instrucțiuni suplimentare în
prolog de funcții care declanșează o capcană dacă dimensiunea stivei este paza-stiva octeți deasupra
dimensiunea stivei (rețineți că stiva de pe S/390 crește în jos). Dacă paza-stiva
opțiunea este omisă cea mai mică putere de 2 mai mare decât dimensiunea cadrului compilat
este aleasă funcția. Aceste opțiuni sunt destinate să fie utilizate pentru a ajuta la depanarea stivei
probleme de preaplin. Codul emis suplimentar cauzează doar o mică suprasarcină și
prin urmare, poate fi folosit și în sisteme asemănătoare producției fără performanțe mai mari
degradare. Valorile date trebuie să fie puteri exacte de 2 și dimensiunea stivei trebuie sa fie
mai mare decât paza-stiva fără a depăși 64k. Pentru a fi eficient plusul
codul presupune că stiva începe la o adresă aliniată cu valoarea
dat de dimensiunea stivei. paza-stiva opțiunea poate fi utilizată numai împreună cu
dimensiunea stivei.

-mhotpatch=pre-jumătăţi de cuvinte,post-jumătate de cuvinte
Dacă opțiunea hotpatch este activată, este generat un prolog al funcției „hot-patching”.
toate funcțiile din unitatea de compilare. Eticheta funcției este prefixată cu cea dată
numărul de instrucțiuni NOP pe doi octeți (pre-jumătăţi de cuvinte, maxim 1000000). După
eticheta, 2* post-jumătate de cuvinte octeții sunt atașați, folosind cele mai mari instrucțiuni de tip NOP
arhitectura permite (maximum 1000000).

Dacă ambele argumente sunt zero, hotpatching-ul este dezactivat.

Această opțiune poate fi suprascrisă pentru funcții individuale cu atributul „hotpatch”.

Scor Opţiuni

Aceste opțiuni sunt definite pentru implementările Score:

-meb
Compilați codul pentru modul big-endian. Aceasta este valoarea implicită.

-mel
Compilați codul pentru modul little-endian.

-mnhwloop
Dezactivați generarea de instrucțiuni „bcnz”.

-muls
Activați generarea sarcinii nealiniate și stocați instrucțiuni.

- mmac
Activați utilizarea instrucțiunilor de multiplicare-acumulare. Dezactivat implicit.

-mscore5
Specificați SCORE5 ca arhitectură țintă.

-mscore5u
Specificați SCORE5U al arhitecturii țintă.

-mscore7
Specificați SCORE7 ca arhitectură țintă. Aceasta este valoarea implicită.

-mscore7d
Specificați SCORE7D ca arhitectură țintă.

SH Opţiuni

Acestea -m opțiunile sunt definite pentru implementările SH:

-m1 Generați codul pentru SH1.

-m2 Generați codul pentru SH2.

-m2e
Generați codul pentru SH2e.

-m2a-nofpu
Generați codul pentru SH2a fără FPU sau pentru un SH2a-FPU în așa fel încât
unitatea în virgulă mobilă nu este utilizată.

-m2a-singur-doar
Generați codul pentru SH2a-FPU, astfel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m2a-singure
Generați codul pentru SH2a-FPU presupunând că unitatea în virgulă mobilă este cu precizie unică
mod implicit.

-m2a
Generați codul pentru SH2a-FPU presupunând că unitatea în virgulă mobilă este în dublă precizie
mod implicit.

-m3 Generați codul pentru SH3.

-m3e
Generați codul pentru SH3e.

-m4-nofpu
Generați codul pentru SH4 fără o unitate în virgulă mobilă.

-m4-singur-doar
Generați cod pentru SH4 cu o unitate în virgulă mobilă care acceptă doar un singur
aritmetica de precizie.

-m4-singura
Generați codul pentru SH4 presupunând că unitatea în virgulă mobilă este în modul de precizie unică
în mod implicit.

-m4 Generați codul pentru SH4.

-m4-100
Generați codul pentru SH4-100.

-m4-100-nofpu
Generați codul pentru SH4-100 în așa fel încât unitatea în virgulă mobilă să nu fie utilizată.

-m4-100-singura
Generați codul pentru SH4-100 presupunând că unitatea în virgulă mobilă este în modul de precizie unică
în mod implicit.

-m4-100-single-doar
Generați codul pentru SH4-100 în așa fel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m4-200
Generați codul pentru SH4-200.

-m4-200-nofpu
Generați codul pentru SH4-200 fără astfel încât unitatea în virgulă mobilă să nu fie
folosit.

-m4-200-singura
Generați codul pentru SH4-200 presupunând că unitatea în virgulă mobilă este în modul de precizie unică
în mod implicit.

-m4-200-single-doar
Generați codul pentru SH4-200 în așa fel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m4-300
Generați codul pentru SH4-300.

-m4-300-nofpu
Generați codul pentru SH4-300 fără astfel încât unitatea în virgulă mobilă să nu fie
folosit.

-m4-300-singura
Generați codul pentru SH4-300 în așa fel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m4-300-single-doar
Generați codul pentru SH4-300 în așa fel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m4-340
Generați codul pentru SH4-340 (fără MMU, fără FPU).

-m4-500
Generați codul pentru SH4-500 (fără FPU). Treci -isa=sh4-nofpu la asamblator.

-m4a-nofpu
Generați codul pentru SH4al-dsp sau pentru un SH4a în așa fel încât virgula mobilă
unitatea nu este utilizată.

-m4a-singur-doar
Generați codul pentru SH4a, astfel încât să nu existe virgulă mobilă cu precizie dublă
se folosesc operatii.

-m4a-singure
Generați codul pentru SH4a presupunând că unitatea în virgulă mobilă este cu precizie unică
mod implicit.

-m4a
Generați codul pentru SH4a.

-m4al
La fel ca -m4a-nofpu, cu excepția faptului că trece implicit -dsp la asamblator. GCC
nu generează nicio instrucțiune DSP în acest moment.

-m5-32media
Generați cod pe 32 de biți pentru SHmedia.

-m5-32media-nofpu
Generați cod pe 32 de biți pentru SHmedia în așa fel încât unitatea în virgulă mobilă să nu fie
folosit.

-m5-64media
Generați cod pe 64 de biți pentru SHmedia.

-m5-64media-nofpu
Generați cod pe 64 de biți pentru SHmedia în așa fel încât unitatea în virgulă mobilă să nu fie
folosit.

-m5-compact
Generați codul pentru SHcompact.

-m5-compact-nofpu
Generați codul pentru SHcompact în așa fel încât unitatea în virgulă mobilă să nu fie utilizată.

-mb Compilați codul pentru procesor în modul big-endian.

-ml Compilați codul pentru procesor în modul little-endian.

-mdalign
Aliniați dublele la granițele de 64 de biți. Rețineți că acest lucru modifică convențiile de apelare,
și astfel unele funcții din biblioteca standard C nu funcționează decât dacă recompilați
mai întâi cu -mdalign.

-mrelaxează-te
Scurtați unele referințe de adrese la momentul link-ului, atunci când este posibil; folosește opțiunea de linker
-Relaxați-vă.

-mbigtable
Utilizați decalaje pe 32 de biți în tabelele „comutați”. Implicit este utilizarea decalajelor de 16 biți.

-mbitops
Activați utilizarea instrucțiunilor de manipulare a biților pe SH2A.

-mfmovd
Activați utilizarea instrucțiunii „fmovd”. Verifica -mdalign pentru constrângeri de aliniere.

-mrenesas
Respectați convențiile de apel definite de Renesas.

-mno-renesas
Respectați convențiile de apelare definite pentru GCC înainte de convențiile Renesas
erau disponibile. Această opțiune este implicită pentru toate țintele lanțului de instrumente SH.

-mnomacsave
Marcați registrul „MAC” ca fiind afectat de apeluri, chiar dacă -mrenesas este dată.

-mieee
-mno-ieee
Controlați conformitatea IEEE a comparațiilor în virgulă mobilă, ceea ce afectează manipularea
a cazurilor în care rezultatul unei comparații este neordonat. În mod implicit -mieee is
implicit activat. Dacă -finit-doar matematică este activat -mno-ieee este implicit setat,
ceea ce are ca rezultat comparații mai rapide cu virgulă mobilă mai mare și mai puțin egale. The
setările implicite pot fi suprascrise prin specificarea fiecăreia -mieee or -mno-ieee.

-minline-ic_invalidate
Cod inline pentru a invalida intrările în cache de instrucțiuni după configurarea funcției imbricate
trambuline. Această opțiune nu are efect dacă -musemode este în vigoare și selectat
opțiunea de generare a codului (de ex -m4) nu permite utilizarea instrucțiunii „icbi”.
Dacă opțiunea de generare a codului selectată nu permite utilizarea „icbi”
instrucție și -musemode nu este în vigoare, codul inline manipulează
matrice de adrese cache de instrucțiuni direct cu o scriere asociativă. Asta nu numai
necesită modul privilegiat în timpul rulării, dar eșuează și dacă linia cache a fost
mapat prin TLB și a devenit nemapat.

- misize
Eliminați dimensiunea instrucțiunii și locația în codul de asamblare.

-mpadstruct
Această opțiune este depreciată. Completează structurile la multiplu de 4 octeți, adică
incompatibil cu SH ABI.

-matomic-model=model
Setează modelul operațiilor atomice și parametrii suplimentari separat prin virgulă
listă. Pentru detalii despre funcțiile încorporate atomice vezi __atomic Construcții.
sunt acceptați următoarele modele și parametri:

nici unul
Dezactivați secvențele atomice generate de compilator și emiteți apeluri de bibliotecă pentru atomic
operațiuni. Aceasta este valoarea implicită dacă ținta nu este „sh*-*-linux*”.

soft-gusa
Generați secvențe atomice de software gUSA compatibile cu GNU/Linux pentru construcția atomică
in functii. Secvențele atomice generate necesită suport suplimentar din partea
codul de gestionare a întreruperii/excepțiilor din sistem și sunt potrivite numai pentru SH3* și
Sisteme cu un singur nucleu SH4*. Această opțiune este activată implicit când ținta este
„sh*-*-linux*” și SH3* sau SH4*. Când ținta este SH4A, această opțiune va fi de asemenea
utilizați parțial instrucțiunile atomice hardware „movli.l” și „movco.l” pentru a
creați un cod mai eficient, cu excepția cazului în care strict este specificat.

soft-tcb
Generați secvențe atomice software care utilizează o variabilă în controlul firului
bloc. Aceasta este o variație a secvențelor gUSA care poate fi folosită și pe SH1*
și ținte SH2*. Secvențele atomice generate necesită sprijin suplimentar din partea
codul de gestionare a întreruperilor/excepțiilor din sistem și sunt potrivite numai pentru
sisteme cu un singur nucleu. Când utilizați acest model, gbr-offset= parametrul trebuie să fie
specificat de asemenea.

masca moale
Generați secvențe atomice software care dezactivează temporar întreruperile prin setare
„SR.IMASK = 1111”. Acest model funcționează numai atunci când programul rulează în modul privilegiat
și este potrivit doar pentru sisteme single-core. Sprijin suplimentar din partea
codul de gestionare a întreruperii/excepțiilor al sistemului nu este necesar. Acest model este
activat în mod implicit când ținta este „sh*-*-linux*” și SH1* sau SH2*.

hard-llcs
Generați secvențe atomice hardware folosind instrucțiunile „movli.l” și „movco.l”.
numai. Acesta este disponibil numai pe SH4A și este potrivit pentru sistemele multi-core.
Deoarece instrucțiunile hardware acceptă doar variabile atomice pe 32 de biți, acces la 8
sau variabilele de 16 biți sunt emulate cu accese de 32 de biți. Cod compilat cu acesta
opțiunea va fi, de asemenea, compatibilă cu alt model atomic software
sisteme de gestionare a întreruperilor/excepțiilor dacă sunt executate pe un sistem SH4A. Adiţional
nu este necesar suportul de la codul de gestionare a întreruperilor/excepțiilor din sistem
pentru acest model.

gbr-offset=
Acest parametru specifică offset-ul în octeți a variabilei din controlul firului
structura de bloc care ar trebui utilizată de secvențele atomice generate atunci când
soft-tcb modelul a fost selectat. Pentru alte modele acest parametru este ignorat.
Valoarea specificată trebuie să fie un multiplu întreg de patru și în intervalul 0-1020.

strict
Acest parametru previne utilizarea mixtă a mai multor modele atomice, chiar dacă acestea
ar fi compatibil și va face compilatorul să genereze secvențe atomice ale
doar modelul specificat.

-mtas
Generați codul operațional „tas.b” pentru „__atomic_test_and_set”. Observați că în funcție de
o anumită configurație hardware și software, aceasta poate degrada performanța generală
din cauza spălărilor de linie cache a operandului care sunt implicate de instrucțiunea „tas.b”. Pe
procesoare SH4A multi-core, instrucțiunea „tas.b” trebuie folosită cu prudență, deoarece aceasta
poate duce la coruperea datelor pentru anumite configurații de cache.

-mprefergot
Când generați cod independent de poziție, emiteți apeluri de funcție folosind Offset-ul global
Tabel în loc de Tabelul de legătură cu proceduri.

-musemode
-mno-modul utilizatorului
Nu permiteți (permite) compilatorului să genereze cod în mod privilegiat. Precizând
-musemode implică de asemenea -mno-inline-ic_invalidate dacă codul inline nu ar funcționa
în modul utilizator. -musemode este implicit când ținta este „sh*-*-linux*”. Dacă
ținta este SH1* sau SH2* -musemode nu are niciun efect, deoarece nu există un mod de utilizator.

-multcost=număr
Setați costul de asumat pentru un insn înmulțit.

-mdiv=strategie
Setați strategia de împărțire care va fi utilizată pentru operațiunile de împărțire întregi. Pentru SHmedia
strategie poate fi unul dintre:

fp Efectuează operația în virgulă mobilă. Aceasta are o latență foarte mare, dar necesită
doar câteva instrucțiuni, așa că ar putea fi o alegere bună dacă codul dvs. are suficient
ILP ușor de exploatat pentru a permite compilatorului să programeze virgulă mobilă
instrucțiuni împreună cu alte instrucțiuni. Împărțirea la zero cauzează a
excepție în virgulă mobilă.

inv Utilizează operații cu numere întregi pentru a calcula inversul divizorului și apoi
înmulțește dividendul cu inversul. Această strategie permite CSE și ridicarea
a calculului invers. Împărțirea cu zero calculează un rezultat nespecificat,
dar nu prinde capcana.

inv:minlat
O variantă a inv unde, dacă nu au fost găsite oportunități de CSE sau de ridicare, sau dacă
intreaga operatiune a fost ridicata in acelasi loc, ultimele etape ale
calculul invers sunt împletite cu înmulțirea finală pentru a reduce totalul
latență, în detrimentul folosirii câtorva instrucțiuni suplimentare, oferind astfel mai puține
oportunități de programare cu alt cod.

apel
Apelează o funcție de bibliotecă care implementează de obicei inv:minlat strategie. Acest
oferă o densitate mare de cod pentru compilațiile „m5-*media-nofpu”.

call2
Utilizează un punct de intrare diferit al aceleiași funcții de bibliotecă, unde presupune că a
pointerul către un tabel de căutare a fost deja configurat, care expune încărcarea pointerului
la CSE și optimizările de ridicare a codului.

inv: apel
inv:call2
inv:fp
Folosește inv algoritm pentru generarea inițială a codului, dar dacă codul rămâne
neoptimizat, reveniți la apel, call2, Sau fp strategii, respectiv. Rețineți că
efectul secundar potențial de captare al împărțirii la zero este purtat de un separat
instrucțiune, deci este posibil ca toate instrucțiunile întregi să fie ridicate,
dar markerul pentru efectul secundar rămâne acolo unde este. O recombinare la
operațiuni în virgulă mobilă sau un apel nu este posibil în acest caz.

inv20u
inv20l
Variante ale inv:minlat strategie. În cazul în care calculul invers este
neseparate de înmulțire, ele accelerează împărțirea acolo unde se potrivește dividendul
în 20 de biți (semnul plus acolo unde este cazul) prin inserarea unui test pentru a omite un număr de
operațiuni în acest caz; acest test încetinește cazul dividendelor mai mari.
inv20u presupune că cazul unui dividend atât de mic este puțin probabil și inv20l
presupune că este probabil.

Pentru alte ținte decât SHmedia strategie poate fi unul dintre:

apel-div1
Apelează o funcție de bibliotecă care folosește instrucțiunea de divizare într-un singur pas „div1” la
efectua operatia. Împărțirea cu zero calculează un rezultat nespecificat și face
nu capcană. Aceasta este valoarea implicită, cu excepția SH4, SH2A și SHcompact.

apel-fp
Apelează o funcție de bibliotecă care efectuează operația în dublă precizie flotantă
punct. Împărțirea la zero provoacă o excepție în virgulă mobilă. Aceasta este valoarea implicită
pentru SHcompact cu FPU. Specificarea acestui lucru pentru ținte care nu au o dublă
FPU de precizie va fi implicit „call-div1”.

masa de apeluri
Apelează o funcție de bibliotecă care utilizează un tabel de căutare pentru divizorii mici și
Instrucțiunea „div1” cu distincție de majuscule pentru divizori mai mari. Impartirea cu zero
calculează un rezultat nespecificat și nu capcană. Aceasta este valoarea implicită pentru SH4.
Specificarea acestui lucru pentru ținte care nu au instrucțiuni de schimbare dinamică va fi
implicit la „call-div1”.

Când o strategie de divizare nu a fost specificată, strategia implicită va fi selectată
pe baza obiectivului actual. Pentru SH2A strategia implicită este de a folosi „divs” și
instrucțiuni „divu” în loc de apeluri de funcție de bibliotecă.

-maccumulate-outgoing-args
Rezervați spațiu o dată pentru argumentele de ieșire în prologul funcției, mai degrabă decât în ​​jur
fiecare apel. În general, benefic pentru performanță și dimensiune. Este necesar și pentru relaxare
pentru a evita modificarea cadrului stivei în jurul codului condiționat.

-mdivsi3_libfunc=nume
Setați numele funcției de bibliotecă utilizată pentru diviziunea semnată pe 32 de biți la nume. Acest
afectează numai numele folosit în apel și inv: apel strategiile de diviziune, iar
Compilatorul încă se așteaptă la aceleași seturi de registre de intrare/ieșire/încărcate ca și cum ar fi acesta
opțiunea nu au fost prezente.

-mfixed-range=registru-gamă
Generați codul tratând intervalul de registre dat ca registre fixe. Un registru fix
este unul pe care alocatorul de registru nu îl poate folosi. Acest lucru este util la compilarea nucleului
cod. Un interval de registre este specificat ca două registre separate printr-o liniuță. Multiplu
intervalele de registru pot fi specificate separate prin virgulă.

-mindexed-adresare
Activați utilizarea modului de adresare indexată pentru SHmedia32/SHcompact. Aceasta este numai
sigur dacă hardware-ul și/sau sistemul de operare implementează o semantică de tip wrap-around pe 32 de biți pentru cei indexați
modul de adresare. Arhitectura permite implementarea procesoarelor pe 64 de biți
MMU, pe care sistemul de operare l-ar putea folosi pentru a obține adresarea pe 32 de biți, dar din moment ce nu există hardware actual
implementarea acceptă aceasta sau orice altă modalitate de a face modul de adresare indexat sigur
pentru a fi utilizat în ABI pe 32 de biți, implicit este -mno-indexat-adresare.

-mgettrcost=număr
Setați costul asumat pentru instrucțiunea „gettr” la număr. Valoarea implicită este 2 dacă
-mpt-fix este în vigoare, 100 altfel.

-mpt-fix
Să presupunem că instrucțiunile „pt*” nu vor capta. Acest lucru generează, în general, un cod mai bine programat,
dar este nesigur pe hardware-ul actual. Definiția actuală a arhitecturii spune asta
„ptabs” și „ptrel” capcană când ținta și cu 3 este 3. Aceasta are
efect neintenționat de a face nesigură programarea acestor instrucțiuni înainte de a
ramificați sau ridicați-le dintr-o buclă. De exemplu, „__do_global_ctors”, o parte din
libgcc care rulează constructori la pornirea programului, apelează funcții dintr-o listă care este
delimitat de -1. Cu -mpt-fix opțiunea, „ptabs” se face înainte de testare
împotriva -1. Asta înseamnă că toți constructorii rulează puțin mai repede, dar când
bucla ajunge la sfârșitul listei, programul se blochează deoarece „ptabs” încarcă -1 într-un
registrul țintă.

Deoarece această opțiune este nesigură pentru orice hardware care implementează arhitectura actuală
specificație, implicit este -mno-pt-fixat. Dacă nu este specificat în mod explicit cu
-mgettrcost, -mno-pt-fixat implică de asemenea -mgettrcost=100; aceasta descurajează înregistrarea
alocare din utilizarea registrelor țintă pentru stocarea numerelor întregi obișnuite.

-minvalid-simboluri
Să presupunem că simbolurile ar putea fi nevalide. Simboluri de funcție obișnuite generate de compilator
sunt întotdeauna valide pentru încărcare cu „movi”/”shori”/”ptabs” sau „movi”/”shori”/”ptrel”, dar
cu trucuri de asamblare și/sau linker este posibil să se genereze simboluri care provoacă
„ptabs” sau „ptrel” la capcană. Această opțiune are sens numai atunci când -mno-pt-fixat este in
efect. Previne CSE cu blocuri de bază încrucișate, ridicarea și cea mai mare parte a programării simbolului
încărcături. Valoarea implicită este -mno-invalid-simboluri.

-mbranch-cost=o
presupune o să fie costul pentru o instruire de ramură. Numerele mai mari fac compilatorul
încercați să generați mai mult cod fără ramuri, dacă este posibil. Dacă nu este specificată valoarea este
selectat în funcție de tipul de procesor pentru care este compilat.

-mzdcbranch
-mno-zdcbranch
Să presupunem (nu să presupunem) că instrucțiunile de ramură condiționată cu deplasare zero „bt” și
„bf” sunt rapide. Dacă -mzdcbranch este specificat, compilatorul va încerca să prefere zero
secvențe de coduri de ramuri de deplasare. Aceasta este activată în mod implicit la generarea codului
pentru SH4 și SH4A. Poate fi dezactivat explicit prin specificare -mno-zdcbranch.

-mfused-madd
-mno-fuzionat-madd
Generați cod care utilizează (nu utilizează) multiplicarea și acumularea în virgulă mobilă
instrucțiuni. Aceste instrucțiuni sunt generate implicit în cazul în virgulă mobilă hardware
este folosit. Dependent de mașină -mfused-madd opțiunea este acum mapată la mașină-
independent -ffp-contract=rapid opțiune și -mno-fuzionat-madd este mapat la
-ffp-contract=off.

-mfsca
-mno-fsca
Permiteți sau interziceți compilatorului să emită instrucțiunea „fsca” pentru sinus și cosinus
aproximări. Opțiunea „-mfsca” trebuie utilizată în combinație cu
„-funsafe-math-optimizations”. Este activat implicit la generarea codului pentru
SH4A. Folosirea „-mno-fsca” dezactivează aproximările sinus și cosinus chiar dacă
„-funsafe-math-optimizations” este în vigoare.

-mfsrra
-mno-fsrra
Permiteți sau interziceți compilatorului să emită instrucțiunea „fsrra” pentru pătrat reciproc
aproximări de rădăcină. Opțiunea „-mfsrra” trebuie utilizată în combinație cu
„-funsafe-math-optimizations” și „-finite-math-only”. Este activat implicit când
generarea codului pentru SH4A. Folosirea „-mno-fsrra” dezactivează rădăcina pătrată reciprocă
aproximări chiar dacă „-funsafe-math-optimizations” și „-finite-math-only” sunt în
efect.

-pretend-cmove
Preferați ramurile condiționate cu deplasare zero pentru instrucțiunile de mutare condiționată
modele. Acest lucru poate duce la un cod mai rapid pe procesorul SH4.

Solaris 2 Opţiuni

Acestea -m opțiunile sunt acceptate pe Solaris 2:

-mclear-hwcap
-mclear-hwcap spune compilatorului să elimine capabilitățile hardware generate de
Asamblator Solaris. Acest lucru este necesar numai atunci când fișierele obiect nu folosesc extensii ISA
acceptate de mașina curentă, dar verificați în timpul execuției dacă să le utilizați sau nu.

-mipur-text
-mipur-text, folosit pe lângă -impartit, îi spune compilatorului să nu treacă -z text la
linkerul atunci când conectați un obiect partajat. Folosind această opțiune, puteți conecta poziție-
cod dependent într-un obiect partajat.

-mipur-text suprimă „relocarile rămân împotriva alocabile, dar nescrise
mesaj de eroare de linker de secțiuni". Cu toate acestea, relocarile necesare declanșează copierea
scrie, iar obiectul partajat nu este de fapt partajat între procese. In loc de
folosind -mipur-text, ar trebui să compilați tot codul sursă cu -fpic or -fPIC.

Aceste comutatoare sunt acceptate în plus față de cele de mai sus pe Solaris 2:

-pthreads
Adăugați suport pentru multithreading folosind biblioteca de fire POSIX. Această opțiune se stabilește
flag-uri atât pentru preprocesor, cât și pentru linker. Această opțiune nu afectează firul
siguranța codului obiect produs de compilator sau a bibliotecilor furnizate cu acesta.

-pthread
Acesta este un sinonim pentru -pthreads.

SPARC Opţiuni

Acestea -m opțiunile sunt acceptate pe SPARC:

-mno-app-regs
-mapp-regs
Specifica -mapp-regs pentru a genera ieșire folosind registrele globale de la 2 la 4, care
SPARC SVR4 ABI rezervă pentru aplicații. La fel ca registrul global 1, fiecare global
registrul de la 2 la 4 este apoi tratat ca un registru alocabil care este lovit de
apeluri de funcții. Aceasta este valoarea implicită.

Pentru a fi pe deplin compatibil SVR4 ABI cu prețul unei pierderi de performanță, specificați
-mno-app-regs. Ar trebui să compilați biblioteci și software de sistem cu această opțiune.

-mflat
-mno-plat
Cu -mflat, compilatorul nu generează instrucțiuni de salvare/restaurare și folosește a
model cu fereastră „plată” sau cu un singur registru. Acest model este compatibil cu modelul obișnuit
modelul ferestrei de înregistrare. Registrele locale și registrele de intrare (0--5) sunt încă
tratate ca registre „apel-salvate” și sunt salvate în stivă după cum este necesar.

Cu -mno-plat (implicit), compilatorul generează instrucțiuni de salvare/restaurare (cu excepția
pentru funcțiile frunzelor). Acesta este modul normal de funcționare.

-mfpu
-mhard-float
Generați rezultate care conțin instrucțiuni în virgulă mobilă. Aceasta este valoarea implicită.

-mno-fpu
-msoft-float
Generați rezultate care conțin apeluri de bibliotecă pentru virgulă mobilă. Avertisment: necesarul
bibliotecile nu sunt disponibile pentru toate țintele SPARC. În mod normal, facilitățile de la
se utilizează compilatorul C obișnuit al mașinii, dar acest lucru nu se poate face direct în cross-
compilare. Trebuie să vă faceți propriile aranjamente pentru a oferi o bibliotecă adecvată
funcții pentru compilare încrucișată. Țintele încorporate sparc-*-aout și sparclit-*-*
oferă suport software în virgulă mobilă.

-msoft-float modifică convenția de apelare în fișierul de ieșire; prin urmare, este numai
util dacă compilați toate a unui program cu această opțiune. În special, trebuie
compila libgcc.a, biblioteca care vine cu GCC, cu -msoft-float pentru aceasta
la locul de muncă.

-mhard-quad-float
Generați rezultate care să conțină instrucțiuni în virgulă mobilă cu patru cuvinte (duble lungi).

-msoft-quad-float
Generați rezultate care conțin apeluri de bibliotecă pentru virgulă mobilă cu patru cuvinte (dublu lung).
instrucțiuni. Funcțiile apelate sunt cele specificate în SPARC ABI. Acesta este
Mod implicit.

În momentul scrierii acestui articol, nu există implementări SPARC care să aibă suport hardware pentru
instrucțiunile în virgulă mobilă cu patru cuvinte. Toți invocă un gestionator de capcane pentru unul dintre
aceste instrucțiuni, iar apoi manipulatorul capcanei emulează efectul instrucțiunii.
Din cauza supraîncărcării de gestionare a capcanelor, acest lucru este mult mai lent decât apelarea bibliotecii ABI
rutine. Astfel, cel -msoft-quad-float opțiunea este implicită.

-mno-nealiniate-duble
-munaligned-duble
Să presupunem că dublele au o aliniere de 8 octeți. Aceasta este valoarea implicită.

Cu -munaligned-duble, GCC presupune că dublele au aliniere pe 8 octeți numai dacă acestea
sunt cuprinse într-un alt tip, sau dacă au o adresă absolută. Altfel, ea
presupune că au o aliniere pe 4 octeți. Specificarea acestei opțiuni evită unele rare
probleme de compatibilitate cu codul generat de alți compilatori. Nu este implicit
deoarece are ca rezultat o pierdere de performanță, în special pentru codul în virgulă mobilă.

-modul-muser
-mno-user-mode
Nu generați cod care poate rula doar în modul supervizor. Acest lucru este relevant doar pentru
instructiunea "casa" emisa pentru procesorul LEON3. Valoarea implicită este
-mno-user-mode.

-mno-faster-structs
-mfaster-structs
Cu -mfaster-structs, compilatorul presupune că structurile ar trebui să aibă 8 octeți
aliniere. Acest lucru permite utilizarea perechilor de instrucțiuni „ldd” și „std” pentru copii
în atribuirea structurii, în locul de două ori mai multe perechi „ld” și „st”. Însă
utilizarea acestei alinieri modificate încalcă direct SPARC ABI. Astfel, este destinat
numai pentru utilizare pe ținte în care dezvoltatorul recunoaște că codul rezultat este
neconform direct cu regulile ABI.

-mcpu=tip_cpu
Setați setul de instrucțiuni, setul de registre și parametrii de programare a instrucțiunilor pentru
tip de mașină tip_cpu. Valori acceptate pentru tip_cpu sunt v7, chiparos, v8, supersparc,
hipersparc, leon, leon3, leon3v7, sparclit, f930, f934, sparclite86x, sclipire,
tsc701, v9, ultrasparc, ultrasparc3, niagara, niagara2, niagara3 și niagara4.

Lanțurile de instrumente native Solaris și GNU/Linux susțin, de asemenea, valoarea nativ, care selectează
cea mai bună opțiune de arhitectură pentru procesorul gazdă. -mcpu=nativ nu are efect dacă
GCC nu recunoaște procesorul.

Parametrii impliciti de programare a instrucțiunilor sunt utilizați pentru valorile care selectează un
arhitectura si nu o implementare. Acestea sunt v7, v8, sparclit, sclipire, v9.

Iată o listă a fiecărei arhitecturi acceptate și implementările lor acceptate.

v7 chiparos, leon3v7

v8 supersparc, hypersparc, leon, leon3

sparclit
f930, f934, sparclite86x

sclipire
tsc701

v9 ultrasparc, ultrasparc3, ​​niagara, niagara2, niagara3, niagara4

În mod implicit (dacă nu este configurat altfel), GCC generează cod pentru varianta V7 a
Arhitectura SPARC. Cu -mcpu=chiparos, compilatorul îl optimizează suplimentar pentru
cipul Cypress CY7C602, așa cum este utilizat în seria SPARCStation/SPARCServer 3xx. Aceasta este
adecvat și pentru SPARCStation 1, 2, IPX mai vechi etc.

Cu -mcpu=v8, GCC generează cod pentru varianta V8 a arhitecturii SPARC. The
singura diferență față de codul V7 este că compilatorul emite multiplicarea întregului și
Instrucțiuni de împărțire întregi care există în SPARC-V8, dar nu și în SPARC-V7. Cu
-mcpu=supersparc, compilatorul îl optimizează suplimentar pentru cipul SuperSPARC, ca
utilizat în seriile SPARCStation 10, 1000 și 2000.

Cu -mcpu=sparclit, GCC generează cod pentru varianta SPARClite a SPARC
arhitectură. Aceasta adaugă înmulțirea întregului, pasul de împărțire a întregului și scanarea ("ffs")
instrucțiuni care există în SPARClite, dar nu și în SPARC-V7. Cu -mcpu=f930,
compilatorul îl optimizează suplimentar pentru cipul Fujitsu MB86930, care este originalul
SPARClite, fără FPU. Cu -mcpu=f934, compilatorul îl optimizează suplimentar pentru
cipul Fujitsu MB86934, care este cel mai recent SPARClite cu FPU.

Cu -mcpu=sparclet, GCC generează cod pentru varianta SPARClet a SPARC
arhitectură. Aceasta adaugă înmulțirea întregului, înmulțirea/acumularea, împărțirea întregului
instrucțiuni de pas și scanare ("ffs") care există în SPARClet, dar nu în SPARC-V7. Cu
-mcpu=tsc701, compilatorul îl optimizează suplimentar pentru cipul TEMIC SPARClet.

Cu -mcpu=v9, GCC generează cod pentru varianta V9 a arhitecturii SPARC. Acest
adaugă instrucțiuni de mutare cu numere întregi și în virgulă mobilă pe 64 de biți, 3 în virgulă mobilă suplimentare
registre de cod de condiție și instrucțiuni de mutare condiționată. Cu -mcpu=ultrasparc,
compilatorul îl optimizează suplimentar pentru cipurile Sun UltraSPARC I/II/IIi. Cu
-mcpu=ultrasparc3, compilatorul îl optimizează suplimentar pentru Sun UltraSPARC
jetoane III/III+/IIIi/IIIi+/IV/IV+. Cu -mcpu=niagara, compilatorul în plus
îl optimizează pentru cipurile Sun UltraSPARC T1. Cu -mcpu=niagara2, compilatorul
îl optimizează suplimentar pentru cipurile Sun UltraSPARC T2. Cu -mcpu=niagara3,
compilatorul îl optimizează suplimentar pentru cipurile Sun UltraSPARC T3. Cu -mcpu=niagara4,
compilatorul îl optimizează suplimentar pentru cipurile Sun UltraSPARC T4.

-mtune=tip_cpu
Setați parametrii de programare a instrucțiunilor pentru tipul de mașină tip_cpu, dar nu setați
setul de instrucțiuni sau setul de registru care opțiunea -mcpu=tip_cpu nu.

Aceleași valori pentru -mcpu=tip_cpu pot fi folosite pentru -mtune=tip_cpu, dar singurul
valorile utile sunt cele care selectează o anumită implementare a CPU. Acestea sunt
chiparos, supersparc, hipersparc, leon, leon3, leon3v7, f930, f934, sparclite86x,
tsc701, ultrasparc, ultrasparc3, niagara, niagara2, niagara3 și niagara4. Cu
lanțuri de instrumente native Solaris și GNU/Linux, nativ poate fi de asemenea utilizat.

-mv8plus
-mno-v8plus
Cu -mv8plus, GCC generează cod pentru SPARC-V8+ ABI. Diferența față de V8
ABI este că registrele globale și out sunt considerate lățime de 64 de biți. Acest lucru este activat
implicit pe Solaris în modul pe 32 de biți pentru toate procesoarele SPARC-V9.

-mvis
-mno-vis
Cu -mvis, GCC generează cod care profită de UltraSPARC Visual
Extensii pentru set de instrucțiuni. Valoarea implicită este -mno-vis.

-mvis2
-mno-vis2
Cu -mvis2, GCC generează cod care profită de versiunea 2.0 a UltraSPARC
Extensii pentru set de instrucțiuni vizuale. Valoarea implicită este -mvis2 când țintiți un procesor care
acceptă astfel de instrucțiuni, cum ar fi UltraSPARC-III și ulterioare. Setare -mvis2 de asemenea
seturi -mvis.

-mvis3
-mno-vis3
Cu -mvis3, GCC generează cod care profită de versiunea 3.0 a UltraSPARC
Extensii pentru set de instrucțiuni vizuale. Valoarea implicită este -mvis3 când țintiți un procesor care
acceptă astfel de instrucțiuni, cum ar fi niagara-3 și mai târziu. Setare -mvis3 de asemenea seturi
-mvis2 și -mvis.

-mcbcond
-mno-cbcond
Cu -mcbcond, GCC generează cod care profită de comparare și ramificare
instrucțiuni, așa cum sunt definite în Sparc Architecture 2011. Valoarea implicită este -mcbcond cand
vizează un procesor care acceptă astfel de instrucțiuni, cum ar fi niagara-4 și mai târziu.

-mpopc
-mno-popc
Cu -mpopc, GCC generează cod care profită de populația UltraSPARC
instrucțiuni de numărare. Valoarea implicită este -mpopc atunci când vizați un procesor care acceptă astfel de
instrucțiuni, cum ar fi Niagara-2 și mai târziu.

-mfmaf
-mno-fmaf
Cu -mfmaf, GCC generează cod care profită de UltraSPARC Fused Multiply-
Adăugați extensii în virgulă mobilă. Valoarea implicită este -mfmaf când țintiți un procesor care
acceptă astfel de instrucțiuni, cum ar fi Niagara-3 și mai târziu.

-mfix-at697f
Activați soluția documentată pentru o singură eroare a procesorului Atmel AT697F
(care corespunde erratumului #13 al procesorului AT697E).

-mfix-ut699
Activați soluțiile documentate pentru errata în virgulă mobilă și memoria cache de date
anulați erratele procesorului UT699.

Acestea -m opțiunile sunt acceptate în plus față de cele de mai sus pe procesoarele SPARC-V9 pe 64 de biți
medii:

-m32
-m64
Generați cod pentru un mediu pe 32 de biți sau 64 de biți. Mediul pe 32 de biți setează int,
lung și indicator la 32 de biți. Mediul pe 64 de biți setează int la 3