arm-linux-gnueabihf-gcc-4.7 - Online în cloud

PROGRAM:

NUME

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

REZUMAT

gcc [-c|-S|-E] [-std=standard]
[-g] [-pag] [-Onivel]
[-Wavertiza...] [-pedant]
[-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 va fi -fno-foo. Acest manual documentează doar unul dintre
aceste 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] -fdump-go-spec=fişier

C Limbă 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 -fms-extensii -fplan9-extensii -trigrafe
-fără-integrat-cpp -tradiţional -traditional-cpp -intars-singura-precizie
-fcond-nepotrivire -conversii-vectorale-in -fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char

C ++ Limbă Opţiuni
-fabi-version=n -fno-control-acces -fcheck-new -fconserve-spațiu
-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-depth=n
-fno-threadsafe-statics -fuzibil-cxa-atexit -fno-slab -nostdinc++ -fno-default-inline
-fvizibility-inline-hidden -fvizibility-ms-compat - Wabi -Wconversion-null
-Wctor-dtor-privacy -Wdelete-non-virtual-dtor -Î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++ Limbă 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

Limbă Independent Opţiuni
-fmessage-length=n -fdiagnostics-show-location=[dată|fiecare-linie]
-fno-diagnostics-show-option

avertizare Opţiuni
-doar fsyntax -fmax-erori=n -pedant -pedant-erori -w -Wextra -Perete
-Waddress -Waggregate-retur - Limite de război -Wno-atribute
-Wno-builtin-macro-redefinit -Wc++-compat -Wc++11-compat -Wcast-align -Wcast-qual
-Wchar-indice -Wclobbered -Wcomentează -Wconversie -Wacoperire-nepotrivire -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-bucla-optimizări
-Wlogic-op -Lung-lung -Wmain -Wpoate-neinițializat - Acolade lipsă
-Inițializatoare-câmp lipsesc -Atribut-format-lipsă -Fără-include-dir-uri
-Wno-flap de noroi -Wno-multichar -Wnonnull -Wno-overflow -Woverlungime-şiruri -Ambalat
-Wpacked-bitfield-compat -Wcaptusit - Paranteze -Wpedantic-ms-format
-Format-wno-pedant-ms -Wpointer-arith -Wno-pointer-to-int-cast -Wredundant-decls
-de tip Wreturn -Wsecvența-punct -Wshadow -Wsign-compara -Wsign-conversie
-Wstack-protector -Wstack-usage=len -Wstrict-aliasing -Wstrict-aliasing=n
-Wstrict-debordare -Wstrict-overflow=n -Wsuggest-atribut=[pur|CONST|fără întoarcere]
- Î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
-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 -fdbg-cnt-list -fdbg-cnt=tejghea-
listă de valori -fdisable-ipa-pass_name -fdisable-rtl-pass_name -fdisable-rtl-trece-
nume=listă-gamă -fdisable-tree-pass_name -fdisable-tree-nume de trecere=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-vcg -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-mudflap[-n]
-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-vrp[-n] -fttree-vectorizer-verbose=n -fdump-tree-storeccp[-n]
-fdump-final-insns=fişier -fcompare-debug[=optează] -fcompare-debug-second
-feliminate-dwarf2-dups -elimină-neutilizate-tipuri-depanare
-elimină-neutilizate-debug-simboluri -femit-class-debug-intotdeauna -fenabil-natural-trece
-fenabil-natural-trece=listă-gamă -fdebug-types-section -fmem-report -fpre-ipa-mem-report
-fpost-ipa-mem-report -fprofil-arcuri -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
-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 -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
-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-matrix-reorg -fipa-pta -fipa-profil -fipa-pură-const
-fipa-referință -fira-algoritm=Algoritmul -fira-region=regiune -fira-bucla-presiune
-fno-ira-share-save-slots -fno-ira-share-spill-slots -fira-verbose=n -fivopt
-fkeep-inline-functions -fkeep-static-const -floop-bloc -floop-platit
-floop-interchange -floop-strip-mina -floop-paraleliza-toate -flto
-flto-nivel-compresie -flato-partition=ALG -flto-raport -fmerge-toate-constantele
-fmerge-constante -fmodulo-sched -fmodulo-sched-allow-regmoves -fmove-loop-invariants
fmudflap -fmudflapir -fmudflapth -fno-ramură-număr-reg -fno-default-inline
-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-register-mute
-foptimize-frate-apeluri -fpartial-inlining -fpeel-bucle -fpredictiv-comuning
-fprefetch-loop-arrays -fprofile-corectie -fprofile-dir=cale -fprofile-generate
-fprofile-generate=cale -fprofile-use -fprofile-use=cale -fprofile-valori
-freciprocal-matematică -gratuit -fregmove -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 -fstrict-aliasing
-fstrict-overflow -fthread-sărituri -ftracer -ftree-bit-ccp -ftree-builtin-call-dce
-ftree-ccp -fttree-ch -fttree-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 -fttree-paraleliza-bucle=n
-fttree-pre -fttree-partial-pre -fttree-pta -fttree-reassoc -ftree-chiuvetă -ftree-sra
-ftree-switch-conversie -fttree-tail-merge -ftree-ter -ftree-vect-loop-versiunea
-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 -plugin-fuse-linker --param nume=valoare -O -O0 -O1 -O2 -O3 -Os
-De repede

Preprocesor Opţiuni
-Aîntrebare=răspunde -ARE-î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

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++ -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

Mașină Dependent Opţiuni
AAArch64 Opţiuni -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 -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

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 -mfpe -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 -mcirrus-fix-invalid-insns
-mno-cirrus-fix-invalid-insns -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

AVR Opţiuni -mmcu=mcu -maccumulate-args -mbranch-cost =costa -mcall-proloage -mentă8
-mno-întreruperi -mrelaxează-te -mshort-calls -mstrict-X -mtiny-stack

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-soluție

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 -malpha-as -mgas -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

Decembrie Alfa/VMS Opţiuni -mvms-coduri-return -mdebug-main=prefix -mmalloc64

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 -mentă32 -malign-300

HPPA Opţiuni -martie=de tip arhitectură -mbig-switch -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-mare-switch -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 -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 -maes -mpclmul
-mfsgsbase -mrdrnd -mf16c -mfma -msse4a -m3dnow -mpopcnt -mabm -mbmi -mtbm -mfma4
-mxop -mlzcnt -mbmi2 -mlwp -mthreads -mno-align-stringops -minline-all-stringops
-minline-stringops-dinamic -mstringop-strategy=ALG -mpush-args
-macumulare-ieşire-args -m128bit-long-dublu -m96bit-long-dublu -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 -mlarge-data-threshold=o -msse2avx
-mfentry -m8bit-idiv -mavx256-split-unaligned-load -mavx256-split-unaligned-store

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

AI-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

IA-64/VMS Opţiuni -mvms-coduri-return -mdebug-main=prefix -mmalloc64

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 -mrepet -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
-mxl-mode-modelul aplicației

Extensie MIPS Opţiuni -CE -EB -martie=arc -mtune=arc -mips1 -mips2 -mips3 -mips4
-mips32 -mips32r2 -mips64 -mips64r2 -mips16 -mno-mips16 -mflip-mips16
-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 -msingle-float -mdouble-float -mdsp -mno-dsp
-mdspr2 -mno-dspr2 -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
-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-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

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 -putere
-mno-putere -putere2 -mno-putere2 -mpowerpc -mpowerpc64 -mno-powerpc -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
-mnew-mnemonic -mucegai-mnemonic -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 -mprioritizare-restricţionat-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

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 -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

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ă -madjust-unroll
-mindexed-adresare -mgettrcost=număr -mpt-fix -macumulare-ieşire-args
-minvalid-simboluri -msoft-atomic -mbranch-cost =o -mcbranchdi -mcmpeqdi -mfused-madd
-pretend-cmove

Solaris 2 Opţiuni -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 -mv8plus -mno-v8plus -mvis -mno-vis -mvis2 -mno-vis2
-mvis3 -mno-vis3 -mfmaf -mno-fmaf -mpopc -mno-popc -mfix-at697f

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

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 -mbig-switch

VAX Opţiuni -mg -mgnu -munix

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
-mesele-funwind -tabele-fasynchronous-unwind -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 -ftrapv
-fwrapv -fbounds-check -fvizibilitate -fstrict-volatile-bitfields

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.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
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 va ieși cu codul 1 dacă orice fază a compilatorului
returnează un cod de returnare nereușit. Daca specificati -coduri de trecere-ieșire, gcc program
va reveni în schimb cu cea mai mare eroare numeric produsă de orice fază care a revenit
o indicație de eroare. Frontend-urile C, C++ și Fortran returnează 4, dacă sunt interne
este întâlnită o eroare de compilator.

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
fiind produs, fie că este un fișier executabil, un fișier obiect, un fișier de asamblare sau
cod C preprocesat.

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 va fi de asemenea transmisă către
diverse procese invocate de gcc, astfel încât să poată afișa opțiunile din linia de comandă
ei acceptă. Dacă -Wextra a fost specificată și opțiunea (înainte de --Ajutor
opțiune), apoi opțiuni de linie de comandă care nu au nicio documentație asociată acestora
va fi de asemenea 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
Aceasta va afișa toate opțiunile de optimizare acceptate de compilator.

avertismente
Aceasta va afișa toate opțiunile care controlează mesajele de avertizare produse de
compilator.

ţintă
Aceasta va afișa opțiuni specifice țintei. spre deosebire de --ţintă-ajutor opțiune
cu toate acestea, opțiunile specifice țintei ale linkerului și ale asamblatorului nu vor fi
afișat. Acest lucru se datorează faptului că acele instrumente nu acceptă în prezent extinderea
--ajutor= sintaxă.

parametrii
Aceasta va afișa valorile recunoscute de --param opțiune.

limbă
Aceasta va afișa opțiunile acceptate pentru limbă, În cazul în care limbă este numele
a uneia dintre limbile acceptate în această versiune a GCC.

comun
Aceasta va afișa 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 poate fi folosit:

--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 restricționează de obicei rezultatul prin
atât de mult încât nu este nimic de afișat. Cu toate acestea, un caz în care funcționează este când
una dintre clase este ţintă. Deci, de exemplu, pentru a afișa toate obiectivele specifice
Opțiuni de optimizare pot fi utilizate următoarele:

--help=țintă,optimizatori

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

Î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

Acest lucru va invoca toate subprogramele ale gcc în gDB --args, astfel invocarea lui cc1
va fi 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.

-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
tratează .c, .h și .i fișierele ca fișiere sursă C++ în loc de fișiere sursă C, cu excepția cazului în care -x is
folosit și specifică automat legătura cu biblioteca C++. Acest program este, de asemenea
util atunci când precompilați un 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, -pedant 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 ar fi în mod normal încorporate, dar care nu au semantică definită de ISO C
(cum ar fi „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. Prin specificarea unui standard de bază,
compilatorul va accepta toate programele care urmează acel standard și cele care folosesc GNU
extensii care nu o contrazic. De exemplu, -std=c90 se stinge anumite
caracteristici ale GCC care sunt incompatibile cu ISO C90, cum ar fi „asm” și „typeof”
cuvinte cheie, dar nu și alte extensii GNU care nu au un sens în ISO C90, cum ar fi
omițând termenul mijlociu al unei expresii „?:”. Pe de altă parte, prin specificarea unui GNU
dialectul unui standard, toate caracteristicile suportate de compilator sunt activate, chiar și atunci când acestea
caracteristicile schimbă semnificația standardului de bază și a unor programe strict conforme
poate fi respins. Standardul special este folosit de -pedant pentru a identifica care
caracteristicile sunt extensii GNU având în vedere acea versiune a standardului. De exemplu -std=gnu90
-pedant ar avertiza despre stilul C++ // comentarii, în timp ce -std=gnu99 -pedant ar
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. Rețineți că acest standard nu este încă pe deplin acceptat; vedea
<http://gcc.gnu.org/gcc-4.7/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. Suportul este incomplet și
experimental. 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. Când ISO C99 este pe deplin implementat în GCC, acest lucru va fi
devin implicit. Numele gnu9x este depreciat.

gnu11
gnu1x
Dialectul GNU al ISO C11. Suportul este incomplet și experimental. Numele gnu1x
este depreciat.

c++98
Standardul ISO C++ din 1998 plus amendamente. La fel ca -ansi pentru codul C++.

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

c++11
Standardul ISO C++ din 2011 plus amendamente. Suportul pentru C++11 este încă
experimental și se poate schimba în moduri incompatibile în versiunile viitoare.

gnu++11
dialectul GNU al -std=c++11. Suportul pentru C++11 este încă experimental și se poate schimba
î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 rele la „printf”, când „printf” este
integrat ș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 are loc într-un mediu găzduit. Asta implică -încorporat.
Un mediu 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 are loc într-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 v3.0http://www.openmp.org/>. Această opțiune
implică -pthreadși, prin urmare, este acceptat numai pe ținte care au suport pentru
-pthread.

-fgnu-tm
Când opțiunea -fgnu-tm este specificat, compilatorul va genera 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.

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

-fără-integrat-cpp
Efectuează o compilare în două treceri: preprocesare și compilare. Această opțiune permite
un utilizator a furnizat „cc1”, „cc1plus” sau „cc1obj” prin intermediul -B opțiune. Utilizatorul a furnizat
pasul de compilare poate adăuga apoi un pas suplimentar de preprocesare după normal
preprocesare dar înainte de compilare. Implicit este utilizarea cpp-ului integrat
(cpp intern)

Semantica acestei opțiuni se va schimba dacă „cc1”, „cc1plus” și „cc1obj” sunt îmbinate.

-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++;
dar puteți folosi și majoritatea opțiunilor compilatorului GNU, indiferent de limba dvs
programul este î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 afară pentru compilarea programelor C++:

-fabi-version=n
Folosiți versiunea n din C++ ABI. Versiunea 2 este prima versiune a C++ ABI
a apărut în G++ 3.4. Versiunea 1 este versiunea C++ ABI care a apărut pentru prima dată în
G++ 3.2. Versiunea 0 va fi întotdeauna versiunea care se conformează cel mai mult cu C++
Specificația ABI. Prin urmare, ABI obținut folosind versiunea 0 se va schimba ca ABI
bug-urile sunt remediate.

Valoarea implicită este versiunea 2.

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” va returna 0 doar dacă este declarat arunca(),
caz în care compilatorul va verifica întotdeauna valoarea returnată chiar și fără aceasta
opțiune. În toate celelalte cazuri, când „operator nou” are o excepție nevide
specificație, epuizarea memoriei este semnalată prin aruncarea „std::bad_alloc”. Vezi si
nou (nothrow).

-fconserve-spațiu
Puneți variabile globale neinițializate sau inițializate în timpul execuției în segmentul comun, cum ar fi
C face. Acest lucru economisește spațiu în executabil cu prețul nediagnosticării duplicatelor
definiții. Dacă compilați cu acest steag și programul dvs. se blochează în mod misterios
după ce „main()” s-a terminat, este posibil să aveți un obiect care este distrus de două ori
deoarece două definiții au fost îmbinate.

Această opțiune nu mai este utilă pentru majoritatea țintelor, acum că a fost adăugat suport pentru
introducerea variabilelor în BSS fără a le face comune.

-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 va
optimizați în continuare pe baza specificațiilor, astfel încât să aruncați o excepție neașteptată
duce la un comportament nedefinit.

-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++.

Valoarea implicită dacă niciunul nu este dat pentru a urma standardul, ci pentru a permite și a da a
avertisment pentru codul de stil 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 în mod diferit, astfel încât compilarea cu și fără optimizare va face
au nevoie de 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 va cauza erori de linker dacă aceste funcții nu sunt
aliniate oriunde sunt numite.

-fms-extensii
Dezactivați avertismentele pedante 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”.
pentru a reduce sau elimina 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 va face de fapt funcția mai mică
deoarece curățările EH pentru acele variabile pot fi optimizate. Semantica
efectul este că o excepție aruncată dintr-o funcție cu o astfel de excepție
specificația va avea ca rezultat un apel la „încetare” 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 va 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
va tipări în mod normal semnătura șablonului urmată de argumentele șablonului
și orice tip de tip sau nume de tip din 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 va 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 usor, folosind -fno-pretty-şabloane le va 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 le va genera după cum este necesar.
dinamic_cast operator poate fi folosit în continuare pentru turnări care nu necesită timp de rulare
informații de tip, 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-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
manipularea destructorilor statici conform standardelor, dar va funcționa numai dacă C
biblioteca acceptă „__cxa_atexit”.

-fno-use-cxa-get-exception-ptr
Nu utilizați rutina de rulare „__cxa_get_exception_ptr”. Acest lucru va cauza
„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 la care adresele celor două funcții au fost 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 va avea 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 mult de un obiect comun diferit: acelea
declarațiile sunt permise dacă ar fi fost permise atunci când era această opțiune
nefolosit.

Î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 vor fi diferite, deci
schimbarea unuia nu va schimba pe celălalt; și că indică către membrii funcției definiți
în diferite obiecte partajate pot să nu se compare egale. Când acest steag este dat, este a
încălcarea ODR pentru a defini diferit tipurile cu același nume.

-fno-slab
Nu utilizați suport pentru simboluri slabe, chiar dacă este furnizat de linker. Implicit, G++
va folosi simboluri slabe dacă acestea sunt disponibile. Această opțiune există doar pentru testare și
nu ar trebui să fie utilizat de utilizatorii finali; va avea ca rezultat 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++:

-fno-default-inline
Nu presupune inline pentru funcțiile definite în cadrul unei clase.
Rețineți că aceste funcții vor avea legături precum funcțiile inline; pur și simplu nu vor
fi aliniat în mod implicit.

- 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 va fi 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++ va plasa „B::f2” în același octet cu „A::f1”; alte compilatoare
nu voi. Puteți evita această problemă completând în mod explicit „A” astfel încât dimensiunea acesteia
este un multiplu al mărimii octeților de pe platforma dvs.; care va provoca G++ și altele
compilatoare la aspectul „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 va plasa „B” în tail-padding pentru „A”; alte
compilatorii vor. 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); asta va
determina G++ și alte compilatoare să dispună „C” în mod 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++ va face uniunea prea mică
după 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++ va plasa clasa de bază „A” a „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ă modificările legate de psABI. Modificările psABI cunoscute în acest moment includ:

· Pentru SYSV/x86-64, la trecerea uniunii cu dublu lung, se schimbă pentru a trece în
memorie așa cum este specificat în psABI. De exemplu:

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

„uniunea U” va fi î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.

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

-Î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
caz în care ar fi posibil, dar nesigur, să ștergeți o instanță a unei clase derivate
printr-un pointer către clasa de bază. Acest avertisment este, de asemenea, activat dacă -Weffc++ is
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 va rearanja inițializatoarele membre pentru i și j pentru a se potrivi cu
ordin de declarare a membrilor, emitând un avertisment în acest sens. Acest avertisment este
activat de -Perete.

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 ++, Al doilea Ediție carte:

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

· Punctul 12: Preferați inițializarea atribuirii în constructori.

· Punctul 14: Faceți destructorii virtuali în clasele de bază.

· Punctul 15: „Operator=" returnează o referință la *acest.

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

De asemenea, avertizați despre încălcările următoarelor reguli de stil de la Scott Meyers Mai Mult
Eficace C ++ carte:

· Punctul 6: Distingeți formele de prefix și postfix de creștere și decreștere
operatori.

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

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 și despre utilizarea unui „NULL” necastat ca sentinelă. La compilarea numai cu
GCC aceasta este o sentinelă validă, deoarece „NULL” este definit ca „__null”. Deși este un nul
constanta pointer nu este un pointer nul, este garantat că va avea aceeași dimensiune ca a
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 va reuși să compilați.

-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++ ar încerca să păstreze caracterul nesemnat, dar standardul impune
comportamentul actual.

struct A {
operator int ();
operator A& = (int);
};

principal ()
{
A a,b;
a = b;
}

În acest exemplu, G++ va sintetiza un implicit A& operator = (const A&);, în timp ce cfront
va folosi cea definită de utilizator operator =.

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 programele Objective-C++, dar puteți utiliza și majoritatea GNU independente 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 afară 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 ea, va înlocui
-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 va rula 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 va rula toți astfel de destructori impliciti,
în ordine inversă.

Metodele „- (id) .cxx_construct” și „- (void) .cxx_destruct” generate astfel vor
operează numai pe variabilele de instanță declarate în clasa curentă Objective-C și nu
cele moștenite din superclase. Este responsabilitatea Obiectivului-C
runtime pentru a invoca toate astfel de metode din ierarhia de moștenire a unui obiect. „- (id)
Metodele .cxx_construct" vor fi invocate de runtime imediat după un nou obiect
instanța este alocată; vor fi invocate metodele „- (void) .cxx_destruct”.
imediat înainte ca runtime-ul să dealocați 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
sursă.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 va omite astfel de avertismente dacă diferențele găsite sunt limitate la tipurile care
împărtășesc 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 afară
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 Mod de control Diagnostic Chat cont Formatarea
În mod tradițional, mesajele de diagnosticare au fost formatate, indiferent de dispozitivul de ieșire
aspect (ex. lățimea acestuia, ...). Opțiunile descrise mai jos pot fi folosite pentru a controla
algoritm de formatare a mesajelor de diagnosticare, de exemplu câte caractere pe linie, cât de des
informațiile despre locația sursă trebuie raportate. În acest moment, doar front-end-ul C++ poate
onora aceste opțiuni. Cu toate acestea, este de așteptat, în viitorul apropiat, ca frontul rămas
capetele le-ar putea digera corect.

-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 va face nicio înfășurare a liniilor; va apărea fiecare mesaj de eroare
pe o singură linie.

-fdiagnostics-show-location=o dată
Numai semnificativ în modul de înfășurare a liniilor. Instruiește raportorul de mesaje de diagnosticare să
emite dată informații despre locația sursă; 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.

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

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 atașat,
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țiunile care încep -W, De exemplu, -Wimplicit
să solicite avertismente asupra declaraţiilor implicite. De asemenea, fiecare dintre aceste opțiuni specifice de avertizare
are 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 mai multe,
opțiunile specifice limbii se referă și la 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), va emite GCC
un diagnostic care afirmă că opțiunea nu este recunoscută. Cu toate acestea, dacă -Nu- forma este
utilizat, comportamentul este ușor diferit: nu va fi produs niciun diagnostic pentru
-Wno-necunoscut-avertisment cu excepția cazului în care se produc alte diagnostice. Acest lucru permite utilizarea
nou -Nu- opțiuni cu compilatoare vechi, dar dacă ceva nu merge bine, compilatorul va avertiza
că a fost folosită o opțiune nerecunoscută.

-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 vor necesita -ansi sau un -std opțiunea care specifică versiunea necesară
din 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.

-pedant 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ă -pedant 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
-pedant. 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 -pedant sunt date acolo unde sunt
cerute de standardul de bază. (Nu ar avea 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 -pedant, 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ă -Wnonnull - 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ă într-un constructor de copiere a 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ă a fost schimbat între -fprofile-gen și -fprofile-use, fișierele cu
feedbackul despre profil poate să nu se potrivească cu fișierul sursă, iar GCC nu poate utiliza profilul
informații de feedback. Î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 va efectua întregul calcul cu „double” deoarece flotantul-
punct literal este un „dublu”.

-Wformat
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ă -pedant este folosit cu -Wformat,
vor fi 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).

Întrucât -Wformat verifică, de asemenea, argumentele de format nul pentru mai multe funcții, -Wformat
implică de asemenea -Wnonnull.

-Wformat este inclus în -Perete. Pentru mai mult control asupra anumitor aspecte ale verificării formatului,
opțiunile -Wformat-y2k, -Wno-format-extra-args, -Wno-format-lungime-zero,
-Wformat-nonliteral, -Wformat-securitate, și -Wformat=2 sunt disponibile, dar nu sunt
inclus în -Perete.

NOTĂ: În Ubuntu 8.10 și versiunile ulterioare, această opțiune este activată implicit pentru C, C++,
ObjC, ObjC++. Pentru a dezactiva, utilizați -Wformat=0.

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

-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 „scanf”
funcția de formatare. Standardul C specifică faptul că astfel de argumente sunt ignorate.

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 va suprima
avertisment dacă argumentele neutilizate sunt toate pointeri, deoarece specificația Unix unică
spune că astfel de argumente nefolosite 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-nonliteral
If -Wformat este specificat, avertizează de asemenea dacă șirul de format nu este un șir literal și
deci nu poate fi verificată, cu excepția cazului în care funcția de format își ia argumentele de format ca a
„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ă formatul
șirul a venit de la o intrare nesigură și conține %n. (Acesta este în prezent un subset al ceea ce
-Wformat-nonliteral avertizează despre, dar în viitor pot fi adăugate avertismente
-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 avertismentele de format
cu -Wformat=0. Pentru a face fatale avertismentele de securitate de format, specificați
-Werror=format-securitate.

-Wformat=2
Permite -Wformat plus verificările de format nu sunt incluse în -Wformat. În prezent echivalent cu
-Wformat -Wformat-nonliteral -Wformat-securitate -Wformat-y2k.

-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 va avertiza despre neinițializarea „i” numai în următorul fragment
cand - Winit-self a fost specificat:

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

-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 -pedant.

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

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 va emite un avertisment atunci când acest indicator este
specificat. Pentru a elimina avertismentul, adăugați acolade explicite în jurul celui mai interior „dacă”
declarație, așa că nu există nicio posibilitate ca „altfel” să aparțină „dacă” din anexare. The
codul rezultat ar arăta astfel:

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

De asemenea, avertizați pentru utilizări periculoase ale ?: cu extensia GNU pentru operandul mijlociu omis. Cand
condiția din operatorul ?: este o expresie booleană, valoarea omisă va fi
întotdeauna 1. Adesea utilizatorul 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++.

-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 return
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.

-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] va provoca un avertisment, în timp ce x[(void)i,j] voi
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 vor depinde 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 pe care variabila nu este
initializat, compilatorul va emite un avertisment daca nu poate dovedi neinitializat
căile nu se întâmplă î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
au o eroare. Iată un exemplu despre cum se poate întâmpla acest lucru:

{
intx;
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, utilizatorul trebuie să furnizeze un caz implicit
cu 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ă, vor fi emise chiar avertismente pentru pragmate necunoscute în
fișierele antet de sistem. Acesta nu este cazul dacă avertismentele au fost 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, similar modului în care funcționează -O. -Wstrict-aliasing is
echivalent cu -Wstrict-aliasing=n, cu n=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
atunci când se estimează câte iterații va necesita o buclă, în special când
determinând dacă o buclă va fi executată.

-Wstrict-overflow=1
Avertizați asupra cazurilor care sunt atât discutabile, cât și ușor de evitat. De exemplu: „x +
1 > x"; cu -fstrict-overflow, compilatorul va simplifica acest lucru la 1. Acest nivel
of -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" va fi simplificat 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” va fi 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” va fi simplificat în „x + 1
>= y". Acest lucru este raportat numai la cel mai înalt nivel de avertizare deoarece aceasta
simplificarea se aplică la multe comparații, astfel încât acest nivel de avertizare va da un foarte
număr mare de fals pozitive.

-Wsuggest-atribut=[pur|CONST|fără întoarcere]
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ă nici nu se î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.

- 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
voi 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, ați verifica
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 nu
în ISO C.

· În C tradițional, unele directive de preprocesor nu existau. Tradiţional
preprocesorii ar considera o linie ca o directivă numai dacă # aparut in
coloana 1 pe linie. Prin urmare - Tradițional avertizează asupra directivelor care
C tradițional înțelege, dar ar ignora deoarece # nu apare ca
primul caracter de pe linie. De asemenea, vă sugerează să ascundeți directive precum #pragma
neînțeles de C tradițional prin indentarea lor. Unele tradiționale
implementările nu ar recunoaște #elif, așa că sugerează să-l evitați 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 ar provoca 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 vor
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 nu va avertiza dacă o variabilă locală umbră a
struct/class/enum, dar va avertiza dacă umbrește un typedef explicit.

-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-bucla-optimizări
Avertizați dacă bucla nu poate fi optimizată deoarece compilatorul nu a putut presupune nimic
limitele indicilor buclei. Cu -optimizări-funsafe-loop avertizează dacă compilatorul
a făcut astfel de presupuneri.

-Format-wno-pedant-ms (doar ținte MinGW)
Dezactivează avertismentele despre specificatorii de lățime a formatului „printf” / „scanf” non-ISO „I32”,
„I64” și „I” sunt utilizate pe ținte Windows, în funcție de timpul de execuție MS, atunci când utilizați
opțiunile -Wformat și -pedant fără extensii gnu.

-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 -pedant.

-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 *" va primi un avertisment. Aceste
avertismentele vă vor ajuta să găsiți la compilare un cod 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, va fi 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.

-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 vor folosi niciodată un operator de conversie de tip: conversii la „void”, the
același tip, o clasă de bază sau o referință la acestea. Avertismente despre conversii între
numerele întregi semnate și nesemnate sunt dezactivate implicit în C++, cu excepția cazului în care -Wsign-conversie
este 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.

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

-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-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 va opri 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. Scopul este de a
detectează funcțiile globale care nu sunt declarate în fișierele antet.

- 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
şabloane de funcţii 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 ar provoca 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 ar declanșa 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.

-Atribut-format-lipsă
Avertizați despre indicatorii de funcție care ar putea fi candidați pentru atributele „format”. Notă
aceștia sunt doar candidați posibili, nu absoluti. GCC va ghici acea funcție
pointeri cu atribute „format” care sunt utilizate în atribuire, inițializare,
instrucțiunile de transmitere sau returnare a parametrilor ar trebui să aibă un atribut „format” corespunzător
în tipul rezultat. Adică partea stângă a atribuirii sau inițializării,
tipul variabilei parametru sau tipul de returnare al funcției care le conține
respectiv ar trebui să aibă și un atribut „format” pentru a evita avertismentul.

GCC va avertiza și despre definițiile funcțiilor care ar putea fi candidate pentru „format”
atribute. Din nou, aceștia sunt doar candidați posibili. GCC va ghici acel „format”
atributele pot fi adecvate pentru orice funcție care apelează o funcție precum „vprintf”
sau „vscanf”, dar s-ar putea să nu fie întotdeauna cazul, iar unele funcții pentru care
Atributele „format” sunt adecvate pot să nu fie detectate.

-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 dori să faceți acest lucru numai dacă utilizați o altă schemă de normalizare (cum ar fi
„D”), deoarece altfel puteți crea cu ușurință erori care sunt literalmente imposibil de realizat
a se vedea.

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 LITERA MINUSCULĂ LATINĂ N”, se va afișa la fel ca un „n” obișnuit
care a fost plasat într-un superscript. ISO 10646 definește NFKC normalizare
schemă pentru a converti toate acestea într-un formular standard, iar GCC vă va avertiza dacă dvs
codul nu este în NFKC dacă îl utilizați -Wnormalizat=nfkc. Acest avertisment este comparabil cu
avertisment despre fiecare identificator care conține litera O, deoarece ar putea fi confuz
cu cifra 0, deci nu este implicit, dar poate fi util ca codare locală
convenție dacă mediul de programare nu poate fi remediat pentru a le afișa
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.

-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” va fi
fi aliniat greșit, chiar dacă „structura bară” nu are în sine atributul împachetat:

struct foo {
intx;
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.

-Winline
Avertizați dacă o funcție nu poate fi inline și a fost declarată ca inline. Chiar și cu asta
opțiunea, compilatorul nu va avertiza despre eșecurile funcțiilor 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 flag 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 -pedant 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.

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

-Wvla
Avertizați dacă în cod este utilizată matrice de lungime variabilă. -Wno-vla va preveni
-pedant 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 au putut gestiona codul în mod eficient. Adesea, problema este că
codul tău este prea mare sau prea complex; GCC va refuza să optimizeze programele atunci când
optimizarea în sine este probabil să ia o perioadă excesivă 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
-pedant, 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 vor fi protejate împotriva spargerii stivelor.

-Wno-flap de noroi
Suprimați avertismentele despre constructe care nu pot fi instrumentate de -fmudflap.

-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 -pedant, și poate fi dezactivat cu -Wno-supralungime-șiruri.

-Wunsufixed-float-constante (doar C și Objective-C)
GCC va emite un avertisment pentru orice constantă flotantă care nu are un sufix. Cand
folosit împreună cu -Wsystem-anteturi va avertiza despre astfel de constante în antetul sistemului
fișiere. Acest lucru poate fi util atunci când pregătiți codul de utilizat cu „FLOAT_CONST_DECIMAL64”
pragma 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 va face ca alți depanatoare să se blocheze sau să refuze să citească programul. Daca vrei
pentru a controla cu siguranță dacă să genereze 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 erau deja la
mână; unele instrucțiuni se pot executa în locuri diferite deoarece au fost mutate din
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.

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

-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 va crește dimensiunea informațiilor de depanare
cu un factor de doi.

-fno-debug-types-section
În mod implicit, atunci când se utilizează DWARF v4 sau un tip superior, DIE-urile vor fi puse în propriile lor
secțiunea .debug_types în loc să le facă parte din secțiunea .debug_info. Este
mai eficient să le puneți într-o secțiune separată de comdat, deoarece linkerul va fi atunci
capabil să elimine duplicatele. Dar nu toți consumatorii DWARF acceptă secțiunile .debug_types
încă.

-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). Acesta este
format utilizat de DBX pe IRIX 6. Valoarea lui versiune poate fi fie 2, 3 sau 4; cel
versiunea implicită este 2.

Rețineți că, cu DWARF versiunea 2, unele porturi necesită și vor folosi întotdeauna unele non-
extensii conflictuale DWARF 3 în tabelele 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.

-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. Aceasta este valoarea implicită.

-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 de depanare VMS (dacă este acceptat). Acesta este
format utilizat de DEBUG pe sistemele 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, dar fără informații despre variabilele locale și fără numere de rând.

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 ar fi generat-o,
sau porniți-l la nivelul 2 în caz contrar. Poziția acestui argument în linia de comandă
nu contează, are efect după ce toate celelalte opțiuni sunt procesate și face acest lucru
o singură dată, indiferent de câte ori este dat. Acesta este destinat în principal a fi utilizat
cu -fcompare-debug.

-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 va fi determinat prin anexare
„.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 va respinge ca opțiune nevalidă în orice
compilare reală (mai degrabă decât preprocesare, asamblare sau legare). Pentru a obține doar un
avertizare, setare 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 DWARF2 eliminând informațiile duplicate despre fiecare
simbol. Această opțiune are sens numai atunci când se generează informații de depanare DWARF2
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 a fost 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 a fost 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 va genera informații de depanare.
Intenția este de a reduce informațiile duplicate de depanare a structurii între diferite obiecte
fișiere din același program.

Această opțiune este o versiune detaliată a -femit-struct-debug-reduced și
-femit-struct-debug-baseonly, care va servi 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 ar fi legală, 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
va emite 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ă tipurile declarate în foo.c și foo.h va avea informații de depanare, dar
tipurile declarate în alt antet nu vor. Valoarea SYS înseamnă 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.

-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ă.

-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 vor potrivi mai bine cu fișierele sursă,
daca 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, AȘA dbg_cnt()
returnează întotdeauna adevărat, cu excepția cazului în care limita superioară este stabilită de această opțiune. ex. Cu
-fdbg-cnt=dce:10,tail_call:0 dbg_cnt(dce) va returna true numai pentru primele 10
invocații

-fenabil-natural-trece
-fdezactiv-natural-trece=listă-gamă
Acesta este un set de opțiuni de depanare care sunt utilizate pentru a dezactiva/activa în mod explicit
trece de optimizare. Pentru utilizatorii compilatorului, opțiuni obișnuite pentru activarea/dezactivarea permiselor
ar trebui folosit în schimb.

*<-fdisable-ipa-trece>
Dezactivează ipa pass 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ă>
Dezactivează trecerea 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ă
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ă nodul cgraph al funcției este uid is
care 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>
Activează ipa pass 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 trecerea rtl trece. Vedea -fdisable-rtl pentru descrierea argumentului de opțiune și
exemple.

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

# 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
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. Rețineți că numărul permisului este
calculat static pe măsură ce permisele sunt înregistrate în managerul de permise. Astfel, cel
numerotarea nu este legată de ordinea dinamică de executare a trecerilor. În special,
o trecere instalată de un plugin ar putea avea un număr peste 200 chiar dacă s-a executat destul de mult
din timp. dumpname este generat din numele fișierului de ieșire, dacă este explicit
specificat și nu este un executabil, altfel este numele de bază al sursei
fişier. 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ă sub-
eliminarea expresiei 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-regmove
Dump după trecerea mișcării registrului.

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

-fdump-rtl-vezi
Dump după eliminarea extensiei semnului.

-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-finish
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
s-a folosit 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.

-dv Pentru fiecare dintre celelalte fișiere dump indicate (-fdump-rtl-trece), gunoi a
reprezentarea graficului fluxului de control potrivit pentru vizualizare cu VCG pentru
fișier.pass.vcg.

-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 va face ca contoarele să fie însumate pe întreaga unitate de compilare în timp ce
-Detalii va arunca fiecare eveniment pe măsură ce trecerile le generează. Implicit cu nr
opțiunea este să însumăm contoarele pentru fiecare funcție compilată.

-fdump-tree-comuta
-fdump-tree-comuta-Opțiuni
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 cazul în care -Opțiuni se folosește forma, Opțiuni este o listă a - opțiuni separate care controlează
detaliile gropii. Nu toate opțiunile sunt aplicabile tuturor depozitelor; cei care sunt
nesemnificativ va fi ignorat. 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
Inhibați dumpingul de membri ai unui domeniu sau a unui corp al unei funcții doar pentru asta
domeniul de aplicare a fost atins. Eliminați astfel de articole numai atunci când sunt accesibile direct
vreo altă cale. Când aruncați copaci destul de imprimați, această opțiune inhibă descărcarea
organele structurilor de control.

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).

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).

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.

toate Activați toate opțiunile, cu excepția crud, subţire, prolix și lineno.

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ă.

vcg Transferați graficul fluxului de control al fiecărei funcție într-un fișier în format VCG. Fișierul
denumirea se face prin anexare .vcg la numele fișierului sursă. Rețineți că dacă fișierul
conține mai mult de o funcție, fișierul generat nu poate fi utilizat direct de
VCG. Va trebui să tăiați și să lipiți graficul fiecărei funcții în propriul său separat
mai întâi fișierul.

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ă.

clapeta de noroi
Eliminați fiecare funcție după adăugarea instrumentelor pentru clapeta de noroi. Numele fișierului este făcut de
alăturarea .clapă de noroi 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.

-fttree-vectorizer-verbose=n
Această opțiune controlează cantitatea de ieșire de depanare pe care o imprimă vectorizatorul. Acest
informațiile sunt scrise în eroare standard, cu excepția cazului în care -fdump-tree-toate or -fdump-tree-vect
este specificat, caz în care este trimis în fișierul obișnuit cu listare de descărcare, .vect. Pentru
n=0 nu sunt raportate informații de diagnosticare. Dacă n=1 vectorizatorul raportează fiecare buclă
care au fost vectorizate și numărul total de bucle care au fost vectorizate. Dacă n=2 cel
vectorizer raportează, de asemenea, bucle nevectorizate care au trecut de prima fază de analiză
(vect_analyze_loop_form) - adică numărabil, cel mai interior, un singur bb, o singură intrare/ieșire
bucle. Acesta este același nivel de verbozitate ca -fdump-tree-vect-stats utilizări. Superior
nivelurile de verbozitate înseamnă fie mai multe informații descărcate pentru fiecare buclă raportată, fie aceeași
cantitatea de informații raportată pentru mai multe bucle: dacă n=3, modelul costului vectorizatorului
informatia este raportata. Dacă n=4, informațiile legate de aliniere sunt adăugate la
rapoarte. Dacă n=5, informații legate de referințe de date (de exemplu, dependențe de memorie, memorie
access-patterns) este adăugat la rapoarte. Dacă n=6, vectorizatorul raportează, de asemenea, non-
cele mai interioare bucle vectorizate care nu au trecut de prima fază de analiză (adică, este posibil să nu
să fie numărabile sau poate avea un flux de control complicat). Dacă n=7, raportează vectorizatorul
de asemenea, bucle imbricate nevectorizate. Dacă n=8, informațiile legate de SLP sunt adăugate la
rapoarte. Pentru n=9, toate informațiile pe care vectorizatorul le generează în timpul analizei sale
iar transformarea este raportată. Acesta este același nivel de verbozitate ca
-fdump-tree-vect-detalii utilizări.

-frandom-seed=şir
Această opțiune oferă o sămânță pe care GCC o folosește atunci când altfel ar folosi numere aleatorii.
Este folosit pentru a genera anumite nume de simbol care trebuie să fie diferite în fiecare
fișier compilat. De asemenea, este folosit pentru a plasa ștampile unice în fișierele de date de acoperire și în fișierele
fișiere obiect care le produc. Puteți folosi -sămânță-frandom opțiunea de a produce
fișiere obiect identice reproductibil.

ş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 ar 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

ar crea 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 varului este dezactivată, caz în care adnotările vor fi
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 va căuta --- ș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
Tipăriți directorul sysroot țintă care va fi 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.)

-elimină-neutilizate-tipuri-depanare
În mod normal, atunci când produce ieșire DWARF2, GCC va emite informații de depanare pentru toți
tipuri declarate într-o unitate de compilare, indiferent dacă sunt sau nu de fapt
utilizat în acea unitate de compilare. Uneori, acest lucru este util, cum ar fi dacă, în depanator,
doriți să turnați o valoare într-un tip care nu este utilizat de fapt în programul dvs. (dar este
declarat). Cel mai adesea, însă, acest lucru are ca rezultat o cantitate semnificativă de spațiu irosit.
Cu această opțiune, GCC va evita producerea de simboluri de depanare pentru tipurile care sunt
nu este folosit nicăieri în fișierul sursă compilat.

Opţiuni Că Mod de control 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 la care te-ai aștepta 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-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 -optimizări scumpe -fgcse
-fgcse-lm -finline-funcții-mici -findirect-inlining -fipa-sra
-foptimize-frate-apeluri -fpartial-inlining -fpeehole2 -fregmove -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,
-fttree-vectoriza, -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 -ftree-vect-loop-versiunea

-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 compatibile standard. Aceasta
se aprinde -ffast-matematică și specificul Fortran -fno-protect-parents și -fstack-arrays.

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 va fi -fno-foo. In masa
mai jos, este listată doar una dintre formulare --- cea pe care o veți utiliza de obicei. Vă puteți da seama
scoateți cealaltă formă 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-default-inline
Nu puneți funcțiile membru în linie în mod implicit doar pentru că sunt definite în interior
domeniul de aplicare al clasei (doar C++). Altfel, când specificați -O, funcții membre definite
domeniul de aplicare al clasei sunt compilate în mod implicit; adică, nu trebuie să adăugați inline
în fața numelui funcției membru.

-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 Linux x32 pe 86 de biți și Darwin x32 pe 86 de biți au fost modificate
-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ă
variabila a fost referită, indiferent dacă optimizarea este sau nu activată, 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 va avea 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 bazată pe SMS-uri mai agresive, cu mișcările de registru permise. De
setarea acestui flag vor fi șterse anumite margini antidependențe care se vor declanșa
generarea de reg-mișcări pe baza analizei intervalului de viață. Această opțiune este
eficient numai 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 fișierul
începutul acelei secțiuni și/sau să facă ipoteze pe baza acesteia.

Valoarea implicită este -fzero-initializat-in-bss.

-fmudflap -fmudflapth -fmudflapir
Pentru front-end-urile care îl acceptă (C și C++), instrumentați toate punctele/matricele riscante
operațiuni de dereferențiere, unele funcții standard de șir de bibliotecă/heap și altele
constructe asociate cu teste de interval/validitate. Modulele astfel instrumentate ar trebui să fie
imun la depășirile de buffer, utilizarea nevalidă a heap-ului și alte clase de C/C++
erori de programare. Instrumentarea se bazează pe o bibliotecă de rulare separată
(libmudflap), care va fi legat într-un program dacă -fmudflap este dat la momentul link-ului.
Comportamentul la timpul de execuție al programului instrumentat este controlat de MUDFLAP_OPTIONS
variabilă de mediu. Consultați „env MUDFLAP_OPTIONS=-help a.out” pentru opțiunile sale.

Utilizare -fmudflapth în loc de -fmudflap pentru a compila și a lega dacă programul dvs. este multi-
filetat. Utilizare -fmudflapir, În plus față de -fmudflap or -fmudflapth, dacă
instrumentația ar trebui să ignore citirile indicatorului. Acest lucru produce mai puține instrumente (și
prin urmare, execuție mai rapidă) și oferă totuși o anumită protecție împotriva memoriei directe
coruperea scrierilor, dar permite propagarea datelor citite eronat în cadrul unui program.

-fthread-sărituri
Efectuați optimizări în care verificăm pentru a vedea dacă un salt se ramifică într-o locație în care
se găseşte o altă comparaţie subsumată primei. Dacă da, prima ramură este
redirecționat fie către destinația celei de-a doua ramuri, fie către un punct imediat
urmând-o, în funcție de faptul că condiția este cunoscută ca fiind 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 declarație „dacă” cu o clauză „altfel”, CSE va urma 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 au fost 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 va încerca
mută în ele încărcăturile care sunt ucise doar de magazine. Acest lucru permite o buclă
care conține o secvență de încărcare/stocare care trebuie schimbată într-o încărcare în afara buclei și a
copiați/stocare în buclă.

Activat în mod implicit când gcse 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 va încerca să mute magazinele din bucle. Cand
folosit împreună cu -fgcse-lm, buclele care conțin o secvență de încărcare/stocare pot fi
schimbat într-o încărcare înainte de buclă și un magazin 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-funsafe-loop
Dacă este dat, optimizatorul de bucle va presupune că indicii de buclă nu se depășesc și asta
buclele cu condiție de ieșire netrivială nu sunt infinite. Acest lucru permite o gamă mai largă
de optimizări de bucle chiar dacă optimizatorul de bucle însuși nu poate dovedi că acestea
ipotezele sunt valabile. Folosind -Wunsafe-bucla-optimizări, compilatorul vă va avertiza
dacă găsește acest tip de buclă.

-fcrossjumping
Efectuați transformarea sărituri încrucișate. Această transformare unifică codul echivalent și
salvați 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 utilizarea
de mișcări condiționate, min, max, set de steaguri și instrucțiuni abs și câteva trucuri fezabile
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.

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

-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 x86 la niveluri -O2, -O3.

-foptimize-register-mute
-fregmove
Încercați să reatribuiți numerele de registru în instrucțiunile de mutare și ca operanzi ai altora
instrucțiuni simple pentru a maximiza cantitatea de legare a registrului. Aceasta este
util în special pe mașinile cu instrucțiuni cu doi operanzi.

notițe -fregmove și -foptimize-register-mute sunt aceeași optimizare.

Activat la niveluri -O2, -O3, -Os.

-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-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 lucru are sens numai atunci când programarea î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 ca urmare registrul se scurge în registru
alocare.

-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 va fi mutat prematur,
-fsched-stalled-insns=0 înseamnă că nu există o limită a numărului 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 insn (cicluri) vor fi examinate pentru o dependență de un blocat
insn care este candidat pentru eliminarea prematură din coada de insns blocate. Acest
are efect numai în timpul celei de-a doua treceri de programare și numai dacă
-fsched-stalled-insns este folosit. -fno-sched-stalled-insns-dep este echivalent cu
-fsched-stalled-insns-dep=0. -fsched-stalled-insns-dep fără valoare este echivalentă
la -fsched-stalled-insns-dep=1.

-fsched2-use-superblocuri
Când programați după alocarea registrului, utilizați algoritmul de programare superbloc.
Programarea superbloc permite mișcarea peste granițele blocurilor de bază, rezultând mai rapidă
orare. Această opțiune este experimentală, deoarece nu toate descrierile de mașini sunt folosite de GCC
modelați 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
Planificarea modulo vine înaintea programarii tradiționale, dacă o buclă a fost modulo
programat, putem dori să împiedicăm trecerile ulterioare de programare să-și schimbe
program, folosim această opțiune pentru a controla asta.

-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 până la unul dintre -fselectiv-programare or -fselectiv-scheduling2 is
pornit.

-fsel-sched-pipelining-bucle-exterioare
La canalizarea buclelor în timpul programării selective, conductați și buclele exterioare. Acest
opțiunea nu are efect până când -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ă
Permiteți alocarea valorilor în registre care vor fi afectate de apelurile de funcții,
prin emiterea de instrucțiuni suplimentare pentru a salva și a restabili registrele din jurul unor astfel de apeluri.
O astfel de alocare se face numai atunci când pare să rezulte un cod mai bun decât ar fi
altfel fi produs.

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 va încerca să folosească mai puțin spațiu de stivă,
chiar dacă asta face programul mai lent. Această opțiune implică setarea stivă mare-
cadru 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.

-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ă nu pot scăpa din unitatea de compilare.
Activat 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ă va efectua 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.

-fipa-matrix-reorg
Efectuați aplatizarea și transpunerea matricei. Aplatizarea matricei încearcă să înlocuiască un
matrice m-dimensională cu matricea sa n-dimensională echivalentă, unde n < m. Acest
reduce nivelul de indirectare necesar pentru accesarea elementelor matricei. The
a doua optimizare este transpunerea matricei, care încearcă să schimbe ordinea
dimensiunile matricei pentru a îmbunătăți localitatea cache-ului. Ambele optimizări au nevoie de
-întregul-program steag. Transpunerea este activată numai dacă informațiile de profilare sunt
disponibile.

-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 va transforma bucla ca și cum utilizatorul ar fi 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

Exploatarea benzii de buclă va transforma bucla ca și cum utilizatorul 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 va transforma bucla ca și cum utilizatorul 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ă
va itera 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-platit
Îndepărtează structura de imbricare a buclei: transformă cuibul buclei într-o singură buclă. Acest
transformarea poate fi utilă ca transformare de activare pentru vectorizare și
paralelizare. Această caracteristică este experimentală. Pentru a utiliza această transformare de cod, GCC
trebuie configurat cu --cu-perpl și --cu-cloog pentru a activa bucla de grafit
infrastructura de transformare.

-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;

ar fi 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ă numai invarianții care ar fi
greu de gestionat la nivel RTL (apeluri de funcții, operațiuni care se extind la non-trivial
secvente de insns). Cu -funswitch-bucle se mişcă şi operanzi ai condiţiilor care
sunt invariante în afara buclei, astfel încât să putem folosi doar analiza invariantei triviale
deconectare în buclă. 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.

-fttree-vectoriza
Efectuați vectorizarea buclei pe copaci. Acest steag este activat implicit la -O3.

-ftree-slp-vectoriza
Efectuați vectorizarea blocurilor de bază pe copaci. Acest steag este activat implicit la -O3 și
cand -fttree-vectoriza este activat.

-ftree-vect-loop-versiunea
Efectuați versiunea în buclă atunci când faceți vectorizarea buclei pe copaci. Când apare o buclă
să fie vectorizabil, cu excepția faptului că alinierea datelor sau dependența de date nu pot fi determinate
în timpul compilării, apoi sunt generate versiuni vectorizate și nevectorizate ale buclei
împreună cu verificări în timpul execuției pentru aliniere sau dependență pentru a controla ce versiune este
executat. Această opțiune este activată implicit, cu excepția nivelului -Os unde este dezactivat.

-modelul-cost-fvect
Activați modelul de cost pentru vectorizare.

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

Combinatie de -fweb iar CSE este adesea suficientă pentru a obține același efect. in orice caz
în cazurile în care corpul buclei este mai complicat decât un singur bloc de bază, acest lucru nu este
de încredere. De asemenea, nu funcționează deloc pe unele dintre arhitecturile din cauza
restricții în permisul CSE.

Această optimizare este activată în mod implicit.

-fexpansiune-variabilă-în-unroler
Cu această opțiune, compilatorul va crea mai multe copii ale unor variabile locale
la derularea unei bucle care 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 va folosi 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
euristica va fi folosită 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.

-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 ca această opțiune să fie 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 va funcționa 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 o va face
întâmpla. Acest lucru permite diverse optimizări. De exemplu, compilatorul va presupune
că o expresie precum „i + 10 > i” va fi întotdeauna adevărată pentru „i” cu semn. Acest
ipoteza este valabilă numai dacă depășirea semnată este nedefinită, deoarece expresia este falsă
dacă „i + 10” depășește atunci când se utilizează aritmetica complementului de doi. Când această opțiune este activată
efectuează orice încercare de a determina dacă o operațiune pe numerele semnate va depăși
trebuie scris cu atenție pentru a nu implica de fapt debordare.

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 s-ar alinia la următoarea graniță de 32 de octeți numai dacă
acest lucru se poate face prin sărirea peste 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 va fi aliniat.

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 vor fi
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.
Speranța este ca bucla să fie executată de mai multe ori, ceea ce va compensa orice
executarea operaţiilor manechinului.

-fno-align-loops și -falign-loops=1 sunt echivalente și înseamnă că buclele nu vor fi
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 vor fi
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 nereferite nu vor fi 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.

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 vor mai rămâne î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. Dacă aur este folosit ca plugin de linker,
Atributele „externally_visible” sunt adăugate automat funcțiilor (nu sunt încă variabile
din cauza unui curent aur problema) care sunt accesate în afara obiectelor LTO conform
fișier de rezoluție produs de aur. Pentru alte linkere care nu pot genera rezoluție
fișier, atributele explicite „externally_visible” sunt încă necesare. În timp ce această opțiune
este echivalent cu utilizarea corectă a cuvântului cheie „static” pentru programele formate din a
fișier unic, în combinație cu opțiunea -flto acest steag poate fi folosit pentru a compila multe
programe la scară mai mică deoarece funcțiile și variabilele devin locale pentru întreg
unitate de compilare combinată, nu pentru fișierul sursă unic în sine.

Această opțiune implică -fthole-file pentru programele Fortran.

-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 trebuie specificat în timpul compilării și în timpul
linkul final. 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 activa optimizările timpului de conectare
-flto flag trebuie să fie transmis atât comenzilor de compilare, cât și de 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 -plugin-fuse-linker) 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.

Rețineți că 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 coduri de octet GIMPLE și codul final obișnuit.
Aceasta înseamnă că fișierele obiect cu informații LTO pot fi legate ca obiect normal
dosare; dacă -flto nu este transmis linker-ului, nu există optimizări interprocedurale
aplicat.

Î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 -flto foo.c
gcc -c -O0 -flto bar.c
gcc -o myprog -flto -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 fără -flto, Apoi myprog nu este optimizat.

La producerea binarului final cu -flto, GCC aplică numai optimizări ale timpului de conectare
la acele 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 prezent, următoarele opțiuni
sunt salvate în fișierele GIMPLE bytecode: -fPIC, -fcomun și toate -m steaguri țintă.

La momentul conexiunii, aceste opțiuni sunt citite și aplicate din nou. Rețineți că curentul
implementarea nu face nicio încercare de a recunoaște valorile conflictuale pentru aceste opțiuni. Dacă
fișiere diferite au valori contradictorii ale opțiunilor (de exemplu, un fișier este compilat cu -fPIC
iar altul nu este), compilatorul folosește pur și simplu ultima valoare citită din bytecode
fișiere. Se recomandă, prin urmare, să compilați toate fișierele care participă la
același link cu aceleași opțiuni.

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.

O altă caracteristică a LTO este că este posibil să se aplice optimizări interprocedurale
pe fișiere scrise în diferite limbi. Acest lucru necesită sprijin pe frontul lingvistic
Sfârșit. În prezent, front-end-urile C, C++ și Fortran sunt capabile să emită GIMPLE
bytecodes, așa că ceva de genul acesta ar trebui să funcționeze:

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); tot ce trebuie să adaugi este -flto la toate
compilați și legați comenzi.

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 activa această funcție, utilizați steag -plugin-fuse-linker
la ora linkului:

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.

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 -plugin-fuse-linker).

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
lucrează cu o versiune mai veche/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ă greșit
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.

Această opțiune este dezactivată implicit

-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).
Specificarea „nimic” ca algoritm dezactivează complet partiționarea și streamingul. The
valoarea implicită este „echilibrat”.

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

-plugin-fuse-linker
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ă accepte linker
pluginuri pentru a permite un mediu de compilare cu funcții complete (capabil să construiască statică
biblioteci etc).

Valoarea implicită este -ffat-lto-obiecte dar această implicită este intenționată să se schimbe în viitor
lansări atunci când mediile activate pentru plugin de linker devin mai comune.

-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=aur
Folosește aur linker în loc de linkerul implicit.

-fuse-ld=bfd
Folosește ld.bfd linker în loc de linkerul implicit.

-fcprop-registre
După alocarea registrului și împărțirea instrucțiunilor de alocare post-registru, noi
efectuează o trecere de copiere-propagare pentru a încerca să reducă dependențele de programare și
elimină ocazional 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 această opțiune este specificată, GCC va
utilizați euristica pentru a corecta sau a netezi astfel de inconsecvențe. În mod implicit, GCC va
emit un mesaj de eroare atunci 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 va folosi
directorul curent ca cale, astfel fișierul de date de profil va apărea în același
director ca fișier 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 va uita la cale pentru a găsi datele de feedback de profil
fișiere. 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”

Î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 va uita la cale pentru a găsi datele de feedback de profil
fișiere. 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 va respecta 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ă
Seturi -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ție, 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 programul a fost 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-valori
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.

-fvpt
Dacă este combinat cu -fprofil-arcuri, instruiește compilatorului să adauge un cod de adunat
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ție 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 va beneficia cel mai mult procesoarelor
multe registre. În funcție de formatul de informații de depanare adoptat de țintă,
cu toate acestea, poate face imposibilă depanarea, deoarece variabilele nu vor mai rămâne în a
„registru de acasă”.

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 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 vor crea obiecte mai mari și
fișiere executabile și, de asemenea, va fi mai lent. Nu veți putea folosi „gprof” pe toate
sisteme dacă specificați această opțiune și este posibil să aveți probleme cu depanarea dacă aveți
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 orice 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.

NOTĂ: În Ubuntu 6.10 și versiunile ulterioare, această opțiune este activată implicit pentru C, C++,
ObjC, ObjC++, dacă niciunul dintre -fno-stack-protector, -nostdlib, nici - de sine stătător sunt
găsite.

-fstack-protector-all
Aprecieri -festack-protector cu excepția faptului că toate funcțiile sunt protejate.

-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; }

ar calcula de obicei adresele tuturor celor trei variabile, dar dacă le compilați
cu -fsectiune-ancore, va accesa variabilele dintr-un punct de ancorare comun
in schimb. 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 va inline 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 date în
următorul tabel:

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 care trebuie luate în considerare pentru crossjumping. 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 efectua crossjumping asupra acestora. Această valoare este ignorată în caz
unde toate instrucțiunile din blocul din care săritul încrucișat 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 este
căutat, economiile de timp de la completarea intervalului de întârziere vor fi minime, așa că opriți-vă
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 va fi alocată pentru a
efectuează optimizarea eliminării subexpresiilor comune globale. Dacă mai multă memorie
decât este necesar, optimizarea nu se va 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, atunci RTL PRE va insera sau elimina expresia și astfel va pleca
calcule parțial redundante în fluxul de instrucțiuni. Valoarea implicită este
20.

lungime-listă-în așteptare maximă
Numărul maxim de programare a dependențelor în așteptare îl va permite înainte de spălare
starea actuală și o luare de la capăt. Funcții mari cu puține ramuri sau apeluri
poate crea 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 va lua în considerare pentru inlining. Doar asta
afectează funcțiile declarate inline și metodele 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
în caz contrar, nu va fi luat în considerare pentru integrare de către compilator va fi investigat. La
acele funcții, o limită diferită (mai restrictivă) față de funcții
declarat inline poate fi aplicat. Valoarea implicită este 40.

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
acest lucru ar putea fi prea strâns (luați în considerare unitatea constând 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 unitati foarte mari formate din
funcții mici inlineabile, totuși este necesară limita generală de creștere a unității
evitați explozia exponențială a dimensiunii codului. Astfel, pentru unitățile mai mici, dimensiunea este
crescut 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 în afara liniilor de copiere a auto-recursive în linie
funcția poate crește prin efectuarea de inline recursive.

Pentru funcțiile declarate inline --param max-inline-insns-recursiv este luat în
cont. Pentru funcția care nu este declarată 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ă de linia recursivă.

Pentru funcțiile declarate inline --param max-inline-recursive-depth este luat în
cont. Pentru funcția care nu este declarată 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 prin apelul dat
expresie. Acest parametru limitează integrarea numai la expresia de apel a cărui
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. Aceasta limitează practic numărul de imbricate
apelurile indirecte inliner timpuriu se pot rezolva. Lanțurile mai adânci sunt încă gestionate până târziu
inliniere.

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 o buclă nu va fi vectorizată 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 va fi mai agresivă cu simplu
expresii, adică expresiile care au costat mai puțin decât gcse-nerestricted-
costa. Specificarea 0 va dezactiva ridicarea expresiilor simple. Implicit
valoarea 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 vor limita 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 atât va fi mai agresivă ridicarea codului. Specificarea 0 va permite toate
expresii pentru a 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 va evita
limitând căutarea, dar poate încetini compilarea de funcții uriașe. Implicit
valoarea 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 ar trebui să le aibă o buclă dacă acea buclă este
derulat, iar dacă bucla este derulată, determină de câte ori codul buclei
este derulat.

max-medie-unrolled-insns
Numărul maxim de instrucţiuni părtinite de probabilităţile executării lor care
o buclă ar trebui să aibă dacă acea buclă este derulată, iar dacă bucla este derulată, aceasta
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 ar trebui să le aibă o buclă dacă acea buclă este dezlipită,
iar dacă bucla este dezlipită, determină de câte ori este dezlipit codul buclei.

max-peel-times
Numărul maxim de peelinguri ale unei singure bucle.

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 la numărul de candidați pentru variabilele de inducție mai mici decât toți candidații
sunt luate în considerare pentru fiecare utilizare în optimizările variabilelor de inducție. Doar cele mai multe
candidații relevanți sunt luați în considerare dacă există mai mulți candidați, pentru 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, încercăm întotdeauna
eliminați iv-urile inutile din set în timpul optimizării acestuia când este adăugat un nou iv
la platou.

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 îl va putea
introduce. 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. Vezi opțiunea ftree-vect-loop-version
pentru mai multe informatii.

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. Vezi opțiunea ftree-vect-loop-version pentru
mai multe informatii.

max-iterații-pentru a urmări
Numărul maxim de iterații ale unei bucle a algoritmului de forță brută pentru analiză
din # de iterații ale buclei încearcă să evalueze.

hot-bb-count-fractie
Selectați o fracțiune din numărul maxim de repetări ale blocului de bază în program
un bloc de bază dat trebuie să fie considerat fierbinte.

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 funcția conține o singură buclă cu legată cunoscută și altă buclă cu
necunoscut. Prezim corect numărul cunoscut de iterații, în timp ce necunoscutul
numărul mediu de iterații la aproximativ 10. Aceasta înseamnă că bucla fără
limitele ar părea artificial reci în raport cu cealaltă.

alinierea-prag
Selectați o fracțiune din frecvența maximă a execuțiilor blocului de bază în funcție
blocul de bază dat va fi aliniat.

aliniere-bucla-iterații
O buclă care se așteaptă să se repete pentru a nu obține numărul selectat de iterații
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. Aceasta este
mai degrabă argument hokey, deoarece majoritatea duplicaturilor vor fi eliminate mai târziu în cruce
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 probabilitate mai mică decât aceasta
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
Instrucțiunile maxime CSE procesează î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ă ramura necondiționată
sau duplicați codul la destinație. Codul este duplicat atunci când este estimat
dimensiunea este mai mică decât această valoare înmulțită cu dimensiunea estimată a necondiționat
sari in punctele fierbinti ale programului.

reordonare-blocare-duplicare-feedback este utilizat numai atunci când feedbackul de profil este
disponibil și 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. 0 - dezactivați
extensia regiunii, N - faceți cel mult N iterații. Valoarea implicită este 0.

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 va fi programat. Valoarea implicită este 40.

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.

timp-selsched-max-programat
Numărul maxim de ori în care o instrucțiune va fi 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 va genera 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.

min-mapping-uri-virtuale
Specifică numărul minim de mapări virtuale în actualizatorul SSA incremental
care ar trebui înregistrate pentru a declanșa mapările euristice virtuale definite de
raportul-mapări-virtuale. Valoarea implicită este 100.

raportul-mapări-virtuale
Dacă numărul de mapări virtuale este virtual-mappings-raport mai mare decât numărul
de simboluri virtuale care urmează să fie actualizate, apoi actualizatorul incremental SSA trece la a
actualizare completă pentru acele simboluri. Raportul implicit este 3.

ssp-buffer-size
Dimensiunea minimă a bufferelor (adică matrice) care vor primi distrugerea stivei
protectie 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.

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ă pe care o vom trata într-o manieră sensibilă la câmp
în timpul analizei 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 pe care o preluăm î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 va refuza să creeze matrice 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 va
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 se va face și
optimizările în funcție de el vor fi dezactivate. Dimensiunea SCC maximă implicită este
10000.

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 și 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 vor fi gestionate atunci de către
optimizări folosind 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 va înlocui un pointer către un agregat cu unul sau mai mulți parametri noi
numai atunci când mărimea lor cumulată este mai mică sau egală cu ipa-sra-ptr-factor-de-creștere
ori mai mare decât parametrul 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 vor fi 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.

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.

arbore-reassoc-latime
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.

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 știe să le recunoască.

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.

-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++.

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

-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 știe să le recunoască.

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
vor fi transmise linker-ului, opțiuni care specifică conectarea bibliotecilor de sistem, cum ar fi
ca „-static-libgcc” sau „-shared-libgcc”, vor fi ignorate. Fișierele standard de pornire
sunt utilizate în mod normal, cu excepția cazului în care -nostartfiles este folosit. Compilatorul poate genera apeluri către
„memcmp”, „memset”, „memcpy” și „memmove”. Aceste intrări sunt de obicei rezolvate de
intrări în libc. Aceste puncte de intrare ar trebui să fie furnizate printr-un alt mecanism
când este specificată această opțiune.

-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 vor fi trecute către linker, opțiuni
specificarea legăturii bibliotecilor de sistem, cum ar fi „-static-libgcc” sau
„-shared-libgcc”, va fi ignorat. Compilatorul poate genera apeluri la „memcmp”,
„memset”, „memcpy” și „memmove”. Aceste intrări sunt de obicei rezolvate prin intrări în
libc. Aceste puncte de intrare ar trebui să fie furnizate printr-un alt mecanism atunci când acesta
este specificată opțiunea.

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. (De exemplu, __principal, folosit pentru a asigura C++
vor fi chemați constructori.)

-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 care au fost utilizate pentru a genera codul
(-fpie, -fPIE, sau subopțiuni de model) când specificați această opțiune.

-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 care au fost folosite pentru a genera codul (-fpic, -fPIC, Sau
subopțiuni de model) când specificați această opțiune.[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 va fi întotdeauna legat de partajat 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, va conecta versiunea partajată a libgcc în biblioteci partajate de
Mod implicit. În caz contrar, va profita de linker și va optimiza
conectarea cu versiunea partajată a libgcc, conectând cu versiunea statică a libgcc
în mod implicit. Acest lucru permite propagarea excepțiilor prin astfel de biblioteci partajate,
fără a suporta 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-libstdc++
Cand g ++ programul este folosit pentru a lega un program C++, acesta va fi în mod normal automat
legătură împotriva libstdc++. Dacă libstdc++ este disponibil ca o bibliotecă partajată, iar
-static opțiunea nu este utilizată, atunci aceasta se va conecta la versiunea partajată a
libstdc++. În mod normal, este bine. Cu toate acestea, uneori este util să înghețe
versiune a libstdc++ utilizat de program fără a merge până la o stare complet statică
legătură. The -static-libstdc++ opțiunea direcționează g ++ driver pentru a conecta libstdc++
static, fără a lega neapărat alte biblioteci static.

-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 va fi ignorată. Directorul va fi în continuare
căutat, dar ca director de sistem în poziția sa normală în sistem include lanț.
Acest lucru este pentru a se asigura că procedura GCC pentru a remedia anteturile de sistem cu erori și comanda
pentru directiva include_next nu sunt modificate din neatenție. Dacă chiar ai nevoie
modificați 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 a fost 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 va verifica pentru a vedea dacă calea furnizată de -B se referă la un director,
iar dacă este necesar va adăuga 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.
Ele se aplică și fișierelor include î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 de la 0 la 9, atunci va fi înlocuit cu [dir/]include. Asta pentru a ajuta
boot-strapping 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 ar căuta în mod normal antete în / usr / include și biblioteci în / Usr / lib,
va căuta în schimb dir/usr/include și dir/usr/lib.

Dacă utilizați atât această opțiune, cât și -isysroot opțiunea, apoi --sysroot opțiunea va
se aplică bibliotecilor, dar -isysroot opțiunea se va aplica 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 va funcționa în continuare, dar aspectul bibliotecii nu va funcționa.

-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 era curent când a fost 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.

Piese metalice 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ă.

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, deci dacă aceasta reduce sau mărește dimensiunea codului
poate varia de la caz la caz.

-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 nu înaintea oricărei alte instrucțiuni generate.

-mno-soft-cmpsf
Pentru comparații cu virgulă mobilă cu precizie unică, emiteți o instrucțiune fsub și testați
steaguri. Aceasta este mai rapidă decât o comparație de software, dar poate obține rezultate incorecte
prezența NaN-urilor sau când două numere mici diferite sunt comparate astfel încât acestea
diferența se calculează ca zero. Valoarea implicită este -msoft-cmpsf, care folosește mai lent, dar
Conform IEEE, comparații software.

-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, compilând un program cu a
decalaj de stivă diferit de cel cu care au fost compilate bibliotecile, în general, nu va
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
offset intervalul instrucțiunilor b / bl și, prin urmare, încărcați adresa funcției în
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 apeluri directe. Implicit
is -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ă o vor face
să fie neafectate, dacă nu folosesc moduri vectoriale SIMD în locuri în care afectează dimensiunea
și/sau alinierea tipurilor relevante.

-msplit-vecmove-devreme
Împărțirea vectorului se mută într-un singur cuvânt înainte de reîncărcare. În teorie acest lucru ar putea 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. Valorile permise pentru reg sunt r43 și r63,
care specifică să se folosească acel registru ca registru fix, și niciunul, ceea ce înseamnă că nu
registrul este utilizat în acest scop. Valoarea implicită este -m1reg-niciuna.

AAArch64 Opţiuni

Aceste opțiuni sunt definite pentru implementările AArch64:

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

-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 valoare pentru arc is armv8-a. Valorile posibile pentru trăsătură sunt documentate în
subsecț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. Această opțiune poate fi utilizată împreună cu sau în locul acestuia -mcpu=
opțiune.

-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 posibil
valori pentru cpu sunt generic, mare. Valorile posibile pentru trăsătură sunt documentate în
subsecț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.

-mtune=nume
Specificați numele procesorului pentru care să reglați performanța. Codul va fi reglat
ca și cum procesorul țintă ar fi de tipul specificat în această opțiune, dar încă folosește
instrucțiuni compatibile cu procesorul țintă specificat de a -mcpu= opțiune. Acest
opțiunea nu poate fi sufixată de modificatorii de caracteristici.

-Martie și -mcpu modificatori de caracteristici

Modificatori de caracteristici utilizați cu -Martie și -mcpu poate fi unul dintre următoarele:

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=.

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 va 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 vor începe cu un set de instrucțiuni recunoscut (sau de fapt unul dintre a
alegerea dintr-un set mic de prologuri de funcții diferite), iar această informație poate fi
folosit pentru a localiza funcțiile start if într-o bucată de cod executabilă. Implicit
is -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, iwmmxt, iwmmxt2, ep9312.

-martie=nativ determină compilatorul să detecteze automat arhitectura build-ului
calculator. În prezent, această caracteristică este acceptată numai pe 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-a15, cortex-r4, cortex-r4f, cortex-r5, cortex-m4, cortex-m3, cortex-m1,
cortex-m0, xscale, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626,
fa726te.

-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 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 Linux și nu toate arhitecturile sunt
recunoscut. Dacă detectarea automată nu are succes, opțiunea nu are efect.

-mfpu=nume
-mfpe=număr
-mfp=număr
Aceasta specifică pe ce hardware în virgulă mobilă (sau emulație hardware) este disponibilă
ținta. Numele permise sunt: FPA, fpe2, fpe3, nonconformist, hoinar, ratacitor, vfp, vfpv3, vfpv3-fp16,
vfpv3-d16, vfpv3-d16-fp16, vfpv3xd, vfpv3xd-fp16, neon, neon-fp16, vfpv4, vfpv4-d16,
fpv4-sp-d16 și neon-vfpv4. -mfp și -mfpe sunt sinonime pentru -mfpu=fpenumăr, Pentru
compatibilitate cu versiunile mai vechi de GCC.

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 vor fi utilizate 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
Mărimea tuturor structurilor și uniunilor va fi rotunjită 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”. Se va
fi 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 vor fi 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 unității de compilare actuale, va
să nu fie transformate în apeluri lungi. Excepția de la această regulă este acea funcție slabă
definiț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 directivă, va fi întotdeauna
transformate în apeluri lungi.

Această caracteristică nu este activată în mod implicit. Precizând -mno-lung-apeluri va restabili
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. Valoarea implicită este R10, cu excepția cazului în care stack-
verificarea este activată, când este utilizat R9.

-mcirrus-fix-invalid-insns
Introduceți NOP-uri în fluxul de instrucțiuni pentru a rezolva problemele cu
combinații de instrucțiuni Maverick nevalide. Această opțiune este valabilă numai dacă
-mcpu=ep9312 opțiunea a fost folosită pentru a permite generarea de instrucțiuni pentru Cirrus
Coprocesor Maverick în virgulă mobilă. Această opțiune nu este activată implicit, deoarece
problema este prezentă doar în implementările Maverick mai vechi. Valoarea implicită poate fi re-
activată prin utilizarea -mno-cirrus-fix-invalid-insns intrerupator.

-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ă dialecte sunt
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.

AVR Opţiuni

-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{}= „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{}= „atmega16u2”, „atmega32u2”, „atmega8u2”,
"attiny167", "at90usb162", "at90usb82".

"avr4"
Dispozitive „îmbunătățite” cu până la 8@tie{}KiB de memorie de program. mcu@tie{}=
„atmega48”, „atmega48a”, „atmega48p”, „atmega8”, „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{}= „atmega16”, „atmega16a”, „atmega16hva”, „atmega16hva2”, „atmega16hvb”,
„atmega16m1”, „atmega16u4”, „atmega161”, „atmega162”, „atmega163”, „atmega164a”,
„atmega164p”, „atmega165”, „atmega165a”, „atmega165p”, „atmega168”, „atmega168a”,
„atmega168p”, „atmega169”, „atmega169a”, „atmega169p”, „atmega169pa”, „atmega32”,
"atmega32c1", "atmega32hvb", "atmega32m1", "atmega32u4", "atmega32u6",
„atmega323”, „atmega324a”, „atmega324p”, „atmega324pa”, „atmega325”, „atmega325a”,
„atmega325p”, „atmega3250”, „atmega3250a”, „atmega3250p”, „atmega328”,
„atmega328p”, „atmega329”, „atmega329a”, „atmega329p”, „atmega329pa”,
„atmega3290”, „atmega3290a”, „atmega3290p”, „atmega406”, „atmega64”, „atmega64c1”,
„atmega64hve”, „atmega64m1”, „atmega640”, „atmega644”, „atmega644a”, „atmega644p”,
„atmega644pa”, „atmega645”, „atmega645a”, „atmega645p”, „atmega6450”,
„atmega6450a”, „atmega6450p”, „atmega649”, „atmega649a”, „atmega649p”,
"atmega6490", "at90can32", "at90can64", "at90pwm216", "at90pwm316", "at90scr100",
„at90usb646”, „at90usb647”, „at94k”, „m3000”.

"avr51"
Dispozitive „îmbunătățite” cu 128@tie{}KiB de memorie de program. mcu@tie{}= „atmega128”,
„atmega128rfa1”, „atmega1280”, „atmega1281”, „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{}= "atxmega16a4", "atxmega16d4", "atxmega16x1", "atxmega32a4",
„atxmega32d4”, „atxmega32x1”.

"avrxmega4"
Dispozitive „XMEGA” cu peste 64@tie{}KiB și până la 128@tie{}KiB de program
memorie. mcu@tie{}= „atxmega64a3”, „atxmega64d3”.

"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{}=
"atxmega128a3", "atxmega128d3", "atxmega192a3", "atxmega192d3", "atxmega256a3",
"atxmega256a3b", "atxmega256a3bu", "atxmega256d3".

"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".

"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.

-mshort-calls
Această opțiune a fost retrasă și va fi eliminată în GCC 4.8. Vezi „-mrelax” pentru a
înlocuire.

Folosiți instrucțiunile „RCALL”/„RJMP” chiar și pe dispozitivele cu 16@tie{}KiB sau mai mult de program
memorie, adică pe dispozitivele care au instrucțiunile „CALL” și „JMP”.

-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ă.

„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 și dacă „-mshort-calls” nu este setat.

„__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_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ționalul sirevision specifică
revizuirea din silicon a procesorului Blackfin țintă. Orice soluții disponibile pentru
revizuirea țintită a siliconului va fi activată. Dacă sirevision is nici unul, nu există soluții alternative
activat. Dacă sirevision is Orice, toate soluțiile pentru procesorul vizat vor fi
activat. Macrocomanda „__SILICON_REVISION__” este definită la două cifre hexazecimale
reprezentând numerele majore și minore în revizuirea siliciului. Dacă sirevision is
nici unul, „__SILICON_REVISION__” nu este definit. Dacă sirevision is Orice,
„__SILICON_REVISION__” este definit ca 0xffff. Dacă acest lucru este opțional sirevision nu este
utilizat, GCC presupune cea mai recentă revizuire cunoscută de siliciu a Blackfin-ului vizat
procesor.

Suport pentru bf561 este incomplet. Pentru bf561, Numai macrocomanda procesorului este definită.
Fără această opțiune, bf532 este folosit ca procesor în mod implicit. Corespondența
macro-uri de procesor predefinite pentru cpu este de definit. Si pentru bfin-elf lanț de instrumente,
acest lucru face ca BSP-ul hardware furnizat de libgloss să fie conectat în if -msim nu este
dat.

-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 va asigura 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 va asigura 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 utilizate 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.
Va fi generat un cod mai lent pentru insn-urile Jump and Call.

-mshared-library-id=n
A specificat numărul de identificare al bibliotecii partajate bazate pe ID care este compilată.
Specificarea unei valori de 0 va genera un cod mai compact, specificarea altor valori va genera
forțați 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 va restabili
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 autonomă pentru procesorul multicore Blackfin. Fișiere de pornire adecvate și
scripturile de link vor fi folosite pentru a suporta multicore. Această opțiune definește
„__BFIN_MULTICORE”. Poate fi folosit doar cu -mcpu=bf561[-sirevision]. Poate fi folosit
cu -mcorea or -mcoreb. Dacă este folosit fără -mcorea or -mcoreb, singur
este utilizat modelul de programare aplicație/dual core. În acest model, funcția principală a
Core B ar trebui să fie numit coreb_main. Dacă este folosit cu -mcorea or -mcoreb, unu
este utilizată aplicația pe model de programare de bază. Dacă această opțiune nu este utilizată, single
este utilizat modelul de programare a aplicațiilor de bază.

-mcorea
Creați o aplicație autonomă pentru Core A din BF561 când utilizați o aplicație per nucleu
model de programare. Fișierele de pornire adecvate și scripturile de link vor fi folosite pentru a sprijini Core A.
Această opțiune definește „__BFIN_COREA”. Trebuie folosit cu -multicore.

-mcoreb
Creați o aplicație autonomă pentru Core B a BF561 când utilizați o aplicație per nucleu
model de programare. Fișierele de pornire adecvate și scripturile de link vor fi folosite pentru a sprijini Core B.
Această opțiune definește „__BFIN_COREB”. Când se utilizează această opțiune, coreb_main ar trebui să fie
folosit în loc de principal. Trebuie folosit cu -multicore.

-msdram
Creați aplicație autonomă pentru SDRAM. Fișierele de pornire adecvate și scripturile de legătură vor fi
folosit pentru a pune aplicația în SDRAM. Loader ar trebui să inițializeze SDRAM înainte de încărcare
aplicația în SDRAM. Această opțiune definește „__BFIN_SDRAM”.

-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-soluție
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 adresare decât post-
creştere.

-mstack-align
-mno-stack-align
-mdata-align
-mno-data-align
-mconst-align
-mno-const-align
Aceste opțiuni (fără opțiuni) aranjează (elimină aranjamente) pentru cadrul stivă,
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 stivă, datele și constantele care pot fi scrise 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
salvat sau stocarea pentru variabila locală 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 validă atunci când opțiunea -mcr16c este aleasă ca arhitectura CR16C nu
susține modelul 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”; va crea un fișier obiect pentru
arhitectura unică pe care a fost construită pentru a viza. GCC-ul Apple pe Darwin creează
fișiere „grase” dacă sunt multiple -arc sunt utilizate opțiuni; face acest lucru rulând compilatorul sau
linker 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
steaguri care specifică ISA pe care GCC îl țintește, 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, va 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.
Linker-ul pentru biblioteci partajate, /usr/bin/libtool, va eșua și va imprima o eroare dacă va solicita
pentru a crea 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, va oferi în liniște executabilului cel mai restrictiv subtip dintre oricare dintre
fișierele sale 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” directorul conținut direct în acesta
care se termină în ".cadru". Numele unui cadru este numele acestui director
excluzând ".cadru". Anteturile asociate cadrului se găsesc într-unul dintre
acele două directoare, cu „Anteturi” fiind căutat mai întâi. Un subcadru este a
directorul cadru care se află într-un cadru "cadre" director. Include din
anteturile subcadru pot apărea numai într-un antet al unui cadru care conține
subcadru sau într-un antet subcadru frate. Două subcadre sunt frați dacă
ele apar în același cadru. Un subcadru nu trebuie să aibă același nume cu a
cadru, va fi emis un avertisment dacă aceasta este încălcată. În prezent un subcadru
nu pot avea subcadre, în viitor, mecanismul poate fi extins la suport
acest. Cadrele standard pot fi găsite în „/System/Library/Frameworks” și
„/Biblioteca/Frameworks”. Un exemplu include arată ca „#include ",
Unde Cadru denotă numele cadrului și antetul.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 STABS,
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-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 codul potrivit pentru dezvoltarea rapidă. Este necesar pentru a activa gdb
încărcați dinamic fișierele „.o” în programele 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 va produce o bibliotecă dinamică în loc de un executabil
la conectare, 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 va fi obișnuit
efectuează operații în virgulă mobilă. Cu excepția cazului în care sunt înlocuite cu rutine care emulează
operațiunile în virgulă mobilă sau compilate în așa fel încât să apeleze astfel de emulări
rutine, aceste rutine vor emite 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
construite ca să nu le cheme.

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. Sub DEC Unix, acest lucru are ca efect
Rutinele bibliotecii de matematică conform IEEE vor fi conectate în.

-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, va scoate fișierul
constantă ca un literal și generați 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, ați folosi această opțiune pentru a construi un încărcător dinamic de bibliotecă partajată. Însuși
o bibliotecă partajată, trebuie să se mute în memorie înainte de a putea găsi variabilele
și constante în propriul segment de date.

-malpha-as
-mgas
Selectați dacă doriți să generați codul pentru a fi asamblat de către asamblatorul furnizat de furnizor
(-malpha-as) sau de către asamblatorul GNU -mgas.

-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 a fost
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
va alege valorile implicite pentru setul de instrucțiuni de la procesorul pe care îl specificați.
Dacă nu specificați un tip de procesor, GCC va utiliza implicit 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.

Decembrie Alfa/VMS Opţiuni

Acestea -m opțiunile sunt definite pentru implementările DEC Alpha/VMS:

-mvms-coduri-return
Returnați codurile de stare VMS de la principal. Valoarea implicită este să returneze condiția de stil POSIX
(de exemplu) coduri de eroare.

-mdebug-main=prefix
Marcați prima rutină al cărei nume începe cu prefix ca principală rutină pentru
depanator.

-mmalloc64
Implicit la rutine de alocare a memoriei pe 64 de biți.

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 vor încadra î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 nops în pachetul anterior.
Această opțiune are efect numai atunci când împachetarea VLIW este activată. Nu creează noi
pachete; doar adaugă nops celor 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 redundante „membar” 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ă.

-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 va rula 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.

-mbig-switch
Generați codul potrivit pentru mesele mari de comutare. Utilizați această opțiune numai dacă
asamblatorul/linkerul se plâng de ramuri în afara intervalului dintr-un tabel de comutare.

-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 va funcționa î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 GNU ld. Aceasta trece -impartit a ld la construirea unui comun
bibliotecă. Este implicit atunci când GCC este configurat, explicit sau implicit, cu
Linker GNU. Această opțiune nu are nici un efect asupra căruia este apelat ld, ci doar
modifică ce parametri trec la acel ld. Ld care este numit este determinat de
il --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`.
Această opțiune 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 HP ld. Aceasta trece -b să ld la construirea unei biblioteci partajate și
trece +Accept Nepotrivire de tip a ld pe toate linkurile. Este valoarea implicită când este GCC
configurat, explicit sau implicit, cu linkerul HP. Această opțiune nu are
orice efect asupra căruia este apelat ld, schimbă doar parametrii care îi sunt trecuți
ld. Ld care este numit este determinat de --cu-ld opțiunea de configurare, GCC
calea de căutare a programului și, în final, de către utilizator PATH. Linkerul folosit de GCC poate fi
tipărit folosind care `gcc -print-prog-name=ld`. Această opțiune este disponibilă numai pe
GCC HP-UX pe 64 de biți, 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 va degrada performanța.
Cu toate acestea, poate fi util în aplicații mari, în special atunci când este o legătură parțială
folosit pentru a construi 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:

-mtune=tip CPU
Acordați-vă tip CPU totul aplicabil despre codul generat, cu excepția ABI
și setul de instrucțiuni disponibile. Alegerile pentru tip CPU sunt:

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 în loc de -mtune=generic. Dar, dacă nu știi exact ce procesor
utilizatorii aplicației dvs. vor avea, atunci ar trebui să utilizați această 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, codul
opțiunea generată se va modifica pentru a reflecta procesoarele care erau cele mai comune când
acea versiune a GCC a fost lansată.

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.

nativ
Aceasta selectează CPU-ul pe care să îl reglați în momentul compilării, determinând procesorul
tipul mașinii de compilare. Folosind -mtune=nativ va produce cod optimizat
pentru mașina locală sub constrângerile setului de instrucțiuni selectat.
Utilizarea -martie=nativ va activa toate subseturile de instrucțiuni acceptate de local
mașină (deci rezultatul ar putea să nu ruleze pe mașini diferite).

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 PentiumMMX bazat pe nucleu Pentium cu suport pentru set de instrucțiuni MMX.

pentiumpro
CPU Intel PentiumPro.

i686
La fel ca „generic”, dar atunci când este folosit ca opțiune „marș”, setul de instrucțiuni PentiumPro
va fi folosit, astfel încât codul va rula pe toate cipurile din familia i686.

pentium2
CPU Intel Pentium2 bazat pe nucleul PentiumPro cu suport pentru set de instrucțiuni MMX.

pentium3, pentium3m
CPU Intel Pentium3 bazat pe nucleul PentiumPro cu set de instrucțiuni MMX și SSE
sprijini.

pentium-m
Versiune de putere redusă a procesorului Intel Pentium3 cu set de instrucțiuni MMX, SSE și SSE2
a sustine. Folosit de caietele Centrino.

pentium4, pentium4m
CPU Intel Pentium4 cu suport pentru set de instrucțiuni MMX, SSE și SSE2.

Prescott
Versiune îmbunătățită a procesorului Intel Pentium4 cu instrucțiuni MMX, SSE, SSE2 și SSE3
setați suportul.

nocona
Versiune îmbunătățită a procesorului Intel Pentium4 cu extensii pe 64 de biți, MMX, SSE, SSE2 și
Suport pentru set de instrucțiuni SSE3.

miez2
CPU Intel Core2 cu extensii pe 64 de biți, instrucțiuni MMX, SSE, SSE2, SSE3 și SSSE3
setați suportul.

corei7
CPU Intel Core i7 cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 și
Suport pentru set de instrucțiuni SSE4.2.

corei7-avx
CPU Intel Core i7 cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suport pentru setul de instrucțiuni SSE4.2, AVX, AES și PCLMUL.

core-avx-i
CPU Intel Core cu extensii pe 64 de biți, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suport pentru setul de instrucțiuni SSE4.2, AVX, AES, PCLMUL, FSGSBASE, RDRND și F16C.

atom
CPU Intel Atom cu extensii pe 64 de biți, instrucțiuni MMX, SSE, SSE2, SSE3 și SSSE3
setați suportul.

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.

atlon, athlon-tbird
CPU AMD Athlon cu MMX, 3dNOW!, 3DNow îmbunătățit! și instrucțiuni de preluare prealabilă SSE
sprijini.

athlon-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 nucleu AMD K8 cu suport pentru set de instrucțiuni x86-64. (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 k8, opteron și athlon64 cu suport pentru setul de instrucțiuni SSE3.

amdfam10, Barcelona
Procesoare bazate pe nuclee de 10 ore din familia AMD 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 de 15 ore din familia AMD 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, 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.)

btver1
Procesoare bazate pe nuclee de 14 ore din familia AMD 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.)

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 Winchip2, tratat în același mod ca i486 cu MMX și 3DNow suplimentar!
suport pentru set de instrucțiuni.

c3 Prin procesor C3 cu MMX și 3DNow! suport pentru set de instrucțiuni. (Nu există nicio programare
implementat pentru acest cip.)

c3-2
Prin CPU C3-2 cu suport pentru set de instrucțiuni MMX și SSE. (Nu există nicio programare
implementat pentru acest cip.)

Geode
CPU AMD încorporat cu MMX și 3DNow! suport pentru set de instrucțiuni.

În timp ce alegeți un anumit tip CPU va programa lucrurile în mod corespunzător pentru asta
un anumit cip, compilatorul nu va genera niciun cod care nu rulează pe
tipul implicit de mașină fără -martie=tip CPU opțiunea utilizată. De exemplu, dacă
GCC este configurat pentru i686-pc-linux-gnu atunci -mtune=pentium4 va genera codul care
este reglat pentru Pentium4, dar va rula în continuare pe mașini i686.

-martie=tip CPU
Generați instrucțiuni pentru tipul de mașină tip CPU. Alegerile pentru tip CPU sunt
la fel ca pentru -mtune. Mai mult, precizând -martie=tip CPU implică -mtune=tip CPU.

-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 suportat de cipuri Pentium3 și mai noi, în linia AMD de
jetoane Athlon-4, Athlon-xp și Athlon-mp. Versiunea anterioară a instrucțiunii SSE
setul acceptă doar aritmetică cu precizie unică, astfel încât dublu și extins-
aritmetica de precizie se fac în continuare folosind 387. O versiune ulterioară, prezentă doar în
Pentium4 și viitoarele cipuri AMD x86-64, acceptă aritmetică cu dublă precizie
prea.

Pentru compilatorul i386, trebuie să utilizați -martie=tip CPU, -msse or -msse2 întrerupătoare
pentru a activa extensiile SSE și pentru a face această opțiune eficientă. 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șiți instrucțiuni asm folosind selectat dialect. Alegerile acceptate sunt Intel or la
(cel 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: necesarul
bibliotecile nu fac parte din GCC. În mod normal, facilitățile obișnuite ale mașinii C
sunt utilizate compilatoare, dar acest lucru nu se poate face direct în compilarea încrucișată. Trebuie să vă
faceți propriile aranjamente pentru a oferi funcții adecvate de bibliotecă pentru
compilare.

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 țintă va avea întotdeauna un FPU și deci instrucțiunea nu va avea
nevoie de emulare. Începând cu revizuirea 2.6.1, aceste instrucțiuni nu sunt generate decât dacă dvs
folosiț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 a 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
va fi aliniat diferit față de interfața binară a aplicației publicate
specificațiile pentru 386 și nu vor fi compatibile binare cu structurile din cod
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ă că „dublu lung” trebuie 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ă suprascrieți valoarea implicită pentru ABI țintă, structurile și
tablourile care conțin variabile „long double” își vor schimba dimensiunea, precum și funcția
convenția de apelare pentru funcția luând „long double” va fi modificată. De aici ei
nu va fi compatibil binar cu matricele sau structurile din codul compilat fără asta
intrerupator.

-mlarge-data-threshold=număr
Cand -mcmodel=mediu este specificat, datele mai mari decât prag sunt plasate în mare
secțiunea de date. Această valoare trebuie să fie aceeași pentru toate obiectele legate în binar
și implicit la 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 returnat cu „ret” o 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”); în caz contrar, va fi generat un cod incorect
pentru apelurile la aceste funcții.

În plus, va rezulta 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 va genera opțiunea
un prolog și un epilog alternativ care realinează stiva de rulare, dacă este necesar.
Acest lucru acceptă amestecarea codurilor vechi care păstrează o stivă aliniată de 4 octeți cu codurile moderne
care păstrează o stivă 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. 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 va fi folosit.

Pe Pentium și PentiumPro, 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 va alinia greșit 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
-maes
-mno-aes
-mpclmul
-mno-pclmul
-mfsgsbase
-mno-fsgsbase
-mrdrnd
-mno-rdrnd
-mf16c
-mno-f16c
-mfma
-mno-fma
-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
-mtbm
-mno-tbm
Aceste comutatoare permit sau dezactivează utilizarea instrucțiunilor în MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP,
LWP, ABM, IMC, BMI2, LZCNT sau 3DNow!
seturi de instrucțiuni extinse. Aceste extensii sunt disponibile și ca încorporate
funcții: vezi X86 Built-in funcţii, pentru detalii despre funcțiile activate și
dezactivate de aceste comutatoare.

Pentru a avea instrucțiuni SSE/SSE2 generate automat din codul în virgulă mobilă (cum ar fi
contrar instrucțiunilor 387), 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 vor permite GCC să utilizeze aceste instrucțiuni extinse în codul generat,
chiar si fara -mfpmath=sse. Aplicațiile care efectuează detectarea CPU în timpul rulării trebuie
compilați fișiere separate pentru fiecare arhitectură acceptată, folosind steagurile corespunzătoare.
În special, fișierul care conține codul de detectare a CPU ar trebui compilat fără
aceste opțiuni.

-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
controlează fluxul în afara funcției pentru a minimiza penalitatea de tranziție AVX la SSE, precum și
eliminarea 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 va permite GCC să utilizeze instrucțiunile CMPXCHG16B în codul generat.
CMPXCHG16B permite operațiuni atomice pe date de 128 de biți dublu quadword (sau oword)
tipuri. Acest lucru este util pentru contoarele de înaltă rezoluție care ar putea fi actualizate de mai multe ori
procesoare (sau nuclee). Această instrucțiune este generată ca parte a atomic built-in
funcții: vezi __sincronizare Construcții or __atomic Construcții pentru detalii.

-msahf
Această opțiune va permite GCC să utilizeze instrucțiunile SAHF în codul de 64 de biți generat. Din timp
Procesoarele Intel cu Intel 64 nu aveau instrucțiuni LAHF și SAHF acceptate de AMD64 până în prezent
introducerea pasului Pentium 4 G1 în decembrie 2005. LAHF și SAHF sunt încărcare și stocare
instrucțiuni, respectiv, pentru anumite steaguri de stare. În modul pe 64 de biți, SAHF
instrucțiunea este utilizată pentru a optimiza funcțiile încorporate „fmod”, „drem” sau „remainder”: vezi
Altele Construcții pentru detalii.

-mmovbe
Această opțiune va permite GCC să folosească instrucțiunile movbe pentru a implementa „__builtin_bswap32”
și „__builtin_bswap64”.

-mcrc32
Această opțiune va activa funcțiile încorporate, „__builtin_ia32_crc32qi”,
„__builtin_ia32_crc32hi”. „__builtin_ia32_crc32si” și „__builtin_ia32_crc32di” pentru
generați instrucțiunea mașinii crc32.

-mrecip
Această opțiune va permite GCC să utilizeze instrucțiunile RCPSS și RSQRTSS (și a acestora
variante vectorizate RCPPS și RSQRTPS) cu un pas suplimentar Newton-Raphson la
crește precizia în loc de DIVSS și SQRTSS (și variantele lor vectorizate) pentru
argumente în virgulă mobilă cu precizie unică. 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 permite controlul instrucțiunilor de estimare reciprocă care pot fi utilizate. opta
este o listă de opțiuni separate prin virgulă, care poate fi precedată de un „!” a inversa
opțiune: „all”: activați toate instrucțiunile de estimare, „default”: activați implicit
instrucțiuni, echivalent cu -mrecip, „niciunul”: 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
aproximare pentru rădăcina pătrată scalară, "vec-sqrt": activați aproximarea pentru
rădăcină pătrată vectorizată.

Deci, de exemplu, -mrecip=toate,!sqrt ar 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ă.
Tipurile acceptate sunt „svml” pentru biblioteca de matematică vectorială scurtă Intel și „acml” pentru
Stilul de interfață al bibliotecii de bază matematică AMD. GCC va 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 este 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 atunci când
-mveclibabi=acml este folosit. Ambii -fttree-vectoriza și -optimizări-funsafe-matematice avea
pentru a fi activat. O bibliotecă compatibilă SVML sau ACML ABI va trebui specificată la link
timp.

-mabi=nume
Generați codul pentru convenția de apelare specificată. Valorile permise sunt: sysv pentru
ABI-ul folosit pe GNU/Linux și alte sisteme și ms pentru Microsoft ABI. Implicit
este să utilizați Microsoft ABI atunci când vizați Windows. Pe toate celelalte sisteme, implicit
este SYSV ABI. Puteți controla acest comportament pentru o anumită funcție folosind
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.

-macumulare-ieşire-args
Dacă este activat, spațiul maxim necesar pentru argumentele de ieșire va fi
calculate în prologul funcţiei. Acest lucru este mai rapid pe majoritatea procesoarelor moderne din cauza
dependențe reduse, programare îmbunătățită și utilizare redusă a stivei atunci când se preferă stiva
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 activată Mingw32. Cod 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 ajutor special pentru fir
bibliotecă -lmingwthrd care curăță datele de gestionare a excepțiilor pentru fiecare fir.

-mno-align-stringops
Nu aliniați destinația operațiilor cu șiruri aliniate. Acest comutator reduce dimensiunea codului
și îmbunătățește performanța în cazul în care destinația este deja aliniată, dar GCC nu
stiu 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ă inline, mărirea dimensiunii codului,
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
Suprascrieți euristica de decizie internă despre un anumit algoritm în șirul inline
operare cu. Valorile permise sunt „rep_byte”, „rep_4byte”, „rep_8byte” pentru
extinderea utilizând prefixul i386 „rep” de dimensiunea specificată, „byte_loop”, „loop”,
„unrolled_loop” pentru extinderea buclei inline, „libcall” pentru bibliotecă care se extinde mereu
apel.

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

-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 legal sau nu, depinde de sistemul de operare și dacă acesta este
cartografiază segmentul pentru a acoperi întreaga zonă TLS.

Pentru sistemele care folosesc GNU libc, 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 apelul contor de profilare înainte de prolog. Notă: Activat
arhitecturi x86 pentru care atributul „ms_hook_prologue” nu este posibil momentan 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.

Acestea -m switch-urile sunt acceptate în plus față de cele de mai sus pe procesoarele AMD x86-64 în
medii pe 64 de biți.

-m32
-m64
-mx32
Generați cod pentru un mediu pe 32 de biți sau 64 de biți. The -m32 seturi de opțiuni int, long și
pointer la 32 de biți și generează cod care rulează pe orice sistem i386. The -m64 opțiune
setează int la 32 de biți și long și pointer la 64 de biți și generează cod pentru AMD
arhitectura x86-64. The -mx32 opțiunea setează int, long și pointer la 32 de biți și
generează cod pentru arhitectura AMD x86-64. Pentru Darwin numai -m64 opțiunea se întoarce
De pe -fno-pic și -mdynamic-no-pic opțiuni.

-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 va
nu poate fi modificat de către manipulatorii de semnal sau întrerupere și, prin urmare, poate fi folosit pentru
date temporare fără a ajusta indicatorul stivei. 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 cei 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 Windows:

-mconsole
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Specifică că o consolă
aplicația urmează să fie generată, indicând linker-ului să seteze antetul PE
tipul de subsistem necesar pentru aplicațiile de consolă. Acesta este comportamentul implicit pentru
Țintele Cygwin și MinGW.

-mdll
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Specifică că un DLL - a
bibliotecă de linkuri 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 ar trebui 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. Specifică că macroul UNICODE
devine predefinit și că este ales codul de pornire compatibil Unicode.

-mwin32
Această opțiune este disponibilă pentru ținte Cygwin și MinGW. Se precizează că tipicul
Macrocomenzile Windows predefinite 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 binarele care rulează
modul kernel al Windows, așa cum există user32 API, care este folosit pentru a seta executabilul
privilegii, nu este disponibil.

-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. Acesta va fi 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.

AI-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 DWARF2. Acest
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 itan,
itaniu1, merced, itaniu2 ș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. Acest lucru va avea ca rezultat
generarea instrucțiunilor ld.a și a instrucțiunilor de verificare corespunzătoare (ld.c /
chk.a). Valoarea implicită este „dezactivare”.

-msched-ar-data-spec
-mno-sched-ar-data-spec
(En/Dis)activați programarea speculativă a datelor după reîncărcare. Acest lucru va avea ca rezultat generare
a instrucțiunilor ld.a și a instrucțiunilor 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). Acest lucru va avea ca rezultat generarea ld.s
instrucțiuni ș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 vor fi alese pentru programare numai dacă există
nu sunt alte alegeri momentan. Acest lucru va face utilizarea speculațiilor de date
mult mai conservatoare. Valoarea implicită este „dezactivare”.

-mno-sched-prefer-non-control-spec-insns
-msched-prefer-non-control-spec-insns
Dacă este activată, instrucțiunile speculative de control vor fi alese pentru programare numai dacă există
nu sunt alte alegeri momentan. Acest lucru va face uz de speculația de control
mult 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 vor fi luate în considerare în timpul calculării
prioritățile instrucțiunilor. Acest lucru va face mai mult utilizarea speculației
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
Nu permiteți mai mult de „msched-max-memory-insns” în grupul de instrucțiuni. În caz contrar, limitează
este „soft”, ceea ce înseamnă că am prefera operațiuni fără memorie când limita este atinsă, dar
mai poate programa operațiuni de memorie.

IA-64/VMS Opţiuni

Acestea -m opțiunile sunt definite pentru implementările IA-64/VMS:

-mvms-coduri-return
Returnați codurile de stare VMS de la principal. Valoarea implicită este să returneze condiția de stil POSIX
(de exemplu) coduri de eroare.

-mdebug-main=prefix
Marcați prima rutină al cărei nume începe cu prefix ca principală rutină pentru
depanator.

-mmalloc64
Implicit la rutine de alocare a memoriei pe 64 de biți.

LM32 Opţiuni

Acestea -m opțiunile sunt definite pentru arhitectura Lattice Mico32:

-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 va folosi în timpul codului
generaţie. Aceste pseudo-registre vor fi folosite ca registre reale, deci există o
compromis între capacitatea GCC de a încadra codul în registrele disponibile și
penalizare de performanță a utilizării memoriei în loc de registre. Rețineți că toate modulele din a
programul trebuie compilat cu aceeași valoare pentru această opțiune. Din cauza asta, tu
nu trebuie să utilizați această opțiune cu bibliotecile de rulare implicite pe care le construiește 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 va genera
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 va genera
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 va genera o instrucțiune mult mai lent
secvența de instrucțiuni „seth/add3/jl”.

-msdata=niciuna
Dezactivați utilizarea zonei mici de date. Variabilele vor fi introduse într-una 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 locul secțiunilor 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 va da o eroare
mesaj---codul incorect nu va fi 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 vor fi preferate
cod condiționat, dacă este 2, atunci se va aplica opusul.

-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 va fi folosit numai dacă o capcană nu este
disponibile.

-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 51CN 51em 51qe
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 macrocomenzile __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”); în caz contrar, va fi generat un cod incorect
pentru apelurile la aceste funcții.

În plus, va rezulta 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 va alinia structurile care conțin
mai sus tipe diferit de interfața binară a celei mai publicate aplicații
specificații 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 vor fi 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 în 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 utilizate biblioteci partajate bazate pe ID. Aceasta este
implicit.

-mshared-library-id=n
A specificat numărul de identificare al bibliotecii partajate bazate pe ID care este compilată.
Specificarea unei valori de 0 va genera un cod mai compact, specificarea altor valori va genera
forțați 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țiunile pe biți.

-mwide-bitfields
-mno-wide-bitfields
Tratați întotdeauna câmpurile de biți ca fiind 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 mediere, î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ți sau mai mici vor fi plasați în secțiunea „.based” de către
Mod implicit. 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"), clear
("bclrm"), inversare ("bnotm") și test-and-set ("tas").

-mc=nume
Selectează în ce secțiune vor fi 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”.

-mrepet
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ți sau mai mici vor fi 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 un anumit CPU. Valorile acceptate sunt în format
vX.YY.Z, În cazul în care X este o versiune majoră, YY este versiunea minoră și Z este compatibilitatea
cod. 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ă. Folosiți -fstack-check în schimb.

-mxl-gp-opt
Utilizați secțiuni sdata/sbss relative 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ă.

-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 să fie 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.

Extensie 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 va rula 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, 4 poză, 4ksd, 5kc, 5kf, 20kc, 24kc, 24kf2_1, 24kf1_1, 24kec, 24kef2_1,
24kef1_1, 34kc, 34kf2_1, 34kf1_1, 74kc, 74kf2_1, 74kf1_1, 74kf3_2, 1004kc, 1004kf2_1,
1004kf1_1, loongson2e, loongson2f, loongson3a, M4K, octeon, octeon+, octeon2, orion,
r2000, r3000, r3900, r4000, r4400, r4600, r4650, r6000, r8000, rm7000, rm9000, r10000,
r12000, r14000, r16000, sb1, sr71000, vr4100, vr4111, vr4120, vr4130, vr4300, vr5000,
vr5400, vr5500 și xlr. Valoarea specială din-abi selectează cel mai compatibil
arhitectura pentru ABI selectat (adică mips1 pentru ABI-uri pe 32 de biți și mips3 pentru 64 biți
ABI-uri).

Lanțurile de instrumente native Linux/GNU și IRIX susțin, de asemenea, valoarea nativ, care selectează
cea mai bună opțiune de arhitectură pentru procesorul gazdă. -martie=nativ nu are efect dacă GCC
nu recunoaște 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 va stabili _MIPS_ARCH la "r2000" și definiți macro-ul _MIPS_ARCH_R2000.

Rețineți că _MIPS_ARCH macro folosește numele de procesor date mai sus. Cu alte cuvinte,
va avea prefixul complet și nu se va prescurta 000 as k. În cazul în care din-
abi, macro-ul denumește arhitectura rezolvată (fie "mips1" or "mips3"). Se numeste
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 va optimiza pentru procesorul specificat de -Martie.
Prin folosirea -Martie și -mtune împreună, este posibil să generați cod care va rula
o familie de procesoare, dar optimizați codul pentru un anumit membru al acestuia
familie.

-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
arhitectura, va folosi 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-mips16
-mno-interlink-mips16
Solicitați (nu necesită) ca codul non-MIPS16 să fie compatibil cu codul MIPS16.

De exemplu, codul non-MIPS16 nu poate sări direct la codul MIPS16; trebuie fie să folosească a
apel sau un salt indirect. -minterlink-mips16 prin urmare, dezactivează săriturile directe cu excepția cazului în care
GCC știe că ținta saltului nu este MIPS16.

-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 mthc1 și mfhc1 instrucțiuni ș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 voi
î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, va funcționa numai dacă GOT-ul este mai mic de aproximativ 64k.
Orice lucru mai mare va determina linkerul 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. Apoi ar trebui să funcționeze cu
GOT-uri foarte mari, deși va fi și mai puțin eficient, deoarece va fi 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ă.

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

-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 va folosi instrucțiunile dacă
arhitectura țintă le sprijină.

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

-mmt
-mno-mt
Folosiți (nu folosiți) instrucțiuni MT Multithreading.

-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 apoi accesa datele mai eficient; 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 vor fi într-o secțiune mică de date dacă
acele date se află î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 vor trece o valoare necunoscută în $gp.
(În astfel de situații, monitorul de pornire în sine ar fi de obicei compilat cu -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.

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

Atunci când sunt utilizate instrucțiuni de multiplicare-acumulare, se calculează produsul intermediar
la o precizie infinită și nu este supus bitului FCSR Flush to Zero. Aceasta ar putea fi
nedorit în anumite circumstanțe.

-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-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
mai degrabă decât de GCC, deși GCC va evita 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 a fost 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 vor 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ă accesele anulate la orice octet din următoarele regiuni nu vor avea parte
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 vor fi 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 programăm FP
instrucțiuni 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 va
aliniați 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) vor fi 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 va invalida 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-2pm 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ă un prototip ar duce la 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__.

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 va
rulați pe oricare dintre celelalte tipuri de AE. Codul nu va fi la fel de eficient precum ar fi dacă
compilat pentru un anumit tip AE și unele tipuri de operații (de exemplu, multiplicare)
nu va funcționa 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 va genera programe mai mari, care rulează mai repede decât atunci când opțiunea nu este
folosit. Cu toate acestea, rezultatele variază de la program la program, așa că este lăsat ca utilizator
opțiunea, în loc 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 va fi generat un avertisment care indică
programator că ar trebui să rescrie codul pentru a evita operațiunile de octeți sau pentru a viza un
Tip AE care are suportul hardware necesar. Această opțiune permite avertismentul
fi dezactivat.

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:

-putere
-mno-putere
-putere2
-mno-putere2
-mpowerpc
-mno-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
GCC acceptă două arhitecturi de seturi de instrucțiuni asociate pentru RS/6000 și PowerPC.
POWER setul de instrucțiuni sunt acele instrucțiuni susținute de rios set de cipuri folosit
în sistemele originale RS/6000 și PowerPC setul de instrucțiuni este arhitectura
microprocesoarele Freescale MPC5xx, MPC6xx, MPC8xx și IBM 4xx, 6xx și
microprocesoare secundare.

Nici una dintre arhitecturi nu este un subset al celeilalte. Cu toate acestea, există un subset comun mare
de instrucţiuni susţinute de ambele. Un registru MQ este inclus în procesoare
susținând arhitectura POWER.

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.

-putere opțiunea permite GCC să genereze instrucțiuni care se găsesc numai în
arhitectura POWER și să utilizeze registrul MQ. Precizând -putere2 implică -Putere și
permite de asemenea GCC să genereze instrucțiuni care sunt prezente în arhitectura POWER2
dar nu arhitectura originală POWER.

-mpowerpc opțiunea permite GCC să genereze instrucțiuni care se găsesc numai în
Subsetul de 32 de biți al arhitecturii PowerPC. Precizând -mpowerpc-gpopt implică
-mpowerpc și, de asemenea, permite GCC să utilizeze instrucțiunile opționale de arhitectură PowerPC în
grupul de uz general, inclusiv rădăcina pătrată în virgulă mobilă. Precizând
-mpowerpc-gfxopt implică -mpowerpc și, de asemenea, permite GCC să utilizeze PowerPC opțional
instrucțiuni de arhitectură 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.

Dacă le specificați pe amândouă -mno-putere și -mno-powerpc, GCC va folosi numai instrucțiunile din
subsetul comun al ambelor arhitecturi plus câteva apeluri speciale în modul comun AIX și
nu va folosi registrul MQ. Precizând ambele -putere și -mpowerpc permite GCC să
utilizați orice instrucțiune din oricare dintre arhitecturi și pentru a permite utilizarea registrului MQ;
specificați acest lucru pentru Motorola MPC601.

-mnew-mnemonic
-mucegai-mnemonic
Selectați ce mnemonice să utilizați în codul de asamblare generat. Cu -mnew-mnemonic,
GCC utilizează mnemonicii de asamblare definite pentru arhitectura PowerPC. Cu
-mucegai-mnemonic folosește mnemonicii de asamblare definite pentru arhitectura POWER.
Instrucțiunile definite într-o singură arhitectură au un singur mnemonic; GCC folosește asta
mnemonic, indiferent de care dintre aceste opțiuni este specificată.

GCC folosește implicit mnemonicile adecvate pentru arhitectura utilizată. Precizând
-mcpu=tip_cpu uneori suprascrie valoarea acestor opțiuni. Dacă nu construiești
un cross-compiler, în mod normal nu ar trebui să specificați nici -mnew-mnemonic or
-mucegai-mnemonic, dar ar trebui să accepte implicit.

-mcpu=tip_cpu
Setați tipul de arhitectură, utilizarea registrului, alegerea mnemotecilor și programarea instrucțiunilor
parametri pentru tipul 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, ec603e, G3, G4, G5, gigant, putere, power2, power3, power4, power5,
putere5+, power6, putere6x, power7, comun, putere pc, powerpc64, rios, râuri1, râuri2, csr,
și rs64.

-mcpu=comun selectează un procesor complet generic. Cod generat în cadrul acestei opțiuni
va rula pe orice procesor POWER sau PowerPC. GCC va folosi numai instrucțiunile din
subsetul comun al ambelor arhitecturi și nu va folosi registrul MQ. GCC presupune a
model de procesor generic în scopuri de programare.

-mcpu=putere, -mcpu=putere2, -mcpu=powerpc, și -mcpu=powerpc64 specificați PUTEREA generică,
POWER2, ​​PowerPC pur pe 32 de biți (adică, nu MPC601) și arhitectură PowerPC pe 64 de biți
tipuri de mașini, cu un model de procesor generic adecvat presupus pentru programare
scopuri.

Celelalte opțiuni specifică un anumit procesor. Cod generat în cadrul acestor opțiuni
va rula 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 -mnew-mnemonic -mpopcntb
-mpopcntd -putere -putere2 -mpowerpc64 -mpowerpc-gpopt -mpowerpc-gfxopt
-msingle-float -mdouble-float -msimple-fpu -mstring -mmulhw -mdlmzb -mmfpgpr -mvsx

Opțiunile speciale setate pentru un anumit CPU vor varia î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 arhitecturii, utilizarea registrului sau alegerea mnemotecilor, cum ar fi -mcpu=tip_cpu
ar. Aceleași valori pentru tip_cpu sunt utilizate pentru -mtune în ceea ce privește -mcpu. Dacă ambele sunt
specificat, codul generat va folosi arhitectura, registrele și setul de mnemonici
by -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.

-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
Avertizare când va fi emisă o instrucțiune de microcod Cell. Un exemplu de celulă
instrucțiunea de microcod este o schimbare variabilă.

-msecure-plt
Generați cod care permite ld și ld.so să construiască executabile și biblioteci partajate cu
non-exec .plt și .got secțiuni. 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 pe care ld.so o completează și necesită .plt și
.got secțiuni care sunt atât inscriptibile, cât și executabile. Acesta este un SYSV PowerPC pe 32 de biți
Opțiunea 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.

-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
va aloca cel puțin o intrare TOC pentru fiecare referință unică a variabilei neautomate
în programul dvs. GCC va plasa, de asemenea, constante în virgulă mobilă în TOC. In orice caz,
doar 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 va produce cod care este mai lent și
mai mare, dar care utilizează extrem de puțin spațiu TOC. Poate doriți să utilizați această opțiune
numai pe fișierele 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 și
-mpowerpc, În timp ce -maix32 dezactivează ABI pe 64 de biți și implică -mno-powerpc64. GCC
implicit la -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
Specificați tipul de unitate în virgulă mobilă. Valorile valide 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 implicit când țintiț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 implicit 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 vor fi 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.

-mprioritizare-restricţionat-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/2 pentru a atribui nu/cel mai înalt/al doilea cel mai înalt prioritate la slotul de expediere restricționată
instructiuni.

-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ța de la magazin la încărcare este costisitoare, număr: orice dependență pentru care latență >=
număr este costisitoare.

-minsert-sched-nops=schemă
Această opțiune controlează ce schemă de inserare nop va fi utilizată în timpul celei de-a doua
permis de programare. Argumentul schemă ia una dintre următoarele valori: Nu.: Nu
inserați nops. tampon: Adăugați cu nops orice grup de expediere care are spații de emisiune libere,
conform grupării programatorului. regrupare_exact: Introduceți nops pentru a forța costisitoare
insns dependente în grupuri separate. Introduceți exact atâtea nop cât este necesar pentru a forța
un insn la un nou grup, conform grupării estimate de procesoare. număr: Inserați
nops pentru a forța instituțiile costisitoare dependente în grupuri separate. Introduce număr nu la
forţa un insn la un grup nou.

-mcall-sysv
Pe System V.4 și sistemele PowerPC încorporate compilați codul folosind convențiile de apelare care
aderă 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.

-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 Booke SPE ABI pentru ABI actual.

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

-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ă au fost transmise în virgulă mobilă
înregistrează în cazul în care funcția preia argumente variabile. Cu -mprototip, doar apeluri
la funcțiile de argument variabile prototipate vor seta sau șterge 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ă de la „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
nu apelează o funcție de inițializare de la „main”, iar -msdata opțiunea va folosi 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 la distanță, astfel încât o apelare mai scumpă
este necesară secvența. 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 va fi 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” va genera „jbsr callee, L42”, plus un
„insula ramură” (cod lipici). Cele două adrese țintă reprezintă apelatul și
„insula ramură”. Linker-ul Darwin/PPC va prefera prima adresă și va genera a
„bl apelat” dacă instrucțiunea PPC „bl” va ajunge direct la apelat; în caz contrar, cel
linkerul va genera „bl L42” pentru a apela „insula ramură”. „Insula ramurilor” este
atașat la corpul funcției de apelare; calculează adresa completă de 32 de biți a
apelatul și sare la el.

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, putem determina GCC să ignore toate specificațiile longcall atunci când linker
se știe că 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 lui ld să asocieze în mod fiabil apelul funcției cu argumentul
instrucțiuni de configurare pentru optimizarea TLS, care la rândul său permite gcc să programeze mai bine
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 va permite GCC să utilizeze estimarea reciprocă și rădăcina pătrată reciprocă
estimați instrucțiunile cu pași suplimentari Newton-Raphson pentru a crește precizia
în loc să faceți o împărțire sau rădăcină pătrată și împărțire pentru argumente în virgulă mobilă. Tu
ar trebui să folosească -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 instrucțiunii non-reciproce, precizia
secvența poate fi redusă 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 permite controlul instrucțiunilor de estimare reciprocă care pot fi utilizate. opta
este o listă de opțiuni separate prin virgulă, care poate fi precedată de un „!” a inversa
opțiune: „all”: activați toate instrucțiunile de estimare, „default”: activați implicit
instrucțiuni, echivalent cu -mrecip, „niciunul”: dezactivați toate instrucțiunile de estimare,
echivalent cu -mno-recip; "div": activați instrucțiunile de aproximare reciprocă pentru
precizie atât simplă cât și dublă; „divf”: activați reciproca cu precizie unică
instrucțiuni de aproximare; „divd”: activați reciproca dublă precizie
instrucțiuni de aproximare; „rsqrt”: activați aproximarea rădăcinii pătrate reciproce
instrucțiuni pentru precizie simplă și dublă; „rsqrtf”: activați unic-
instrucțiuni de aproximare a rădăcinii pătrate reciproce de precizie; „rsqrtd”: activați
instrucțiuni de aproximare a rădăcinii pătrate reciproce cu dublă precizie;

Deci, de exemplu, -mrecip=all,!rsqrtd ar permite întreaga estimare 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 or
-mcpu=putere7 selectează automat -mrecip-precizie. Pătratul cu dublă precizie
Instrucțiunile de estimare rădăcină nu sunt generate implicit pe mașinile cu precizie redusă,
întrucât nu oferă o estimare care să convergă după trei etape.

-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 va 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 activat. Bibliotecile MASS vor trebui 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 veți putea suna prin intermediul
pointeri către funcții imbricate sau pointeri către funcții compilate în alte limbi care
utilizați lanțul 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ă.

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ă vor fi generate numai pentru valorile în virgulă mobilă pe 32 de biți
cu toate acestea, deci dacă -m64bit-duble opțiunea este în uz, atunci hardware-ul FPU nu va fi
folosit la dublu.

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 care ar fi putut fi păstrate cândva în registrul rezervat sunt acum
împins pe stivă.

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 către asamblatorul GAS, dar are unele
restricții, astfel încât generarea acestuia nu este opțiunea 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 o va face
încercarea de a reduce dimensiunea unui program prin găsirea de versiuni mai scurte ale diverselor
instrucțiuni. Dezactivat 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” va fi
rezervat utilizării exclusive a operatorilor de întrerupere rapide. O valoare de 2 rezerve
„r13” și „r12”. O valoare de 3 rezervă „r13”, „r12” și „r11”, iar o valoare de 4
rezervă „r13” prin „r10”. O valoare de 0, implicită, nu rezervă niciuna
registre.

-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 vor face printr-un offset de la 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ă.

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 va asigura că folosește numai
înregistrează „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 va fi folosit
pentru a efectua 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
va fi folosit pentru a efectua operații zecimale cu virgulă mobilă. Cand -mhard-dfp is
specificat, compilatorul generează instrucțiuni hardware zecimale în virgulă mobilă. Acest
este implicit pentru -martie=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 cadru de apel 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 va rula 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 și z10. 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. Aceasta 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 s390 emite instrucțiuni suplimentare în
prolog de funcții care declanșează o capcană dacă dimensiunea stivei este paza-stiva octeți de mai sus
il dimensiunea stivei (rețineți că stiva de pe s390 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 de producție 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.

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 instrucțiunii bcnz.

-muls
Activați generarea sarcinii nealiniate și stocarea instrucțiunilor.

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

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

-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 vor funcționa 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.

-mhitachi
Respectați convențiile de apel definite de Renesas.

-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ă -mhitachi 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ă -musermode este activ și este selectat
Opțiunea de generare a codului (de exemplu -m4) nu permite utilizarea instrucțiunii icbi. Dacă
opțiunea de generare a codului selectată nu permite utilizarea instrucțiunii icbi,
și -musermode nu este în vigoare, codul înliniat va manipula instrucțiunea
matrice de adrese cache direct cu o scriere asociativă. Acest lucru nu necesită doar
modul privilegiat, dar va eșua și dacă linia cache a fost mapată prin TLB
și a devenit necartografiat.

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

-msoft-atomic
Generați secvențe atomice de software gUSA compatibile cu GNU/Linux pentru atomul încorporat
funcții. Secvențele atomice generate necesită suport de la întreruperea /
codul de gestionare a excepțiilor sistemului și sunt potrivite numai pentru sistemele cu un singur nucleu.
Ele nu vor funcționa corect pe sistemele multi-core. Această opțiune este activată de
implicit când ținta este „sh-*-linux*”. Pentru detalii despre atomic built-in
functii vezi __atomic Construcții.

-mspace
Optimizați pentru spațiu în loc de viteză. Implicat de -Os.

-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
Nu generați cod numai pentru modul privilegiat; implică -mno-inline-ic_invalidate dacă
codul inline nu ar funcționa în modul utilizator. Aceasta este valoarea implicită când este ținta
„sh-*-linux*”.

-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ă.

-macumulare-ieşire-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 strategiile de divizare a apelurilor și inv:call și
compilatorul se va aștepta în continuare la aceleași seturi de registre de intrare/ieșire/încărcate ca și cum
această opțiune nu era prezentă.

-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ă.

-madjust-unroll
Derularea accelerației pentru a evita zdrobirea registrelor țintă. Această opțiune are doar un
efect dacă baza de cod gcc acceptă cârligul țintă TARGET_ADJUST_UNROLL_MAX.

-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 va genera, în general, o programare mai bună
cod, dar este nesigur pe hardware-ul actual. Definiția actuală a arhitecturii spune
că ptabs și ptrel capcană atunci când ținta anded cu 3 este 3. Aceasta are
efect neintenționat de a face nesigură programarea ptabs / ptrel înaintea unei sucursale sau
ridică-l dintr-o buclă. De exemplu, __do_global_ctors, o parte a libgcc care rulează
constructorii la pornirea programului, apelează funcții într-o listă care este delimitată de -1.
Cu opțiunea -mpt-fixed, ptabs-urile vor fi făcute înainte de a testa împotriva -1. Acea
înseamnă că toți constructorii vor fi rulați puțin mai repede, dar când vine bucla
la sfârșitul listei, programul se blochează deoarece ptabs încarcă -1 într-o țintă
Inregistreaza-te. Deoarece această opțiune este nesigură pentru orice hardware care implementează curentul
specificația arhitecturii, implicit este -mno-pt-fixed. Cu excepția cazului în care utilizatorul specifică a
cost specific cu -mgettrcost, -mno-pt-fixed implică de asemenea -mgettrcost=100; acest
descurajează alocarea registrelor folosind registrele ț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
va fi întotdeauna valabil pentru a încărca cu movi/shori/ptabs sau movi/shori/ptrel, dar cu
trucuri de asamblare și/sau linker este posibil să se genereze simboluri care vor provoca
ptabs / ptrel to trap. Această opțiune are sens numai atunci când -mno-pt-fixat este in
efect. Acesta va preveni apoi încrucișarea blocului de bază, ridicarea și cea mai mare parte a programării
încărcături de simbol. Valoarea implicită este -mno-invalid-simboluri.

-mbranch-cost =o
presupune o să fie costul pentru o instruire de ramură. Numerele mai mari vor face ca
compilatorul încearcă să genereze 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.

-mcbranchdi
Activați modelul de instrucțiuni „cbranchdi4”.

-mcmpeqdi
Emite modelul de instrucțiuni „cmpeqdi_t” chiar și atunci când -mcbranchdi este în vigoare.

-mfused-madd
Permiteți utilizarea instrucțiunii „fmac” (înmulțire-acumulare în virgulă mobilă) dacă
tipul de procesor îl acceptă. Activarea acestei opțiuni poate genera cod care produce
rezultate numerice diferite în virgulă mobilă în comparație cu aritmetica strictă IEEE 754.

-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:

-mipur-text
-mipur-text, folosit pe lângă -impartit, îi spune compilatorului să nu treacă -z a) Sport and Nutrition Awareness Day in Manasia Around XNUMX people from the rural commune Manasia have participated in a sports and healthy nutrition oriented activity in one of the community’s sports ready yards. This activity was meant to gather, mainly, middle-aged people from a Romanian rural community and teach them about the benefits that sports have on both their mental and physical health and on how sporting activities can be used to bring people from a community closer together. Three trainers were made available for this event, so that the participants would get the best possible experience physically and so that they could have the best access possible to correct information and good sports/nutrition practices. b) Sports Awareness Day in Poiana Țapului A group of young participants have taken part in sporting activities meant to teach them about sporting conduct, fairplay, and safe physical activities. The day culminated with a football match. 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 vor declanșa copierea
la scriere, 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 vor fi 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ă.

-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
nu va fi direct în conformitate 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, 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

v8 supersparc, hypersparc, leon

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 ar fi.

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, f930, f934, sparclite86x, tsc701, ultrasparc,
ultrasparc3, niagara, niagara2, niagara3 și niagara4. Cu Solaris nativ și
lanțuri de instrumente 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.

-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).

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 32 de biți și lung și
pointer la 64 de biți.

-mcmmodel=care
Setați modelul de cod la unul dintre

medlow
Modelul de cod mediu/scăzut: adrese pe 64 de biți, programele trebuie să fie legate în 32 de biți
bucăți de memorie. Programele pot fi legate static sau dinamic.

medmid
Modelul de cod Mediu/Mijloc: adrese pe 64 de biți, programele trebuie să fie legate în jos
44 de biți de memorie, segmentele de text și de date trebuie să aibă o dimensiune mai mică de 2 GB și
segmentul de date trebuie să fie localizat la 2 GB de segmentul de text.

medany
Modelul de cod Medium/Anywhere: adrese pe 64 de biți, programele pot fi legate oriunde
în memorie, segmentele de text și de date trebuie să aibă o dimensiune mai mică de 2 GB și datele
segmentul trebuie să fie localizat în limita a 2 GB de segmentul de text.

embmedany
Modelul de cod Medium/Anywhere pentru sistemele încorporate: adrese pe 64 de biți, text
iar segmentele de date trebuie să aibă o dimensiune mai mică de 2 GB, ambele pornind de oriunde în memorie
(determinat la momentul linkului). Registrul global %g4 indică la baza datelor
segment. Programele sunt legate static și PIC nu este acceptat.

-model-memorie=mem-model
Setați modelul de memorie în vigoare pe procesor la unul dintre

lipsă
Modelul de memorie implicit pentru procesor și sistem de operare.

rmo Ordine de memorie relaxată

PSO Comanda parțială în magazin

Tso Comanda totală în magazin

sc Consistență secvențială

Aceste modele de memorie sunt definite oficial în Anexa D la arhitectura Sparc V9
manual, așa cum se stabilește în câmpul „PSTATE.MM” al procesorului.

-mstack-bias
-mno-stack-bias
cu -mstack-bias, GCC presupune că indicatorul de stivă și indicatorul de cadru, dacă sunt prezente,
sunt compensate cu -2047 care trebuie adăugate înapoi atunci când faceți referințe de cadre stive. Acest
este implicit în modul pe 64 de biți. În caz contrar, presupuneți că nu există o astfel de compensare.

SPU Opţiuni

Acestea -m opțiunile sunt acceptate pe SPU:

-mwarn-reloc
-merror-reloc
Încărcătorul pentru SPU nu se ocupă de relocari dinamice. În mod implicit, GCC va da un
eroare când generează cod care necesită o relocare dinamică. -mno-error-reloc
dezactivează eroarea, -mwarn-reloc va genera în schimb un avertisment.

-msafe-dma
-munsafe-dma
Instrucțiunile care inițiază sau testează finalizarea DMA nu trebuie reordonate cu
în ceea ce privește încărcările și stocurile de memorie care este accesată. Utilizatorii de obicei
rezolvați această problemă folosind cuvântul cheie volatil, dar asta poate duce la cod ineficient
în locurile în care se știe că memoria nu se schimbă. În loc să marcheze memoria ca
volatile, tratăm instrucțiunile DMA ca având potențial efect asupra întregii memorie. Cu
-munsafe-dma utilizatorii trebuie să folosească cuvântul cheie volatil pentru a proteja accesul la memorie.

-mbranch-hints
În mod implicit, GCC va genera o instrucțiune de indiciu de ramificație pentru a evita blocarea conductei
întotdeauna luate sau probabil luate ramuri. Un indiciu nu va fi generat mai aproape de 8
instrucțiuni departe de ramura sa. Există puține motive pentru a le dezactiva, cu excepția
în scopuri de depanare sau pentru a face un obiect puțin mai mic.

-msmall-mem
-mlarge-mem
În mod implicit, GCC generează cod presupunând că adresele nu sunt niciodată mai mari de 18 biți.
cu -mlarge-mem este generat un cod care presupune o adresă completă de 32 de biți.

-mstdmain
În mod implicit, GCC se leagă de codul de pornire care își asumă funcția principală în stil SPU
interfață (care are o listă de parametri neconvențional). Cu -mstdmain, GCC va conecta
programul dumneavoastră împotriva codului de pornire care presupune o interfață în stil C99 la „principal”,
inclusiv o copie locală a șirurilor „argv”.

-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ă.

-mea32
-mea64
Compilați codul presupunând că pointerii către spațiul de adrese PPU accesat prin „__ea”
calificativul spațiului de adresă numit are fie 32, fie 64 de biți. Valoarea implicită este de 32 de biți.
Deoarece aceasta este o opțiune de schimbare ABI, tot codul obiect dintr-un executabil trebuie să fie compilat
cu aceeași setare.

-maddress-space-conversion
-mno-conversie-spațiu-adresă
Permiteți/dezactivați tratarea spațiului de adresă „__ea” ca superset al adresei generice
spaţiu. Aceasta permite turnări de tip explicite între „__ea” și indicatorul generic, precum și
conversii implicite de pointeri generici în pointeri „__ea”. Valoarea implicită este de a permite
conversii de indicator al spațiului de adresă.

-mcache-size=mărimea cache-ului
Această opțiune controlează versiunea libgcc pe care compilatorul o conectează la un executabil
și selectează un cache gestionat de software pentru accesarea variabilelor din adresa „__ea”.
spațiu cu o anumită dimensiune cache. Opțiuni posibile pentru mărimea cache-ului sunt 8, 16, 32, 64
și 128. Dimensiunea implicită a memoriei cache este de 64 KB.

-actualizări-matomic
-actualizări-mno-atomice
Această opțiune controlează versiunea libgcc pe care compilatorul o conectează la un executabil
și selectează dacă actualizările atomice ale memoriei cache gestionate de software ale variabilelor din partea PPU
sunt utilizate. Dacă utilizați actualizări atomice, modificări la o variabilă PPU din codul SPU folosind
calificativul de spațiu de adresă numit „__ea” nu va interfera cu modificările altor PPU
variabilele care se află în aceeași linie de cache din codul PPU. Dacă nu utilizați atomic
actualizări, pot apărea astfel de interferențe; cu toate acestea, rescrierea liniilor cache va fi mai mult
eficient. Comportamentul implicit este utilizarea actualizărilor atomice.

-mdual-nops
-mdual-nops=n
În mod implicit, GCC va insera nop pentru a crește problema duală atunci când se așteaptă să crească
performanță. n poate fi o valoare de la 0 la 10. Un mai mic n va introduce mai puține nop. 10
este valoarea implicită, 0 este la fel ca -mno-dual-nops. Dezactivat cu -Os.

-mhint-max-nops=n
Numărul maxim de nop de inserat pentru un indiciu de ramificare. Un indiciu de ramură trebuie să fie de cel puțin 8
instrucțiuni departe de ramura pe care o efectuează. GCC va insera până la n nu la
impune acest lucru, altfel nu va genera indiciu de ramură.

-mhint-max-distance=n
Codificarea instrucțiunii de indiciu de ramificare limitează indicația să fie în 256
instrucțiuni ale ramurii pe care o efectuează. În mod implicit, GCC se asigură că se află în interior
125.

-msafe-hints
Soluționați o eroare hardware care face ca SPU să se blocheze pe termen nelimitat. În mod implicit, GCC
va insera instrucțiunea „hbrp” pentru a se asigura că acest blocaj nu se va întâmpla.

Opţiuni pentru Sistem V

Aceste opțiuni suplimentare sunt disponibile pe System V Release 4 pentru compatibilitate cu altele
compilatoare pe acele sisteme:

-G Creați un obiect partajat. Este recomandat ca -simbolic or -impartit fi folosit în schimb.

-Qy Identificați versiunile fiecărui instrument folosit de compilator, într-un asamblator „.ident”.
directivă în ieșire.

-Qn Abțineți-vă de la adăugarea directivelor „.ident” la fișierul de ieșire (acesta este implicit).

-Da,dirs
Căutați în directoare dirs, și nu altele, pentru bibliotecile specificate cu -l.

- Da,dir
Uită-te în director dir pentru a găsi preprocesorul M4. Asamblatorul folosește acest lucru
opțiune.

TILE-Gx Opţiuni

Acestea -m opțiunile sunt acceptate pe TILE-Gx:

-mcpu=nume
Selectează tipul de CPU care urmează să fie vizat. În prezent, singurul tip acceptat este tilegx.

-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 indică 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.

TILEPro Opţiuni

Acestea -m opțiunile sunt acceptate pe TILEPro:

-mcpu=nume
Selectează tipul de CPU care urmează să fie vizat. În prezent, singurul tip acceptat este tilepro.

-m32
Generați cod pentru un mediu pe 32 de biți, care setează int, long și pointer la 32 de biți.
Acesta este singurul comportament acceptat, astfel încât steagul este în esență ignorat.

V850 Opţiuni

Acestea -m opțiunile sunt definite pentru implementările V850:

-mlong-apeluri
-mno-lung-apeluri
Tratați toate apelurile ca fiind departe (aproape). Dacă se presupune că apelurile sunt la distanță,
compilatorul va încărca întotdeauna adresa funcțiilor într-un registru și va apela indirect
prin indicator.

-mno-ep
-mep
Nu optimizați (optimizați) blocurile de bază care folosesc același indicator de index 4 sau mai mult
ori pentru a copia indicatorul în registrul „ep” și utilizați „sld” și „sst” mai scurte
instrucțiuni. The -mep opțiunea este activată în mod implicit dacă optimizați.

-mno-prolog-functie
-functie-mprolog
Nu utilizați (utilizați) funcții externe pentru a salva și a restaura registrele la prolog
și epilogul unei funcții. Funcțiile externe sunt mai lente, dar folosesc mai puțin cod
spațiu dacă mai multe funcții salvează același număr de registre. The
-functie-mprolog opțiunea este activată în mod implicit dacă optimizați.

-mspace
Încercați să faceți codul cât mai mic posibil. În prezent, aceasta pornește doar -mep
și -functie-mprolog opțiuni.

-mtda=n
Puneți variabile statice sau globale a căror dimensiune este n octeți sau mai puțin în zona minusculă de date
acel registru „ep” indică. Zona mică de date poate conține până la 256 de octeți în total
(128 de octeți pentru referințe de octeți).

-msda=n
Puneți variabile statice sau globale a căror dimensiune este n octeți sau mai puțin în zona mică de date
acel registru indica "gp". Zona mică de date poate conține până la 64 de kiloocteți.

-mzda=n
Puneți variabile statice sau globale a căror dimensiune este n octeți sau mai puțin în primii 32
kiloocteți de memorie.

-mv850
Specificați că procesorul țintă este V850.

-mbig-switch
Generați codul potrivit pentru mesele mari de comutare. Utilizați această opțiune numai dacă
asamblatorul/linkerul se plâng de ramuri în afara intervalului dintr-un tabel de comutare.

-mapp-regs
Această opțiune va face ca r2 și r5 să fie utilizate în codul generat de compilator.
Această setare este implicită.

-mno-app-regs
Această opțiune va face ca r2 și r5 să fie tratați ca registre fixe.

-mv850e2v3
Specificați că procesorul țintă este V850E2V3. Constantele preprocesorului
__v850e2v3__ va fi definit dacă se utilizează această opțiune.

-mv850e2
Specificați că procesorul țintă este V850E2. Constantele preprocesorului
__v850e2__ va fi definit dacă se utilizează această opțiune.

-mv850e1
Specificați că procesorul țintă este V850E1. Constantele preprocesorului
__v850e1__ și __v850e__ va fi definit dacă se utilizează această opțiune.

-mv850es
Specificați că procesorul țintă este V850ES. Acesta este un alias pentru -mv850e1
opțiune.

-mv850e
Specificați că procesorul țintă este V850E. Constanta preprocesorului __v850e__
va fi definit dacă se utilizează această opțiune.

Dacă nici unul -mv850 nici -mv850e nici -mv850e1 nici -mv850e2 nici -mv850e2v3 sunt definite
atunci va fi ales un procesor țintă implicit și cel relevant __v850*__ preprocesor
constantă va fi definită.

Constantele preprocesorului __v850 și __v851__ sunt întotdeauna definite, indiferent de care
ținta este varianta procesorului.

-mdisable-callt
Această opțiune va suprima generarea instrucțiunii CALLT pentru v850e, v850e1,
variantele v850e2 și v850e2v3 ale arhitecturii v850. Valoarea implicită este
-mno-disable-callt care permite utilizarea instrucțiunii CALLT.

VAX Opţiuni

Acestea -m opțiunile sunt definite pentru VAX:

-munix
Nu scoateți anumite instrucțiuni de salt („aobleq” și așa mai departe) pe care asamblatorul Unix
pentru că VAX nu se poate descurca pe distanțe lungi.

-mgnu
Emiteți acele instrucțiuni de salt, presupunând că veți asambla cu
Asamblator GNU.

-mg Cod de ieșire pentru numere în virgulă mobilă în format G în loc de format D.

VxWorks Opţiuni

Opțiunile din această secțiune sunt definite pentru toate obiectivele VxWorks. Opțiuni specifice pentru
hardware-ul țintă sunt listate cu celelalte opțiuni pentru acea țintă.

-mrtp
GCC poate genera cod atât pentru nucleele VxWorks, cât și pentru procesele în timp real (RTP). Acest
opțiunea trece de la prima la cea din urmă. De asemenea, definește macro-ul preprocesorului
„__RTP__”.

-nestatic
Conectați un executabil RTP cu biblioteci partajate, mai degrabă decât cu biblioteci statice. The
Opțiuni -static și -impartit poate fi folosit și pentru RTP-uri; -static este implicit.

-Bstatic
-Bdinamic
Aceste opțiuni sunt transmise linkerului. Sunt definite pentru compatibilitate cu
Diab.

-Xbind-leneș
Activați legarea leneșă a apelurilor de funcții. Această opțiune este echivalentă cu -Wl,-z,acum şi este
definit pentru compatibilitate cu Diab.

-Xbind-acum
Dezactivați legarea leneșă a apelurilor de funcții. Această opțiune este implicită și este definită pentru
compatibilitate cu Diab.

x86-64 Opţiuni

Acestea sunt enumerate sub

Xstormy16 Opţiuni

Aceste opțiuni sunt definite pentru Xstormy16:

-msim
Alegeți fișierele de pornire și scriptul de linker potrivite pentru simulator.

Xtensa Opţiuni

Aceste opțiuni sunt acceptate pentru țintele Xtensa:

-mconst16
-mno-const16
Activați sau dezactivați utilizarea instrucțiunilor „CONST16” pentru încărcarea valorilor constante. The
Instrucțiunea „CONST16” nu este în prezent o opțiune standard de la Tensilica. Cand
activat, instrucțiunile „CONST16” sunt întotdeauna folosite în locul standardului „L32R”
instrucțiuni. Utilizarea „CONST16” este activată în mod implicit numai dacă „L32R”
instrucțiunile nu sunt disponibile.

-mfused-madd
-mno-fuzionat-madd
Activați sau dezactivați utilizarea instrucțiunilor de înmulțire/adăugare și înmulțire/scădere fuzionate în
opțiunea în virgulă mobilă. Acest lucru nu are niciun efect dacă opțiunea în virgulă mobilă nu este de asemenea
activat. Dezactivarea instrucțiunilor de înmulțire/adunare și înmulțire/scădere fuzionate forțează
compilatorul să folosească instrucțiuni separate pentru operațiile de înmulțire și adunare/scădere.
Acest lucru poate fi de dorit în unele cazuri în care rezultatele stricte conforme cu IEEE 754 sunt
necesar: instrucțiunile de adunare/scădere înmulțire fuzionate nu rotunjesc intermediarul
rezultat, producând astfel rezultate cu mai mult biți de precizie decât cele specificate de
Standardul IEEE. Dezactivarea instrucțiunilor de adunare/scădere de multiplicare fuzionată asigură, de asemenea, acest lucru
ieșirea programului nu este sensibilă la capacitatea compilatorului de a combina înmulțirea și
operații de adunare/scădere.

-mserialize-volatile
-mno-serializare-volatil
Când această opțiune este activată, GCC inserează instrucțiuni „MEMW” înainte de memoria „volatilă”.
referințe pentru a garanta consistența secvențială. Valoarea implicită este -mserialize-volatile.
Utilizare -mno-serializare-volatil pentru a omite instrucțiunile „MEMW”.

-mforce-no-pic
Pentru ținte, cum ar fi GNU/Linux, unde tot codul Xtensa în modul utilizator trebuie să fie poziționat-
cod independent (PIC), această opțiune dezactivează PIC pentru compilarea codului de kernel.

-mtext-section-literals
-mno-text-section-literale
Controlați tratamentul piscinelor literale. Valoarea implicită este -mno-text-section-literale,
care plasează literalele într-o secțiune separată din fișierul de ieșire. Acest lucru permite
pool literal să fie plasat într-o memorie RAM/ROM de date și, de asemenea, permite linkerului să se combine
pool-uri literale din fișiere obiect separate pentru a elimina literalele redundante și pentru a îmbunătăți codul
mărimea. Cu -mtext-section-literals, literalele sunt intercalate în secțiunea de text
pentru a le menţine cât mai aproape de referinţele lor. Acest lucru poate fi necesar
pentru dosare mari de asamblare.

-mtarget-align
-mno-target-align
Când această opțiune este activată, GCC instruiește asamblatorului să se alinieze automat
instrucțiuni pentru a reduce penalitățile de ramură în detrimentul unei anumite densități de cod. The
asamblatorul încearcă să extindă instrucțiunile de densitate pentru a alinia țintele de ramuri și
instrucțiuni urmând instrucțiunile de apel. Dacă nu există suficiente seifuri precedente
instrucțiuni de densitate pentru a alinia o țintă, nu se va efectua nicio lărgire. Valoarea implicită este
-mtarget-align. Aceste opțiuni nu afectează tratamentul auto-aliniat
instrucțiuni precum „LOOP”, pe care asamblatorul le va alinia întotdeauna, fie prin lărgire
instrucțiuni de densitate sau inserând instrucțiuni fără operațiuni.

-mlongcalls
-mno-apeluri lungi
Când această opțiune este activată, GCC îi instruiește asamblatorului să traducă apelurile directe către
apeluri indirecte, cu excepția cazului în care poate determina că ținta unui apel direct este în
interval permis de instrucțiunea de apel. Această traducere are loc de obicei pentru apelurile către
funcții în alte fișiere sursă. Mai exact, asamblatorul traduce un direct
Instrucțiunea „CALL” într-un „L32R” urmat de o instrucțiune „CALLX”. Valoarea implicită este
-mno-apeluri lungi. Această opțiune ar trebui utilizată în programele în care ținta apelului poate
poate fi în afara intervalului. Această opțiune este implementată în asamblator, nu în
compilator, astfel încât codul de asamblare generat de GCC va afișa în continuare apelul direct
instrucțiuni --- uitați-vă la codul obiectului dezasamblat pentru a vedea instrucțiunile reale.
Rețineți că asamblatorul va folosi un apel indirect pentru fiecare apel între fișiere, nu doar
cele care cu adevărat vor fi în afara intervalului.

zSeries Opţiuni

Acestea sunt enumerate sub

Opţiuni pentru Cod Generație Convenții
Aceste opțiuni independente de mașină controlează convențiile de interfață utilizate în cod
generaţie.

Cele mai multe dintre ele au atât forme pozitive, cât și negative; forma negativă a -ffoo va fi
-fno-foo. În tabelul de mai jos, este listată doar una dintre forme --- cea care nu este
Mod implicit. Puteți descoperi cealaltă formă fie prin eliminarea nO- sau adăugându-l.

-fbounds-check
Pentru front-end-urile care îl acceptă, generați cod suplimentar pentru a verifica dacă indicii obișnuiau
matricele de acces sunt în intervalul declarat. Acest lucru este în prezent susținut doar de
Front-end-urile Java și Fortran, unde această opțiune este implicită true și false
respectiv.

-ftrapv
Această opțiune generează capcane pentru depășirea semnată la adunare, scădere,
operatii de inmultire.

-fwrapv
Această opțiune indică compilatorului să presupună acea depășire aritmetică semnată de
adunarea, scăderea și înmulțirea se înfășoară folosind complementul în doi
reprezentare. Acest indicator activează unele optimizări și dezactivează altele. Acest
opțiunea este activată în mod implicit pentru front-end-ul Java, așa cum este cerut de limbajul Java
specificație.

-excepții
Activați gestionarea excepțiilor. Generează cod suplimentar necesar pentru a propaga excepțiile. Pentru
unele ținte, aceasta înseamnă că GCC va genera informații despre derularea cadrului pentru toți
funcții, care pot produce o suprasarcină semnificativă a dimensiunii datelor, deși nu o face
afectează execuția. Dacă nu specificați această opțiune, GCC o va activa în mod implicit
pentru limbaje precum C++ care necesită în mod normal gestionarea excepțiilor și dezactivați-l pentru
limbaje precum C care în mod normal nu necesită acest lucru. Cu toate acestea, poate fi necesar să activați
această opțiune atunci când compilați codul C care trebuie să interoperați corect cu excepție
handlere scrise în C++. De asemenea, poate doriți să dezactivați această opțiune dacă sunteți
compilarea de programe C++ mai vechi care nu folosesc gestionarea excepțiilor.

-fnon-call-exceptions
Generați cod care permite instrucțiunilor de captare să arunce excepții. Rețineți că aceasta
necesită suport de rulare specific platformei, care nu există peste tot. În plus,
doar permite capcane instrucțiuni pentru a arunca excepții, adică referințe de memorie sau
instrucțiuni în virgulă mobilă. Nu permite să fie aruncate excepții din arbitrare
handler-uri de semnal precum „SIGALRM”.

-mesele-funwind
similar -excepții, cu excepția faptului că va genera doar orice date statice necesare, dar
nu va afecta codul generat în niciun alt mod. În mod normal, nu veți activa
această opțiune; în schimb, un procesor de limbă care are nevoie de această manipulare l-ar activa
în numele dvs.

-tabele-fasynchronous-unwind
Generați un tabel de desfășurare în format dwarf2, dacă este acceptat de mașina țintă. Masa este
exact la granița fiecărei instrucțiuni, deci poate fi folosit pentru derularea stivei din
evenimente asincrone (cum ar fi depanatorul sau colectorul de gunoi).

-fpcc-struct-return
Returnează valorile „scurte” „struct” și „union” în memorie ca cele mai lungi, mai degrabă decât în
registre. Această convenție este mai puțin eficientă, dar are avantajul de a permite
intercalabilitate între fișierele compilate de GCC și fișierele compilate cu alte compilatoare,
în special Compilatorul C portabil (pcc).

Convenția precisă pentru returnarea structurilor în memorie depinde de țintă
macrocomenzi de configurare.

Structurile și uniunile scurte sunt cele ale căror dimensiuni și aliniament se potrivesc cu cele ale unora
tipul întreg.

Avertisment: cod compilat cu -fpcc-struct-return comutatorul nu este compatibil binar
cu codul compilat cu -freg-struct-retur intrerupator. Folosiți-l pentru a vă conforma unui non-
interfață binară implicită a aplicației.

-freg-struct-retur
Returnează valorile „struct” și „union” în registre atunci când este posibil. Acest lucru este mai eficient
pentru structuri mici decât -fpcc-struct-return.

Dacă nu specificați niciunul -fpcc-struct-return nici -freg-struct-retur, GCC este implicit
oricare ar fi convenția standard pentru țintă. Dacă nu există o convenție standard,
GCC este implicit -fpcc-struct-return, cu excepția țintelor în care GCC este principalul
compilator. În acele cazuri, putem alege standardul, iar noi l-am ales pe cel mai eficient
alternativă de returnare a registrului.

Avertisment: cod compilat cu -freg-struct-retur comutatorul nu este compatibil binar
cu codul compilat cu -fpcc-struct-return intrerupator. Folosiți-l pentru a vă conforma unui non-
interfață binară implicită a aplicației.

-fshort-enums
Alocați unui tip „enum” doar câți octeți are nevoie pentru intervalul declarat de
valori posibile. Mai exact, tipul „enum” va fi echivalent cu cel mai mic
tip întreg care are suficient spațiu.

Avertisment: il -fshort-enums comutatorul face ca GCC să genereze cod care nu este binar
compatibil cu codul generat fără comutatorul respectiv. Folosiți-l pentru a vă conforma unui non-
interfață binară implicită a aplicației.

-fscurt-dublu
Folosiți aceeași dimensiune pentru „dublu” ca și pentru „float”.

Avertisment: il -fscurt-dublu comutatorul face ca GCC să genereze cod care nu este binar
compatibil cu codul generat fără comutatorul respectiv. Folosiți-l pentru a vă conforma unui non-
interfață binară implicită a aplicației.

-fshort-wchar
Ignorați tipul de bază pentru wchar_t pentru a fi mic de statura nesemnat int în loc de
implicit pentru țintă. Această opțiune este utilă pentru construirea de programe sub care să ruleze
VIN.

Avertisment: il -fshort-wchar comutatorul face ca GCC să genereze cod care nu este binar
compatibil cu codul generat fără comutatorul respectiv. Folosiți-l pentru a vă conforma unui non-
interfață binară implicită a aplicației.

-fno-comună
În codul C, controlează plasarea variabilelor globale neinițializate. Compilatoare Unix C
au permis în mod tradițional definiții multiple ale unor astfel de variabile în diferite
unități de compilare prin plasarea variabilelor într-un bloc comun. Acesta este comportamentul
specificat de -fcomunși este valoarea prestabilită pentru GCC pe majoritatea țintelor. Pe de altă parte,
acest comportament nu este cerut de ISO C, iar pe unele ținte poate avea o viteză sau un cod
penalizare de dimensiune pe referințe variabile. The -fno-comună opțiunea specifică faptul că
compilatorul ar trebui să plaseze variabile globale neinițializate în secțiunea de date a obiectului
fișier, în loc să le genereze ca blocuri comune. Acest lucru are ca efect că dacă
aceeași variabilă este declarată (fără „extern”) în două compilații diferite
primiți o eroare cu definiții multiple atunci când le conectați. În acest caz, trebuie să compilați
cu -fcomun in schimb. Compilarea cu -fno-comună este util pe țintele pentru care acesta
oferă performanțe mai bune sau dacă doriți să verificați dacă programul va funcționa
alte sisteme care tratează întotdeauna declarațiile de variabile neinițializate în acest fel.

-fno-ident
Ignorați #ident directivă.

-directiva-dimensiune-finhibit
Nu scoateți o directivă de asamblare „.size” sau orice altceva care ar cauza probleme
dacă funcția este împărțită la mijloc, iar cele două jumătăți sunt plasate în locații îndepărtate
separat în memorie. Această opțiune este folosită la compilare crtstuff.c; nu ar trebui să ai nevoie
să-l folosească pentru orice altceva.

-fverbose-asm
Puneți informații suplimentare de comentariu în codul de asamblare generat pentru a face mai mult
lizibil. Această opțiune este, în general, de folos numai celor care au nevoie să citească
cod de asamblare generat (poate în timpul depanării compilatorului însuși).

-fno-verbos-asm, implicit, face ca informațiile suplimentare să fie omise și este
util la compararea a două fișiere de asamblare.

-frecord-gcc-switch-uri
Această comutare face ca linia de comandă care a fost folosită pentru a invoca compilatorul să fie
înregistrate în fișierul obiect care este creat. Acest comutator este implementat doar
pe unele ținte și formatul exact al înregistrării este formatul de fișier țintă și binar
dependent, dar de obicei ia forma unei secțiuni care conține text ASCII. Acest
comutatorul este legat de -fverbose-asm comutator, dar acel comutator doar înregistrează
informațiile din fișierul de ieșire al asamblatorului ca comentarii, astfel încât nu ajunge niciodată la obiect
fişier. Vezi si -grecord-gcc-switch-uri pentru un alt mod de stocare a opțiunilor compilatorului în
fișierul obiect.

-fpic
Generați cod independent de poziție (PIC) potrivit pentru utilizare într-o bibliotecă partajată, dacă
suportat pentru mașina țintă. Un astfel de cod accesează toate adresele constante prin a
tabel global de compensare (GOT). Încărcătorul dinamic rezolvă intrările GOT atunci când
programul pornește (încărcătorul dinamic nu face parte din GCC; este parte a operațiunii
sistem). Dacă dimensiunea GOT pentru executabilul legat depășește un maxim specific pentru mașină
dimensiune, primiți un mesaj de eroare de la linker care indică asta -fpic nu funcționează; în
acest caz, recompila cu -fPIC in schimb. (Aceste maxime sunt 8k pe SPARC și 32k
pe m68k și RS/6000. 386 nu are o astfel de limită.)

Codul independent de poziție necesită suport special și, prin urmare, funcționează numai pe
anumite mașini. Pentru 386, GCC acceptă PIC pentru System V, dar nu pentru Sun
386i. Codul generat pentru IBM RS/6000 este întotdeauna independent de poziție.

Când acest indicator este setat, macrocomenzile „__pic__” și „__PIC__” sunt definite la 1.

-fPIC
Dacă este acceptat pentru mașina țintă, emite cod independent de poziție, potrivit pentru
legarea dinamică și evitarea oricărei limite privind dimensiunea tabelului global de compensare. Acest
opțiunea face diferența pe m68k, PowerPC și SPARC.

Codul independent de poziție necesită suport special și, prin urmare, funcționează numai pe
anumite mașini.

Când acest indicator este setat, macrocomenzile „__pic__” și „__PIC__” sunt definite la 2.

-fpie
-fPIE
Aceste opțiuni sunt similare cu -fpic și -fPIC, dar a generat cod independent de poziție
poate fi conectat numai în executabile. De obicei, aceste opțiuni sunt folosite când -plăcintă CGC
opțiunea va fi utilizată în timpul conectării.

-fpie și -fPIE ambele definesc macrocomenzile „__pie__” și „__PIE__”. Macro-urile au
valoarea 1 pentru -fpie și 2 pentru -fPIE.

-fno-sarituri-mesele
Nu folosiți tabele de salt pentru instrucțiunile de comutare chiar și acolo unde ar fi mai eficient
decât alte strategii de generare a codului. Această opțiune este utilizată împreună cu
-fpic or -fPIC pentru codul de construcție care face parte dintr-un linker dinamic și nu poate
referiți la adresa unui tabel de salt. Pe unele ținte, mesele de sărituri nu necesită a
GOT și această opțiune nu este necesară.

-fixat-reg
Tratați registrul numit reg ca registru fix; codul generat nu ar trebui să se refere niciodată la
acesta (cu excepția poate ca indicator de stivă, indicator de cadru sau într-un alt rol fix).

reg trebuie să fie numele unui registru. Numele de registru acceptate sunt specifice mașinii
și sunt definite în macro-ul „REGISTER_NAMES” din fișierul macro de descriere a mașinii.

Acest steag nu are o formă negativă, deoarece specifică o alegere cu trei căi.

-fcall-folosit-reg
Tratați registrul numit reg ca un registru alocabil care este zdrobit de funcție
apeluri. Poate fi alocat pentru temporare sau variabile care nu locuiesc peste a
apel. Funcțiile compilate în acest fel nu vor salva și nu vor restaura registrul reg.

Este o eroare să utilizați acest indicator cu indicatorul de cadru sau indicatorul de stivă. Utilizarea acestuia
flag pentru alte registre care au roluri dominante fixe în execuția mașinii
modelul va produce rezultate dezastruoase.

Acest steag nu are o formă negativă, deoarece specifică o alegere cu trei căi.

-fcall-salvat-reg
Tratați registrul numit reg ca registru alocabil salvat de funcții. S-ar putea
alocate chiar și pentru temporare sau variabile care trăiesc într-un apel. Funcții
compilat în acest fel va salva și restabili registrul reg dacă îl folosesc.

Este o eroare să utilizați acest indicator cu indicatorul de cadru sau indicatorul de stivă. Utilizarea acestuia
flag pentru alte registre care au roluri dominante fixe în execuția mașinii
modelul va produce rezultate dezastruoase.

Un alt tip de dezastru va rezulta din utilizarea acestui steag pentru un registru în
care valori ale funcției pot fi returnate.

Acest steag nu are o formă negativă, deoarece specifică o alegere cu trei căi.

-fpack-struct[=n]
Fără o valoare specificată, împachetați toate elementele structurii împreună fără găuri. Când un
este specificată valoarea (care trebuie să fie o putere mică de doi), membrii structurii pachetului
conform acestei valori, reprezentând alinierea maximă (adică obiecte cu
Cerințele implicite de aliniere mai mari decât aceasta vor fi potențial nealiniate
la următoarea locație de montare.

Avertisment: il -fpack-struct comutatorul face ca GCC să genereze cod care nu este binar
compatibil cu codul generat fără acel comutator. În plus, face codul
suboptimal. Utilizați-l pentru a se conforma unei interfețe binare de aplicație care nu este implicită.

-finstrument-funcţii
Generați apeluri de instrumente pentru intrarea și ieșirea în funcții. Imediat după funcție
intrare și chiar înainte de ieșirea funcției, vor fi apelate următoarele funcții de profilare
cu adresa funcției curente și site-ul ei de apel. (Pe unele platforme,
„__builtin_return_address” nu funcționează dincolo de funcția curentă, deci site-ul de apel
este posibil ca informațiile să nu fie disponibile pentru funcțiile de profilare altfel.)

void __cyg_profile_func_enter (void *this_fn,
void *call_site);
void __cyg_profile_func_exit (void *this_fn,
void *call_site);

Primul argument este adresa de început a funcției curente, care poate fi
a căutat exact în tabelul cu simboluri.

Această instrumentare se face și pentru funcțiile extinse în linie în alte funcții.
Apelurile de profilare vor indica unde, conceptual, este introdusă funcția inline
și a ieșit. Aceasta înseamnă că trebuie să fie disponibile versiuni adresabile ale unor astfel de funcții.
Dacă toate utilizările dvs. ale unei funcții sunt extinse în linie, aceasta poate însemna o funcție suplimentară
extinderea dimensiunii codului. Dacă utilizați extern inline în codul dvs. C, un adresabil
trebuie furnizată versiunea acestor funcții. (De obicei, acesta este cazul oricum, dar
dacă aveți noroc și optimizatorul extinde întotdeauna funcțiile în linie, este posibil să aveți
a scăpat fără a furniza copii statice.)

O funcție poate primi atributul „no_instrument_function”, caz în care acesta
instrumentarea nu se va face. Acesta poate fi folosit, de exemplu, pentru profilare
funcțiile enumerate mai sus, rutinele de întrerupere cu prioritate ridicată și orice funcții din care
funcțiile de profilare nu pot fi apelate în siguranță (poate manipulatorii de semnal, dacă
rutinele de profilare generează rezultate sau alocă memorie).

-finstrument-functions-exclude-file-list=fişier,fişier, ...
Setați lista de funcții care sunt excluse din instrumentare (consultați descrierea
a „-finstrument-functions”). Dacă fișierul care conține o definiție a funcției se potrivește
cu unul din fişier, atunci acea funcție nu este instrumentată. Meciul se termina pe
subșiruri: dacă fişier parametrul este un subșir al numelui fișierului, se consideră că
fi o potrivire.

De exemplu:

-finstrument-functions-exclude-file-list=/bits/stl,include/sys

va exclude orice funcție inline definită în fișierele ale căror căi conțin „/bits/stl”
sau „include/sys”.

Dacă, dintr-un motiv oarecare, doriți să includeți litera „,” într-unul dintre sym, scrie ','. Pentru
exemplu, „-finstrument-functions-exclude-file-list=',,tmp'” (rețineți ghilimele simple
înconjurând opțiunea).

-finstrument-functions-exclude-function-list=sym,sym, ...
Aceasta este similară cu „-finstrument-functions-exclude-file-list”, dar această opțiune este setată
lista numelor de funcții care trebuie excluse din instrumentare. Numele funcției la
fi potriviți este numele său vizibil de utilizator, cum ar fi „vector bla (const vector &)",
nu numele intern alterat (de exemplu, „_Z4blahRSt6vectorIiSaIiEE”). Meciul este gata
pe subșiruri: dacă sym parametrul este un subșir al numelui funcției, este
considerat a fi o potrivire. Pentru identificatorii extinși C99 și C++, numele funcției
trebuie dat în UTF-8, fără a folosi nume universale de caractere.

-fstack-check
Generați cod pentru a verifica dacă nu depășiți limita stivei. Tu
ar trebui să specificați acest indicator dacă rulați într-un mediu cu mai multe fire de execuție,
dar rareori trebuie să-l specificați într-un mediu cu un singur fir de la stiva
overflow este detectat automat pe aproape toate sistemele dacă există o singură stivă.

Rețineți că acest comutator nu determină de fapt efectuarea verificării; operarea
sistemul sau runtime-ul limbajului trebuie să facă asta. Comutatorul determină generarea de cod
asigurați-vă că văd stiva fiind extinsă.

În plus, puteți specifica un parametru șir: „nu” înseamnă nicio verificare, „generic”
înseamnă forțarea utilizării verificării în stil vechi, „specific” înseamnă a folosi cea mai bună verificare
metoda și este echivalent cu bare -fstack-check.

Verificarea în stil vechi este un mecanism generic care nu necesită suport specific pentru ținte
compilatorul, dar vine cu următoarele dezavantaje:

1. Strategia de alocare modificată pentru obiecte mari: acestea vor fi întotdeauna alocate
dinamic dacă dimensiunea lor depășește un prag fix.

2. Limită fixă ​​a dimensiunii cadrului static de funcții: când este depășit de a
funcție specială, verificarea stivei nu este de încredere și este emis un avertisment de către
compilator.

3. Ineficiență: din cauza atât a strategiei de alocare modificate, cât și a genericei
implementarea, performanțele codului sunt îngreunate.

Rețineți că verificarea stivei în stil vechi este, de asemenea, metoda de rezervă pentru „specific” dacă nu
Suportul țintă a fost adăugat în compilator.

-fstack-limit-register=reg
-fstack-limit-simbol=sym
-fno-stack-limit
Generați cod pentru a vă asigura că nici stiva nu crește peste o anumită valoare
valoarea unui registru sau adresa unui simbol. Dacă stiva ar crește dincolo
valoarea, se ridică un semnal. Pentru majoritatea țintelor, semnalul este ridicat înainte de
stiva depășește granița, deci este posibil să captezi semnalul fără a lua
precauții speciale.

De exemplu, dacă stiva începe la adresa absolută 0x80000000 și crește în jos,
poti folosi steagurile -fstack-limit-symbol=__stack_limit și
-Wl,--defsym,__stack_limit=0x7ffe0000 pentru a aplica o limită de stivă de 128KB. Rețineți că
acest lucru poate funcționa numai cu linkerul GNU.

-fsplit-stack
Generați cod pentru a împărți automat stiva înainte de a se depăși. Rezultați
programul are o stivă necontiguă care poate depăși numai dacă programul nu poate
mai alocă memorie. Acest lucru este cel mai util atunci când rulați programe threaded, așa cum este
nu mai este necesar să se calculeze o dimensiune bună a stivei de utilizat pentru fiecare fir. Aceasta este
Momentan implementat doar pentru back-end-urile i386 și x86_64 care rulează GNU/Linux.

Când codul este compilat cu -fsplit-stack apeluri cod compilat fără -fsplit-stack, Acolo
s-ar putea să nu existe mult spațiu de stivă disponibil pentru rularea ultimului cod. Dacă compilați toate
cod, inclusiv codul bibliotecii, cu -fsplit-stack nu este o opțiune, atunci linkerul poate
remediați aceste apeluri astfel încât codul compilat fără -fsplit-stack are întotdeauna un mare
grămadă. Suportul pentru aceasta este implementat în linkerul de aur în versiunea GNU binutils
2.21 și ulterior.

-fugatoare-subliniere
Această opțiune și omologul său, -fno-lide-subliniere, schimbă forțat modul C
simbolurile sunt reprezentate în fișierul obiect. O utilizare este de a ajuta la conectarea cu moștenirea
cod de asamblare.

Avertisment: il -fugatoare-subliniere comutatorul face ca GCC să genereze cod care nu este
binar compatibil cu codul generat fără acel comutator. Folosiți-l pentru a vă conforma a
interfață binară a aplicației care nu este implicită. Nu toate obiectivele oferă suport complet
pentru acest comutator.

-ftls-model=model
Modificați modelul de stocare local al firului de utilizat. The model argumentul ar trebui să fie unul dintre
„global-dinamic”, „local-dinamic”, „inițial-exec” sau „local-exec”.

Implicit fără -fpic este „inițial-exec”; cu -fpic implicit este
„global-dinamic”.

-fvizibilitate=implicit|intern|ascuns|protejat
Setați vizibilitatea implicită a simbolului imaginii ELF la opțiunea specificată --- toate simbolurile vor fi
fi marcat cu acest lucru, dacă nu este suprascris în cod. Utilizarea acestei caracteristici poate foarte
îmbunătăți substanțial timpul de conectare și încărcare a bibliotecilor de obiecte partajate, produce mai mult
cod optimizat, oferă export API aproape perfect și previne ciocnirile de simboluri. Este
tare vă recomandăm să utilizați acest lucru în orice obiecte partajate pe care le distribuiți.

În ciuda nomenclaturii, „implicit” înseamnă întotdeauna public; adică disponibil pentru a fi legat
împotriva din afara obiectului comun. „protejat” și „intern” sunt destul de inutile
în utilizarea în lumea reală, astfel încât singura altă opțiune utilizată în mod obișnuit va fi „ascunsă”. The
implicit dacă -fvizibilitate nu este specificat este „implicit”, adică faceți fiecare simbol
public --- acest lucru determină același comportament ca și versiunile anterioare ale GCC.

O bună explicație a beneficiilor oferite prin asigurarea faptului că simbolurile ELF sunt corecte
vizibilitatea este dată de „How To Write Shared Libraries” de Ulrich Drepper (care poate fi
găsit lahttp://people.redhat.com/~drepper/>)---totuși o soluție superioară făcută
posibil prin această opțiune pentru a marca lucrurile ascunse atunci când implicit este public este de a face
implicit ascunse și marca lucrurile publice. Aceasta este norma cu DLL-urile pe Windows și
cu -fvizibility=ascuns și „__attribute__ ((vizibilitate(„implicit”)))” în loc de
„__declspec(dllexport)” obțineți o semantică aproape identică cu sintaxă identică.
Acesta este un avantaj extraordinar pentru cei care lucrează cu proiecte multiplatforme.

Pentru cei care adaugă suport pentru vizibilitate codului existent, este posibil să găsiți #pragma CGC
vizibilitate util. Acest lucru funcționează prin anexarea declarațiilor pe care doriți să le setați
vizibilitate pentru cu (de exemplu) #pragma CGC vizibilitate împinge (ascuns) și #pragma CGC
vizibilitate pop. Rețineți că vizibilitatea simbolului ar trebui să fie vizualizată as parte of il
API interfață contract și astfel, tot codul nou ar trebui să specifice întotdeauna vizibilitatea atunci când acesta
nu este implicit; adică, declarațiile numai pentru utilizare în cadrul OSD local ar trebui mereu
fi marcat în mod explicit ca fiind ascuns, astfel încât să se evite cheltuielile indirecte PLT --- ceea ce face
foarte clar, de asemenea, ajută la lizibilitatea și auto-documentarea codului. Rețineți că
din cauza cerințelor specificațiilor ISO C++, operatorul nou și operatorul șterge trebuie
să fie întotdeauna de vizibilitate implicită.

Rețineți că anteturile din afara proiectului dvs., în special anteturile de sistem și
antete din orice altă bibliotecă pe care o utilizați, este posibil să nu vă așteptați să fie compilate
vizibilitate, alta decât cea implicită. Poate fi necesar să spui în mod explicit #pragma CGC
vizibilitate push(implicit) înainte de a include astfel de anteturi.

extern declaraţiile nu sunt afectate de -fvizibilitate, deci o mulțime de cod poate fi
recompilat cu -fvizibility=ascuns fara modificari. Cu toate acestea, aceasta înseamnă că
apelează la extern funcțiile fără vizibilitate explicită vor folosi PLT, deci este mai mult
eficient de utilizat __atribut ((vizibilitate)) şi / sau #pragma CGC vizibilitate să-i spună
compilator care extern declarațiile ar trebui tratate ca ascunse.

Rețineți că -fvizibilitate afectează entitățile de legătură vagă C++. Aceasta înseamnă că, pentru
de exemplu, o clasă de excepție care va fi aruncată între DSO-uri trebuie să fie în mod explicit
marcat cu vizibilitate implicită astfel încât tip_info nodurile vor fi unificate între
DSO-uri.

O privire de ansamblu asupra acestor tehnici, beneficiile lor și modul de utilizare a acestora este la
<http://gcc.gnu.org/wiki/Visibility>.

-fstrict-volatile-bitfields
Această opțiune ar trebui utilizată dacă accesează câmpuri de biți volatile (sau altă structură
câmpuri, deși compilatorul onorează oricum acele tipuri) ar trebui să folosească un singur
accesul pe lățimea tipului câmpului, aliniat la un aliniament natural dacă este posibil.
De exemplu, ținte cu registre periferice mapate în memorie ar putea necesita toate acestea
accesele să aibă o lățime de 16 biți; cu acest flag, utilizatorul ar putea declara toți biții periferici
câmpuri ca „unsigned short” (presupunând că scurtul este de 16 biți pe aceste ținte) pentru a forța GCC
pentru a folosi accese pe 16 biți în loc de, poate, un acces pe 32 biți mai eficient.

Dacă această opțiune este dezactivată, compilatorul va folosi cea mai eficientă instrucțiune. În
exemplul anterior, ar putea fi o instrucțiune de încărcare pe 32 de biți, chiar dacă așa va fi
octeți de acces care nu conțin nicio porțiune a câmpului de biți sau mapați în memorie
registre fără legătură cu cel în curs de actualizare.

Dacă ținta necesită o aliniere strictă și respectarea tipului de câmp ar necesita
încălcând această aliniere, se emite un avertisment. Dacă câmpul are atributul „ambalat”,
accesul se face fără a respecta tipul câmpului. Dacă câmpul nu are
atribut „packed”, accesul se face respectând tipul câmpului. În ambele cazuri, GCC
presupune că utilizatorul știe ceva despre hardware-ul țintă de care nu cunoaște.

Valoarea implicită a acestei opțiuni este determinată de interfața binară a aplicației pentru
procesorul țintă.

MEDIUL

Această secțiune descrie mai multe variabile de mediu care afectează modul în care funcționează GCC. niste
dintre ele funcționează prin specificarea directoarelor sau prefixelor de utilizat atunci când căutați diferite tipuri
a dosarelor. Unele sunt folosite pentru a specifica alte aspecte ale mediului de compilare.

Rețineți că puteți specifica, de asemenea, locuri în care să căutați folosind opțiuni precum -B, -I și -L.
Acestea au prioritate față de locurile specificate folosind variabile de mediu, care la rândul lor
au prioritate față de cele specificate de configurația GCC.

LIMBA
LC_CTYPE
LC_MESSAGES
LC_ALL
Aceste variabile de mediu controlează modul în care GCC utilizează informațiile de localizare
ceea ce permite GCC să lucreze cu diferite convenții naționale. GCC inspectează locația
categorii LC_CTYPE și LC_MESSAGES dacă a fost configurat să facă acest lucru. Aceste locații
categoriile pot fi setate la orice valoare acceptată de instalarea dvs. O valoare tipică este
en_GB.UTF-8 pentru engleză în Regatul Unit codificat în UTF-8.

LC_CTYPE variabila de mediu specifică clasificarea caracterelor. GCC îl folosește pentru
determinați limitele caracterelor dintr-un șir; acest lucru este necesar pentru unii multiocteți
codificări care conțin ghilimele și caracterele de escape care altfel ar fi interpretate
ca un capăt de sfoară sau de evadare.

LC_MESSAGES variabila de mediu specifică limba de utilizat în diagnosticare
mesaje.

În cazul în care LC_ALL variabila de mediu este setată, suprascrie valoarea lui LC_CTYPE și
LC_MESSAGES; in caz contrar, LC_CTYPE și LC_MESSAGES implicit la valoarea lui LIMBA
variabilă de mediu. Dacă niciuna dintre aceste variabile nu este setată, GCC va fi implicit tradițional
C comportament englezesc.

TMPDIR
If TMPDIR este setat, specifică directorul de utilizat pentru fișierele temporare. GCC utilizeaza
fișiere temporare pentru a păstra rezultatul unei etape de compilare care urmează să fie utilizată ca
intrare la etapa următoare: de exemplu, ieșirea preprocesorului, care este
intrare în compilatorul propriu-zis.

GCC_COMPARE_DEBUG
reglaj GCC_COMPARE_DEBUG este aproape echivalent cu trecerea -fcompare-debug la
driver de compilator. Consultați documentația acestei opțiuni pentru mai multe detalii.

GCC_EXEC_PREFIX
If GCC_EXEC_PREFIX este setat, specifică un prefix de utilizat în numele
subprograme executate de compilator. Nu este adăugată nicio bară oblică atunci când acest prefix este combinat
cu numele unui subprogram, dar puteți specifica un prefix care se termină cu o bară oblică if
ai vrea tu.

If GCC_EXEC_PREFIX nu este setat, GCC va încerca să găsească un prefix adecvat pentru
utilizați pe baza căii cu care a fost invocat.

Dacă GCC nu poate găsi subprogramul folosind prefixul specificat, încearcă să caute în
locuri obișnuite pentru subprogram.

Valoarea implicită a GCC_EXEC_PREFIX is prefix/lib/gcc/ Unde prefix este prefixul la
compilatorul instalat. În multe cazuri prefix este valoarea „prefixului” când ați rulat
configura script-ul.

Alte prefixe specificate cu -B a avea prioritate asupra acestui prefix.

Acest prefix este folosit și pentru a găsi fișiere precum crt0.o care sunt folosite pentru legare.

În plus, prefixul este folosit într-un mod neobișnuit în găsirea directoarelor de căutat
pentru fișierele antet. Pentru fiecare dintre directoarele standard al căror nume începe în mod normal
cu /usr/local/lib/gcc (mai precis, cu valoarea de GCC_INCLUDE_DIR), GCC încearcă
înlocuind acel început cu prefixul specificat pentru a produce un director alternativ
Nume. Astfel, cu -Bfoo/, GCC va căuta foo/bar unde ar căuta în mod normal
/usr/local/lib/bar. Aceste directoare alternative sunt căutate mai întâi; standardul
Urmează directoarele. Dacă un director standard începe cu cel configurat prefix apoi
valoarea prefix se înlocuiește cu GCC_EXEC_PREFIX când căutați fișiere antet.

COMPILER_PATH
Valoarea a COMPILER_PATH este o listă de directoare separate prin puncte, la fel ca PATH.
GCC încearcă directoarele astfel specificate atunci când caută subprograme, dacă nu poate
găsiți subprogramele folosind GCC_EXEC_PREFIX.

LIBRARY_PATH
Valoarea a LIBRARY_PATH este o listă de directoare separate prin puncte, la fel ca PATH.
Când este configurat ca compilator nativ, GCC încearcă directoarele astfel specificate când
cautând fișiere speciale de linker, dacă nu le poate găsi folosind GCC_EXEC_PREFIX.
Conectarea folosind GCC folosește și aceste directoare atunci când caută biblioteci obișnuite
pentru -l opțiunea (dar directoarele specificate cu -L vin pe primul loc).

LIMBA
Această variabilă este folosită pentru a transmite informații despre locale către compilator. Un fel în care
această informație este folosită pentru a determina setul de caractere care trebuie utilizat atunci când caracter
literalele, literalele șirurile și comentariile sunt analizate în C și C++. Când compilatorul este
configurat pentru a permite caractere multibyte, următoarele valori pentru LIMBA sunt
recunoscut:

C-JIS
Recunoașteți caracterele JIS.

C-SJIS
Recunoaște caracterele SJIS.

C-EUCJP
Recunoaște caracterele EUCJP.

If LIMBA nu este definit sau dacă are o altă valoare, atunci compilatorul va folosi
mblen și mbtowc așa cum sunt definite de localitatea implicită pentru a recunoaște și a traduce multiocteți
caractere.

Unele variabile de mediu suplimentare afectează comportamentul preprocesorului.

CPATH
C_INCLUDE_PATH
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
Valoarea fiecărei variabile este o listă de directoare separate printr-un caracter special, mult
ca PATH, în care să căutați fișierele antet. Caracterul special,
„PATH_SEPARATOR”, depinde de țintă și este determinată la momentul construirii GCC. Pentru Microsoft
Țintele bazate pe Windows este un punct și virgulă, iar pentru aproape toate celelalte ținte este un
colon.

CPATH specifică o listă de directoare pentru a fi căutate ca și cum ar fi fost specificate -I, Dar
după orice căi date cu -I opțiuni pe linia de comandă. Această variabilă de mediu
este folosit indiferent de limbajul care este preprocesat.

Variabilele de mediu rămase se aplică numai la preprocesarea particulară
limba indicată. Fiecare specifică o listă de directoare care trebuie căutate ca și cum
specificat cu -isistem, dar după orice căi date cu -isistem opțiuni pe
Linie de comanda.

În toate aceste variabile, un element gol indică compilatorului să caute curentul său
directorul de lucru. Elementele goale pot apărea la începutul sau la sfârșitul unei căi. Pentru
de exemplu, dacă valoarea lui CPATH este „:/special/include”, care are același efect ca
-Eu. -eu/special/include.

DEPENDENCE_OUTPUT
Dacă această variabilă este setată, valoarea ei specifică modul de ieșire a dependențelor pentru Make based
pe fișierele antet non-sistem procesate de compilator. Fișierele antet de sistem sunt
ignorat în rezultatul dependenței.

Valoarea a DEPENDENCE_OUTPUT poate fi doar un nume de fișier, caz în care regulile Make
sunt scrise în acel fișier, ghicind numele țintă din numele fișierului sursă. Sau
valoarea poate avea forma fişier ţintă, caz în care regulile sunt scrise la dosar fişier
folosind ţintă ca nume țintă.

Cu alte cuvinte, această variabilă de mediu este echivalentă cu combinarea opțiunilor -MM
și -MF, cu opțional -MT comuta si el.

SUNPRO_DEPENDENCE
Această variabilă este aceeași cu DEPENDENCE_OUTPUT (vezi mai sus), cu excepția acelui sistem
Fișierele antet nu sunt ignorate, așa că implică -M mai degrabă decât -MM. Însă
dependența de fișierul de intrare principal este omisă.

Utilizați arm-linux-gnueabihf-gcc-4.7 online folosind serviciile onworks.net