arm-linux-gnueabi-gcc-4.7 - Online na nuvem

PROGRAMA:

NOME

gcc - compilador C e C ++ do projeto GNU

SINOPSE

gcc [-c|-S|-E] [-std =padrão]
[-g] [-pg] [-Onível]
[-Wavisar...] [-pedante]
[-Idir...] [-Ldir...]
[-Dmacro[=definir] ...] [-Umacro]
[-fopção...] [-mopção de máquina...]
[-o arquivo de saída] [@lima] no arquivo...

Apenas as opções mais úteis são listadas aqui; veja abaixo para o restante. g ++ aceita
principalmente as mesmas opções que gcc.

DESCRIÇÃO

Quando você invoca o GCC, ele normalmente faz o pré-processamento, a compilação, a montagem e a vinculação.
As "opções gerais" permitem interromper esse processo em um estágio intermediário. Para
exemplo, o -c opção diz para não executar o vinculador. Então, a saída consiste no objeto
arquivos produzidos pelo montador.

Outras opções são passadas para um estágio de processamento. Algumas opções controlam o
pré-processador e outros, o próprio compilador. No entanto, outras opções controlam o montador e
vinculador; a maioria deles não está documentada aqui, já que você raramente precisa usar algum deles.

A maioria das opções de linha de comando que você pode usar com o GCC são úteis para programas C; quando
uma opção só é útil com outra linguagem (geralmente C ++), a explicação diz isso
explicitamente. Se a descrição de uma determinada opção não menciona uma fonte
idioma, você pode usar essa opção com todos os idiomas suportados.

A gcc programa aceita opções e nomes de arquivo como operandos. Muitas opções têm
nomes de letras; portanto, várias opções de uma única letra podem não ser agrupado: -dv é muito
diferente -d -v.

Você pode misturar opções e outros argumentos. Na maior parte, a ordem que você usa não
matéria. A ordem é importante quando você usa várias opções do mesmo tipo; por exemplo, se
você especifica -L mais de uma vez, os diretórios são pesquisados ​​na ordem especificada. Também,
a colocação do -l opção é significativa.

Muitas opções têm nomes longos começando com -f ou com -W---por exemplo,
-fmove-loop-invariantes, -Wformato e assim por diante. A maioria deles tem aspectos positivos e negativos
formulários; a forma negativa de -foo seria -fno-foo. Este manual documenta apenas um dos
esses dois formulários, o que não for o padrão.

OPÇÕES

Opção Resumo
Aqui está um resumo de todas as opções, agrupadas por tipo. As explicações estão nas seguintes
.

No geral Opções
-c -S -E -o lima -sem prefixos canônicos -tubo -códigos de saída -x língua -v
- ### --Socorro[=classe[, ...]] --alvo-ajuda --versão -embrulho @lima -fplugin =lima
-fplugin-arg-nome=arg -fdump-ada-spec[-fino] -fdump-go-spec =lima

C Língua Opções
-ansi -std =padrão -fgnu89-inline -aux-info nome do arquivo
-funções variádicas sem parâmetros de pousio -fno-asm -fno-construído -fno-embutido-função
-fhosted -freestanding -fopenmp -extensões-fms -fplan9-extensões -trígrafos
-no-integrado-cpp -tradicional -tradicional-cpp -precisão simples de pousio
-fcond-incompatibilidade -flax-vector-conversões -fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char

C + + Língua Opções
-fabi-version =n -fno-controle de acesso -fcheck-novo -fconservar-espaço
-fconstexpr-depth =n -injeção de amigo -fno-elide-construtores -fno-enforce-eh-especificações
-ffor-escopo -fno-para-escopo -fno-gnu-palavras-chave -fno-implícito-templates
-FNO-implícito-modelos em linha -fno-implementar-inlines -extensões-fms
-fno-nonansi-builtins -fnothrow-opt -fno-nomes-operadores -fno-opcional-diags
-fpermissivo -fno-modelos bonitos -frepo -fno-rtti -fstats -ftemplate-depth =n
-fno-threadsafe-statics -fuse-cxa-atexit -não-fraco -nostdinc ++ -fno-default-in-line
-fvisibility-inlines-oculto -fvisibility-ms-compat -Wabi -Wconversion-nulo
-Wctor-dtor-privacidade -Delete-não-virtual-dtor -Aviso -Wnoexceto
-Wnon-virtual-dtor -Encomendar -Weffc ++ -Wstrict-null-sentinela
-Não-não-amigo-modelo -Estilo antigo -Woverloaded-virtual -Wno-pmf-conversões
-Wsign-promoção

Objective-C e Objective-C ++ Língua Opções
-fconstant-string-class =nome da classe -fgnu-tempo de execução -fnext-tempo de execução -fno-nil-receptores
-fobjc-abi-version =n -fobjc-call-cxx-cdtors -fobjc-despacho direto -fobjc-exceções
-fobjc-gc -fobjc-nilcheck -fobjc-std = objc1 -freplace-objc-classes -fzero-link
-gen-decls -Watribuir-interceptar -Wno-protocolo -Seletor -Wstrict-seletor-match
-Seletor Wundeclared

Língua Independente Opções
-fmessage-length =n -fdiagnostics-show-location =[uma vez|Cada linha]
-fno-diagnóstico-show-option

Aviso Opções
-fsintaxe somente -fmax-errors =n -pedante -erros-pedantes -w -Wextra -Parede
-Endereço -Waggregate-retorno - Limites da guerra -Wno-atributos
-Wno-builtin-macro-redefinido -Wc ++ - compat -Wc ++ 11-compat -Wcast-align -qualidade wcast
-Wchar-subscritos -Wclobbered -Comentário -Wconversão -Wcoverage-inmatch -Wno-cpp
-Wno-obsoleto -Wno-declarações-depreciadas -Wdisabled-otimização -Wno-div-por-zero
-Dupla promoção -Corpo-vazio -Wenum-comparar -Wno-endif-rótulos -Erro -Werror = *
-Wfatal-erros -Wfloat-igual -Wformato -Wformat = 2 -Wno-format-contém-nul
-Wno-format-extra-args -Wformat-não literal -Wformato-segurança -Wformato-y2k
-Wframe-maior-que =len -Wno-free-nonheap-objeto -Wjump-misses-init
-Wignored-qualificadores -Wimplícito -Declaração de função explícita -Wimplicit-int
-Win-self -Winline -Wtalvez não inicializado -Wno-int-para-ponteiro-cast
-Wno-inválido-offsetof -Winvalid-pch -Maior que =len -Wunsafe-loop-otimizações
-Wlógico-op -Muito longo -Wprincipal -Wtalvez não inicializado - Suspensórios
-Wmissing-field-inicializadores - Atributo de formato de saudação -Wmissing-include-dirs
-Sem pára-lamas -Wno-multichar -Wnão nulo -Wno-estouro -Woverlength-strings -Embalado
-Wpacked-bitfield-compatível -W acolchoado -Parênteses -Wpedantic-ms-formato
- Formato Wno-pedante-ms -Wpointer-arith -Wno-ponteiro-para-int-cast -Wredundant-decls
-Tipo de retrocesso -Ponto de sequência -Sombra -Wsign-comparar -Conversão de sinal
-Wstack-protetor -Wstack-usage =len -Wstrict-aliasing -Wstrict-aliasing = n
-Wstrict-overflow -Wstrict-overflow =n -Wsuggest-attribute =[puro|const|Noreturn]
-Mudar -Wswitch-padrão -Wswitch-enum -Wsync-nand -Wsystem-cabeçalhos -Wtrampolins
-Wtrigraphs -Limites de tipo -Wundef -W não inicializado -Pragmas desconhecidos -Wno-pragmas
-Wunsuffixed-float-constantes -Não usado -Função não usada -Wunused-rótulo
-Wunused-local-typedefs -Wunused-parâmetro -Wno-resultado não utilizado -Valor não utilizado
-Wunused-variável -Wunused-mas-set-parameter -Wunused-mas-set-variável
-Wvariádicos-macros -Wector-operation-performance -Wvla -Wvolatile-registro-var
-Wwrite-strings -Wzero-as-null-ponteiro-constante

C e Somente Objective-C Aviso Opções
-Wbad-função-cast -Declarações-saudações - Tipo de parâmetro ausente
-Protótipos-saudade -Wnested-externos -Declaração de estilo antigo -Definição de estilo antigo
-Wstrict-protótipos -Wtradicional -Wconversão tradicional
-Wdeclaração-após-declaração -Wpointer-sinal

depuração Opções
-dletras -dumpspecs -máquina de despejo -versão de despejo -fdbg-cnt-lista -fdbg-cnt =contra-
lista de valores -fdisable-ipa-nome_senha -fdisable-rtl-nome_senha -fdisable-rtl-passar-
nome=lista de alcance -fdisable-árvore-nome_senha -fdisable-árvore-senha=lista de alcance
-fdump-noaddr -fdump-sem número -fdump-links não numerados -fdump-unidade de tradução[-n]
-fdump-class-hierarquia[-n] -fdump-ipa-tudo -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-passes -fdump-estatísticas -fdump-tree-tudo -fdump-tree-original[-n]
-fdump-tree-otimizado[-n] -fdump-árvore-cfg -fdump-árvore-vcg -fdump-tree-alias
-fdump-árvore-ch -fdump-árvore-ssa[-n] -fdump-tree-pré[-n] -fdump-árvore-ccp[-n]
-fdump-árvore-dce[-n] -fdump-tree-gimple[-cru] -fdump-tree-mudflap[-n]
-fdump-árvore-dom[-n] -fdump-árvore-dse[-n] -fdump-árvore-phiprop[-n] -fdump-árvore-phiopt[-n]
-fdump-tree-forwprop[-n] -fdump-tree-copyrename[-n] -fdump-árvore-nrv -fdump-árvore-vecto
-fdump-tree-sink -fdump-árvore-sra[-n] -fdump-tree-forwprop[-n] -fdump-tree-fre[-n]
-fdump-árvore-vrp[-n] -ftree-vectorizer-verbose =n -fdump-tree-storeccp[-n]
-fdump-final-insns =lima -fcompare-depurar[=opta] -fcompare-debug-segundo
-feliminar-anão2-dups -feliminar-tipos-depuração-não-usados
-feliminar-símbolos-de-depuração-não-usados -femit-class-debug-sempre -fenável-tipo-passar
-fenável-tipo-passar=lista de alcance -fdebug-types-seção -fmem-relatório -fpre-ipa-mem-relatório
-fpost-ipa-mem-relatório -fprofile-arcos -frandom-seed =corda -fsched-verbose =n
-fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -fstack-uso
-teste-cobertura -ftime-relatório -fvar-rastreamento -fvar-atribuições de rastreamento
-fvar-tracking-assignments-toggle -g -gnível -gtoggle -gcoff -gdwarf-versão -ggdb
-grecord-gcc-switches -gno-record-gcc-switches -gstabs -gstabs + -gstrict-anão
-gno-estrito-anão -gvms -gxcoff -gxcoff + -fno-merge-debug-strings
-fno-dwarf2-cfi-asm -fdebug-prefix-map =velho=novo -femit-struct-debug-baseonly
-femit-struct-debug-reduzido -femit-struct-debug-Detailed[=lista de especificações] -p -pg
-print-file-name =biblioteca -print-libgcc-nome-do-arquivo -print-multi-diretório
-print-multi-lib -print-multi-os-diretório -print-prog-name =programa
-print-search-dirs -Q -print-sysroot -print-sysroot-headers-suffix -save-tempos
-save-temps = cwd -save-temps = obj -Tempo[=lima]

Operacional Opções
-falign-functions [=n] -falign-jumps [=n] -falign-labels [=n] -falign-loops [=n]
-fassociativa-matemática -fauto-inc-dec -fbranch-probabilidades -fbranch-target-load-optimize
-fbranch-target-load-optimize2 -fbtr-bb-exclusivo -fcaller-salva -fcheck-data-deps
-fcombine-stack-settings -fconserve-stack -fcompare-elim -fcprop-registros
-f salto cruzado -fcse-follow-jumps -fcse-skip-blocos -fcx-fortran-regras
-fcx-intervalo limitado -fdata-seções -fdce -framo-atrasado -fdelete-null-pointer-checks
-fdesvirtualize -fdse -com medo -fipa-sra -otimizações caras
-ffat-lto-objetos -rápida matemática -finite-matemática-apenas -loat-store
-fexcess-precision =estilo -fforward-propagar -ffp-contract =estilo -funções-seções
-fgcse -fgcse-após-recarregar -fgcse-las -fgcse-lm -fgrafite-identidade -fgcse-sm
-fif-conversão -fif-conversão2 -findirect-inlining -funções-finline
-funções-finline-chamadas uma vez -finline-limit =n -finline-pequenas-funções -fipa-cp
-fipa-cp-clone -fipa-matriz-reorg -fipa-pta -fipa-perfil -fipa-puro-const
-fipa-referência -fira-algorithm =algoritmo -fira-region =região -fira-loop-pressão
-fno-ira-compartilhar-salvar-slots -Fno-IRA-Share-Spill-Slots -fira-verbose =n -cincopts
-fkeep-inline-funções -fkeep-static-consts -bloop-block -flat-flat
-intercâmbio-floop -flop-strip-mine -floop-paralelize-tudo -flto
-flto-nível de compressão -flto-partição =alg -flto-reportar -fmerge-all-constantes
-fmerge-constantes -fmodulo-sched -fmodulo-sched-allow-regmoves -fmove-loop-invariantes
abafador de lama -fmudflapir -fmudflapth -fno-branch-count-reg -fno-default-in-line
-fno-adiar-pop -fno-função-cse -fno-adivinha-probabilidade-ramo -fno-inline
-fno-matemática-errno -fno-olho mágico -fno-olho mágico2 -fno-sched-interblock -fno-sched-spec
-não-zeros assinados -fno-reordenação de nível superior -fno-trapping-matemática
-fno-zero-inicializado-em-bss -fomit-frame-ponteiro -foptimize-registrar-mover
-foptimize-irmãos-chamadas -f inlining parcial -fpeel-loops -fcomunização preditiva
-fprefetch-loop-arrays - correção de perfil -fprofile-dir =caminho -fprofile-gerar
-fprofile-generate =caminho -fprofile-use -fprofile-use =caminho -fprofile-valores
-frecíproca-matemática -livre -fregmove -frename-registros -freorder-blocos
-freorder-blocos e partição -funções-freorder -frerun-cse-após-loop
-freschedule-modulo-Schedules-loops -matriz-matemática -fsched2-use-superblocos
-fsched-pressão -fsched-spec-load -fsched-spec-load-perigoso
-fsched-stalled-insns-dep [=n] -fsched-stalled-insns [=n] -fsched-group-heurística
-fsched-heurística do caminho crítico -fsched-spec-insn-heurística -fsched-rank-heurística
-fsched-last-insn-heurística -fsched-dep-count-heurística -fschedule-insns
-fschedule-insns2 - âncoras de seção - agendamento seletivo - agendamento seletivo 2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops -fshrink-wrap
-fsinalização-nans -fconstante de precisão única -fsplit-ivs-no-desenrolamento
-fsplit-wide-types -fstack-protetor -fstack-protetor-tudo -fstrict-aliasing
-fstrict-overflow -fthread-salta -ftracer -ftree-bit-ccp -ftree-built-in-call-dce
-ftree-ccp -ftree-ch -ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copiar-prop
-ftree-nome da cópia -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop
-sem árvores -ftree-loop-se-converter -ftree-loop-if-convert-lojas -ftree-loop-im
-ftree-phiprop -ftree-loop-distribuição -ftree-loop-distrib-patterns
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-otimizar -ftree-parallelize-loops =n
-ftree-pré -ftree-parcial-pre -ftree-pta -ftree-reassoc -ftree-pia -ftree-sra
-ftree-switch-conversão -ftree-tail-merge -ftree-ter -ftree-vect-loop-versão
-ftree-vetorize -ftree-vrp -Funit-at-a-time -funroll-todos-loops -funroll-loops
-funsafe-loop-otimizations -funsafe-math-otimizations -funswitch-loops
-fexpansão-da-variável-no-desenrolador -fvect-modelo de custo -fvpt -fweb -fwhole-programa -fwpa
-fuse-ld =vinculador -plug-in de ligação de fusível --param nome=valor -O -O0 -O1 -O2 -O3 -Os
-Rápido

Pré-processador Opções
-Aquestão=responder -A-questão[=responder] -C -dD -dEu -dM -dN -Dmacro[=definir] -E -H
-dirijo dir -incluir lima -imacros lima -iprefixo lima -i com prefixo dir
- com o prefixo antes dir -isistema dir -imultilib dir -isysroot dir -M -MILÍMETROS -MF -MG
-MP -MQ -MT -nostdinc -P -fdebug-cpp -ftrack-macro-expansão -diretório-fworking
-remapear -trígrafos -undef -Umacro -Wp,opção -Xpré-processador opção

Assembler Opção
-Uau,opção -Xassembler opção

Vinculador Opções
nome-do-arquivo-objeto -lbiblioteca -nostartfiles -nodefaultlibs -nostdlib -torta -rdinâmica -s
-estático -static-libgcc -static-libstdc ++ -compartilhado -shared-libgcc -simbólico -T escrita
-Wl,opção -Xlinker opção -u símbolo

Diretório Opções
-Bprefixo -Idir -iplugindir =dir -Eu citodir -Ldir -specs =lima -I- --sysroot =dir

Lavagem Dependente Opções
AAArch64 Opções -mbi-endian -mlittle-endian -mgeneral-regs-somente -mcmodel = tiny
-mcmodel = pequeno -mcmodel = grande -mstrict-align -momit-folha-frame-ponteiro
-mno-omitir-ponteiro-quadro-folha -mtls-dialect = desc -mtls-dialect = tradicional -march =nome
-mcpu =nome -mtune =nome

Adaptava Epifania Opções -meia-reg-arquivo -mprefer-short-insn-regs -mbranch-cost =Números
-mcmove -mnops =Números -msoft-cmpsf -msplit-lohi -mpost-inc -mpost-modificar
-mstack-offset =Números -modo-mais próximo -muito chamadas -mshort-chamadas -msmall16 -mfp-mode =modo
-mvect-duplo -max-vect-align =Números -msplit-vecmove-cedo -m1reg-reg

ARM Opções -mapcs-quadro -mno-apcs-quadro -mabi =nome -mapcs-stack-check
-mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reentrante
-mno-apcs-reentrante -msched-prólogo -mno-sched-prolog -mlittle-endian -mbi-endian
-mwords-little-endian -mfloat-abi =nome -mfpe -mfp16-format =nome -mthumb-intertrabalho
-mno-thumb-interwork -mcpu =nome -march =nome -mfpu =nome -mstructure-size-boundary =n
-mabort-on-noreturn -muito chamadas -mno-long-chamadas -msingle-pic-base
-mno-single-pic-base -mpic-register =reg -mnop-fun-dllimportar -mcirrus-fix-insns inválidos
-mno-cirrus-fix-insns inválidos -mpoke-nome-função -mthumb -marm -mtpcs-quadro
-mtpcs-folha-quadro -mcaller-superinterworking -mcallee-superinterworking -mtp =nome
-mtls-dialect =dialeto -mword-relocações -mfix-córtex-m3-ldrd -acesso-imunalinhado
-mneon-para-64bits

AVR Opções -mmcu =MCU -maccumulate-args -mbranch-cost =custo -mcall-prólogos -hortelã8
-mno-interrupções -mrelax -mshort-chamadas -mstrict-X -mtiny-pilha

Blackfin Opções -mcpu =cpu[-revisão] -msim -momit-folha-frame-ponteiro
-mno-omitir-ponteiro-quadro-folha -mspeld-anomalia -mno-specld-anomalia -mcsync-anomalia
-mno-csync-anomalia -mlow-64k -mno-low64k -mstack-check-l1 -mid-biblioteca compartilhada
-mno-id-biblioteca compartilhada -mshared-library-id =n -mleaf-id-biblioteca compartilhada
-mno-leaf-id-biblioteca compartilhada -msep-dados -mno-sep-dados -muito chamadas -mno-long-chamadas
-mfast-fp -minline-plt -mmulticore -mcorea -mcoreb -msdram -micplb

C6X Opções -mbi-endian -mlittle-endian -march =cpu -msim -msdata =tipo sdata

CRIS Opções -mcpu =cpu -march =cpu -mtune =cpu -mmax-stack-frame =n
-melinux-stacksize =n -metrax4 -metrax100 -mpdebug -mcc-init -mno-efeitos colaterais
-mstack-align -mdata-align -mconst-alinhar -m32 bits -m16 bits -m8 bits
-mno-prólogo-epílogo -mno-gotplt -me -maout -melinux -mlinux -sim -sim2
-mmul-bug-solução -mno-mul-bug-solução

CR16 Opções -mmac -mcr16cplus -mcr16c -msim -hortelã32 -mbit-ops -mdata-model =modelo

Darwin Opções -all_load -allowable_client -arco -arch_errors_fatal -arch_only
-bind_at_load -agrupar -bundle_loader -Nome do cliente -compatibilidade_versão
-Versão Atual -dead_strip -arquivo de dependência -dylib_file -dylinker_install_name
-dinâmico -dinamiclib -lista_de_símbolos_exportados -lista de arquivos -flat_namespace
-force_cpusubtype_ALL -force_flat_namespace -headerpad_max_install_names -iframework
-imagem_base -iniciar -nome_instalação -keep_private_externs -multi_módulo
-multiplicar_definido -multiply_definido_não utilizado -noall_load
-no_dead_strip_inits_and_terms -nofixprebinding -nomultidefs -noprebind
-noseglinkedit -pagezero_size -pré-ligar -prebind_all_twolevel_modules -private_bundle
-read_only_relocs -sectalign -símbolos de objeto da seita -porque -seg1addr -sectcriar
-símbolos de objeto da seita -ordem do setor -segaddr -segs_read_only_addr -segs_read_write_addr
-seg_addr_table -seg_addr_table_filename -seglinkedit -Segripor. -segs_read_only_addr
-segs_read_write_addr -módulo_único -estático -sub_library -sub_guarda-chuva
-dois níveis_namespace - guarda-chuva -Indefinido -lista_de_símbolos_uexportados
-weak_reference_mismatches - o que foi carregado -F -sentiu -g cheio -mmacosx-version-min =versão
-mkernel -mon-byte-bool

Dezembro alfa Opções -mno-fp-regs -msoft-float -malpha-as -mgas -meee
-mieee-com-inexato -mieee-conformante -mfp-trap-mode =modo -mfp-rounding-mode =modo
-mtrap-precision =modo -mbuild-constantes -mcpu =tipo cpu -mtune =tipo cpu -mbwx -mmax
-mfix -mcix -mfloat-vax -mfloat-ieee -mexplícito-relocs -msmall-dados -mlarge-dados
-msmall-texto -texto-grande -mmemory-latency =tempo

Dezembro Alpha / VMS Opções -mvms-códigos de retorno -mdebug-main =prefixo -mmalloc64

FR30 Opções -modelo msmall -mno-lsim

FRV Opções -mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64 -mhard-float -msoft-float
-malloc-cc -mfixo-cc -mdpalavra -mno-dword -duplo -mno-duplo -mídia -mno-mídia
-mmulad -mno-mulad -mfdpic -minline-plt -mgprel-ro -multilib-biblioteca-pic
-mlinked-fp -muito chamadas -rótulos malignos -mlibrary-pic -macc-4 -macc-8 -mpack
-mno-pack -mno-flags -mcond-movimento -mno-cond-movimento -moptimize-membar
-mno-optimize-membar -mscc -mno-scc -mcond-exec -mno-cond-exec -mvliw-ramo
-mno-vliw-branch -multi-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-estatísticas -mTLS -mtls -mcpu =cpu

GNU / Linux Opções -mglibc -muclibc -mbiônico -mandróide -tno-android-cc -tno-android-ld

H8 / 300 Opções -mrelax -mh -em -mn -hortelã32 -maligno-300

HPPA Opções -march =tipo de arquitetura -big-switch -mdisable-fpregs
-mdisable-indexação -mrápido-indireto-chamadas -mgas -mgnu-ld -mhp-ld
-mfixed-range =intervalo de registro -mjump-in-atraso -mlinker-opt -muito chamadas
-mlong-load-store -mno-grande-interruptor -mno-disable-fpregs -mno-disable-indexação
-mno-chamadas indiretas rápidas -mno-gás -mno-jump-in-delay -mno-long-load-store
-mno-tempo de execução portátil -mno-soft-float -mno-espaço-regs -msoft-float -mpa-risc-1-0
-mpa-risc-1-1 -mpa-risc-2-0 -mportável-tempo de execução -mschedule =tipo cpu -mspace-regs
-msio -mwsio -munix =unix-std -nolibdld -estático -tópicos

i386 e x86-64 Opções -mtune =tipo cpu -march =tipo cpu -mfpmath =unidade -masm =dialeto
-mno-fantasia-matemática-387 -mno-fp-ret-in-387 -msoft-float -mno-multiplicação ampla -mrtd
-malign-duplo -mpreferred-stack-boundary =Números -mincoming-stack-boundary =Números -mcld
-mcx16 -msahf -mmovbe -mcrc32 -mreceita -mrecip =optar -mvzeroupper -mprefer-avx128 -mmmx
-msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx -mavx2 -maes -mpclmul
-mfsgsbase -mrdrnd -mf16c -mfma -msse4a -m3dagora -mpopct -mabm -mbmi -mtbm -mfma4
-mxop -mlzcnt -mbmi2 -mlwp -mthreads -mno-align-stringops -minline-all-stringops
-minline-stringops-dinamicamente -mstringop-strategy =alg -mpus-args
-maccumulate-args de saída -m128bit-longo-duplo -m96bit-longo-duplo -mregparm =Números
-msseregparm -mveclibabi =tipo -mvect8-ret-in-mem -mpc32 -mpc64 -mpc80 -mstackrealign
-momit-folha-frame-ponteiro -mno-zona vermelha -mno-tls-direct-seg-refs -mcmodel =modelo de código
-mabi =nome -maddress-mode =modo -m32 -m64 -mx32 -mlarge-data-threshold =Números -msse2avx
-mfentry -m8bit-idiv -mavx256-carga não alinhada dividida -mavx256-split-unaligned-store

i386 e x86-64 Windows Opções -mconsole -mcygwin -mno-cygwin -mdll
-mnop-fun-dllimportar -mthread -municódigo -mwin32 - janelas -fno-set-stack-executável

IA-64 Opções -mbi-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic
-mvolátil-asm-stop -mregister-nomes -msdados -mno-sdata -mconstante-gp -mauto-pic
-mfuso-louco -minline-float-divide-min-latência -minline-float-divide-max-rendimento
-mno-inline-float-divide -minline-int-divide-min-latência
-minline-int-divide-max-rendimento -mno-inline-int-divide -minline-sqrt-min-latência
-minline-sqrt-max-rendimento -mno-inline-sqrt -mdwarf2-asm -poucos-stop-bits
-mfixed-range =intervalo de registro -mtls-size =tamanho tls -mtune =tipo 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-after-ever-cycle
-msched-count-spec-in-critical-path -msel-sched-dont-check-control-spec
-msched-fp-mem-deps-zero-custo -msched-max-memory-insns-hard-limit
-msched-max-memory-insns =max-insns

IA-64 / VMS Opções -mvms-códigos de retorno -mdebug-main =prefixo -mmalloc64

LM32 Opções -barrel-shift-habilitado -mdivide habilitado -multiply ativado
-msign-extend-habilitado -muser ativado

M32R / D Opções -m32r2 -m32rx -m32r -mdebug -loops malignos -mno-align-loops
- taxa de emissão =número -mbranch-cost =número -mmodel =código-tamanho-modelo-tipo -msdata =dados-
tipo -mno-flush-func -mflush-func =nome -mno-flush-trap -mflush-trap =número -G Números

M32C Opções -mcpu =cpu -msim -memregs =número

M680x0 Opções -march =arco -mcpu =cpu -mtune =afinação -m68000 -m68020 -m68020-40
-m68020-60 -m68030 -m68040 -m68060 -mcpu32 -m5200 -m5206e -m528x -m5307 -m5407
-mcfv4e -mbitcampo -mno-bitfield -mc68000 -mc68020 -mnobitfield -mrtd -mno-rtd
-mdiv -mno-div -mcurto -mno-curto -mhard-float -m68881 -msoft-float -mpcrel
-maligno-int -mstrict-align -msep-dados -mno-sep-dados -mshared-library-id = n
-mid-biblioteca compartilhada -mno-id-biblioteca compartilhada -mxgot -mno-xgot

MCore Opções -mhardlit -mno-hardlit -mdiv -mno-div -mrelax-imediates
-mno-relax-imediates -mwide-bitfields -mno-wide-bitfields -m4byte-funções
-mno-4byte-funções -mcallgraph-dados -mno-callgraph-dados -mslow-bytes
-mno-bytes lentos -mno-lsim -mlittle-endian -mbi-endian -m210 -m340
-incremento de mstack

EuP Opções -mabsdiff -pequenas opções -maédia -mbasado =n -mbitops -mc =n -mclip
-mconfig =nome -mcop -mcop32 -mcop64 -mivc2 -mdc -mdiv -meb -mel -mio-volátil -ml
-mleadz -milímetros -mminmax -multo -mno-opções -repetir -em -msatur -msdram -msim -msimnovec
-mtf -mtiny =n

MicroBlaze Opções -msoft-float -mhard-float -msmall-divide -mcpu =cpu -mmemcpy
-mxl-soft-mul -mxl-soft-div -mxl-barril-shift -mxl-padrão-comparar -mxl-stack-check
-mxl-gp-opt -mno-clearbss -mxl-multiplicar-alto -mxl-float-converter -mxl-float-sqrt
-mxl-modo-modelo de aplicativo

MIPS Opções -A -EB -march =arco -mtune =arco -mips1 -mips2 -mips3 -mips4
-mips32 -mips32r2 -mips64 -mips64r2 -mips16 -mno-mips16 -mflip-mips16
-minterlink-mips16 -mno-interlink-mips16 -mabi =abi -mabicalls -mno-abicals
-mshared -mno-compartilhado -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 =tipo fpu -msmartmips -mno-smartmips -mpareado-único
-mno-pareado-único -mdmx -mno-mdmx -mips3d -mno-mips3d -mmt -mno-mt -mllsc
-mno-llsc -mlong64 -mlong32 -msym32 -mno-sym32 -GNúmeros -mlocal-sdata
-mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt -dados-incorporados
-mno-dados incorporados -muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable =contexto -msplit-address -mno-split-address -mexplícito-relocs
-mno-explícito-relocs -mcheck-zero-divisão -mno-check-zero-divisão -mdivide-armadilhas
-mdivide-quebras -mmemcpy -mno-memcpy -muito chamadas -mno-long-chamadas -mmad -mno-louco
-mfuso-louco -mno-fundido-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 =função -mno-flush-func -mbranch-cost =Números -mbranch-provável
-mno-branch-provável -mfp-exceções -mno-fp-exceções -mvr4130-alinhar -mno-vr4130-align
-msynci -mno-sinci -mrelax-pic-chamadas -mno-relax-pic-chamadas -mmcount-ra-endereço

MIX Opções -mlibfuncs -mno-libfuncs -mepsilon -mno-épsilon -mabi = gnu
-mabi = mmixware -mzero-estender -mknuthdiv -mtoplevel-símbolos -me -mbranch-prognosticar
-mno-branch-Pred -mbase-endereços -mno-base-address -m saída única
-mno-single-saída

MN10300 Opções -mmult-bug -mno-mult-bug -mno-am33 -mam33 -mam33-2 -mam34 -mtune =CPU-
tipo -mreturn-ponteiro-on-d0 -mno-crt0 -mrelax -mliw -msetlb

PDP-11 Opções -mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10 -mbcopiar
-mbcopy-construído -hortelã32 -mno-int16 -hortelã16 -mno-int32 -mfloat32 -mno-float64
-mfloat64 -mno-float32 -mabshi -mno-abshi -mbranch-caro -mbranch-barato
-munix-asm -mdec-asm

picochip Opções -mae =tipo_ae -mvliw-lookahead =N -msímbolo-como-endereço
-mno-ineficiente-avisos

PowerPC Opções Consulte RS / 6000 e Opções PowerPC.

RL78 Opções -msim -mmul = nenhum -mmul = g13 -mmul = rl78

RS / 6000 e PowerPC Opções -mcpu =tipo cpu -mtune =tipo cpu -mcmodel =modelo de código -power
-mno-poder -mpower2 -mno-poder2 -mpowerpc -mpowerpc64 -mno-powerpc -maltivec
-mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt
-mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb -mpopctd -mno-popcntd -mfprnd
-mno-fprnd -mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mnew-mnemônicos -mold-mnemônicos -mfull-toc -mínimo-toc -mno-fp-in-toc
-mno-soma-em-toc -m64 -m32 -mxl-compatibilidade -mno-xl-compatível -mpe -poder maligno
-maligno-natural -msoft-float -mhard-float -múltiplos -mno-múltiplo -msingle-float
-mdouble-float -msimple-fpu -mstring -mno-string -mupdate -mno-atualização
-mavoid-indexed-endereços -mno-Avoid-indexed-endereços -mfuso-louco -mno-fundido-madd
-mbit-align -mno-bit-align -mstrict-align -mno-strict-align -mrelocável
-mno-relocável -mrelocável-lib -mno-relocável-lib -mtoc -mno-toc -um pouco
-mlittle-endian -grande -mbi-endian -mdynamic-no-pic -maltivec -mswdiv
-msingle-pic-base -mprioritize-restricted-insns =prioridade
-msched-costly-dep =tipo_dependência -minsert-sched-nops =esquema -mcall-sysv
-mcall-netbsd -maix-struct-retorno -msvr4-struct-return -mabi =tipo abi -msecure-plt
-mbss-plt -mblock-move-inline-limit =Números -misel -mno-isel -misel = sim -misel = não -mspe
-mno-spe -mspe = sim -mspe = não -mparado -mgen-célula-microcódigo -mwarn-cell-microcódigo
-mvrsave -mno-vrsave -mmulhw -mno-mulhw -mdlmzb -mno-dlmzb -mfloat-gprs = yes
-mfloat-gprs = no -mfloat-gprs = single -mfloat-gprs = double -mprotótipo -mno-protótipo
-msim -mmvme -loucos -faca amarela -membro -msdados -msdata =optar -mvxworks -G Números
-pthread -mreceita -mrecip =optar -mno-receita -mrecip-precisão -mno-recip-precisão
-mveclibabi =tipo -mfriz -mno-friz -mpointers-para-funções aninhadas
-mno-ponteiros-para-funções aninhadas -msave-toc-indireto -mno-save-toc-indireto

RX Opções -m64bit-duplos -m32bit-duplos -fpu -nofpu -mcpu = -mbi-endian-data
-mlittle-endian-dados -msmall-dados -msim -mno-sim -mas100-sintaxe -mno-as100-sintaxe
-mrelax -mmax-constant-size = -mint-register = -mpid -msave-acc-in-interrupções

S / 390 e Série z Opções -mtune =tipo cpu -march =tipo cpu -mhard-float -msoft-float
-mhard-dfp -mno-hard-dfp -mlong-duplo-64 -mlong-duplo-128 -mbackchain
-mno-backchain -empacked-stack -mno -pack-stack -msmall-exec -mno-pequeno-executivo
-mmvcle -mno-mvcle -m64 -m31 -mdebug -mno-depurar -mesa -mzarch -mtpf-traço
-mno-tpf-trace -mfuso-louco -mno-fundido-madd -mwarn-framesize -mwarn-dynamicstack
-tamanho da pilha -mstack-guard

Pontuação Opções -meb -mel -mnhwloop -muls -mmac -mscore5 -mscore5u -mscore7 -mscore7d

SH Opções -m1 -m2 -m2e -m2a-nofpu -m2a-single-somente -m2a-único -m2a -m3 -m3e
-m4-nofpu -m4-single-somente -m4-único -m4 -m4a-nofpu -m4a-single-somente -m4a-único
-m4a -m4al -m5-64mídia -m5-64media-nofpu -m5-32mídia -m5-32media-nofpu -m5-compacto
-m5-compact-nofpu -mb -ml -mdalign -mrelax -mbigtable -mfmovd -mhitachi -mrenesas
-mno-renesas -mnomacsave -meee -mno-ieee -mbitops -dimensionar -minline-ic_invalidate
-mpadstruct -mespaço -mprefergot -musermode -multcost =número -mdiv =estratégia
-mdivsi3_libfunc =nome -mfixed-range =intervalo de registro -madjust-desenrolar
-mindexed-address -mgettrcost =número - sintoma corrigido -maccumulate-args de saída
-símbolos-minválidos -msoft-atômico -mbranch-cost =Números -mcbranchdi -mcmpeqdi -mfuso-louco
-pretend-cmove

Solaris 2 Opções -mimpure-texto -mno-texto impuro -pthreads -pthread

SPARC Opções -mcpu =tipo cpu -mtune =tipo cpu -mcmodel =modelo de código -mmemory-model =mem-
modelo -m32 -m64 -map-regs -mno-app-regs -maior-structs -mno-mais rápido-structs
-mflat -mno-plano -mfpu -mno-fpu -mhard-float -msoft-float -mhard-quad-float
-msoft-quad-float -mstack-bias -mno-stack-viés -munaligned-duplos
-mno-duplas não alinhadas -mv8plus -mno-v8plus -mvis -mno-vis -mvis2 -mno-vis2
-mvis3 -mno-vis3 -mfmaf -mno-fmaf -mpopc -mno-popc -mfix-at697f

SPU Opções -mwarn-reloc -merr-reloc -msafe-dma -munsafe-dma -dicas de ramificação
-msmall-mem -mlarge-mem -mstdmain -mfixed-range =intervalo de registro -mea32 -mea64
-maddress-espacial-conversão -mno-address-space-conversion -mcache-size =tamanho da memória cache
-atualizações-matomic -mno-atômicas-atualizações

System V Opções -Qy -Qn -Sim,caminhos -Sim,dir

TELHA-Gx Opções -mcpu =cpu -m32 -m64

TILEPro Opções -mcpu =cpu -m32

V850 Opções -muito chamadas -mno-long-chamadas -mep -mno-ep -mprolog-função
-mno-prolog-função -mespaço -mtda =n -msda =n -mzda =n -map-regs -mno-app-regs
-mdisable-call -mno-disable-call -mv850e2v3 -mv850e2 -mv850e1 -mv850es -mv850e
-mv850 -big-switch

VAX Opções -mg -mgnu -munix

VxWorks Opções -mrtp -não estático -Bestático -Bdinâmico -Xbind-preguiçoso -Xbind-agora

x86-64 Opções Consulte as opções i386 e x86-64.

Xstormy16 Opções -msim

Xtensa Opções -mconst16 -mno-const16 -mfuso-louco -mno-fundido-madd -mforce-no-pic
-mserializar-volátil -mno-serialize-volátil -mtext-section-literais
-mno-text-section-liters -mtarget-alinhar -mno-target-align -mlongcalls
-mno-longcalls

Série z Opções Consulte as opções S / 390 e zSeries.

Code Generation Opções
-fcall-salvo-reg -fcall-usado-reg -fixado-reg -fexceções -fnon-call-exceções
-funwind-mesas -fasynchronous -wind-tables -finhibit-size-Directive
-funções de instrumentos -finstrument-functions-exclude-function-list =sym,sym, ...
-finstrument-functions-exclude-file-list =lima,lima, ... -fno-comum -fno-ident
-fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-jump-tables -frecord-gcc-switches
-freg-struct-return -fshort-enums -fcurto-duplo -fshort-wchar -fverbose-asm
-fpack-struct [=n] -fstack-verificar -fstack-limit-register =reg -fstack-limit-symbol =sym
-fno-limite de pilha -fsplit-stack -fluindo-sublinhado -ftls-model =modelo -ftrapv
-fwrapv -fbounds-verificar -fvisibilidade -fstrict-voláteis-bitfields

Opções Controlador da Tipo of saída
A compilação pode envolver até quatro etapas: pré-processamento, compilação adequada, montagem e
vinculando, sempre nessa ordem. O GCC é capaz de pré-processar e compilar vários
arquivos em vários arquivos de entrada do montador ou em um arquivo de entrada do montador; então
cada arquivo de entrada do montador produz um arquivo de objeto, e a vinculação combina todos os objetos
arquivos (os recém-compilados e os especificados como entrada) em um arquivo executável.

Para qualquer arquivo de entrada, o sufixo do nome do arquivo determina que tipo de compilação é
feito:

lima.c
Código-fonte C que deve ser pré-processado.

lima.i
Código-fonte C que não deve ser pré-processado.

lima.ii
Código-fonte C ++ que não deve ser pré-processado.

lima.m
Código-fonte Objective-C. Observe que você deve vincular com o libobjc biblioteca para fazer um
Trabalho do programa Objective-C.

lima.mi
Código-fonte Objective-C que não deve ser pré-processado.

lima.milímetros
lima.M
Código-fonte Objective-C ++. Observe que você deve vincular com o libobjc biblioteca para fazer
um trabalho de programa Objective-C ++. Observe que .M refere-se a um M maiúsculo literal.

lima.mii
Código-fonte Objective-C ++ que não deve ser pré-processado.

lima.h
Arquivo de cabeçalho C, C ++, Objective-C ou Objective-C ++ para ser transformado em um pré-compilado
cabeçalho (padrão), ou arquivo de cabeçalho C, C ++ para ser transformado em uma especificação Ada (por meio do
-fdump-ada-spec trocar).

lima. Cc
lima.cp
lima.cxx
lima.cpp
lima.CPP
lima.c ++
lima.C
Código-fonte C ++ que deve ser pré-processado. Observe que em .cxx, as duas últimas letras
devem ser ambos literalmente x. Da mesma forma, .C refere-se a um C maiúsculo literal

lima.milímetros
lima.M
Código-fonte Objective-C ++ que deve ser pré-processado.

lima.mii
Código-fonte Objective-C ++ que não deve ser pré-processado.

lima.hh
lima.H
lima.hp
lima.hxx
lima.hpp
lima.HPP
lima.h ++
lima.tcc
Arquivo de cabeçalho C ++ a ser transformado em um cabeçalho pré-compilado ou especificação Ada.

lima.f
lima.para
lima.ftn
Código-fonte Fortran de formato fixo que não deve ser pré-processado.

lima.F
lima.PARA
lima.fpp
lima.FPP
lima.FTN
Código-fonte Fortran de forma fixa que deve ser pré-processado (com o tradicional
pré-processador).

lima.f90
lima.f95
lima.f03
lima.f08
Código-fonte Fortran de formato livre que não deve ser pré-processado.

lima.F90
lima.F95
lima.F03
lima.F08
Código-fonte Fortran de forma livre que deve ser pré-processado (com o tradicional
pré-processador).

lima.ir
Código-fonte Go.

lima.Publicidades
Arquivo de código-fonte Ada que contém uma declaração de unidade de biblioteca (uma declaração de um
pacote, subprograma ou genérico, ou uma instanciação genérica), ou uma unidade de biblioteca
declaração de renomeação (uma declaração de renomeação de pacote, genérica ou subprograma). Tal
arquivos também são chamados óculos.

lima.adb
Arquivo de código-fonte Ada contendo um corpo de unidade de biblioteca (um subprograma ou corpo de pacote).
Esses arquivos também são chamados corpos.

lima.s
Código Assembler.

lima.S
lima.sx
Código assembler que deve ser pré-processado.

de outros
Um arquivo de objeto a ser alimentado diretamente na vinculação. Qualquer nome de arquivo sem reconhecimento
sufixo é tratado desta forma.

Você pode especificar o idioma de entrada explicitamente com o -x opção:

-x língua
Especifique explicitamente o língua para os seguintes arquivos de entrada (em vez de permitir que o
o compilador escolhe um padrão com base no sufixo do nome do arquivo). Esta opção se aplica a todos
seguindo os arquivos de entrada até o próximo -x opção. Valores possíveis para língua como:

c c-cabeçalho cpp-saída
c ++ c ++ - cabeçalho c ++ - saída cpp
objetivo-c objetivo-c-cabeçalho objetivo-c-cpp-saída
objetiva-c ++ objetiva-c ++ - cabeçalho objetiva-c ++ - saída cpp
montador montador-com-cpp
ada
f77 f77-cpp-entrada f95 f95-cpp-entrada
go
Java

-x Nenhum
Desative qualquer especificação de um idioma, para que os arquivos subsequentes sejam tratados
de acordo com seus sufixos de nome de arquivo (como eles são se -x não foi usado).

-códigos de saída
Normalmente o gcc o programa sairá com o código 1 se houver alguma fase do compilador
retorna um código de retorno sem sucesso. Se você especificar -códigos de saída, gcc programa
em vez disso, retornará com o maior erro numericamente produzido por qualquer fase que retornou
uma indicação de erro. Os front-ends C, C ++ e Fortran retornam 4, se um interno
foi encontrado um erro do compilador.

Se você quiser apenas algumas das etapas de compilação, você pode usar -x (ou sufixos de nome de arquivo)
contar gcc por onde começar e uma das opções -c, -Sou -E para dizer onde gcc é
Pare. Observe que algumas combinações (por exemplo, -x saída cpp -E) instruir gcc façam
nada mesmo.

-c Compile ou monte os arquivos de origem, mas não os vincule. O estágio de vinculação é simplesmente
não realizado. A saída final está na forma de um arquivo de objeto para cada arquivo de origem.

Por padrão, o nome do arquivo de objeto para um arquivo de origem é feito substituindo o sufixo .c,
.i, .s, etc., com .o.

Arquivos de entrada não reconhecidos, que não requerem compilação ou montagem, são ignorados.

-S Pare após a fase de compilação propriamente dita; não monte. A saída está no
forma de um arquivo de código assembler para cada arquivo de entrada não assembler especificado.

Por padrão, o nome do arquivo assembler para um arquivo de origem é feito substituindo o sufixo
.c, .i, etc., com .s.

Os arquivos de entrada que não requerem compilação são ignorados.

-E Pare após a etapa de pré-processamento; não execute o compilador adequado. A saída está em
a forma de código-fonte pré-processado, que é enviado para a saída padrão.

Os arquivos de entrada que não requerem pré-processamento são ignorados.

-o lima
Coloque a saída no arquivo lima. Isso se aplica independentemente de qualquer tipo de saída
sendo produzido, seja um arquivo executável, um arquivo objeto, um arquivo assembler ou
código C pré-processado.

If -o não for especificado, o padrão é colocar um arquivo executável em a.out, o objeto
arquivo para fonte.sufixo in fonte.o, seu arquivo assembler em fontes, um pré-compilado
arquivo de cabeçalho em fonte.sufixo.gche todas as fontes C pré-processadas na saída padrão.

-v Imprimir (na saída de erro padrão) os comandos executados para executar as etapas de
compilação. Imprima também o número da versão do programa do driver do compilador e do
pré-processador e o compilador adequado.

- ###
Como -v exceto que os comandos não são executados e os argumentos são colocados entre aspas, a menos que eles
conter apenas caracteres alfanuméricos ou "./-_". Isso é útil para scripts de shell para
capturar as linhas de comando geradas pelo driver.

-tubo
Use canais em vez de arquivos temporários para a comunicação entre as várias fases do
compilação. Isso não funciona em alguns sistemas onde o montador é incapaz de ler
de um tubo; mas o GNU assembler não tem problemas.

--Socorro
Imprime (na saída padrão) uma descrição das opções de linha de comando compreendidas por
gcc. Se o -v opção também é especificada então --Socorro também será repassado para o
vários processos invocados por gcc, para que eles possam exibir as opções de linha de comando
eles aceitam. Se o -Wextra opção também foi especificada (antes do --Socorro
opção), em seguida, opções de linha de comando que não têm documentação associada a eles
também será exibido.

--alvo-ajuda
Imprime (na saída padrão) uma descrição das opções de linha de comando específicas do destino
para cada ferramenta. Para alguns alvos, informações adicionais específicas do alvo também podem ser
impresso.

--help = {classe|[^]qualificador}[, ...]
Imprime (na saída padrão) uma descrição das opções de linha de comando compreendidas por
o compilador que se encaixa em todas as classes e qualificadores especificados. Estes são os
aulas com suporte:

otimizadores
Isso exibirá todas as opções de otimização suportadas pelo compilador.

avisos
Isso exibirá todas as opções que controlam as mensagens de aviso produzidas pelo
compilador

alvo
Isso exibirá opções específicas do alvo. Ao contrário do --alvo-ajuda opção
no entanto, as opções específicas de destino do vinculador e montador não serão
exibido. Isso ocorre porque essas ferramentas não suportam atualmente o estendido
--help = sintaxe.

params
Isso exibirá os valores reconhecidos pelo --param opção.

língua
Isso exibirá as opções com suporte para língua, Onde língua É o nome
de um dos idiomas suportados nesta versão do GCC.

comum
Isso exibirá as opções comuns a todos os idiomas.

Estes são os qualificadores suportados:

não documentado
Exibe apenas as opções que não estão documentadas.

ingressou
Exibir opções usando um argumento que aparece após um sinal de igual no mesmo
pedaço contínuo de texto, como: --help = target.

separado
Exibir opções usando um argumento que aparece como uma palavra separada após o
opção original, como: -o arquivo de saída.

Assim, por exemplo, para exibir todos os interruptores específicos do alvo não documentados suportados por
o compilador, o seguinte pode ser usado:

--help = alvo, não documentado

O sentido de um qualificador pode ser invertido prefixando-o com o ^ personagem, então para
exemplo para exibir todas as opções binárias de aviso (ou seja, aquelas que estão ligadas ou desligadas
e que não levam um argumento) que têm uma descrição, use:

--help = avisos, ^ juntou-se, ^ não documentado

O argumento para --help = não deve consistir apenas em qualificadores invertidos.

Combinar várias classes é possível, embora isso geralmente restrinja a saída por
tanto que não há nada para exibir. Um caso em que funciona é quando
uma das aulas é alvo. Por exemplo, para exibir todos os dados específicos do alvo
opções de otimização, as seguintes podem ser usadas:

--help = alvo, otimizadores

A --help = opção pode ser repetida na linha de comando. Cada uso sucessivo irá
exibir sua classe de opções solicitada, pulando aquelas que já foram
exibido.

Se o -Q opção aparece na linha de comando antes do --help = opção, então o
texto descritivo exibido por --help = Mudou. Em vez de descrever o
opções, uma indicação é dada se a opção está habilitada, desabilitada ou definida
a um valor específico (assumindo que o compilador sabe disso no ponto onde o
--help = opção é usada).

Aqui está um exemplo truncado da porta ARM de gcc:

% gcc -Q -mabi = 2 --help = target -c
As seguintes opções são específicas do alvo:
-mabi = 2
-mabort-on-noreturn [desativado]
-mapcs [desativado]

A saída é sensível aos efeitos das opções de linha de comando anteriores, portanto, para
exemplo, é possível descobrir quais otimizações estão habilitadas em -O2 usando:

-Q -O2 --help = otimizadores

Alternativamente, você pode descobrir quais otimizações binárias são habilitadas por -O3 usando:

gcc -c -Q -O3 --help = otimizadores> / tmp / O3-opts
gcc -c -Q -O2 --help = otimizadores> / tmp / O2-opts
diff / tmp / O2-opts / tmp / O3-opts | grep habilitado

-sem prefixos canônicos
Não expanda nenhum link simbólico, resolva as referências para /../ or /./, ou faça o caminho
absoluto ao gerar um prefixo relativo.

--versão
Exibe o número da versão e os direitos autorais do GCC invocado.

-embrulho
Chame todos os subcomandos em um programa wrapper. O nome do programa wrapper e
seus parâmetros são passados ​​como uma lista separada por vírgulas.

gcc -c tc -wrapper gdb, - args

Isso irá invocar todos os subprogramas de gcc para gdb --args, portanto, a invocação de cc1
será gdb --args cc1 ....

-fplugin =nome.assim
Carregue o código do plugin no arquivo nome.so, assumido ser um objeto compartilhado a ser aberto por
o compilador. O nome base do arquivo de objeto compartilhado é usado para identificar o plugin
para fins de análise de argumento (Veja -fplugin-arg-nome-chave=valor abaixo). Cada
O plug-in deve definir as funções de retorno de chamada especificadas na API de plug-ins.

-fplugin-arg-nome-chave=valor
Defina um argumento chamado chave com um valor de valor para o plugin chamado nome.

-fdump-ada-spec[-fino]
Para fontes C e C ++ e arquivos de inclusão, gere as especificações Ada correspondentes.

-fdump-go-spec =lima
Para arquivos de entrada em qualquer idioma, gere declarações Go correspondentes em lima. Este
gera declarações Go "const", "type", "var" e "func" que podem ser uma forma útil
para começar a escrever uma interface Go para o código escrito em alguma outra linguagem.

@lima
Leia as opções de linha de comando de lima. As opções lidas são inseridas no lugar do
original @lima opção. Se lima não existe ou não pode ser lido, então a opção
será tratado literalmente e não removido.

Opções em lima são separados por espaços em branco. Um caractere de espaço em branco pode ser incluído
em uma opção, colocando toda a opção entre aspas simples ou duplas. Algum
caractere (incluindo uma barra invertida) pode ser incluído prefixando o caractere a ser
incluído com uma barra invertida. o lima pode conter @ adicionaislima opções; algum
essas opções serão processadas recursivamente.

Compilando C + + Programas
Arquivos de origem C ++ convencionalmente usam um dos sufixos .C, . Cc, .cpp, .CPP, .c ++, .cpou
.cxx; Arquivos de cabeçalho C ++ costumam usar .hh, .hpp, .H, ou (para código de modelo compartilhado) .tcc; e
arquivos C ++ pré-processados ​​usam o sufixo .ii. O GCC reconhece arquivos com esses nomes e
compila-os como programas C ++ mesmo se você chamar o compilador da mesma forma que para compilar
Programas C (geralmente com o nome gcc).

No entanto, o uso de gcc não adiciona a biblioteca C ++. g ++ é um programa que chama GCC e
trata .c, .h e .i arquivos como arquivos de origem C ++ em vez de arquivos de origem C, a menos que -x is
usado e especifica automaticamente a vinculação com a biblioteca C ++. Este programa também é
útil ao pré-compilar um arquivo de cabeçalho C com um .h extensão para uso em compilações C ++.
Em muitos sistemas, g ++ também é instalado com o nome c ++.

Ao compilar programas C ++, você pode especificar muitas das mesmas opções de linha de comando que
você usa para compilar programas em qualquer linguagem; ou opções de linha de comando significativas para C
e línguas relacionadas; ou opções que são significativas apenas para programas C ++.

Opções Controlador C Dialeto
As opções a seguir controlam o dialeto de C (ou linguagens derivadas de C, como C ++,
Objective-C e Objective-C ++) que o compilador aceita:

-ansi
No modo C, isso é equivalente a -std = c90. No modo C ++, é equivalente a
-std = c ++ 98.

Isso desativa certos recursos do GCC que são incompatíveis com ISO C90 (quando
compilar código C), ou de C ++ padrão (ao compilar código C ++), como o "asm" e
palavras-chave "typeof" e macros predefinidas como "unix" e "vax" que identificam o
tipo de sistema que você está usando. Também permite o ISO indesejável e raramente usado
recurso trigraph. Para o compilador C, desativa o reconhecimento do estilo C ++ //
comentários, bem como a palavra-chave "inline".

As palavras-chave alternativas "__asm__", "__extension__", "__inline__" e "__typeof__"
continue a trabalhar apesar de -ansi. Você não gostaria de usá-los em um programa ISO C,
claro, mas é útil colocá-los em arquivos de cabeçalho que podem ser incluídos em
compilações feitas com -ansi. Macros predefinidas alternativas, como "__unix__" e
"__vax__" também estão disponíveis, com ou sem -ansi.

A -ansi opção não faz com que programas não ISO sejam rejeitados gratuitamente. Para
que, -pedante é necessário além de -ansi.

A macro "__STRICT_ANSI__" é predefinida quando o -ansi opção é usada. Algum cabeçalho
arquivos podem notar esta macro e evitar declarar certas funções ou definir
certas macros que o padrão ISO não exige; isso é para evitar interferir
com quaisquer programas que possam usar esses nomes para outras coisas.

Funções que normalmente estariam integradas, mas não têm semântica definida pelo ISO C
(como "alloca" e "ffs") não são funções integradas quando -ansi é usado.

-std =
Determine o padrão do idioma. Esta opção é atualmente suportada apenas quando
compilar C ou C ++.

O compilador pode aceitar vários padrões básicos, como c90 or c ++ 98e dialetos GNU
desses padrões, como gnu90 or gnu ++ 98. Ao especificar um padrão básico, o
o compilador aceitará todos os programas que seguem esse padrão e aqueles que usam GNU
extensões que não o contradizem. Por exemplo, -std = c90 desliga certo
recursos do GCC que são incompatíveis com ISO C90, como "asm" e "typeof"
palavras-chave, mas não outras extensões GNU que não tenham um significado na ISO C90, como
omitindo o termo do meio de uma expressão "?:". Por outro lado, especificando um GNU
dialeto de um padrão, todos os recursos de suporte do compilador estão habilitados, mesmo quando aqueles
características mudam o significado do padrão básico e alguns programas de conformidade estrita
pode ser rejeitado. O padrão particular é usado por -pedante para identificar qual
recursos são extensões GNU para essa versão do padrão. Por exemplo -std = gnu90
-pedante alertaria sobre o estilo C ++ // comentários, enquanto -std = gnu99 -pedante seria
não.

Um valor para esta opção deve ser fornecido; valores possíveis são

c90
c89
iso9899: 1990
Suporta todos os programas ISO C90 (certas extensões GNU que entram em conflito com ISO C90
estão desativados). Igual a -ansi para o código C.

iso9899: 199409
ISO C90 conforme modificado na alteração 1.

c99
c9x
iso9899: 1999
iso9899: 199x
ISO C99. Observe que este padrão ainda não é totalmente suportado; Vejo
<http://gcc.gnu.org/gcc-4.7/c99status.html> para mais informações. Os nomes c9x
e iso9899: 199x estão obsoletos.

c11
c1x
iso9899: 2011
ISO C11, a revisão de 2011 do padrão ISO C. O suporte está incompleto e
experimental. O nome c1x está obsoleto.

gnu90
gnu89
Dialeto GNU do ISO C90 (incluindo alguns recursos do C99). Este é o padrão para C
código.

gnu99
gnu9x
Dialeto GNU de ISO C99. Quando o ISO C99 for totalmente implementado no GCC, isso irá
se tornar o padrão. O nome gnu9x está obsoleto.

gnu11
gnu1x
Dialeto GNU de ISO C11. O suporte é incompleto e experimental. O nome gnu1x
está obsoleto.

c ++ 98
O padrão ISO C ++ de 1998 mais emendas. Igual a -ansi para código C ++.

gnu ++ 98
Dialeto GNU de -std = c ++ 98. Este é o padrão para o código C ++.

c ++ 11
O padrão ISO C ++ de 2011 mais emendas. O suporte para C ++ 11 ainda é
experimental e pode mudar de maneiras incompatíveis em versões futuras.

gnu ++ 11
Dialeto GNU de -std = c ++ 11. O suporte para C ++ 11 ainda é experimental e pode mudar
de maneiras incompatíveis em versões futuras.

-fgnu89-inline
A opção -fgnu89-inline diz ao GCC para usar a semântica GNU tradicional para "inline"
funções quando no modo C99.
Esta opção é aceita e ignorada pelas versões 4.1.3 do GCC até mas não incluindo
4.3. Nas versões 4.3 e posteriores do GCC, ele muda o comportamento do GCC no modo C99. Usando
esta opção é aproximadamente equivalente a adicionar o atributo de função "gnu_inline" a todos
funções inline.

A opção -fno-gnu89-inline diz explicitamente ao GCC para usar a semântica C99 para
"inline" quando no modo C99 ou GNU99 (ou seja, especifica o comportamento padrão). Esse
opção foi inicialmente suportada no GCC 4.3. Esta opção não é suportada em -std = c90 or
-std = gnu90 modo.

As macros de pré-processador "__GNUC_GNU_INLINE__" e "__GNUC_STDC_INLINE__" podem ser usadas
para verificar qual semântica está em vigor para funções "inline".

-aux-info nome do arquivo
Saída para as declarações prototipadas de nome de arquivo fornecido para todas as funções declaradas e / ou
definido em uma unidade de tradução, incluindo aqueles em arquivos de cabeçalho. Esta opção é
silenciosamente ignorado em qualquer idioma diferente de C.

Além das declarações, o arquivo indica, nos comentários, a origem de cada declaração
(arquivo fonte e linha), se a declaração era implícita, prototipada ou
desprotipado (I, N para novo ou O para velho, respectivamente, no primeiro caractere após
o número da linha e os dois pontos), e se veio de uma declaração ou definição
(C or F, respectivamente, no caractere seguinte). No caso de função
definições, uma lista de argumentos no estilo K&R seguida por suas declarações também é
fornecidos, dentro dos comentários, após a declaração.

-funções variádicas sem parâmetros de pousio
Aceite funções variáveis ​​sem parâmetros nomeados.

Embora seja possível definir tal função, isso não é muito útil, pois é
não é possível ler os argumentos. Isso só é compatível com C, pois esta construção é
permitido por C ++.

-fno-asm
Não reconheça "asm", "inline" ou "typeof" como uma palavra-chave, para que o código possa usar esses
palavras como identificadores. Você pode usar as palavras-chave "__asm__", "__inline__" e
"__typeof__" em vez disso. -ansi implica -fno-asm.

Em C ++, essa opção afeta apenas a palavra-chave "typeof", uma vez que "asm" e "inline" são
palavras-chave padrão. Você pode querer usar o -fno-gnu-palavras-chave sinalizar em vez disso, que tem
o mesmo efeito. No modo C99 (-std = c99 or -std = gnu99), essa mudança afeta apenas o
palavras-chave "asm" e "typeof", visto que "inline" é uma palavra-chave padrão no ISO C99.

-fno-construído
-fno-embutido-função
Não reconheça funções integradas que não comecem com __construídas em_ como prefixo.

GCC normalmente gera código especial para lidar com certas funções embutidas mais
eficientemente; por exemplo, chamadas para "alloca" podem se tornar instruções únicas que
ajuste a pilha diretamente e as chamadas para "memcpy" podem se tornar loops de cópia em linha. o
o código resultante é geralmente menor e mais rápido, mas como a função não chama
mais aparecem como tal, você não pode definir um ponto de interrupção nessas chamadas, nem pode alterar
o comportamento das funções vinculando-se a uma biblioteca diferente. Além disso, quando
uma função é reconhecida como uma função embutida, o GCC pode usar informações sobre isso
função para avisar sobre problemas com chamadas para essa função, ou para gerar mais
código eficiente, mesmo se o código resultante ainda contiver chamadas para essa função. Para
exemplo, os avisos são dados com -Wformato para chamadas ruins para "printf", quando "printf" é
embutido, e "strlen" é conhecido por não modificar a memória global.

Com o -fno-embutido-função opção apenas a função embutida função está desabilitado.
função não deve começar com __construídas em_. Se for nomeada uma função que não está embutida
nesta versão do GCC, esta opção é ignorada. Não há correspondência
-fconstruído-função opção; se você deseja habilitar funções integradas seletivamente quando
utilização -fno-construído or -freestanding, você pode definir macros como:

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

-fhosted
Afirme que a compilação ocorre em um ambiente hospedado. Isso implica -fconstruído.
Um ambiente hospedado é aquele em que toda a biblioteca padrão está disponível, e em
qual "main" tem um tipo de retorno de "int". Os exemplos são quase tudo, exceto um
núcleo. Isso é equivalente a -fno-autônomo.

-freestanding
Afirme que a compilação ocorre em um ambiente independente. Isso implica
-fno-construído. Um ambiente independente é aquele em que a biblioteca padrão não pode
existem, e a inicialização do programa pode não ser necessariamente em "principal". O exemplo mais óbvio
é um kernel do sistema operacional. Isso é equivalente a -fno-hospedado.

-fopenmp
Habilite o manuseio das diretivas OpenMP "#pragma omp" em C / C ++ e "! $ Omp" em Fortran.
Quando -fopenmp é especificado, o compilador gera código paralelo de acordo com o
Interface de programa de aplicativo OpenMP v3.0http://www.openmp.org/>. Esta opção
implica -pthreade, portanto, só é compatível com destinos que tenham suporte para
-pthread.

-fgnu-tm
Quando a opção -fgnu-tm for especificado, o compilador irá gerar código para o Linux
variante do documento de especificação ABI de memória transacional atual da Intel (revisão
1.1, 6 de maio de 2009). Este é um recurso experimental cuja interface pode mudar em
versões futuras do GCC, conforme a especificação oficial muda. Por favor, note que não
todas as arquiteturas são suportadas para este recurso.

Para obter mais informações sobre o suporte do GCC para memória transacional,

Observe que o recurso de memória transacional não é compatível com exceções sem chamada
(-fnon-call-exceções).

-extensões-fms
Aceite algumas construções não padrão usadas em arquivos de cabeçalho da Microsoft.

No código C ++, isso permite que nomes de membros em estruturas sejam semelhantes aos tipos anteriores
declarações.

typedef int UOW;
estrutura ABC {
UOU UOU;
};

Alguns casos de campos sem nome em estruturas e uniões só são aceitos com este
opção.

-fplan9-extensões
Aceite algumas construções não padrão usadas no código do Plano 9.

Isso permite -extensões-fms, permite passar ponteiros para estruturas com anônimos
campos para funções que esperam ponteiros para elementos do tipo do campo, e
permite referir-se a campos anônimos declarados usando um typedef. Este é apenas
com suporte para C, não C ++.

-trígrafos
Suporta trigraphs ISO C. o -ansi opção (e -std opções para ISO C estrito
conformidade) implica -trígrafos.

-no-integrado-cpp
Executa uma compilação em duas etapas: pré-processamento e compilação. Esta opção permite
um usuário forneceu "cc1", "cc1plus" ou "cc1obj" por meio do -B opção. O usuário fornecido
a etapa de compilação pode então adicionar uma etapa de pré-processamento adicional após o normal
pré-processamento, mas antes de compilar. O padrão é usar o cpp integrado
(cpp interno)

A semântica desta opção mudará se "cc1", "cc1plus" e "cc1obj" forem mesclados.

-tradicional
-tradicional-cpp
Anteriormente, essas opções faziam com que o GCC tentasse emular um compilador C pré-padrão.
Eles agora são suportados apenas com o -E trocar. O pré-processador continua a oferecer suporte
um modo pré-padrão. Veja o manual GNU CPP para detalhes.

-fcond-incompatibilidade
Permitir expressões condicionais com tipos incompatíveis no segundo e terceiro argumentos.
O valor de tal expressão é nulo. Esta opção não é compatível com C ++.

-flax-vector-conversões
Permitir conversões implícitas entre vetores com diferentes números de elementos e / ou
tipos de elementos incompatíveis. Esta opção não deve ser usada para novo código.

-funsigned-char
Deixe o tipo "char" sem sinal, como "unsigned char".

Cada tipo de máquina tem um padrão para o que "char" deve ser. É como
"unsigned char" por padrão ou como "assinado char" por padrão.

Idealmente, um programa portátil deve sempre usar "assinado char" ou "unsigned char" quando
depende da assinatura de um objeto. Mas muitos programas foram escritos para usar
simplesmente "char" e espera que seja assinado, ou espera que não seja, dependendo do
máquinas para as quais foram escritos. Esta opção, e seu inverso, permitem que você faça um
programa funcione com o padrão oposto.

O tipo "char" é sempre um tipo distinto de cada um de "char assinado" ou "unsigned
char ", embora seu comportamento seja sempre igual a um desses dois.

-fsigned-char
Deixe o tipo "char" ser assinado, como "char assinado".

Observe que isso é equivalente a -fno-unsigned-char, que é a forma negativa de
-funsigned-char. Da mesma forma, a opção -fno-assinado-char é equivalente a
-funsigned-char.

-fsigned-bitfields
-funsigned-bitfields
-fno-assinado-bitfields
-fno-campos de bits não assinados
Essas opções controlam se um campo de bits é assinado ou não, quando a declaração
não usa "assinado" ou "não assinado". Por padrão, esse campo de bits é assinado,
porque isso é consistente: os tipos inteiros básicos, como "int", são tipos com sinal.

Opções Controlador C + + Dialeto
Esta seção descreve as opções de linha de comando que são significativas apenas para programas C ++;
mas você também pode usar a maioria das opções do compilador GNU, independentemente de qual idioma seu
está dentro do programa. Por exemplo, você pode compilar um arquivo "firstClass.C" como este:

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

Neste exemplo, apenas -frepo é uma opção destinada apenas a programas C ++; você pode usar o
outras opções com qualquer idioma suportado pelo GCC.

Aqui está uma lista de opções que são só para compilar programas C ++:

-fabi-version =n
Use a versão n do C ++ ABI. A versão 2 é a versão do C ++ ABI que primeiro
apareceu no G ++ 3.4. A versão 1 é a versão do C ++ ABI que apareceu pela primeira vez em
G ++ 3.2. A versão 0 será sempre a versão que mais se aproxima do C ++
Especificação ABI. Portanto, o ABI obtido usando a versão 0 mudará conforme o ABI
bugs são corrigidos.

O padrão é a versão 2.

A versão 3 corrige um erro ao mutilar um endereço constante como um argumento de modelo.

A versão 4, que apareceu pela primeira vez no G ++ 4.5, implementa um mangling padrão para vetor
tipos.

A versão 5, que apareceu pela primeira vez no G ++ 4.6, corrige a mutilação do atributo
const / volatile em tipos de ponteiro de função, tipo de decl de um decl simples e uso de um
parâmetro de função na declaração de outro parâmetro.

A versão 6, que apareceu pela primeira vez no G ++ 4.7, corrige o comportamento de promoção do C ++ 11
enums com escopo definido e mutilação de pacotes de argumentos de modelo, const / static_cast, prefixo ++
e -, e uma função de escopo de classe usada como um argumento de modelo.

Veja também -Wabi.

-fno-controle de acesso
Desative todas as verificações de acesso. Esta opção é útil principalmente para contornar bugs em
o código de controle de acesso.

-fcheck-novo
Verifique se o ponteiro retornado por "operador novo" não é nulo antes de tentar
modificar o armazenamento alocado. Esta verificação é normalmente desnecessária porque o C ++
padrão especifica que "operador novo" retornará apenas 0 se for declarado lançar(),
Nesse caso, o compilador sempre verificará o valor de retorno, mesmo sem este
opção. Em todos os outros casos, quando "operador novo" tem uma exceção não vazia
especificação, o esgotamento da memória é sinalizado lançando "std :: bad_alloc". Veja também
novo (não jogue).

-fconservar-espaço
Coloque variáveis ​​globais não inicializadas ou inicializadas em tempo de execução no segmento comum, como
C faz. Isso economiza espaço no executável ao custo de não diagnosticar duplicatas
definições. Se você compilar com este sinalizador e seu programa travar misteriosamente
após a conclusão de "main ()", você pode ter um objeto que está sendo destruído duas vezes
porque duas definições foram mescladas.

Esta opção não é mais útil na maioria dos destinos, agora que o suporte foi adicionado para
colocar variáveis ​​no BSS sem torná-las comuns.

-fconstexpr-depth =n
Defina a profundidade de avaliação aninhada máxima para funções constexpr do C ++ 11 para n. Um limite
é necessário para detectar recursão infinita durante a avaliação de expressão constante. o
mínimo especificado pelo padrão é 512.

-fdeduce-lista de inicialização
Habilite a dedução de um parâmetro de tipo de modelo como std :: initializer_list de uma chave
lista de inicializadores inclusa, ou seja

modelo encaminhamento automático (T t) -> decltype (realfn (t))
{
retornar realfn(t);
}

void f ()
{
para a frente ({1,2}); // reencaminhamento de chamadas >
}

Esta dedução foi implementada como uma possível extensão ao originalmente proposto
semântica para o padrão C ++ 11, mas não fazia parte do padrão final, então é
desativado por padrão. Esta opção está obsoleta e pode ser removida no futuro
versão do G ++.

-injeção de amigo
Injetar funções de amigo no namespace delimitador, de modo que fiquem visíveis fora
o escopo da classe em que são declarados. As funções de amigo foram documentadas
trabalhar dessa maneira no antigo Manual de Referência C ++ Anotado e nas versões do G ++ anteriores
4.1 sempre funcionou assim. No entanto, em ISO C ++ uma função amiga que não é
declarado em um escopo delimitador só pode ser encontrado usando pesquisa dependente de argumento.
Esta opção faz com que amigos sejam injetados como eram em versões anteriores.

Esta opção é para compatibilidade e pode ser removida em uma versão futura do G ++.

-fno-elide-construtores
O padrão C ++ permite que uma implementação omita a criação de um temporário que é apenas
usado para inicializar outro objeto do mesmo tipo. Especificar esta opção desativa
essa otimização e força o G ++ a chamar o construtor de cópia em todos os casos.

-fno-enforce-eh-especificações
Não gere código para verificar a violação das especificações de exceção em tempo de execução.
Esta opção viola o padrão C ++, mas pode ser útil para reduzir o tamanho do código em
construções de produção, bem como definir NDEBUG. Isso não dá permissão ao código do usuário
lançar exceções que violem as especificações de exceção; o compilador irá
ainda otimizar com base nas especificações, portanto, lançar uma exceção inesperada
resultar em comportamento indefinido.

-ffor-escopo
-fno-para-escopo
If -ffor-escopo é especificado, o escopo das variáveis ​​declaradas em um instrução for-init
é limitado ao for loop em si, conforme especificado pelo padrão C ++. Se
-fno-para-escopo é especificado, o escopo das variáveis ​​declaradas em um instrução for-init
estende-se até o final do escopo, como era o caso nas versões antigas do G ++, e
outras implementações (tradicionais) de C ++.

O padrão se nenhum sinalizador for fornecido para seguir o padrão, mas para permitir e fornecer um
aviso para código de estilo antigo que de outra forma seria inválido ou teria
comportamento.

-fno-gnu-palavras-chave
Não reconheço "typeof" como uma palavra-chave, de modo que o código pode usar essa palavra como um
identificador. Você pode usar a palavra-chave "__typeof__" em seu lugar. -ansi implica
-fno-gnu-palavras-chave.

-fno-implícito-templates
Nunca emita código para modelos não embutidos que são instanciados implicitamente (ou seja, por
usar); apenas emita código para instanciações explícitas.

-FNO-implícito-modelos em linha
Também não emita código para instanciações implícitas de modelos embutidos. O padrão
é lidar com inlines de maneira diferente, de modo que as compilações com e sem otimização irão
precisa do mesmo conjunto de instanciações explícitas.

-fno-implementar-inlines
Para economizar espaço, não emita cópias fora de linha de funções em linha controladas por
#pragma implementação. Isso causará erros de vinculador se essas funções não forem
inline em todos os lugares em que são chamados.

-extensões-fms
Desative avisos pedantes sobre construções usadas em MFC, como int implícito e
obter um ponteiro para a função de membro por meio de sintaxe não padrão.

-fno-nonansi-builtins
Desative as declarações integradas de funções que não são exigidas pelo ANSI / ISO C. Estes
incluem "ffs", "alloca", "_exit", "index", "bzero", "conjf" e outros relacionados
funções.

-fnothrow-opt
Trate uma especificação de exceção "throw ()" como se fosse uma especificação "noexcept"
para reduzir ou eliminar a sobrecarga do tamanho do texto em relação a uma função, sem exceção
especificação. Se a função tiver variáveis ​​locais de tipos com não triviais
destruidores, a especificação de exceção tornará a função menor
porque as limpezas EH para essas variáveis ​​podem ser otimizadas. A semântica
efeito é que uma exceção lançada fora de uma função com tal exceção
a especificação resultará em uma chamada para "encerrar" em vez de "inesperado".

-fno-nomes-operadores
Não trate as palavras-chave do nome do operador "e", "bitand", "bitor", "compl", "não", "ou"
e "xor" como sinônimos e palavras-chave.

-fno-opcional-diags
Desative os diagnósticos que o padrão diz que um compilador não precisa emitir.
Atualmente, o único diagnóstico emitido pelo G ++ é aquele para um nome tendo
múltiplos significados dentro de uma classe.

-fpermissivo
Faça downgrade de alguns diagnósticos sobre códigos não conformes de erros para avisos. Assim,
utilização -fpermissivo permitirá que algum código não conforme seja compilado.

-fno-modelos bonitos
Quando uma mensagem de erro se refere a uma especialização de um modelo de função, o compilador
irá imprimir normalmente a assinatura do modelo seguida dos argumentos do modelo
e quaisquer typedefs ou nomes de tipos na assinatura (por exemplo, "void f (T) [com T = int]", em vez
do que "void f (int)") para que fique claro qual modelo está envolvido. Quando um erro
mensagem se refere a uma especialização de um modelo de classe, o compilador irá omitir qualquer
argumentos de modelo que correspondem aos argumentos de modelo padrão para esse modelo. Se
qualquer um desses comportamentos torna mais difícil entender a mensagem de erro, em vez de
mais fácil, usando -fno-modelos bonitos irá desativá-los.

-frepo
Habilite a instanciação automática do modelo no momento do link. Esta opção também implica
-fno-implícito-templates.

-fno-rtti
Desative a geração de informações sobre cada classe com funções virtuais para uso por
os recursos de identificação de tipo de tempo de execução C ++ (elenco_dinâmico e Typeid) Se você não
usar essas partes da linguagem, você pode economizar espaço usando este sinalizador. Observação
esse tratamento de exceção usa as mesmas informações, mas irá gerá-las conforme necessário.
A elenco_dinâmico operador ainda pode ser usado para conversões que não requerem tempo de execução
tipo de informação, ou seja, projeta para "void *" ou para classes base não ambíguas.

-fstats
Emita estatísticas sobre o processamento de front-end no final da compilação. Esse
as informações geralmente são úteis apenas para a equipe de desenvolvimento do G ++.

-fstrict-enums
Permita que o compilador otimize usando a suposição de que um valor do tipo enumerado
só pode ser um dos valores da enumeração (conforme definido no padrão C ++;
basicamente, um valor que pode ser representado no número mínimo de bits necessários para
representam todos os enumeradores). Esta suposição pode não ser válida se o programa usar
um elenco para converter um valor inteiro arbitrário para o tipo enumerado.

-ftemplate-depth =n
Defina a profundidade máxima de instanciação para classes de modelo para n. Um limite no
a profundidade da instanciação do template é necessária para detectar recursões infinitas durante o template
instanciação de classe. Os programas em conformidade com ANSI / ISO C ++ não devem depender de um máximo
profundidade maior que 17 (alterado para 1024 em C ++ 11). O valor padrão é 900, pois o
o compilador pode ficar sem espaço de pilha antes de atingir 1024 em algumas situações.

-fno-threadsafe-statics
Não emita o código extra para usar as rotinas especificadas no C ++ ABI para thread-
inicialização segura de estática local. Você pode usar esta opção para reduzir o tamanho do código
ligeiramente em código que não precisa ser thread-safe.

-fuse-cxa-atexit
Registre destruidores para objetos com duração de armazenamento estático com o "__cxa_atexit"
função em vez da função "atexit". Esta opção é necessária para
manipulação de destruidores estáticos em conformidade com os padrões, mas só funcionará se o seu C
a biblioteca suporta "__cxa_atexit".

-fno-use-cxa-get-exception-ptr
Não use a rotina de tempo de execução "__cxa_get_exception_ptr". Isso vai causar
"std :: uncaught_exception" esteja incorreto, mas é necessário se a rotina de tempo de execução for
não está disponível.

-fvisibility-inlines-oculto
Esta opção declara que o usuário não tenta comparar ponteiros para inline
funções ou métodos em que os endereços das duas funções foram tomados em diferentes
objetos compartilhados.

O efeito disso é que o GCC pode, efetivamente, marcar métodos inline com
"__attribute__ ((visibility (" hidden ")))" para que não apareçam na exportação
tabela de um DSO e não requerem uma indireção PLT quando usados ​​dentro do DSO.
Ativar esta opção pode ter um efeito dramático nos tempos de carregamento e link de um DSO, pois
reduz enormemente o tamanho da tabela de exportação dinâmica quando a biblioteca torna-se pesada
uso de modelos.

O comportamento desta opção não é exatamente o mesmo que marcar os métodos como ocultos
diretamente, porque não afeta as variáveis ​​estáticas locais para a função ou causa
o compilador para deduzir que a função é definida em apenas um objeto compartilhado.

Você pode marcar um método como tendo uma visibilidade explicitamente para negar o efeito do
mudar para esse método. Por exemplo, se você deseja comparar os ponteiros para um
método inline particular, você pode marcá-lo como tendo visibilidade padrão. Marcando o
encerrar a classe com visibilidade explícita não terá efeito.

Métodos embutidos explicitamente instanciados não são afetados por esta opção como sua ligação
pode, de outra forma, cruzar o limite de uma biblioteca compartilhada.

-fvisibility-ms-compat
Este sinalizador tenta usar as configurações de visibilidade para fazer o modelo de ligação C ++ do GCC
compatível com o do Microsoft Visual Studio.

O sinalizador faz essas alterações no modelo de ligação do GCC:

1. Ele define a visibilidade padrão para "oculto", como -fvisibility = oculto.

2. Tipos, mas não seus membros, não são ocultados por padrão.

3. A regra de definição única é relaxada para tipos sem visibilidade explícita
especificações que são definidas em mais de um objeto compartilhado diferente: aqueles
declarações são permitidas se tivessem sido permitidas quando esta opção era
não usado.

No novo código, é melhor usar -fvisibility = oculto e exportar as classes que são
pretende ser externamente visível. Infelizmente, é possível que o código confie,
talvez acidentalmente, no comportamento do Visual Studio.

Entre as consequências dessas mudanças estão que os membros de dados estáticos do mesmo tipo
com o mesmo nome, mas definidos em diferentes objetos compartilhados, serão diferentes, então
mudar um não mudará o outro; e que ponteiros para membros de função definidos
em diferentes objetos compartilhados não podem comparar iguais. Quando este sinalizador é dado, é um
violação do ODR para definir tipos com o mesmo nome de forma diferente.

-não-fraco
Não use suporte de símbolo fraco, mesmo se for fornecido pelo vinculador. Por padrão, G ++
usará símbolos fracos, se estiverem disponíveis. Esta opção existe apenas para teste e
não deve ser usado por usuários finais; isso resultará em um código inferior e não tem benefícios.
Esta opção pode ser removida em uma versão futura do G ++.

-nostdinc ++
Não procure por arquivos de cabeçalho nos diretórios padrão específicos para C ++, mas faça
ainda pesquise os outros diretórios padrão. (Esta opção é usada ao construir o
Biblioteca C ++.)

Além disso, essas opções de otimização, aviso e geração de código têm apenas significados
para programas C ++:

-fno-default-in-line
Não presuma em linha para funções definidas dentro de um escopo de classe.
Observe que essas funções terão ligações como funções embutidas; eles simplesmente não vão
ser embutido por padrão.

-Wabi (C, Objective-C, C ++ e Objective-C ++ apenas)
Avisa quando G ++ gera código que provavelmente não é compatível com o fornecedor neutro
C ++ ABI. Embora um esforço tenha sido feito para alertar sobre todos esses casos, há
provavelmente alguns casos que não são avisados, embora G ++ esteja gerando
código incompatível. Também pode haver casos em que os avisos são emitidos mesmo que o
o código gerado será compatível.

Você deve reescrever seu código para evitar esses avisos se estiver preocupado com o
fato de que o código gerado por G ++ pode não ser binário compatível com o código gerado por
outros compiladores.

As incompatibilidades conhecidas em -fabi-version = 2 (o padrão) inclui:

· Um modelo com um parâmetro de modelo não-tipo do tipo de referência está mutilado
incorretamente:

externo int N;
modelo struct S {};
void n (S ) {2}

Isso é corrigido em -fabi-version = 3.

· Tipos de vetor SIMD declarados usando "__attribute ((vector_size))" são mutilados em um
forma não padrão que não permite a sobrecarga de funções tomando vetores
de tamanhos diferentes.

A mutilação é alterada em -fabi-version = 4.

As incompatibilidades conhecidas em -fabi-version = 1 incluem:

· Manuseio incorreto de preenchimento de cauda para campos de bits. G ++ pode tentar empacotar dados
no mesmo byte de uma classe base. Por exemplo:

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

Nesse caso, G ++ colocará "B :: f2" no mesmo byte que "A :: f1"; outros compiladores
não vou. Você pode evitar esse problema preenchendo explicitamente "A" para que seu tamanho
é um múltiplo do tamanho do byte em sua plataforma; que fará com que o G ++ e outros
compiladores para o layout "B" de forma idêntica.

· Manuseio incorreto de acolchoamento de cauda para bases virtuais. G ++ não usa cauda
preenchimento ao dispor as bases virtuais. Por exemplo:

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

Nesse caso, o G ++ não colocará "B" no preenchimento da cauda de "A"; de outros
compiladores vão. Você pode evitar esse problema preenchendo explicitamente "A" para que seu
o tamanho é um múltiplo de seu alinhamento (ignorando as classes base virtuais); aquilo vai
fazer com que o G ++ e outros compiladores apresentem o layout "C" de forma idêntica.

· Manuseio incorreto de campos de bits com larguras declaradas maiores do que a de seus
tipos subjacentes, quando os campos de bits aparecem em uma união. Por exemplo:

união U {int i: 4096; };

Supondo que um "int" não tenha 4096 bits, G ++ tornará a união muito pequena
pelo número de bits em um "int".

· Classes vazias podem ser colocadas em deslocamentos incorretos. Por exemplo:

estrutura A {};

estrutura B {
Uma;
vazio virtual f ();
};

struct C: público B, público A {};

G ++ colocará a classe base "A" de "C" em um deslocamento diferente de zero; deve ser colocado
no deslocamento zero. G ++ acredita erroneamente que o membro de dados "A" de "B" é
já no deslocamento zero.

· Nomes de funções de modelo cujos tipos envolvem "nome de tipo" ou modelo de modelo
os parâmetros podem ser mutilados incorretamente.

modelo
void f (nome do tipo Q :: X) {}

modelo classe Q>
void f (nome do tipo Q :: X) {}

As instanciações desses modelos podem ser alteradas incorretamente.

Ele também avisa sobre alterações relacionadas ao psABI. As alterações conhecidas de psABI neste ponto incluem:

· Para SYSV / x86-64, ao passar união com duplo longo, é alterado para passar
memória conforme especificado em psABI. Por exemplo:

união U {
longo duplo ld;
int i;
};

"união U" sempre será passada na memória.

-Wctor-dtor-privacidade (Apenas C ++ e Objective-C ++)
Avisa quando uma classe parece inutilizável porque todos os construtores ou destruidores naquele
classes são privadas e não tem amigos nem funções de membro estáticas públicas.

-Delete-não-virtual-dtor (Apenas C ++ e Objective-C ++)
Avisar quando excluir é usado para destruir uma instância de uma classe que tem funções virtuais
e destruidor não virtual. Não é seguro excluir uma instância de uma classe derivada
por meio de um ponteiro para uma classe base se a classe base não tiver um virtual
destruidor. Este aviso é habilitado por -Parede.

-Aviso (Apenas C ++ e Objective-C ++)
Avisar quando uma conversão de estreitamento proibida por C ++ 11 ocorre dentro { }, por exemplo

int i = {2.2}; // erro: estreitando de duplo para interno

Esta bandeira está incluída em -Parede e -Wc ++ 11-compat.

Com -std = c ++ 11, -Wno-estreitando suprime o diagnóstico exigido pelo padrão.
Observe que isso não afeta o significado do código bem formado; redução de conversões
ainda são considerados mal formados no contexto SFINAE.

-Wnoexceto (Apenas C ++ e Objective-C ++)
Avisa quando uma expressão noexcept é avaliada como falsa devido a uma chamada para uma função
que não tem uma especificação de exceção sem lançamento (ou seja, lançar() or sem exceção)
mas é conhecido pelo compilador por nunca lançar uma exceção.

-Wnon-virtual-dtor (Apenas C ++ e Objective-C ++)
Avisa quando uma classe tem funções virtuais e destruidor não virtual acessível, em
caso em que seria possível, mas não seguro, excluir uma instância de uma classe derivada
por meio de um ponteiro para a classe base. Este aviso também é habilitado se -Weffc ++ is
Especificadas.

-Encomendar (Apenas C ++ e Objective-C ++)
Avisa quando a ordem dos inicializadores de membro fornecida no código não corresponde à ordem
em que devem ser executados. Por exemplo:

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

O compilador irá reorganizar os inicializadores de membro para i e j para combinar com o
declaração de ordem dos associados, emitindo advertência nesse sentido. Este aviso é
ativado por -Parede.

Os seguintes -C... as opções não são afetadas por -Parede.

-Weffc ++ (Apenas C ++ e Objective-C ++)
Avisar sobre violações das seguintes diretrizes de estilo de Scott Meyers ' Eficaz
C ++, Segundo edição livro:

· Item 11: Definir um construtor de cópia e um operador de atribuição para classes com
memória alocada dinamicamente.

· Item 12: Prefira a inicialização à atribuição em construtores.

· Item 14: Tornar destruidores virtuais nas classes base.

· Item 15: Faça com que "operador =" retorne uma referência * a isso.

· Item 23: Não tente retornar uma referência quando você deve retornar um objeto.

Também avisa sobre violações das seguintes diretrizes de estilo de Scott Meyers ' Mais
Eficaz C + + livro:

· Item 6: Distinguir entre as formas prefixadas e pós-fixadas de incremento e decremento
operadores.

· Item 7: Nunca sobrecarregue "&&", "||" ou ",".

Ao selecionar esta opção, esteja ciente de que os cabeçalhos da biblioteca padrão não obedecem a todos
dessas diretrizes; usar grep -v para filtrar esses avisos.

-Wstrict-null-sentinela (Apenas C ++ e Objective-C ++)
Alertar também sobre o uso de um "NULL" não lançado como sentinela. Ao compilar apenas com
GCC este é um sentinela válido, pois "NULL" é definido como "__null". Embora seja um nulo
constante de ponteiro não é um ponteiro nulo, é garantido que seja do mesmo tamanho que um
ponteiro. Mas esse uso não é portátil em diferentes compiladores.

-Não-não-amigo-modelo (Apenas C ++ e Objective-C ++)
Desative os avisos quando funções de amigo não padronizadas forem declaradas em um modelo.
Desde o advento do suporte de especificação de modelo explícito em G ++, se o nome do
amigo é um id não qualificado (ou seja, amigos foo (int)), a especificação da linguagem C ++
exige que o amigo declare ou defina uma função comum, não-modelo. (Seção
14.5.3). Antes de G ++ implementar a especificação explícita, unqualified-ids poderiam ser
interpretado como uma especialização particular de uma função modelada. Porque isso
comportamento não conforme não é mais o comportamento padrão para G ++,
-Wnon-modelo-amigo permite que o compilador verifique o código existente para problemas em potencial
pontos e está ativado por padrão. Este novo comportamento do compilador pode ser desativado com
-Não-não-amigo-modelo, que mantém o código do compilador em conformidade, mas desativa o
aviso útil.

-Estilo antigo (Apenas C ++ e Objective-C ++)
Avisa se uma conversão de estilo antigo (estilo C) para um tipo não vazio é usada em um programa C ++.
Os elencos de novo estilo (elenco_dinâmico, static_cast, reinterpretar_cast e const_cast) estamos
menos vulnerável a efeitos indesejados e muito mais fácil de pesquisar.

-Woverloaded-virtual (Apenas C ++ e Objective-C ++)
Avisa quando uma declaração de função oculta funções virtuais de uma classe base. Para
exemplo, em:

estrutura A {
vazio virtual f ();
};

struct B: público A {
void f (int);
};

a versão de classe "A" de "f" está oculta em "B" e codifica como:

B * b;
b-> f ();

falhará ao compilar.

-Wno-pmf-conversões (Apenas C ++ e Objective-C ++)
Desative o diagnóstico para converter um ponteiro vinculado para uma função de membro em um simples
ponteiro.

-Wsign-promoção (Apenas C ++ e Objective-C ++)
Avisa quando a resolução de sobrecarga escolhe uma promoção de tipo não assinado ou enumerado para
um tipo assinado, sobre uma conversão para um tipo não assinado do mesmo tamanho. Anterior
versões do G ++ tentariam preservar a não sinalização, mas o padrão exige que o
comportamento atual.

estrutura A {
operador int ();
A & operador = (int);
};

a Principal ()
{
A a, b;
uma = b;
}

Neste exemplo, G ++ irá sintetizar um padrão A& operador = (const UMA&);, enquanto cfront
usará o definido pelo usuário operador =.

Opções Controlador Objective-C e Objective-C ++ Dialetos
(NOTA: Este manual não descreve as linguagens Objective-C e Objective-C ++
si mesmos.

Esta seção descreve as opções de linha de comando que são significativas apenas para Objective-C
e programas Objective-C ++, mas você também pode usar a maioria dos programas GNU independentes de linguagem
opções do compilador. Por exemplo, você pode compilar um arquivo "some_class.m" como este:

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

Neste exemplo, -fgnu-tempo de execução é uma opção destinada apenas para Objective-C e Objective-C ++
programas; você pode usar as outras opções com qualquer idioma suportado pelo GCC.

Observe que, como Objective-C é uma extensão da linguagem C, as compilações Objective-C
também pode usar opções específicas para o front-end C (por exemplo, -Wtradicional). Da mesma forma,
Compilações Objective-C ++ podem usar opções específicas de C ++ (por exemplo, -Wabi).

Aqui está uma lista de opções que são só para compilar Objective-C e Objective-C ++
programas:

-fconstant-string-class =nome da classe
Use nome da classe como o nome da classe a instanciar para cada string literal
especificado com a sintaxe "@" ... "". O nome da classe padrão é "NXConstantString" se
o runtime GNU está sendo usado, e "NSConstantString" se o runtime NeXT está sendo
usado (veja abaixo). o -fconstant-cfstrings opção, se também estiver presente, substituirá o
-fconstant-string-class definir e fazer com que literais "@" ... "" sejam dispostos como constantes
Strings CoreFoundation.

-fgnu-tempo de execução
Gere código de objeto compatível com o tempo de execução GNU Objective-C padrão. Isto é
o padrão para a maioria dos tipos de sistemas.

-fnext-tempo de execução
Gere saída compatível com o tempo de execução NeXT. Este é o padrão para baseado em NeXT
sistemas, incluindo Darwin e Mac OS X. A macro "__NEXT_RUNTIME__" é predefinida se
(e somente se) esta opção for usada.

-fno-nil-receptores
Suponha que todas as mensagens Objective-C despachadas ("[mensagem do receptor: arg]") neste
unidade de tradução certifique-se de que o receptor não seja "nulo". Isso permite mais
pontos de entrada eficientes no tempo de execução a serem usados. Esta opção está disponível apenas em
conjunto com o tempo de execução NeXT e ABI versão 0 ou 1.

-fobjc-abi-version =n
Use a versão n do Objective-C ABI para o tempo de execução selecionado. Esta opção é
atualmente com suporte apenas para o tempo de execução NeXT. Nesse caso, a versão 0 é o
ABI tradicional (32 bits) sem suporte para propriedades e outros Objective-C 2.0
aditivos. A versão 1 é a ABI tradicional (32 bits) com suporte para propriedades e
outras adições Objective-C 2.0. A versão 2 é a ABI moderna (64 bits). Se nada for
especificado, o padrão é a Versão 0 em máquinas de destino de 32 bits e a Versão 2 em 64 bits
máquinas-alvo.

-fobjc-call-cxx-cdtors
Para cada classe Objective-C, verifique se alguma de suas variáveis ​​de instância é um objeto C ++
com um construtor padrão não trivial. Em caso afirmativo, sintetize um "- (id) especial
.cxx_construct "método de instância que irá executar construtores padrão não triviais em qualquer
tais variáveis ​​de instância, em ordem, e então retornam "self". Da mesma forma, verifique se algum
variável de instância é um objeto C ++ com um destruidor não trivial e, em caso afirmativo, sintetizar
um método especial "- (void) .cxx_destruct" que irá executar todos os destruidores padrão,
Em ordem inversa.

Os métodos "- (id) .cxx_construct" e "- (void) .cxx_destruct" gerados serão
operar apenas em variáveis ​​de instância declaradas na classe Objective-C atual, e não
aqueles herdados de superclasses. É responsabilidade do Objective-C
runtime para invocar todos esses métodos na hierarquia de herança de um objeto. O ID)
métodos .cxx_construct "serão chamados pelo tempo de execução imediatamente após um novo objeto
instância é alocada; os métodos "- (void) .cxx_destruct" serão invocados
imediatamente antes de o tempo de execução desalocar uma instância do objeto.

No momento em que este livro foi escrito, apenas o tempo de execução NeXT no Mac OS X 10.4 e posterior tem suporte para
invocando os métodos "- (id) .cxx_construct" e "- (void) .cxx_destruct".

-fobjc-despacho direto
Permitir saltos rápidos para o despachante de mensagens. Em Darwin, isso é feito por meio do
página de comunicação.

-fobjc-exceções
Habilite o suporte sintático para manipulação de exceção estruturada em Objective-C, semelhante a
o que é oferecido por C ++ e Java. Esta opção é necessária para usar o Objective-C
palavras-chave @try, @throw, @catch, @finally e @synchronized. Esta opção está disponível
com o GNU runtime e o NeXT runtime (mas não disponível em conjunto com
o tempo de execução NeXT no Mac OS X 10.2 e anterior).

-fobjc-gc
Habilite a coleta de lixo (GC) nos programas Objective-C e Objective-C ++. Esta opção
está disponível apenas com o tempo de execução NeXT; o tempo de execução GNU tem um lixo diferente
implementação de coleção que não requer sinalizadores de compilador especiais.

-fobjc-nilcheck
Para o tempo de execução NeXT com a versão 2 da ABI, verifique se há um receptor nulo no método
chamadas antes de fazer a chamada do método real. Este é o padrão e pode ser
desabilitado usando -fno-objc-nilcheck. Métodos de classe e super chamadas nunca são verificados
para nil dessa forma, não importa como esse sinalizador esteja definido. Atualmente esta bandeira faz
nada quando o tempo de execução GNU, ou uma versão mais antiga do ABI de tempo de execução NeXT, é usado.

-fobjc-std = objc1
Esteja em conformidade com a sintaxe da linguagem Objective-C 1.0, a linguagem reconhecida pelo GCC 4.0.
Isso afeta apenas as adições Objective-C à linguagem C / C ++; não afeta
conformidade com os padrões C / C ++, que é controlada pelo dialeto C / C ++ separado
sinalizadores de opção. Quando esta opção é usada com Objective-C ou Objective-C ++
compilador, qualquer sintaxe Objective-C que não seja reconhecida pelo GCC 4.0 é rejeitada. Esse
é útil se você precisa ter certeza de que seu código Objective-C pode ser compilado com
versões mais antigas do GCC.

-freplace-objc-classes
Emita um marcador especial de instrução ld(1) não vincular estaticamente ao objeto resultante
arquivo e permitir dyld(1) para carregá-lo em tempo de execução. Isso é usado em
conjunto com o modo de depuração Fix-and-Continue, onde o arquivo de objeto está
a questão pode ser recompilada e recarregada dinamicamente no decorrer do programa
execução, sem a necessidade de reiniciar o próprio programa. Atualmente, Fix-and-
A funcionalidade Continuar está disponível apenas em conjunto com o tempo de execução NeXT no Mac
OS X 10.3 e posterior.

-fzero-link
Ao compilar para o tempo de execução NeXT, o compilador normalmente substitui as chamadas para
"objc_getClass (" ... ")" (quando o nome da classe é conhecido em tempo de compilação) com
referências de classe estáticas que são inicializadas no momento do carregamento, o que melhora o tempo de execução
atuação. Especificando o -fzero-link sinalizar suprime esse comportamento e causa
chamadas para "objc_getClass (" ... ")" para serem retidas. Isso é útil no Zero-Link
modo de depuração, uma vez que permite que implementações de classes individuais sejam modificadas
durante a execução do programa. O tempo de execução GNU atualmente sempre mantém chamadas para
"objc_get_class (" ... ")" independentemente das opções de linha de comando.

-gen-decls
Despejar declarações de interface para todas as classes vistas no arquivo de origem para um arquivo denominado
nome de origem.decl.

-Watribuir-interceptar (Objective-C e Objective-C ++ apenas)
Avisa sempre que uma atribuição Objective-C está sendo interceptada pelo coletor de lixo.

-Wno-protocolo (Objective-C e Objective-C ++ apenas)
Se uma classe é declarada para implementar um protocolo, um aviso é emitido para cada método
no protocolo que não é implementado pela classe. O comportamento padrão é
emitir um aviso para cada método não explicitamente implementado na classe, mesmo se um
a implementação do método é herdada da superclasse. Se você usar o -Wno-protocolo
opção, então os métodos herdados da superclasse são considerados para serem implementados,
e nenhum aviso é emitido para eles.

-Seletor (Objective-C e Objective-C ++ apenas)
Avisar se vários métodos de tipos diferentes para o mesmo seletor forem encontrados durante
compilação. A verificação é realizada na lista de métodos na fase final de
compilação. Além disso, uma verificação é realizada para cada seletor que aparece em um
expressão "@selector (...)", e um método correspondente para esse seletor foi
encontrado durante a compilação. Porque essas verificações examinam a tabela de métodos apenas no final
de compilação, esses avisos não são produzidos se o estágio final de compilação for
não alcançado, por exemplo, porque um erro foi encontrado durante a compilação, ou porque o
-fsintaxe somente opção está sendo usada.

-Wstrict-seletor-match (Objective-C e Objective-C ++ apenas)
Avisa se vários métodos com argumentos e / ou tipos de retorno diferentes são encontrados para um
determinado seletor ao tentar enviar uma mensagem usando este seletor para um receptor de
digite "id" ou "Class". Quando este sinalizador está desligado (que é o comportamento padrão), o
o compilador irá omitir tais avisos se quaisquer diferenças encontradas estiverem confinadas a tipos que
compartilham o mesmo tamanho e alinhamento.

-Seletor Wundeclared (Objective-C e Objective-C ++ apenas)
Avisa se uma expressão "@selector (...)" referindo-se a um seletor não declarado for encontrada. UMA
o seletor é considerado não declarado se nenhum método com esse nome foi declarado antes
a expressão "@selector (...)", explicitamente em uma @interface ou @protocol
declaração, ou implicitamente em uma seção @implementation. Esta opção sempre funciona
suas verificações assim que uma expressão "@selector (...)" for encontrada, enquanto -Seletor só
executa suas verificações na fase final de compilação. Isso também reforça a codificação
convenção de estilo de que os métodos e seletores devem ser declarados antes de serem usados.

-print-objc-runtime-info
Gera cabeçalho C que descreve a maior estrutura que é passada por valor, se houver.

Opções para Controle Diagnóstico Mensagens formatação
Tradicionalmente, as mensagens de diagnóstico são formatadas independentemente do dispositivo de saída
aspecto (por exemplo, sua largura, ...). As opções descritas abaixo podem ser usadas para controlar o
algoritmo de formatação de mensagens de diagnóstico, por exemplo, quantos caracteres por linha, com que freqüência
as informações de localização da fonte devem ser relatadas. No momento, apenas o front-end C ++ pode
honrar essas opções. No entanto, espera-se, em um futuro próximo, que a restante frente
fins seriam capazes de digeri-los corretamente.

-fmessage-length =n
Tente formatar mensagens de erro para que caibam em linhas de cerca de n personagens. o
o padrão é 72 caracteres para g ++ e 0 para o resto das interfaces suportadas por
GCC. Se n for zero, nenhuma quebra de linha será feita; cada mensagem de erro aparecerá
em uma única linha.

-fdiagnostics-show-location = once
Significativo apenas no modo de quebra de linha. Instrui o relator de mensagens de diagnóstico a
emitir uma vez informações de localização da fonte; ou seja, no caso de a mensagem ser muito longa para caber
em uma única linha física e precisa ser agrupada, o local de origem não será emitido
(como prefixo) novamente, continuamente, nas linhas de continuação subsequentes. Isto é o
comportamento padrão.

-fdiagnostics-show-location = every-line
Significativo apenas no modo de quebra de linha. Instrui o relator de mensagens de diagnóstico a
emitem as mesmas informações de localização de origem (como prefixo) para linhas físicas que resultam
do processo de quebra de uma mensagem que é muito longa para caber em uma única linha.

-fno-diagnóstico-show-option
Por padrão, cada diagnóstico emitido inclui texto indicando a opção de linha de comando
que controla diretamente o diagnóstico (se tal opção for conhecida pelo diagnóstico
máquinas). Especificando o -fno-diagnóstico-show-option bandeira suprime isso
comportamento.

Opções para SOLICITAÇÃO or Suprimir Advertências
Os avisos são mensagens de diagnóstico que relatam construções que não são inerentemente
erradas, mas que são arriscadas ou sugerem que pode ter havido um erro.

As seguintes opções independentes de idioma não permitem avisos específicos, mas controlam o
tipos de diagnósticos produzidos pelo GCC.

-fsintaxe somente
Verifique se há erros de sintaxe no código, mas não faça nada além disso.

-fmax-errors =n
Limita o número máximo de mensagens de erro a n, ponto em que o GCC se recupera em vez
do que tentar continuar processando o código-fonte. Se n é 0 (o padrão),
não há limite para o número de mensagens de erro produzidas. Se -Wfatal-erros É também
especificado, então -Wfatal-erros tem precedência sobre esta opção.

-w Iniba todas as mensagens de aviso.

-Erro
Transforme todos os avisos em erros.

-Werror =
Transforme o aviso especificado em um erro. O especificador de um aviso é anexado,
por exemplo -Werror = switch transforma os avisos controlados por -Mudar em erros.
Esta opção assume uma forma negativa, para ser usada para negar -Erro para avisos específicos,
por exemplo -Wno-error = switch faz -Mudar os avisos não são erros, mesmo quando -Erro
está em vigor.

A mensagem de aviso para cada aviso controlável inclui a opção que controla
O aviso. Essa opção pode então ser usada com -Werror = e -Wno-error = Como descrito
acima de. (A impressão da opção na mensagem de aviso pode ser desativada usando o
-fno-diagnóstico-show-option bandeira.)

Observe que especificar -Werror =Foo implica automaticamente -WFoo. Porém, -Wno-error =Foo
não implica nada.

-Wfatal-erros
Esta opção faz com que o compilador aborte a compilação no primeiro erro ocorrido
em vez de tentar continuar e imprimir outras mensagens de erro.

Você pode solicitar muitos avisos específicos com opções começando -W, Por exemplo -Wimplícito
para solicitar avisos sobre declarações implícitas. Cada uma dessas opções de aviso específicas também
tem uma forma negativa começando -Não- para desligar os avisos; por exemplo, -Wno-implícito.
Este manual lista apenas um dos dois formulários, o que não for o padrão. Para mais adiante,
opções específicas de idioma também se referem a C + + Dialeto Opções e Objective-C e
Objective-C ++ Dialeto Opções.

Quando uma opção de aviso não reconhecida é solicitada (por exemplo, -Aviso desconhecido), O GCC irá emitir
um diagnóstico informando que a opção não foi reconhecida. No entanto, se o -Não- forma é
usado, o comportamento é ligeiramente diferente: Nenhum diagnóstico será produzido para
-Wno-aviso desconhecido a menos que outros diagnósticos estejam sendo produzidos. Isso permite o uso de
novo -Não- opções com compiladores antigos, mas se algo der errado, o compilador irá avisar
que uma opção não reconhecida foi usada.

-pedante
Emitir todos os avisos exigidos por ISO C e ISO C ++ estritos; rejeitar todos os programas que
usar extensões proibidas e alguns outros programas que não seguem ISO C e ISO
C ++. Para ISO C, segue a versão do padrão ISO C especificado por qualquer -std
opção usada.

Os programas ISO C e ISO C ++ válidos devem ser compilados corretamente com ou sem esta opção
(embora alguns raros exijam -ansi ou um -std opção especificando a versão necessária
da ISO C). No entanto, sem esta opção, certas extensões GNU e C e tradicionais
Recursos C ++ também são suportados. Com esta opção, eles são rejeitados.

-pedante não causa mensagens de aviso para o uso de palavras-chave alternativas cujo
nomes começam e terminam com __. Avisos pedantes também estão desabilitados na expressão
que segue "__extension__". No entanto, apenas os arquivos de cabeçalho do sistema devem usar esses
rotas de fuga; os programas de aplicação devem evitá-los.

Alguns usuários tentam usar -pedante para verificar se os programas estão em conformidade com o ISO C estrito. Elas
logo descobrirá que não faz exatamente o que eles querem: encontra algumas práticas não ISO,
mas não todos --- apenas aqueles para os quais ISO C exige um diagnóstico, e alguns outros para
quais diagnósticos foram adicionados.

Um recurso para relatar qualquer falha em conformidade com o ISO C pode ser útil em alguns casos,
mas exigiria um trabalho adicional considerável e seria bastante diferente de
-pedante. Não temos planos de oferecer suporte a esse recurso em um futuro próximo.

Onde o padrão especificado com -std representa um dialeto estendido GNU de C, como
gnu90 or gnu99, há um correspondente base padrão, a versão do ISO C em que
o dialeto estendido GNU é baseado. Avisos de -pedante são dados onde estão
exigido pelo padrão básico. (Não faria sentido que tais avisos fossem dados
apenas para recursos que não estão no dialeto GNU C especificado, uma vez que, por definição, o GNU
dialetos de C incluem todos os recursos que o compilador suporta com a opção fornecida, e
não haveria nada para avisar.)

-erros-pedantes
Como -pedante, exceto que são produzidos erros em vez de avisos.

-Parede
Isso ativa todos os avisos sobre construções que alguns usuários consideram
questionáveis ​​e fáceis de evitar (ou modificar para evitar o aviso), mesmo em
conjunção com macros. Isso também permite alguns avisos específicos do idioma descritos
in C + + Dialeto Opções e Objective-C e Objective-C ++ Dialeto Opções.

-Parede ativa os seguintes sinalizadores de aviso:

-Endereço - Limites da guerra (somente com -O2) -Wc ++ 11-compat -Wchar-subscritos
-Wenum-comparar (em C / Objc; ativado por padrão em C ++) -Wimplicit-int (C e
Objective-C apenas) -Declaração de função explícita (C e Objective-C apenas) -Comentário
-Wformato -Wprincipal (apenas para C / ObjC e a menos que -freestanding) -Wtalvez não inicializado
- Suspensórios -Wnão nulo -Parênteses -Wpointer-sinal -Encomendar -Tipo de retrocesso
-Ponto de sequência -Wsign-comparar (apenas em C ++) -Wstrict-aliasing -Wstrict-overflow = 1
-Mudar -Wtrigraphs -W não inicializado -Pragmas desconhecidos -Função não usada
-Wunused-rótulo -Valor não utilizado -Wunused-variável -Wvolatile-registro-var

Observe que alguns sinalizadores de aviso não estão implícitos em -Parede. Alguns deles alertam sobre
construções que os usuários geralmente não consideram questionáveis, mas que
ocasionalmente você pode querer verificar; outros alertam sobre construções que são
necessário ou difícil de evitar em alguns casos, e não há uma maneira simples de modificar o
código para suprimir o aviso. Alguns deles são habilitados por -Wextra mas muitos deles
deve ser ativado individualmente.

-Wextra
Isso ativa alguns sinalizadores de aviso extras que não são ativados por -Parede. (Esta opção usada
ser chamado -W. O nome mais antigo ainda é compatível, mas o nome mais recente é mais
descritivo.)

-Wclobbered -Corpo-vazio -Wignored-qualificadores -Wmissing-field-inicializadores
- Tipo de parâmetro ausente (Apenas C) -Declaração de estilo antigo (Apenas C) -Woverride-init
-Wsign-comparar -Limites de tipo -W não inicializado -Wunused-parâmetro (somente com -Não usado or
-Parede) -Wunused-mas-set-parameter (somente com -Não usado or -Parede)

A opção -Wextra também imprime mensagens de aviso para os seguintes casos:

· Um ponteiro é comparado com o inteiro zero com <, <=, >ou >=.

· (Somente C ++) Um enumerador e um não enumerador aparecem em um condicional
expressão.

· (Somente C ++) Bases virtuais ambíguas.

· (Somente C ++) Subscrever uma matriz que foi declarada cadastre-se.

· (C ++ apenas) Pegando o endereço de uma variável que foi declarada cadastre-se.

· (Somente C ++) Uma classe base não é inicializada no construtor de cópia de uma classe derivada.

-Wchar-subscritos
Avisa se um subscrito de array possui o tipo "char". Esta é uma causa comum de erro, pois
os programadores freqüentemente esquecem que esse tipo é assinado em algumas máquinas. Este aviso é
ativado por -Parede.

-Comentário
Avisar sempre que uma sequência de início de comentário /* aparece em um /* comentário, ou sempre que um
Barra invertida-nova linha aparece em um // Comente. Este aviso é habilitado por -Parede.

- Incompatibilidade de cobertura sem correspondência
Avisa se os perfis de feedback não correspondem ao usar o -fprofile-use opção. Se um
arquivo de origem foi alterado entre -fprofile-gen e -fprofile-use, os arquivos com o
o feedback do perfil pode não corresponder ao arquivo de origem e o GCC não pode usar o perfil
informações de feedback. Por padrão, esse aviso está ativado e é tratado como um erro.
- Incompatibilidade de cobertura sem correspondência pode ser usado para desativar o aviso ou
-Wno-error = cobertura-incompatibilidade pode ser usado para desativar o erro. Desativando o erro
para este aviso pode resultar em código mal otimizado e é útil apenas no caso de
mudanças muito pequenas, como correções de bugs em uma base de código existente. Desativando completamente
o aviso não é recomendado.

-Wno-cpp
(C, Objective-C, C ++, Objective-C ++ e Fortran apenas)

Suprime as mensagens de aviso emitidas pelas diretivas "#warning".

-Dupla promoção (Apenas C, C ++, Objective-C e Objective-C ++)
Dê um aviso quando um valor do tipo "float" for implicitamente promovido a "double". CPUs
com uma unidade de ponto flutuante de "precisão única" de 32 bits implementa "flutuação" no hardware,
mas emular "double" no software. Em tal máquina, fazer cálculos usando
valores "duplos" são muito mais caros devido à sobrecarga necessária para o software
emulação.

É fácil fazer cálculos acidentalmente com "double" porque o ponto flutuante
literais são implicitamente do tipo "duplo". Por exemplo, em:

área de flutuação (raio de flutuação)
{
return 3.14159 * raio * raio;
}

o compilador irá realizar todo o cálculo com "double" porque o
literal de ponto é um "duplo".

-Wformato
Verifique as chamadas para "printf" e "scanf", etc., para se certificar de que os argumentos fornecidos
têm tipos apropriados para a string de formato especificada, e que as conversões
especificado na string de formato faz sentido. Isso inclui funções padrão e
outros especificados por atributos de formato, em "printf", "scanf", "strftime" e
"strfmon" (uma extensão X / Open, não no padrão C) famílias (ou outro alvo-
famílias específicas). Quais funções são verificadas sem que os atributos de formato tenham sido
especificado depende da versão padrão selecionada, e tais verificações de funções
sem o atributo especificado são desativados por -freestanding or -fno-construído.

Os formatos são verificados em relação aos recursos de formato suportados pelo GNU libc versão 2.2.
Isso inclui todos os recursos ISO C90 e C99, bem como recursos do Single Unix
Especificação e algumas extensões BSD e GNU. Outras implementações de biblioteca não podem
suporte a todos esses recursos; O GCC não oferece suporte a avisos sobre recursos que vão além
limitações de uma biblioteca particular. No entanto, se -pedante é usado com -Wformato,
avisos serão dados sobre recursos de formato não na versão padrão selecionada (mas
não para formatos "strfmon", uma vez que não estão em nenhuma versão do padrão C).

Como -Wformato também verifica se há argumentos de formato nulo para várias funções, -Wformato
também implica -Wnão nulo.

-Wformato está incluído no -Parede. Para obter mais controle sobre alguns aspectos da verificação de formato,
as opções -Wformato-y2k, -Wno-format-extra-args, -Wno-formato-zero-comprimento,
-Wformat-não literal, -Wformato-segurança e -Wformat = 2 estão disponíveis, mas não são
incluído em -Parede.

NOTA: No Ubuntu 8.10 e versões posteriores, esta opção é habilitada por padrão para C, C ++,
ObjC, ObjC ++. Para desativar, use -Wformat = 0.

-Wformato-y2k
If -Wformato é especificado, também avisa sobre os formatos "strftime" que podem produzir apenas um
ano de dois dígitos.

-Wno-format-contém-nul
If -Wformato for especificado, não avisa sobre strings de formato que contêm bytes NUL.

-Wno-format-extra-args
If -Wformato é especificado, não avisa sobre o excesso de argumentos para um "printf" ou "scanf"
função de formato. O padrão C especifica que tais argumentos são ignorados.

Onde os argumentos não usados ​​ficam entre os argumentos usados ​​que são especificados com $
especificações de número de operando, normalmente avisos ainda são dados, uma vez que o
implementação não poderia saber que tipo passar para "va_arg" para pular o não utilizado
argumentos. No entanto, no caso de formatos "scanf", esta opção irá suprimir o
avisando se os argumentos não usados ​​são todos ponteiros, uma vez que a Especificação Única do Unix
diz que tais argumentos não utilizados são permitidos.

-Wno-formato-zero-comprimento
If -Wformato for especificado, não avisa sobre formatos de comprimento zero. O padrão C
especifica que formatos de comprimento zero são permitidos.

-Wformat-não literal
If -Wformato for especificado, também avisa se a string de formato não é uma string literal e
portanto, não pode ser verificado, a menos que a função de formato receba seus argumentos de formato como um
"va_list".

-Wformato-segurança
If -Wformato é especificado, também avisa sobre o uso de funções de formato que representam
possíveis problemas de segurança. No momento, isso avisa sobre chamadas para "printf" e
funções "scanf" em que a string de formato não é uma string literal e não há
argumentos de formato, como em "printf (foo);". Isso pode ser uma falha de segurança se o formato
string veio de uma entrada não confiável e contém %n. (Este é atualmente um subconjunto do que
-Wformat-não literal avisa sobre, mas no futuro os avisos podem ser adicionados a
-Wformato-segurança que não estão incluídos em -Wformat-não literal.)

NOTA: No Ubuntu 8.10 e versões posteriores, esta opção é habilitada por padrão para C, C ++,
ObjC, ObjC ++. Para desativar, use -Wno-formato-segurançaou desative todos os avisos de formato
com -Wformat = 0. Para tornar fatais os avisos de segurança de formato, especifique
-Werror = format-security.

-Wformat = 2
permitir -Wformato além de verificações de formato não incluídas em -Wformato. Atualmente equivalente a
-Wformato -Wformat-não literal -Wformato-segurança -Wformato-y2k.

-Wnão nulo
Avisar sobre a passagem de um ponteiro nulo para argumentos marcados como exigindo um valor não nulo
pelo atributo de função "não nula".

-Wnão nulo está incluído no -Parede e -Wformato. Pode ser desativado com o -Wno-nonnull
opção.

-Win-self (Apenas C, C ++, Objective-C e Objective-C ++)
Avisa sobre variáveis ​​não inicializadas que são inicializadas com elas mesmas. Observe isso
opção só pode ser usada com a -W não inicializado opção.

Por exemplo, o GCC avisará sobre o "i" não ter sido inicializado apenas no seguinte snippet
quando -Win-self foi especificado:

int f ()
{
int = i;
retorno eu;
}

-Wimplicit-int (C e Objective-C apenas)
Avisa quando uma declaração não especifica um tipo. Este aviso é habilitado por -Parede.

-Declaração de função explícita (C e Objective-C apenas)
Dê um aviso sempre que uma função for usada antes de ser declarada. No modo C99
(-std = c99 or -std = gnu99), este aviso é habilitado por padrão e é transformado em um
erro de -erros-pedantes. Este aviso também é habilitado por -Parede.

-Wimplícito (C e Objective-C apenas)
Igual a -Wimplicit-int e -Declaração de função explícita. Este aviso está habilitado
by -Parede.

-Wignored-qualificadores (Somente C e C ++)
Avisa se o tipo de retorno de uma função possui um qualificador de tipo como "const". Para ISO C
tal qualificador de tipo não tem efeito, uma vez que o valor retornado por uma função não é um
lvalue. Para C ++, o aviso é emitido apenas para tipos escalares ou "void". ISO C
proíbe tipos de retorno "nulos" qualificados em definições de função, portanto, tais tipos de retorno
sempre recebe um aviso, mesmo sem essa opção.

Este aviso também é habilitado por -Wextra.

-Wprincipal
Avisa se o tipo de principal é suspeito. principal deve ser uma função com externo
ligação, retornando int, recebendo nenhum argumento, dois ou três argumentos de
tipos apropriados. Este aviso é habilitado por padrão em C ++ e é habilitado por qualquer
-Parede or -pedante.

- Suspensórios
Avisa se um inicializador de agregação ou união não está totalmente entre colchetes. Na sequência
exemplo, o inicializador para a não está totalmente entre colchetes, mas isso para b é totalmente
entre colchetes.

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

Este aviso é habilitado por -Parede.

-Wmissing-include-dirs (Apenas C, C ++, Objective-C e Objective-C ++)
Avisa se um diretório de inclusão fornecido pelo usuário não existe.

-Parênteses
Avisa se os parênteses são omitidos em certos contextos, como quando há um
atribuição em um contexto onde um valor verdadeiro é esperado ou quando os operadores estão aninhados
cuja precedência as pessoas costumam ficar confusas.

Também avisa se uma comparação como x <= y <= z parece; isso é equivalente a (x <= y ? 1 : 0)
<= z, que é uma interpretação diferente daquela da notação matemática comum.

Também avise sobre construções onde pode haver confusão para qual declaração "if" um
O ramo "else" pertence. Aqui está um exemplo de tal caso:

{
se um)
se (b)
fo ();
outro
Barra ();
}

Em C / C ++, cada branch "else" pertence à instrução "if" mais interna possível, que
neste exemplo é "if (b)". Muitas vezes não é o que o programador esperava, pois
ilustrado no exemplo acima por indentação que o programador escolheu. Quando há
o potencial para esta confusão, o GCC emitirá um aviso quando este sinalizador for
Especificadas. Para eliminar o aviso, adicione colchetes explícitos ao redor do "se" mais interno
de forma que não haja nenhuma maneira de o "outro" pertencer ao "se" delimitador. o
o código resultante ficaria assim:

{
se um)
{
se (b)
fo ();
outro
Barra ();
}
}

Também avisa sobre o uso perigoso do?: Com a extensão GNU do operando intermediário omitida. Quando
a condição no?: operador é uma expressão booleana o valor omitido será
sempre 1. Freqüentemente, o usuário espera que seja um valor calculado dentro do condicional
expressão em vez disso.

Este aviso é habilitado por -Parede.

-Ponto de sequência
Avisar sobre código que pode ter semântica indefinida devido a violações de sequência
regras de ponto nos padrões C e C ++.

Os padrões C e C ++ definem a ordem em que as expressões em um programa C / C ++ são
avaliado em termos de seqüência pontos, que representam uma ordenação parcial entre os
execução de partes do programa: aquelas executadas antes do ponto de sequência, e aquelas
executado depois disso. Estes ocorrem após a avaliação de uma expressão completa (aquela que
não faz parte de uma expressão maior), após a avaliação do primeiro operando de um
"&&", "||", "?:" ou "," operador (vírgula), antes de uma função ser chamada (mas após o
avaliação de seus argumentos e a expressão que denota a função chamada), e em
certos outros lugares. Diferente do expresso pelas regras de ponto de sequência, a ordem
de avaliação de subexpressões de uma expressão não é especificado. Todas essas regras
descrever apenas um pedido parcial em vez de um pedido total, uma vez que, por exemplo, se dois
funções são chamadas dentro de uma expressão sem nenhum ponto de sequência entre elas, o
a ordem em que as funções são chamadas não é especificada. No entanto, os padrões
comitê decidiu que as chamadas de função não se sobrepõem.

Não é especificado quando entre pontos de sequência modificações nos valores de
objetos entram em vigor. Programas cujo comportamento depende disso têm comportamento indefinido;
os padrões C e C ++ especificam que "Entre o ponto de sequência anterior e seguinte
objeto deve ter seu valor armazenado modificado no máximo uma vez pela avaliação de um
expressão. Além disso, o valor anterior deve ser lido apenas para determinar o valor para
ser armazenado. ". Se um programa quebrar essas regras, os resultados em qualquer
implementação são totalmente imprevisíveis.

Exemplos de código com comportamento indefinido são "a = a ++;", "a [n] = b [n ++]" e "a [i ++] =
i; ". Alguns casos mais complicados não são diagnosticados por esta opção, e pode dar um
resultado falso positivo ocasional, mas em geral foi considerado bastante eficaz em
detectar esse tipo de problema em programas.

O padrão é redigido de forma confusa, portanto, há algum debate sobre o
significado das regras de ponto de sequência em casos sutis. Links para discussões do
problema, incluindo as definições formais propostas, pode ser encontrado na página de leituras do GCC,
nohttp://gcc.gnu.org/readings.html>.

Este aviso é habilitado por -Parede para C e C ++.

-Tipo de retrocesso
Avisa sempre que uma função é definida com um tipo de retorno cujo padrão é "int". Também
avisar sobre qualquer instrução de "retorno" sem valor de retorno em uma função cujo tipo de retorno
não é "vazio" (cair do final do corpo da função é considerado retorno
sem um valor), e sobre uma declaração de "retorno" com uma expressão em uma função
cujo tipo de retorno é "vazio".

Para C ++, uma função sem tipo de retorno sempre produz uma mensagem de diagnóstico, mesmo
quando -Wno-retorno-tipo é especificado. As únicas exceções são principal e funções
definido nos cabeçalhos do sistema.

Este aviso é habilitado por -Parede.

-Mudar
Avisa sempre que uma instrução "switch" tem um índice do tipo enumerado e não tem um "caso"
para um ou mais dos códigos nomeados dessa enumeração. (A presença de um "padrão"
rótulo evita esse aviso.) rótulos de "caso" fora do intervalo de enumeração também
provocar avisos quando esta opção for usada (mesmo se houver um rótulo "padrão"). Esse
aviso é habilitado por -Parede.

-Wswitch-padrão
Avisa sempre que uma instrução "switch" não tem um caso "padrão".

-Wswitch-enum
Avisa sempre que uma instrução "switch" tem um índice do tipo enumerado e não tem um "caso"
para um ou mais dos códigos nomeados dessa enumeração. rótulos de "caso" fora do
intervalo de enumeração também provoca avisos quando esta opção é usada. A única diferença
entre -Mudar e esta opção é que esta opção dá um aviso sobre um omitido
código de enumeração, mesmo se houver um rótulo "padrão".

-Wsync-nand (Somente C e C ++)
Avisa quando as funções integradas "__sync_fetch_and_nand" e "__sync_nand_and_fetch" são
usado. Essas funções mudaram a semântica no GCC 4.4.

-Wtrigraphs
Avisa se forem encontrados trígrafos que possam mudar o significado do programa
(trigraphs nos comentários não são avisados). Este aviso é habilitado por -Parede.

-Wunused-mas-set-parameter
Avisa sempre que um parâmetro de função é atribuído, mas não utilizado (exceto
sua declaração).

Para suprimir este aviso, use o não usado atributo.

Este aviso também é habilitado por -Não usado Juntamente com -Wextra.

-Wunused-mas-set-variável
Avisa sempre que uma variável local é atribuída a, mas de outra forma não utilizada (além de seu
declaração). Este aviso é habilitado por -Parede.

Para suprimir este aviso, use o não usado atributo.

Este aviso também é habilitado por -Não usado, que é habilitado por -Parede.

-Função não usada
Avisar sempre que uma função estática for declarada, mas não definida ou uma função estática não inline
função não é usada. Este aviso é habilitado por -Parede.

-Wunused-rótulo
Avisa sempre que um rótulo é declarado, mas não usado. Este aviso é habilitado por -Parede.

Para suprimir este aviso, use o não usado atributo.

-Wunused-local-typedefs (C, Objective-C, C ++ e Objective-C ++ apenas)
Avisa quando um typedef definido localmente em uma função não é usado.

-Wunused-parâmetro
Avisa sempre que um parâmetro de função não é usado, além de sua declaração.

Para suprimir este aviso, use o não usado atributo.

-Wno-resultado não utilizado
Não avise se um chamador de uma função marcada com o atributo "warn_unused_result" faz
não use seu valor de retorno. O padrão é -Resultado não usado.

-Wunused-variável
Avisar sempre que uma variável local ou variável estática não constante não for usada, exceto
sua declaração. Este aviso é habilitado por -Parede.

Para suprimir este aviso, use o não usado atributo.

-Valor não utilizado
Avisa sempre que uma instrução calcula um resultado que não é explicitamente usado. Suprimir
este aviso lançou a expressão não usada para anular. Isso inclui uma declaração de expressão
ou o lado esquerdo de uma expressão de vírgula que não contém efeitos colaterais. Para
exemplo, uma expressão como x [i, j] irá causar um aviso, enquanto x [(vazio) i, j] precisarão
não.

Este aviso é habilitado por -Parede.

-Não usado
Todas as opções acima descritas -Não usado opções combinadas.

Para receber um aviso sobre um parâmetro de função não utilizado, você deve especificar
-Wextra -Não usado (Observe que -Parede implica -Não usado), ou especificar separadamente
-Wunused-parâmetro.

-W não inicializado
Avisa se uma variável automática é usada sem primeiro ser inicializada ou se uma variável
pode ser superado por uma chamada "setjmp". Em C ++, avisa se uma referência não estática ou não
estático const membro aparece em uma classe sem construtores.

Se você quiser avisar sobre o código que usa o valor não inicializado da variável em
seu próprio inicializador, use o -Win-self opção.

Esses avisos ocorrem para elementos individuais não inicializados ou destruídos da estrutura,
variáveis ​​de união ou matriz, bem como para variáveis ​​não inicializadas ou superadas
como um todo. Eles não ocorrem para variáveis ​​ou elementos declarados "voláteis". Porque
esses avisos dependem da otimização, das variáveis ​​ou elementos exatos para os quais
Esses avisos dependerão das opções precisas de otimização e da versão do GCC usado.

Observe que pode não haver nenhum aviso sobre uma variável que é usada apenas para calcular um
valor que nunca é usado, porque tais cálculos podem ser excluídos pelo fluxo de dados
análise antes de os avisos serem impressos.

-Wtalvez não inicializado
Para uma variável automática, se houver um caminho da entrada da função para um uso de
a variável que é inicializada, mas existem alguns outros caminhos em que a variável não é
inicializado, o compilador emitirá um aviso se não puder provar o não inicializado
caminhos não acontecem em tempo de execução. Esses avisos são opcionais porque o GCC não é
inteligente o suficiente para ver todas as razões pelas quais o código pode estar correto, apesar de parecer
tem um erro. Aqui está um exemplo de como isso pode acontecer:

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

Se o valor de "y" é sempre 1, 2 ou 3, então "x" é sempre inicializado, mas GCC
não sabe disso. Para suprimir o aviso, o usuário precisa fornecer um caso padrão
com afirmar(0) ou código semelhante.

Esta opção também avisa quando uma variável automática não volátil pode ser alterada por um
ligue para "longjmp". Esses avisos também são possíveis apenas na otimização
compilação.

O compilador vê apenas as chamadas para "setjmp". Ele não pode saber onde "longjmp" estará
chamado; na verdade, um manipulador de sinal poderia chamá-lo em qualquer ponto do código. Como um
resultado, você pode receber um aviso mesmo quando não há nenhum problema porque "longjmp"
não pode, de fato, ser chamado no local que causaria um problema.

Alguns avisos falsos podem ser evitados se você declarar todas as funções que usa que
nunca retorne como "noreturn".

Este aviso é habilitado por -Parede or -Wextra.

-Pragmas desconhecidos
Avisa quando uma diretiva "#pragma" é encontrada e não é compreendida pelo GCC. Se este
opção de linha de comando for usada, avisos serão até mesmo emitidos para pragmas desconhecidos em
arquivos de cabeçalho do sistema. Este não é o caso se os avisos só foram ativados pelo
-Parede opção de linha de comando.

-Wno-pragmas
Não avise sobre o uso indevido de pragmas, como parâmetros incorretos, sintaxe inválida ou
conflitos entre pragmas. Veja também -Pragmas desconhecidos.

-Wstrict-aliasing
Esta opção só está ativa quando -fstrict-aliasing está ativo. Ele avisa sobre o código que
pode quebrar as regras estritas de aliasing que o compilador está usando para otimização.
O aviso não captura todos os casos, mas tenta capturar os mais comuns
armadilhas. Está incluído em -Parede. É equivalente a -Wstrict-aliasing = 3

-Wstrict-aliasing = n
Esta opção só está ativa quando -fstrict-aliasing está ativo. Ele avisa sobre o código que
pode quebrar as regras estritas de aliasing que o compilador está usando para otimização.
Níveis mais altos correspondem a maior precisão (menos falsos positivos). Níveis mais altos
também correspondem a mais esforço, semelhante à forma como -O funciona. -Wstrict-aliasing is
equivalente a -Wstrict-aliasing = n, com n = 3.

Nível 1: mais agressivo, rápido, menos preciso. Possivelmente útil quando níveis mais altos
não avisa, mas -fstrict-aliasing ainda quebra o código, pois tem muito poucos false
negativos. No entanto, ele tem muitos falsos positivos. Avisa para todas as conversões de ponteiro
entre tipos possivelmente incompatíveis, mesmo que nunca tenham sido desreferenciados. Corre na frente
fim apenas.

Nível 2: agressivo, rápido, não muito preciso. Pode ainda ter muitos falsos positivos (não
embora tantos quanto o nível 1), e poucos falsos negativos (mas possivelmente mais do que o nível 1).
Ao contrário do nível 1, ele só avisa quando um endereço é obtido. Avisa sobre tipos incompletos.
É executado apenas no front-end.

Nível 3 (padrão para -Wstrict-aliasing): Deve ter muito poucos falsos positivos e poucos
falsos negativos. Um pouco mais lento do que os níveis 1 ou 2 quando a otimização está ativada.
Cuida do padrão comum de trocadilho + desreferência no front end:
"* (int *) & some_float". Se a otimização estiver habilitada, ela também será executada no back end, onde
ele lida com vários casos de instrução usando informações de pontos sensíveis ao fluxo.
Avisa apenas quando o ponteiro convertido é desreferenciado. Não avisa sobre incompleto
tipos.

-Wstrict-overflow
-Wstrict-overflow =n
Esta opção só está ativa quando -fstrict-overflow está ativo. Avisa sobre casos
onde o compilador otimiza com base na suposição de que o estouro assinado não
ocorrer. Observe que ele não avisa sobre todos os casos em que o código pode estourar: ele
apenas avisa sobre os casos em que o compilador implementa alguma otimização. Portanto, este
o aviso depende do nível de otimização.

Uma otimização que assume que o estouro assinado não ocorre é perfeitamente segura se
os valores das variáveis ​​envolvidas são tais que o estouro nunca, de fato,
ocorrer. Portanto, este aviso pode facilmente dar um falso positivo: um aviso sobre o código
isso não é realmente um problema. Para ajudar a focar em questões importantes, vários avisos
os níveis são definidos. Nenhum aviso é emitido para o uso de estouro assinado indefinido
ao estimar quantas iterações um loop exigirá, em particular quando
determinar se um loop será executado.

-Wstrict-overflow = 1
Avise sobre casos questionáveis ​​e fáceis de evitar. Por exemplo: "x +
1> x "; com -fstrict-overflow, o compilador irá simplificar isso para 1. Este nível
of -Wstrict-overflow é habilitado por -Parede; níveis mais altos não são, e devem ser
solicitado explicitamente.

-Wstrict-overflow = 2
Também avise sobre outros casos em que uma comparação é simplificada para uma constante. Para
exemplo: "abs (x)> = 0". Isso só pode ser simplificado quando -fstrict-overflow é em
efeito, porque "abs (INT_MIN)" transborda para "INT_MIN", que é menor que zero.
-Wstrict-overflow (sem nível) é o mesmo que -Wstrict-overflow = 2.

-Wstrict-overflow = 3
Avise também sobre outros casos em que a comparação é simplificada. Por exemplo: "x + 1
> 1 "será simplificado para" x> 0 ".

-Wstrict-overflow = 4
Alertar também sobre outras simplificações não contempladas nos casos acima. Para
exemplo: "(x * 10) / 5" será simplificado para "x * 2".

-Wstrict-overflow = 5
Também avisa sobre os casos em que o compilador reduz a magnitude de uma constante
envolvidos em uma comparação. Por exemplo: "x + 2> y" será simplificado para "x + 1
> = y ". Isso é relatado apenas no nível de aviso mais alto porque este
a simplificação se aplica a muitas comparações, portanto, este nível de aviso fornecerá uma
grande número de falsos positivos.

-Wsuggest-attribute =[puro|const|Noreturn]
Avise sobre os casos em que adicionar um atributo pode ser benéfico. Os atributos atualmente
suportados estão listados abaixo.

-Wsuggest-attribute = pure
-Wsuggest-attribute = const
-Wsuggest-attribute = noreturn
Avisar sobre funções que podem ser candidatas aos atributos "puro", "const" ou
"noreturn". O compilador só avisa para funções visíveis em outra compilação
unidades ou (no caso de "puro" e "const") se não puder provar que a função
retorna normalmente. Uma função retorna normalmente se não contiver um infinito
loop nem retorna anormalmente lançando, chamando "abort ()" ou trapping. Esse
análise requer opção -fipa-puro-const, que é habilitado por padrão em -O e
superior. Níveis de otimização mais altos melhoram a precisão da análise.

- Limites da guerra
Esta opção só está ativa quando -ftree-vrp está ativo (padrão para -O2 e acima). Isto
avisa sobre subscritos para matrizes que estão sempre fora dos limites. Este aviso é
ativado por -Parede.

-Wno-div-por-zero
Não avise sobre a divisão inteira em tempo de compilação por zero. Divisão de ponto flutuante por
zero não é avisado, pois pode ser uma forma legítima de obter infinitos e
NaNs.

-Wsystem-cabeçalhos
Imprimir mensagens de aviso para construções encontradas em arquivos de cabeçalho do sistema. Avisos de
cabeçalhos do sistema são normalmente suprimidos, na suposição de que geralmente não
indicam problemas reais e apenas tornam a saída do compilador mais difícil de ler. Usando
esta opção de linha de comando diz ao GCC para emitir avisos dos cabeçalhos do sistema como se eles
ocorreu no código do usuário. No entanto, observe que usar -Parede em conjunto com esta opção
precisarão não avisar sobre pragmas desconhecidos nos cabeçalhos do sistema --- para isso, -Pragmas desconhecidos
também deve ser usado.

-Wtrampolins
Avisar sobre trampolins gerados para ponteiros para funções aninhadas.

Um trampolim é um pequeno pedaço de dados ou código que é criado durante a execução
tempo na pilha quando o endereço de uma função aninhada é obtido, e
é usado para chamar a função aninhada indiretamente. Para alguns alvos,
é composto apenas de dados e, portanto, não requer nenhum tratamento especial. Mas,
para a maioria dos alvos, é feito de código e, portanto, requer a pilha
para ser executado para que o programa funcione corretamente.

-Wfloat-igual
Avisa se valores de ponto flutuante são usados ​​em comparações de igualdade.

A ideia por trás disso é que às vezes é conveniente (para o programador)
considere os valores de ponto flutuante como aproximações de números reais infinitamente precisos.
Se você está fazendo isso, você precisa calcular (analisando o código, ou em algum
outra forma) o erro máximo ou provável máximo que o cálculo introduz, e
permitir isso ao realizar comparações (e ao produzir saída, mas isso é um
problema diferente). Em particular, em vez de testar a igualdade, você verificaria
para ver se os dois valores têm intervalos que se sobrepõem; e isso é feito com o
operadores relacionais, portanto, as comparações de igualdade provavelmente estão erradas.

-Wtradicional (C e Objective-C apenas)
Avise sobre certas construções que se comportam de maneira diferente no tradicional e no ISO C. Também
avisar sobre construções ISO C que não têm equivalente C tradicional e / ou problemático
construções que devem ser evitadas.

· Parâmetros de macro que aparecem dentro de literais de string no corpo da macro. No
substituição de macro C tradicional ocorre dentro de literais de string, mas não
em ISO C.

· No C tradicional, algumas diretivas de pré-processador não existiam. Tradicional
pré-processadores só considerariam uma linha como uma diretiva se o # apareceu
coluna 1 na linha. Portanto -Wtradicional avisa sobre as diretivas que
tradicional C entende, mas iria ignorar porque o # não aparece como o
primeiro personagem na linha. Também sugere que você oculte diretivas como #pragma
não compreendido pelo C tradicional recuando-os. Alguns tradicionais
implementações não reconheceriam #elif, por isso sugere evitá-lo completamente.

· Uma macro semelhante a uma função que aparece sem argumentos.

· O operador mais unário.

· O U sufixo constante inteiro, ou o F or L sufixos constantes de ponto flutuante.
(C tradicional suporta o L sufixo em constantes inteiras.) Observe, estes
sufixos aparecem em macros definidas nos cabeçalhos de sistema da maioria dos sistemas modernos,
por exemplo, o _MIN/_MÁX. macros em " ". O uso dessas macros no código do usuário pode
normalmente levam a avisos falsos, no entanto, o pré-processador integrado do GCC tem
contexto suficiente para evitar avisos nesses casos.

· Uma função declarada externa em um bloco e então usada após o final do
bloquear.

· Uma instrução "switch" possui um operando do tipo "long".

· Uma declaração de função não "estática" segue uma declaração "estática". Esta construção não é
aceito por alguns compiladores C tradicionais.

· O tipo ISO de uma constante inteira tem uma largura ou sinal diferente de seu
tipo tradicional. Este aviso só é emitido se a base da constante for dez.
Ou seja, valores hexadecimais ou octais, que normalmente representam padrões de bits, não são
alertado sobre.

· Foi detectado o uso de concatenação de string ISO.

· Inicialização de agregados automáticos.

· O identificador está em conflito com os rótulos. C tradicional carece de um namespace separado para
etiquetas.

· Inicialização de sindicatos. Se o inicializador for zero, o aviso será omitido.
Isso é feito supondo que o inicializador zero no código do usuário apareça
condicionado, por exemplo, "__STDC__" para evitar a falta de avisos do inicializador e depende de
inicialização padrão para zero no caso C tradicional.

· Conversões por protótipos entre valores fixos / de ponto flutuante e vice-versa. o
ausência desses protótipos ao compilar com o C tradicional causaria sérios
problemas. Este é um subconjunto dos avisos de conversão possíveis, para o conjunto completo
usar -Wconversão tradicional.

· Uso de definições de função de estilo ISO C. Este aviso é intencionalmente não emitido
para declarações de protótipo ou funções variáveis ​​porque esses recursos ISO C irão
aparecem em seu código ao usar macros de compatibilidade C tradicionais da libiberty,
"PARAMS" e "VPARAMS". Este aviso também é ignorado para funções aninhadas
porque esse recurso já é uma extensão do GCC e, portanto, não é relevante para
compatibilidade C tradicional.

-Wconversão tradicional (C e Objective-C apenas)
Avisa se um protótipo causa uma conversão de tipo diferente do que aconteceria
ao mesmo argumento na ausência de um protótipo. Isso inclui conversões de
ponto fixo para flutuante e vice-versa, e conversões alterando a largura ou
assinatura de um argumento de ponto fixo, exceto quando o mesmo que a promoção padrão.

-Wdeclaração-após-declaração (C e Objective-C apenas)
Avisa quando uma declaração é encontrada após uma declaração em um bloco. Esta construção, conhecida
do C ++, foi introduzido com ISO C99 e é permitido por padrão no GCC. Não é
suportado pelo ISO C90 e não era suportado pelas versões do GCC anteriores ao GCC 3.0.

-Wundef
Avisa se um identificador indefinido é avaliado em um #E se Directiva.

-Wno-endif-rótulos
Não avise sempre que um #else ou um #fim se são seguidos por texto.

-Sombra
Avisa sempre que uma variável local ou declaração de tipo obscurece outra variável,
parâmetro, tipo ou membro de classe (em C ++), ou sempre que uma função embutida é
sombreado. Observe que em C ++, o compilador não avisará se uma variável local sombreia um
struct / class / enum, mas avisará se sombreia um typedef explícito.

-Maior que =len
Avisar sempre que um objeto maior que len bytes é definido.

-Wframe-maior-que =len
Avisa se o tamanho de um quadro de função é maior que len bytes. O cálculo feito
para determinar o tamanho do quadro da pilha é aproximado e não conservador. O real
os requisitos podem ser um pouco maiores do que len mesmo se você não receber um aviso. No
além disso, qualquer espaço alocado por meio de "alloca", matrizes de comprimento variável ou
construções não são incluídas pelo compilador ao determinar se deve ou não emitir um
Atenção.

-Wno-free-nonheap-objeto
Não avise ao tentar liberar um objeto que não foi alocado no heap.

-Wstack-usage =len
Avisa se o uso da pilha de uma função pode ser maior do que len bytes. O cálculo
feito para determinar o uso da pilha é conservador. Qualquer espaço alocado via "alloca",
matrizes de comprimento variável ou construções relacionadas são incluídas pelo compilador quando
determinar se deve ou não emitir um aviso.

A mensagem está de acordo com a saída de -fstack-uso.

· Se o uso da pilha for totalmente estático, mas exceder a quantidade especificada, é:

aviso: o uso da pilha é 1120 bytes

· Se o uso da pilha é (parcialmente) dinâmico, mas limitado, é:

aviso: o uso da pilha pode ser 1648 bytes

· Se o uso da pilha for (parcialmente) dinâmico e não limitado, é:

aviso: o uso da pilha pode ser ilimitado

-Wunsafe-loop-otimizações
Avisa se o loop não pode ser otimizado porque o compilador não pode assumir nada em
os limites dos índices do loop. Com -funsafe-loop-otimizations avisar se o compilador
fez tais suposições.

- Formato Wno-pedante-ms (Apenas alvos MinGW)
Desativa os avisos sobre especificadores de largura de formato "printf" / "scanf" não ISO "I32",
"I64" e "I" usados ​​em alvos do Windows dependendo do tempo de execução do MS, quando você estiver usando
as opções -Wformato e -pedante sem extensões GNU.

-Wpointer-arith
Avise sobre qualquer coisa que dependa do "tamanho" de um tipo de função ou de "vazio". GNU C
atribui a esses tipos um tamanho de 1, por conveniência em cálculos com "void *"
ponteiros e ponteiros para funções. Em C ++, avisa também quando uma operação aritmética
envolve "NULL". Este aviso também é habilitado por -pedante.

-Limites de tipo
Avisa se uma comparação é sempre verdadeira ou sempre falsa devido ao intervalo limitado do
tipo de dados, mas não avisa sobre expressões constantes. Por exemplo, avisar se um não assinado
variável é comparada contra zero com < or >=. Este aviso também é habilitado por
-Wextra.

-Wbad-função-cast (C e Objective-C apenas)
Avisa sempre que uma chamada de função é convertida em um tipo não correspondente. Por exemplo, avise se
"int malloc ()" é convertido em "qualquer coisa *".

-Wc ++ - compat (C e Objective-C apenas)
Avisar sobre construções ISO C que estão fora do subconjunto comum de ISO C e ISO
C ++, por exemplo, solicitação de conversão implícita de "void *" para um ponteiro para não "nulo"
tipo.

-Wc ++ 11-compat (Apenas C ++ e Objective-C ++)
Avisar sobre construções C ++ cujo significado difere entre ISO C ++ 1998 e ISO C ++ 2011,
por exemplo, identificadores em ISO C ++ 1998 que são palavras-chave em ISO C ++ 2011. Este aviso
liga -Aviso e é habilitado por -Parede.

-qualidade wcast
Avisa sempre que um ponteiro é lançado para remover um qualificador de tipo do tipo de destino.
Por exemplo, avisa se um "const char *" é convertido em um "char *" comum.

Também avisa ao fazer uma conversão que introduz um qualificador de tipo de maneira insegura. Para
exemplo, lançar "char **" para "const char **" não é seguro, como neste exemplo:

/ * p é o valor char **. * /
const char ** q = (const char **) p;
/ * Atribuição de string somente leitura para const char * está OK. * /
* q = "string";
/ * Agora o ponteiro char ** aponta para a memória somente leitura. * /
** p = 'b';

-Wcast-align
Avisa sempre que um ponteiro é lançado de forma que o alinhamento necessário do alvo seja
aumentou. Por exemplo, avisa se um "char *" é convertido para um "int *" em máquinas onde
inteiros só podem ser acessados ​​em limites de dois ou quatro bytes.

-Wwrite-strings
Ao compilar C, dê às constantes de string o tipo "const char [comprimento]" de modo que copiar
o endereço de um em um ponteiro não "const" "char *" receberá um aviso. Esses
avisos irão ajudá-lo a encontrar em tempo de compilação o código que pode tentar escrever em uma string
constante, mas apenas se você tiver sido muito cuidadoso ao usar "const" nas declarações
e protótipos. Caso contrário, será apenas um incômodo. É por isso que não fizemos
-Parede solicitar esses avisos.

Ao compilar C ++, avise sobre a conversão obsoleta de literais de string para "char
* ". Este aviso é ativado por padrão para programas C ++.

-Wclobbered
Avisar sobre variáveis ​​que podem ser alteradas por long jmp or garfo. Este aviso também é
ativado por -Wextra.

-Wconversão
Avisa para conversões implícitas que podem alterar um valor. Isso inclui conversões
entre real e inteiro, como "abs (x)" quando "x" é "duplo"; conversões entre
assinado e não assinado, como "unsigned ui = -1"; e conversões para tipos menores, como
"sqrtf (M_PI)". Não avise para conversões explícitas como "abs ((int) x)" e "ui =
(sem sinal) -1 ", ou se o valor não for alterado pela conversão como em" abs (2.0) ".
Avisos sobre conversões entre inteiros assinados e não assinados podem ser desativados por
utilização -Wno-sign-conversão.

Para C ++, também avise para resolução de sobrecarga confusa para conversões definidas pelo usuário; e
conversões que nunca usarão um operador de conversão de tipo: conversões para "void", o
mesmo tipo, uma classe base ou uma referência a eles. Avisos sobre conversões entre
inteiros assinados e não assinados são desabilitados por padrão em C ++, a menos que -Conversão de sinal
está explicitamente habilitado.

-Wno-conversão-nulo (Apenas C ++ e Objective-C ++)
Não avise sobre conversões entre os tipos "NULL" e não apontadores. -Wconversion-nulo is
habilitado por padrão.

-Wzero-as-null-ponteiro-constante (Apenas C ++ e Objective-C ++)
Avisa quando um '0' literal é usado como constante de ponteiro nulo. Isso pode ser útil para
facilitar a conversão para "nullptr" em C ++ 11.

-Corpo-vazio
Avisa se um corpo vazio ocorre em um if, outro or do enquanto demonstração. Este aviso é
também habilitado por -Wextra.

-Wenum-comparar
Avise sobre uma comparação entre valores de diferentes tipos enumerados. Em C ++ enumeral
incompatibilidades em expressões condicionais também são diagnosticadas e o aviso é habilitado por
predefinição. Em C, este aviso é habilitado por -Parede.

-Wjump-misses-init (C, Objective-C apenas)
Avisa se uma instrução "goto" ou uma instrução "switch" salta para a frente no
inicialização de uma variável ou salta para trás para um rótulo após a variável ter sido
inicializado. Isso só avisa sobre variáveis ​​que são inicializadas quando são
declarado. Este aviso é compatível apenas com C e Objective-C; em C ++ este tipo de
ramo é um erro em qualquer caso.

-Wjump-misses-init está incluído no -Wc ++ - compat. Pode ser desativado com o
-Wno-jump-misses-init opção.

-Wsign-comparar
Avisa quando uma comparação entre valores com e sem sinal pode produzir um erro
resultado quando o valor com sinal é convertido em sem sinal. Este aviso também está habilitado
by -Wextra; para obter os outros avisos de -Wextra sem este aviso, use -Wextra
-Wno-sinal-comparar.

-Conversão de sinal
Avisar sobre conversões implícitas que podem alterar o sinal de um valor inteiro, como
atribuir uma expressão de número inteiro com sinal a uma variável de número inteiro sem sinal. Um explícito
elenco silencia o aviso. Em C, esta opção é habilitada também por -Wconversão.

-Endereço
Avise sobre usos suspeitos de endereços de memória. Isso inclui o uso do endereço de um
função em uma expressão condicional, como "void func (void); if (func)", e
comparações com o endereço de memória de um literal de string, como "if (x ==" abc ")".
Esses usos normalmente indicam um erro do programador: o endereço de uma função sempre
avalia como verdadeiro, então seu uso em uma condição geralmente indica que o programador
esqueceu os parênteses em uma chamada de função; e comparações com literais de string
resultam em comportamento não especificado e não são portáteis em C, então eles geralmente indicam
que o programador pretendia usar "strcmp". Este aviso é habilitado por -Parede.

-Wlógico-op
Avise sobre usos suspeitos de operadores lógicos em expressões. Isso inclui o uso de
operadores lógicos em contextos onde um operador bit a bit é provavelmente esperado.

-Waggregate-retorno
Avisa se alguma função que retorna estruturas ou uniões é definida ou chamada. (No
linguagens em que você pode retornar uma matriz, isso também provoca um aviso.)

-Wno-atributos
Não avise se um "__attribute__" inesperado for usado, como atributos não reconhecidos,
atributos de função aplicados a variáveis, etc. Isso não impedirá erros para
uso incorreto de atributos suportados.

-Wno-builtin-macro-redefinido
Não avise se certas macros integradas forem redefinidas. Isso suprime avisos para
redefinição de "__TIMESTAMP__", "__TIME__", "__DATE__", "__FILE__" e
"__BASE_FILE__".

-Wstrict-protótipos (C e Objective-C apenas)
Avisa se uma função é declarada ou definida sem especificar os tipos de argumento. (Um
a definição de função no estilo antigo é permitida sem aviso se precedida por um
declaração que especifica os tipos de argumento.)

-Declaração de estilo antigo (C e Objective-C apenas)
Avisar sobre utilizações obsoletas, de acordo com a Norma C, em declaração. Para
exemplo, avisar se especificadores de classe de armazenamento como "estático" não são as primeiras coisas em um
declaração. Este aviso também é habilitado por -Wextra.

-Definição de estilo antigo (C e Objective-C apenas)
Avisa se uma definição de função no estilo antigo é usada. Um aviso é dado mesmo se houver
um protótipo anterior.

- Tipo de parâmetro ausente (C e Objective-C apenas)
Um parâmetro de função é declarado sem um especificador de tipo nas funções de estilo K e R:

void foo (bar) {}

Este aviso também é habilitado por -Wextra.

-Protótipos-saudade (C e Objective-C apenas)
Avisa se uma função global é definida sem uma declaração de protótipo anterior. Esse
o aviso é emitido mesmo se a própria definição fornecer um protótipo. O objetivo é
detectar funções globais que não são declaradas em arquivos de cabeçalho.

-Declarações-saudações
Avisa se uma função global é definida sem uma declaração prévia. Faça isso mesmo se
a própria definição fornece um protótipo. Use esta opção para detectar global
funções que não são declaradas em arquivos de cabeçalho. Em C ++, nenhum aviso é emitido para
modelos de função ou para funções embutidas ou para funções em namespaces anônimos.

-Wmissing-field-inicializadores
Avisa se o inicializador de uma estrutura tem alguns campos faltando. Por exemplo, o seguinte
código causaria esse aviso, porque "xh" é implicitamente zero:

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

Esta opção não avisa sobre inicializadores designados, então a seguinte modificação
não acionaria um aviso:

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

Este aviso está incluído em -Wextra. Para conseguir outro -Wextra avisos sem este,
usar -Wextra -Wno-missing-field-inicializadores.

- Atributo de formato de saudação
Avise sobre ponteiros de função que podem ser candidatos a atributos de "formato". Observação
esses são apenas candidatos possíveis, não absolutos. GCC vai adivinhar essa função
ponteiros com atributos de "formato" que são usados ​​na atribuição, inicialização,
passagem de parâmetro ou instruções de retorno devem ter um atributo "formato" correspondente
no tipo resultante. Ou seja, o lado esquerdo da atribuição ou inicialização,
o tipo da variável de parâmetro ou o tipo de retorno da função que o contém
respectivamente, também deve ter um atributo "format" para evitar o aviso.

O GCC também avisará sobre as definições de função que podem ser candidatas a "formato"
atributos. Novamente, esses são apenas candidatos possíveis. GCC vai adivinhar que "formato"
atributos podem ser apropriados para qualquer função que chame uma função como "vprintf"
ou "vscanf", mas pode não ser sempre o caso, e algumas funções para as quais
Os atributos "format" apropriados podem não ser detectados.

-Wno-multichar
Não avise se uma constante de vários caracteres ('FOOF') é usado. Normalmente eles indicam um
erro de digitação no código do usuário, pois eles têm valores definidos pela implementação e não devem ser
usado em código portátil.

-Wnormalized =
Em ISO C e ISO C ++, dois identificadores são diferentes se forem sequências diferentes de
personagens. No entanto, às vezes quando os caracteres fora do conjunto de caracteres ASCII básico
são usados, você pode ter duas sequências de caracteres diferentes que parecem iguais. Evitar
confusão, o padrão ISO 10646 estabelece alguns normalização regras que quando aplicado
certifique-se de que duas sequências que parecem iguais sejam transformadas na mesma sequência. GCC
pode avisá-lo se você estiver usando identificadores que não foram normalizados; esta opção
controla esse aviso.

Existem quatro níveis de aviso suportados pelo GCC. O padrão é -Wnormalized = nfc,
que avisa sobre qualquer identificador que não esteja na forma normalizada ISO 10646 "C",
NFC. NFC é a forma recomendada para a maioria dos usos.

Infelizmente, existem alguns caracteres permitidos em identificadores por ISO C e ISO C ++
que, quando transformados em NFC, não são permitidos nos identificadores. Ou seja, não tem como
para usar esses símbolos em ISO C ou C ++ portátil e ter todos os seus identificadores em NFC.
-Wnormalized = id suprime o aviso para esses caracteres. Espera-se que o futuro
versões dos padrões envolvidos irão corrigir isso, razão pela qual esta opção não é
o padrão.

Você pode desligar o aviso para todos os caracteres, escrevendo -Wnormalized = nenhum. Você
só iria querer fazer isso se você estivesse usando algum outro esquema de normalização (como
"D"), porque, de outra forma, você pode facilmente criar bugs que são literalmente impossíveis de
ver.

Alguns caracteres em ISO 10646 têm significados distintos, mas parecem idênticos em algumas fontes
ou metodologias de exibição, especialmente depois que a formatação foi aplicada. Por exemplo
"\ u207F", "SUPERSCRIPT LATIN SMALL LETTER N" será exibido como um "n" normal
que foi colocado em um sobrescrito. ISO 10646 define o NFKC normalização
esquema para converter tudo isso em um formato padrão também, e o GCC irá avisar se o seu
o código não está em NFKC se você usar -Wnormalized = nfkc. Este aviso é comparável a
aviso sobre cada identificador que contém a letra O porque pode ser confuso
com o dígito 0 e, portanto, não é o padrão, mas pode ser útil como uma codificação local
convenção se o ambiente de programação não puder ser corrigido para exibi-los
personagens distintamente.

-Wno-obsoleto
Não avise sobre o uso de recursos obsoletos.

-Wno-declarações-depreciadas
Não avise sobre o uso de funções, variáveis ​​e tipos marcados como obsoletos por
usando o atributo "obsoleto".

-Wno-estouro
Não avise sobre estouro de tempo de compilação em expressões constantes.

-Woverride-init (C e Objective-C apenas)
Avisa se um campo inicializado sem efeitos colaterais é sobrescrito ao usar o
inicializadores.

Este aviso está incluído em -Wextra. Para conseguir outro -Wextra avisos sem este,
usar -Wextra -Wno-override-init.

-Embalado
Avisa se uma estrutura recebe o atributo empacotado, mas o atributo empacotado não tem
efeito sobre o layout ou tamanho da estrutura. Essas estruturas podem estar desalinhadas para
pouco benefício. Por exemplo, neste código, a variável "fx" em "struct bar" irá
ser desalinhado, embora "struct bar" não tenha o atributo compactado:

estrutura foo {
int x;
caracter a, b, c, d;
} __attribute __ ((embalado));
barra de estrutura {
caractere z;
struct fo f;
};

-Wpacked-bitfield-compatível
As séries 4.1, 4.2 e 4.3 do GCC ignoram o atributo "compactado" em campos de bits do tipo
"Caracteres". Isso foi corrigido no GCC 4.4, mas a mudança pode levar a diferenças no
layout da estrutura. O GCC informa quando o deslocamento de tal campo mudou no GCC
4.4. Por exemplo, não há mais um preenchimento de 4 bits entre os campos "a" e "b" neste
estrutura:

estrutura foo
{
char a: 4;
char b: 8;
} __attribute__ ((embalado));

Este aviso é habilitado por padrão. Usar -Wno-pack-bitfield-compat para desabilitar isso
Atenção.

-W acolchoado
Avisa se o preenchimento está incluído em uma estrutura, seja para alinhar um elemento do
estrutura ou para alinhar toda a estrutura. Às vezes, quando isso acontece, é possível
para reorganizar os campos da estrutura para reduzir o preenchimento e assim fazer o
estrutura menor.

-Wredundant-decls
Avisa se algo for declarado mais de uma vez no mesmo escopo, mesmo nos casos em que
declaração múltipla é válida e não muda nada.

-Wnested-externos (C e Objective-C apenas)
Avisa se uma declaração "externa" for encontrada em uma função.

-Winline
Avisa se uma função não pode ser embutida e foi declarada como embutida. Mesmo com isso
opção, o compilador não avisará sobre falhas nas funções inline declaradas em
cabeçalhos do sistema.

O compilador usa uma variedade de heurísticas para determinar se deve ou não embutir um
função. Por exemplo, o compilador leva em consideração o tamanho da função que está sendo
inline e a quantidade de inline que já foi feita na função atual.
Portanto, mudanças aparentemente insignificantes no programa de origem podem causar o
avisos produzidos por -Winline aparecer ou desaparecer.

-Wno-inválido-offsetof (Apenas C ++ e Objective-C ++)
Suprimir avisos de aplicação do deslocamento de macro para um tipo não-POD. De acordo com
o padrão ISO C ++ de 1998, aplicando deslocamento de para um tipo não-POD é indefinido. No
implementações C ++ existentes, no entanto, deslocamento de normalmente dá resultados significativos
mesmo quando aplicado a certos tipos de tipos não POD. (Como um simples struct que
falha em ser um tipo de POD apenas em virtude de ter um construtor.) Este sinalizador é para
usuários que estão cientes de que estão escrevendo um código não portável e que deliberadamente
optou por ignorar o aviso sobre isso.

As restrições sobre deslocamento de pode ser relaxado em uma versão futura do padrão C ++.

-Wno-int-para-ponteiro-cast
Suprime os avisos de conversões para o tipo de ponteiro de um inteiro de tamanho diferente. No
C ++, converter para um tipo de ponteiro de tamanho menor é um erro. Elenco de Wint para ponteiro is
habilitado por padrão.

-Wno-ponteiro-para-int-cast (C e Objective-C apenas)
Suprime os avisos de projeções de um ponteiro para um tipo inteiro de tamanho diferente.

-Winvalid-pch
Avisa se um cabeçalho pré-compilado for encontrado no caminho de pesquisa, mas não puder ser usado.

-Muito longo
Avisar se longo longo tipo é usado. Isso é habilitado por qualquer -pedante or -Wtradicional
nos modos ISO C90 e C ++ 98. Para inibir as mensagens de aviso, use -Não-longo-longo.

-Wvariádicos-macros
Avisar se macros variáveis ​​são usadas no modo pedante ISO C90 ou na sintaxe alternativa GNU
quando no modo pedante ISO C99. Este é o padrão. Para inibir as mensagens de aviso, use
-Wno-variádicos-macros.

-Wector-operation-performance
Avisa se a operação do vetor não é implementada por meio dos recursos SIMD da arquitetura.
Principalmente útil para o ajuste de desempenho. A operação vetorial pode ser implementada
"por partes", o que significa que a operação escalar é realizada em cada vetor
elemento; "em paralelo", o que significa que a operação vetorial é implementada usando
escalares de tipo mais amplo, que normalmente é mais eficiente em termos de desempenho; e "como um único
escalar ", o que significa que o vetor se ajusta a um tipo escalar.

-Wvla
Avisa se a matriz de comprimento variável é usada no código. -Wno-vla irá prevenir o
-pedante aviso da matriz de comprimento variável.

-Wvolatile-registro-var
Avisa se uma variável de registro é declarada volátil. O modificador volátil não
inibir todas as otimizações que podem eliminar leituras e / ou gravações para registrar
variáveis. Este aviso é habilitado por -Parede.

-Wdisabled-otimização
Avisa se um passo de otimização solicitado está desabilitado. Este aviso geralmente não
indicar que há algo errado com seu código; simplesmente indica que o GCC
otimizadores não conseguiram lidar com o código de forma eficaz. Muitas vezes, o problema é que
seu código é muito grande ou muito complexo; O GCC se recusará a otimizar programas quando o
a própria otimização provavelmente levará muito tempo.

-Wpointer-sinal (C e Objective-C apenas)
Avisa para passagem de argumento de ponteiro ou atribuição com sinalização diferente. Esse
opção só é suportada para C e Objective-C. Está implícito por -Parede e por
-pedante, que pode ser desativado com -Wno-sinal de ponteiro.

-Wstack-protetor
Esta opção só está ativa quando -fstack-protetor está ativo. Avisa sobre funções
que não será protegido contra quebra de pilha.

-Sem pára-lamas
Suprimir avisos sobre construções que não podem ser instrumentadas por -fmudflap.

-Woverlength-strings
Avisar sobre constantes de string maiores que o comprimento "máximo mínimo"
especificado no padrão C. Compiladores modernos geralmente permitem constantes de string que
são muito mais longos do que o limite mínimo do padrão, mas programas muito portáteis devem
evite usar strings mais longas.

O limite se aplica depois de concatenação de constante de string, e não conta o
NUL. No C90, o limite era de 509 caracteres; em C99, foi aumentado para 4095. C ++ 98
não especificar um máximo mínimo normativo, portanto, não diagnosticamos strings de comprimento excessivo em
C ++.

Esta opção está implícita em -pedante, e pode ser desativado com -Wno-overlength-strings.

-Wunsuffixed-float-constantes (C e Objective-C apenas)
O GCC emitirá um aviso para qualquer constante flutuante que não tenha um sufixo. Quando
usado junto com -Wsystem-cabeçalhos irá avisar sobre tais constantes no cabeçalho do sistema
arquivos. Isso pode ser útil ao preparar o código para usar com o "FLOAT_CONST_DECIMAL64"
pragma da extensão de ponto flutuante decimal para C99.

Opções for depuração investimentos Agenda or GCC
O GCC tem várias opções especiais que são usadas para depurar seu programa ou GCC:

-g Produzir informações de depuração no formato nativo do sistema operacional (stabs, COFF,
XCOFF ou DWARF 2). O GDB pode trabalhar com essas informações de depuração.

Na maioria dos sistemas que usam o formato stabs, -g permite o uso de informações extras de depuração
que apenas GDB pode usar; esta informação extra faz com que a depuração funcione melhor no GDB, mas
provavelmente fará com que outros depuradores travem ou se recusem a ler o programa. Se você quiser
para controlar com certeza se deve gerar as informações extras, use -gstabs +,
-gstabs, -gxcoff +, -gxcoffou -gvms (ver abaixo).

GCC permite que você use -g com -O. Os atalhos tomados pelo código otimizado podem
ocasionalmente produzem resultados surpreendentes: algumas variáveis ​​que você declarou podem não existir em
tudo; o fluxo de controle pode mover-se brevemente para onde você não esperava; algumas declarações podem
não podem ser executados porque calculam resultados constantes ou seus valores já estavam em
mão; algumas instruções podem ser executadas em locais diferentes porque foram retiradas de
rotações.

No entanto, é possível depurar a saída otimizada. Isso o torna razoável
para usar o otimizador para programas que podem ter bugs.

As seguintes opções são úteis quando o GCC é gerado com a capacidade de mais
de um formato de depuração.

-ggdb
Produza informações de depuração para uso pelo GDB. Isso significa usar o mais expressivo
formato disponível (DWARF 2, stabs, ou o formato nativo se nenhum deles for
suportado), incluindo extensões GDB, se possível.

-gstabs
Produzir informações de depuração em formato stabs (se houver suporte), sem GDB
extensões. Este é o formato usado pelo DBX na maioria dos sistemas BSD. No MIPS, Alpha e
Sistemas System V Release 4, esta opção produz uma saída de depuração de stabs que não é
compreendido por DBX ou SDB. Em sistemas System V Release 4, esta opção requer o GNU
para montar.

-feliminar-símbolos-de-depuração-não-usados
Produz informações de depuração em formato stabs (se houver suporte), apenas para símbolos
que são realmente usados.

-femit-class-debug-sempre
Em vez de emitir informações de depuração para uma classe C ++ em apenas um arquivo de objeto,
emita-o em todos os arquivos de objeto que usam a classe. Esta opção deve ser usada apenas com
depuradores que são incapazes de lidar com a maneira como o GCC normalmente emite informações de depuração
para classes porque usar esta opção aumentará o tamanho das informações de depuração
por até um fator de dois.

-fno-debug-types-seção
Por padrão, ao usar DWARF v4 ou superior, os DIEs serão colocados em seus próprios
seção .debug_types em vez de torná-los parte da seção .debug_info. Isto é
mais eficiente colocá-los em seções separadas do comdat, pois o linker será
capaz de remover duplicatas. Mas nem todos os consumidores DWARF suportam seções .debug_types
ainda.

-gstabs +
Produza informações de depuração em formato stabs (se houver suporte), usando GNU
extensões compreendidas apenas pelo depurador GNU (GDB). O uso dessas extensões é
provavelmente fará outros depuradores travarem ou se recusarem a ler o programa.

-gcoff
Produza informações de depuração no formato COFF (se houver suporte). Isto é o
formato usado pelo SDB na maioria dos sistemas System V antes do System V Release 4.

-gxcoff
Produza informações de depuração no formato XCOFF (se houver suporte). Isto é o
formato usado pelo depurador DBX em sistemas IBM RS / 6000.

-gxcoff +
Produza informações de depuração no formato XCOFF (se houver suporte), usando GNU
extensões compreendidas apenas pelo depurador GNU (GDB). O uso dessas extensões é
provavelmente fará outros depuradores travarem ou se recusarem a ler o programa, e pode causar
assemblers diferentes do GNU assembler (GAS) falharão com um erro.

-gdwarf-versão
Produza informações de depuração no formato DWARF (se houver suporte). Isto é o
formato usado por DBX no IRIX 6. O valor de versão pode ser 2, 3 ou 4; a
a versão padrão é 2.

Observe que, com DWARF versão 2, algumas portas exigem, e sempre usarão, algumas
extensões DWARF 3 conflitantes nas tabelas de desenrolamento.

A versão 4 pode exigir GDB 7.0 e -fvar-atribuições de rastreamento para o benefício máximo.

-grecord-gcc-switches
Esta opção faz com que as opções de linha de comando usadas para invocar o compilador que pode
afetar a geração de código a ser anexado ao atributo DW_AT_producer em DWARF
informações de depuração. As opções são concatenadas com espaços separando-as do
uns aos outros e da versão do compilador. Veja também -frecord-gcc-switches para outro
maneira de armazenar opções do compilador no arquivo de objeto.

-gno-record-gcc-switches
Não permitir o acréscimo de opções de linha de comando ao atributo DW_AT_producer em DWARF
informações de depuração. Este é o padrão.

-gstrict-anão
Não permitir o uso de extensões da versão padrão DWARF posterior à selecionada com
-gdwarf-versão. Na maioria dos alvos usando extensões DWARF não conflitantes posteriores
versões padrão são permitidas.

-gno-estrito-anão
Permitir o uso de extensões da versão padrão DWARF posterior à selecionada com
-gdwarf-versão.

-gvms
Produza informações de depuração no formato de depuração VMS (se houver suporte). Isto é o
formato usado por DEBUG em sistemas VMS.

-gnível
-ggdbnível
-gstabsnível
-gcoffnível
-gxcoffnível
-gvmsnível
Solicite informações de depuração e também use nível para especificar quanta informação. o
o nível padrão é 2.

O nível 0 não produz nenhuma informação de depuração. Assim, -g0 nega -g.

O nível 1 produz informações mínimas, o suficiente para fazer retrocessos em partes do
programa que você não planeja depurar. Isso inclui descrições de funções e
variáveis ​​externas, mas nenhuma informação sobre variáveis ​​locais e nenhum número de linha.

O nível 3 inclui informações extras, como todas as definições de macro presentes no
programa. Alguns depuradores suportam expansão de macro quando você usa -g3.

-gdwarf-2 não aceita um nível de depuração concatenado, porque o GCC costumava oferecer suporte a um
opção -anão que pretendia gerar informações de depuração na versão 1 do DWARF
formato (que é muito diferente da versão 2), e teria sido muito confuso.
Esse formato de depuração está obsoleto há muito tempo, mas a opção não pode ser alterada agora. Em vez disso, use
um adicional -gnível opção para alterar o nível de depuração para DWARF.

-gtoggle
Desative a geração de informações de depuração, se deixar esta opção geraria isso,
ou ligue-o no nível 2, caso contrário. A posição deste argumento na linha de comando
não importa, ele entra em vigor depois que todas as outras opções são processadas, e faz isso
apenas uma vez, não importa quantas vezes seja dado. Destina-se principalmente a ser usado
com -fcompare-depurar.

-fdump-finais-insns[=lima]
Despeje a representação interna final (RTL) para lima. Se o argumento opcional for
omitido (ou se lima é "."), o nome do arquivo de despejo será determinado anexando
".gkd" para o nome do arquivo de saída da compilação.

-fcompare-depurar[=opta]
Se nenhum erro ocorrer durante a compilação, execute o compilador uma segunda vez, adicionando opta e
-fcompare-debug-segundo aos argumentos passados ​​para a segunda compilação. Jogue o
representação interna final em ambas as compilações e imprime um erro se forem diferentes.

Se o sinal de igual for omitido, o padrão -gtoggle é usado.

A variável de ambiente GCC_COMPARE_DEBUG, se definido, não vazio e diferente de zero,
habilita implicitamente -fcompare-depurar. Se GCC_COMPARE_DEBUG é definido como uma string
começando com um traço, então é usado para opta, caso contrário, o padrão -gtoggle is
usava.

-fcompare-debug =, com o sinal de igual, mas sem opta, é equivalente a
-fno-compare-depurar, o que desabilita o despejo da representação final e do
segunda compilação, impedindo até GCC_COMPARE_DEBUG de fazer efeito.

Para verificar a cobertura total durante -fcompare-depurar teste, conjunto GCC_COMPARE_DEBUG dizer
-fcompare-debug-não-substituído, que o GCC rejeitará como uma opção inválida em qualquer
compilação real (em vez de pré-processamento, montagem ou vinculação). Para obter apenas um
aviso, configuração GCC_COMPARE_DEBUG para -w% n-fcompare-debug não sobrescrito vai fazer.

-fcompare-debug-segundo
Esta opção é passada implicitamente ao compilador para a segunda compilação solicitada
by -fcompare-depurar, junto com opções para silenciar avisos e omitir outras opções
que causaria saídas do compilador de efeito colateral para arquivos ou para a saída padrão.
Arquivos de despejo e arquivos temporários preservados são renomeados para conter o ".gk"
extensão adicional durante a segunda compilação, para evitar sobrescrever aqueles
gerado pelo primeiro.

Quando esta opção é passada para o driver do compilador, faz com que o primeiro compilação para
ser ignorado, o que o torna útil apenas para depurar o compilador adequado.

-feliminar-anão2-dups
Compacte as informações de depuração DWARF2 eliminando informações duplicadas sobre cada
símbolo. Esta opção só faz sentido ao gerar informações de depuração DWARF2
com -gdwarf-2.

-femit-struct-debug-baseonly
Emita informações de depuração para tipos semelhantes a estruturas apenas quando o nome de base do
o arquivo de origem da compilação corresponde ao nome base do arquivo no qual a estrutura foi definida.

Esta opção reduz substancialmente o tamanho das informações de depuração, mas em
perda potencial significativa de informações de tipo para o depurador. Ver
-femit-struct-debug-reduzido para uma opção menos agressiva. Ver
-femit-struct-debug-Detailed para um controle mais detalhado.

Esta opção funciona apenas com DWARF 2.

-femit-struct-debug-reduzido
Emita informações de depuração para tipos semelhantes a estruturas apenas quando o nome de base do
arquivo fonte de compilação corresponde ao nome base do arquivo no qual o tipo foi definido,
a menos que a estrutura seja um modelo ou definida em um cabeçalho do sistema.

Esta opção reduz significativamente o tamanho das informações de depuração, com alguns
perda potencial de informações de tipo para o depurador. Ver -femit-struct-debug-baseonly
para uma opção mais agressiva. Ver -femit-struct-debug-Detailed para mais detalhado
controlar.

Esta opção funciona apenas com DWARF 2.

-femit-struct-debug-Detailed[=lista de especificações]
Especifique os tipos de estrutura para os quais o compilador gerará informações de depuração.
A intenção é reduzir as informações de depuração de estrutura duplicadas entre objetos diferentes
arquivos dentro do mesmo programa.

Esta opção é uma versão detalhada de -femit-struct-debug-reduzido e
-femit-struct-debug-baseonly, que atenderá à maioria das necessidades.

Uma especificação tem a sintaxe [é:|ind:][ordem:|gênero:](qualquer|sys|base|Nenhum)

A primeira palavra opcional limita a especificação às estruturas que são usadas diretamente
(é:) ou usado indiretamente (ind:) Um tipo de estrutura é usado diretamente quando é o tipo
de uma variável, membro. Os usos indiretos surgem por meio de indicadores para estruturas. Isso é,
quando o uso de uma estrutura incompleta for legal, o uso é indireto. Um exemplo é
struct um direto; struct dois * indireto;.

A segunda palavra opcional limita a especificação de estruturas comuns (ordem:) ou
estruturas genéricas (gênero:) Estruturas genéricas são um pouco complicadas de explicar. Para C ++,
essas são especializações não explícitas de classes de modelo ou classes não de modelo
dentro do acima. Outras linguagens de programação têm genéricos, mas
-femit-struct-debug-Detailed ainda não os implementa.

A terceira palavra especifica os arquivos de origem para aquelas estruturas para as quais o compilador
irá emitir informações de depuração. Os valores Nenhum e qualquer tem o significado normal. o
valor base significa que a base do nome do arquivo em que a declaração de tipo
aparece deve corresponder à base do nome do arquivo de compilação principal. Na prática,
isso significa que os tipos declarados em foo.c e foo.h terá informações de depuração, mas
tipos declarados em outro cabeçalho não. O valor que sys significa que esses tipos satisfazem
base ou declarado nos cabeçalhos do sistema ou do compilador.

Você pode precisar fazer experiências para determinar as melhores configurações para seu aplicativo.

O padrão é -femit-struct-debug-Detailed = all.

Esta opção funciona apenas com DWARF 2.

-fno-merge-debug-strings
Direcione o vinculador para não mesclar strings nas informações de depuração que são
idênticos em diferentes arquivos de objeto. A mesclagem não é suportada por todos os montadores ou
linkers. A fusão diminui o tamanho das informações de depuração no arquivo de saída em
o custo de aumentar o tempo de processamento do link. A mesclagem está habilitada por padrão.

-fdebug-prefix-map =velho=novo
Ao compilar arquivos no diretório velho, registre informações de depuração descrevendo-as como
in novo ao invés.

-fno-dwarf2-cfi-asm
Emita informações de desenrolamento DWARF 2 conforme a seção ".eh_frame" gerada pelo compilador em vez de usar
Diretivas GAS ".cfi_ *".

-p Gere código extra para escrever informações de perfil adequadas para o programa de análise
prof. Você deve usar esta opção ao compilar os arquivos de origem sobre os quais deseja dados,
e você também deve usá-lo ao vincular.

-pg Gere código extra para escrever informações de perfil adequadas para o programa de análise
gprof. Você deve usar esta opção ao compilar os arquivos de origem sobre os quais deseja dados,
e você também deve usá-lo ao vincular.

-Q Faz com que o compilador imprima cada nome de função à medida que é compilado e imprime alguns
estatísticas sobre cada passagem quando ela termina.

-ftime-relatório
Faz com que o compilador imprima algumas estatísticas sobre o tempo consumido por cada passagem quando
termina.

-fmem-relatório
Faz com que o compilador imprima algumas estatísticas sobre a alocação de memória permanente quando
termina.

-fpre-ipa-mem-relatório
-fpost-ipa-mem-relatório
Faz com que o compilador imprima algumas estatísticas sobre a alocação de memória permanente antes ou
após a otimização interprocedural.

-fstack-uso
Faz com que o compilador produza informações de uso da pilha para o programa, por função
base. O nome do arquivo para o despejo é feito anexando .su ao nome auxiliar. nome auxiliar is
gerado a partir do nome do arquivo de saída, se especificado explicitamente e não é um
executável, caso contrário, é o nome de base do arquivo de origem. Uma entrada é composta de
três campos:

· O nome da função.

· Vários bytes.

· Um ou mais qualificadores: "estático", "dinâmico", "limitado".

O qualificador "estático" significa que a função manipula a pilha estaticamente: a
número fixo de bytes são alocados para o quadro na entrada da função e liberados na
saída de função; nenhum ajuste de pilha é feito de outra forma na função. O segundo
campo é este número fixo de bytes.

O qualificador "dinâmico" significa que a função manipula a pilha dinamicamente: em
além da alocação estática descrita acima, os ajustes de pilha são feitos no
corpo da função, por exemplo, para empurrar / pop argumentos em torno das chamadas de função. Se o
qualificador "limitado" também está presente, o valor desses ajustes é limitado a
tempo de compilação e o segundo campo é um limite superior da quantidade total de pilha usada
pela função. Se não estiver presente, o valor desses ajustes não é limitado
em tempo de compilação e o segundo campo representa apenas a parte limitada.

-fprofile-arcos
Adicione o código para que o fluxo do programa arcos são instrumentados. Durante a execução do programa
registra quantas vezes cada ramal e chamada é executada e quantas vezes é realizada
ou retorna. Quando o programa compilado sai, ele salva esses dados em um arquivo chamado
nomeaux.gcda para cada arquivo de origem. Os dados podem ser usados ​​para direcionados a perfis
otimizações (-fbranch-probabilidades), ou para análise de cobertura de teste
(-teste-cobertura) Cada arquivo de objeto nome auxiliar é gerado a partir do nome do
arquivo de saída, se especificado explicitamente e não é o executável final, caso contrário,
é o nome de base do arquivo de origem. Em ambos os casos, qualquer sufixo é removido (por exemplo
foo.gcda para arquivo de entrada dir / foo.cou dir / foo.gcda para arquivo de saída especificado como -o
dir / foo.o).

--cobertura
Esta opção é usada para compilar e vincular o código instrumentado para análise de cobertura. o
opção é um sinônimo de -fprofile-arcos -teste-cobertura (ao compilar) e -lgcov
(ao vincular). Consulte a documentação dessas opções para obter mais detalhes.

· Compilar os arquivos de origem com -fprofile-arcos além de otimização e geração de código
opções. Para análise de cobertura de teste, use o adicional -teste-cobertura opção.
Você não precisa criar o perfil de cada arquivo de origem em um programa.

· Vincule seus arquivos de objeto com -lgcov or -fprofile-arcos (o último implica o
antigo).

· Executar o programa em uma carga de trabalho representativa para gerar o perfil do arco
em formação. Isso pode ser repetido várias vezes. Você pode executar simultaneamente
instâncias do seu programa, e desde que o sistema de arquivos suporte bloqueio, o
os arquivos de dados serão atualizados corretamente. Além disso, chamadas "fork" são detectadas e
tratada corretamente (contagem dupla não acontecerá).

· Para otimizações direcionadas ao perfil, compilar os arquivos de origem novamente com o mesmo
opções de otimização e geração de código mais -fbranch-probabilidades.

· Para análise de cobertura de teste, use gcov para produzir informações legíveis por humanos de
da .gcno e .gcda arquivos. Consulte o gcov documentação para mais
informações.

Com -fprofile-arcos, para cada função do seu programa, o GCC cria um fluxo de programa
gráfico, em seguida, encontra uma árvore de abrangência para o gráfico. Apenas arcos que não estão no
árvore de abrangência deve ser instrumentada: o compilador adiciona código para contar o número de
vezes que esses arcos são executados. Quando um arco é a única saída ou única entrada para
um bloco, o código de instrumentação pode ser adicionado ao bloco; caso contrário, um novo básico
bloco deve ser criado para conter o código de instrumentação.

-teste-cobertura
Produza um arquivo de notas que o gcov o utilitário de cobertura de código pode usar para mostrar o programa
cobertura. Cada arquivo de nota do arquivo fonte é chamado nomeaux.gcno. Consulte o
-fprofile-arcos opção acima para uma descrição de nome auxiliar e instruções sobre como
gerar dados de cobertura de teste. Os dados de cobertura corresponderão mais aos arquivos de origem,
se você não otimizar.

-fdbg-cnt-lista
Imprima o nome e o limite superior do contador para todos os contadores de depuração.

-fdbg-cnt =lista de contra-valores
Defina o limite superior do contador de depuração interno. lista de contra-valores é um separado por vírgulas
lista de nome:valor pares que define o limite superior de cada contador de depuração nome para
valor. Todos os contadores de depuração têm o limite superior inicial de UINT_MAX, Assim dbg_cnt ()
retorna true sempre, a menos que o limite superior seja definido por esta opção. por exemplo, com
-fdbg-cnt = dce: 10, tail_call: 0 dbg_cnt (dce) retornará verdadeiro apenas para os primeiros 10
invocações

-fenável-tipo-passar
-fdesable-tipo-passar=lista de alcance
Este é um conjunto de opções de depuração usadas para desabilitar / habilitar explicitamente
otimização passa. Para usuários do compilador, opções regulares para habilitar / desabilitar passes
deve ser usado em seu lugar.

* <- fdisable-ipa-passar>
Desativar ipa pass passar. passar é o nome do passe. Se a mesma passagem for estaticamente
chamado no compilador várias vezes, o nome da passagem deve ser anexado com um
número sequencial começando em 1.

* <- fdisable-rtl-passar>
* <- fdisable-rtl-passar=lista de alcance>
Desativar rtl pass passar. passar é o nome do passe. Se a mesma passagem for estaticamente
chamado no compilador várias vezes, o nome da passagem deve ser anexado com um
número sequencial começando em 1. lista de alcance é uma lista separada por vírgulas de
intervalos de função ou nomes de assembler. Cada intervalo é um par de números separados por um
cólon. O intervalo é inclusivo em ambas as extremidades. Se o intervalo for trivial, o número
par pode ser simplificado como um único número. Se o nó cgraph da função uid is
caindo dentro de um dos intervalos especificados, o passar está desabilitado para isso
função. o uid é mostrado no cabeçalho da função de um arquivo de despejo, e a passagem
os nomes podem ser despejados usando a opção -fdump-passes.

* <- fdisable-tree-passar>
* <- fdisable-tree-passar=lista de alcance>
Desativar passagem de árvore passar. Ver -fdisable-rtl para a descrição da opção
argumentos.

* <- fenable-ipa-passar>
Habilitar ipa pass passar. passar é o nome do passe. Se a mesma passagem for estaticamente
chamado no compilador várias vezes, o nome da passagem deve ser anexado com um
número sequencial começando em 1.

* <- fenable-rtl-passar>
* <- fenable-rtl-passar=lista de alcance>
Habilitar rtl pass passar. Ver -fdisable-rtl para a descrição do argumento da opção e
exemplos.

* <- árvore fenable-passar>
* <- árvore fenable-passar=lista de alcance>
Habilitar passagem de árvore passar. Ver -fdisable-rtl para a descrição dos argumentos da opção.

# desativar ccp1 para todas as funções
-fdisable-árvore-ccp1
# desativa o desenrolar completo para a função cujo nó cgraph uid é 1
-fenable-tree-cunroll = 1
# desativar gcse2 para funções nos seguintes intervalos [1,1],
# [300,400] e [400,1000]
# disable gcse2 para as funções foo e foo2
-fdisable-rtl-gcse2 = foo, foo2
# desativar o inlining inicial
-fdisable-árvore-einline
# desabilita o inlining do ipa
-fdisable-ipa-inline
# ativar o desenrolar completo da árvore
-enable-tree-unroll

-dletras
-fdump-rtl-passar
Diz para fazer despejos de depuração durante a compilação em momentos especificados por letras. Este
é usado para depurar as passagens baseadas em RTL do compilador. Os nomes de arquivo para a maioria
dos despejos são feitos anexando um número de passagem e uma palavra ao nome de despejo, e o
os arquivos são criados no diretório do arquivo de saída. Observe que o número da passagem é
calculado estaticamente à medida que os passes são registrados no gerenciador de passes. Assim, o
a numeração não está relacionada à ordem dinâmica de execução dos passes. Em particular,
um passe instalado por um plugin pode ter um número acima de 200 mesmo se for executado completamente
cedo. nome de despejo é gerado a partir do nome do arquivo de saída, se explicitamente
especificado e não é um executável, caso contrário, é o nome de base da fonte
Arquivo. Essas opções podem ter efeitos diferentes quando -E é usado para pré-processamento.

Depurar despejos podem ser habilitados com um -fdump-rtl mudar ou algum -d opção letras. Aqui
são as letras possíveis para uso em passar e letras, e seus significados:

-fdump-rtl-alinhamentos
Despejar depois que os alinhamentos de ramificação foram calculados.

-fdump-rtl-asmcons
Despeje depois de corrigir as declarações rtl que têm restrições de entrada / saída insatisfeitas.

-fdump-rtl-auto_inc_dec
Despejar após descoberta auto-inc-dec. Este passe só é executado em arquiteturas que
tem instruções de auto inc ou auto dec.

-fdump-rtl-barreiras
Despeje depois de limpar as instruções de barreira.

-fdump-rtl-bbpart
Despeje após particionar blocos básicos quentes e frios.

-fdump-rtl-bbro
Despejar após reordenar o bloco.

-fdump-rtl-btl1
-fdump-rtl-btl2
-fdump-rtl-btl1 e -fdump-rtl-btl2 habilitar o despejo após o alvo de dois ramos
otimização de carga passa.

-fdump-rtl-ignorar
Despeje após ignorar salto e otimizações de fluxo de controle.

-fdump-rtl-combinar
Despeje após a aprovação da combinação de instruções RTL.

-fdump-rtl-compgotos
Despeje após duplicar os gotos computados.

-fdump-rtl-ce1
-fdump-rtl-ce2
-fdump-rtl-ce3
-fdump-rtl-ce1, -fdump-rtl-ce2 e -fdump-rtl-ce3 permitir o despejo após os três
se a conversão for aprovada.

-fdump-rtl-cprop_hardreg
Despejar após a propagação da cópia de registro físico.

-fdump-rtl-csa
Despeje após combinar os ajustes da pilha.

-fdump-rtl-cse1
-fdump-rtl-cse2
-fdump-rtl-cse1 e -fdump-rtl-cse2 permitir o despejo após os dois sub-
eliminação de expressão passa.

-fdump-rtl-dce
Despeje após a eliminação do código morto autônomo.

-fdump-rtl-dbr
Despejar após agendamento de filial atrasado.

-fdump-rtl-dce1
-fdump-rtl-dce2
-fdump-rtl-dce1 e -fdump-rtl-dce2 permitir o despejo após os dois depósitos mortos
eliminação passa.

-fdump-rtl-eh
Despejar após a finalização do código de tratamento EH.

-fdump-rtl-eh_ranges
Despejar após a conversão das regiões de alcance de manuseio EH.

-fdump-rtl-expandir
Despejar após a geração do RTL.

-fdump-rtl-fwprop1
-fdump-rtl-fwprop2
-fdump-rtl-fwprop1 e -fdump-rtl-fwprop2 permitir o despejo após os dois para a frente
passagem de propagação.

-fdump-rtl-gcse1
-fdump-rtl-gcse2
-fdump-rtl-gcse1 e -fdump-rtl-gcse2 habilitar despejo após comum global
eliminação de subexpressão.

-fdump-rtl-init-regs
Dump após a inicialização dos registros.

-fdump-rtl-initvals
Despeje após o cálculo dos conjuntos de valores iniciais.

-fdump-rtl-into_cfglayout
Despeje após converter para o modo cfglayout.

-fdump-rtl-ira
Despejar após alocação de registro iterada.

-fdump-rtl-jump
Despeje após a segunda otimização de salto.

-fdump-rtl-loop2
-fdump-rtl-loop2 permite o despejo após a otimização do loop rtl passar.

-fdump-rtl-mach
Despeje depois de executar o passo de reorganização dependente da máquina, se esse passo
existe.

-fdump-rtl-mode_sw
Despeje após remover os interruptores de modo redundante.

-fdump-rtl-rnreg
Despejar após a renumeração do registro.

-fdump-rtl-outof_cfglayout
Despeje após converter do modo cfglayout.

-fdump-rtl-peephole2
Despeje após a passagem do olho mágico.

-fdump-rtl-postreload
Despeje após otimizações pós-recarregamento.

-fdump-rtl-pro_and_epilogue
Despeje após gerar os prólogos e epílogos da função.

-fdump-rtl-regmove
Despejar após a passagem de movimentação do registro.

-fdump-rtl-sched1
-fdump-rtl-sched2
-fdump-rtl-sched1 e -fdump-rtl-sched2 permitir despejo após o bloco básico
agendamento de passes.

-fdump-rtl-ver
Despejar após eliminação da extensão do sinal.

-fdump-rtl-seqabstr
Despejar após a descoberta de sequência comum.

-fdump-rtl-encurtar
Despeje após encurtar ramos.

-fdump-rtl-irmão
Despejar após otimizações de chamadas de irmãos.

-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 e
-fdump-rtl-split5 habilitar o despejo após cinco rodadas de divisão de instrução.

-fdump-rtl-sms
Despejar após o agendamento do módulo. Este passe só é executado em algumas arquiteturas.

-fdump-rtl-stack
Despejar após a conversão dos registros de "arquivo de registro plano" do GCC para os registros do x87
registradores tipo pilha. Esta passagem só é executada em variantes x86.

-fdump-rtl-subreg1
-fdump-rtl-subreg2
-fdump-rtl-subreg1 e -fdump-rtl-subreg2 permitir o despejo após os dois sub-regs
expansão passa.

-fdump-rtl-descompartilhar
Despejar depois que todos os rtl foram descompartilhados.

-fdump-rtl-vartrack
Despejar após o rastreamento de variável.

-fdump-rtl-vregs
Despeje após converter registros virtuais em registros físicos.

-fdump-rtl-web
Despejar após a divisão da faixa ao vivo.

-fdump-rtl-regclass
-fdump-rtl-subregs_of_mode_init
-fdump-rtl-subregs_of_mode_finish
-fdump-rtl-dfinit
-fdump-rtl-dfinish
Esses dumps são definidos, mas sempre produzem arquivos vazios.

-in
-fdump-rtl-tudo
Produza todos os despejos listados acima.

-dA Anote a saída do assembler com diversas informações de depuração.

-dD Despeje todas as definições de macro, no final do pré-processamento, além do normal
saída.

-dH Produza um dump de memória sempre que ocorrer um erro.

-dp Anote a saída do montador com um comentário indicando qual padrão e
alternativa foi usada. O comprimento de cada instrução também é impresso.

-dP Despeje o RTL na saída do montador como um comentário antes de cada instrução. Também
liga -dp anotação.

-dv Para cada um dos outros arquivos de despejo indicados (-fdump-rtl-passar), despeje um
representação do gráfico de fluxo de controle adequado para visualização com VCG para
arquivo.pass.vcg.

-dx Apenas gere RTL para uma função em vez de compilá-la. Normalmente usado com
-fdump-rtl-expandir.

-fdump-noaddr
Ao fazer despejos de depuração, suprima a saída de endereço. Isso torna mais viável
use diff na depuração de dumps para invocações do compilador com diferentes binários do compilador
e / ou locais de início text / bss / data / heap / stack / dso diferentes.

-fdump-sem número
Ao fazer despejos de depuração, suprima os números das instruções e a saída do endereço. Esse
torna mais viável o uso de diff em despejos de depuração para invocações do compilador com
opções diferentes, em particular com e sem -g.

-fdump-links não numerados
Ao fazer despejos de depuração (veja -d opção acima), suprimir números de instrução para o
links para as instruções anteriores e seguintes em uma sequência.

-fdump-unidade de tradução (Apenas C ++)
-fdump-translation-unit-opções (Apenas C ++)
Despeje uma representação da estrutura em árvore de toda a unidade de tradução para um arquivo.
O nome do arquivo é feito anexando .tu ao nome do arquivo de origem, e o arquivo é
criado no mesmo diretório do arquivo de saída. Se o -opções formulário é usado,
opções controla os detalhes do despejo conforme descrito para o -fdump-árvore opções.

-fdump-class-hierarquia (Apenas C ++)
-fdump-classe-hierarquia-opções (Apenas C ++)
Despeje uma representação da hierarquia de cada classe e layout da tabela de função virtual para um
Arquivo. O nome do arquivo é feito anexando .classe ao nome do arquivo de origem, e o arquivo
é criado no mesmo diretório do arquivo de saída. Se o -opções formulário é usado,
opções controla os detalhes do despejo conforme descrito para o -fdump-árvore opções.

-fdump-ipa-interruptor
Controle o despejo em vários estágios da árvore de linguagem de análise entre procedimentos para um
Arquivo. O nome do arquivo é gerado anexando um sufixo específico do switch à fonte
nome do arquivo, e o arquivo é criado no mesmo diretório do arquivo de saída. o
os seguintes despejos são possíveis:

todos os Ativa todos os despejos de análise entre procedimentos.

gráfico
Despeja informações sobre otimização de gráfico de chamada, remoção de função não utilizada e
decisões inlining.

em linha
Despejo após inlining de função.

-fdump-passes
Despeje a lista de passos de otimização que são ativados e desativados pelo atual
opções de linha de comando.

-fdump-estatísticas-opção
Habilite e controle o despejo de estatísticas de aprovação em um arquivo separado. O nome do arquivo é
gerado anexando um sufixo terminando em .Estatisticas ao nome do arquivo de origem, e o
O arquivo é criado no mesmo diretório do arquivo de saída. Se o -opção forma é
usava, -Estatísticas fará com que os contadores sejam somados em toda a unidade de compilação enquanto
-detalhes irá despejar todos os eventos à medida que os passes os geram. O padrão sem
opção é somar contadores para cada função compilada.

-fdump-árvore-interruptor
-fdump-árvore-interruptor-opções
Controle o despejo em vários estágios de processamento da árvore de linguagem intermediária para
um arquivo. O nome do arquivo é gerado anexando um sufixo específico do switch ao
nome do arquivo de origem e o arquivo é criado no mesmo diretório do arquivo de saída.
Se o -opções formulário é usado, opções é uma lista de - opções separadas que controlam
os detalhes do despejo. Nem todas as opções são aplicáveis ​​a todos os dumps; aqueles que são
não significativo será ignorado. As seguintes opções estão disponíveis

endereço
Imprima o endereço de cada nó. Normalmente, isso não é significativo, pois muda
de acordo com o ambiente e o arquivo fonte. Seu uso principal é para amarrar um
arquivo de despejo com um ambiente de depuração.

nome_asm
Se "DECL_ASSEMBLER_NAME" foi definido para um determinado declínio, use-o no despejo
em vez de "DECL_NAME". Seu uso principal é a facilidade de uso trabalhando para trás a partir de
nomes mutilados no arquivo de montagem.

fino
Inibir o despejo de membros de um escopo ou corpo de uma função simplesmente porque
escopo foi alcançado. Apenas descarte esses itens quando eles estiverem diretamente acessíveis por
algum outro caminho. Ao despejar árvores bem impressas, esta opção inibe o despejo
os corpos das estruturas de controle.

cru Imprima uma representação bruta da árvore. Por padrão, as árvores são bem impressas em
uma representação semelhante a C.

detalhes
Habilite despejos mais detalhados (não respeitados por todas as opções de despejo).

stats
Habilita o despejo de várias estatísticas sobre a passagem (não respeitado por todos os despejos
opção).

blocos
Habilite a exibição de limites de bloco básicos (desabilitado em despejos brutos).

vops
Habilite a exibição de operandos virtuais para cada instrução.

linha
Habilite a exibição de números de linha para declarações.

uid Habilite a exibição do ID único ("DECL_UID") para cada variável.

detalhado
Ative a exibição do despejo da árvore para cada instrução.

eh Habilite a exibição do número da região EH que contém cada instrução.

scev
Ative a exibição de detalhes da análise de evolução escalar.

todos os Ative todas as opções, exceto cru, fino, detalhado e linha.

Os seguintes despejos de árvore são possíveis:

original
Despeje antes de qualquer otimização baseada em árvore, para arquivo.original.

otimizado
Despeje após toda a otimização baseada em árvore, para arquivo.otimizado.

ondulante
Despeje cada função antes e depois da passagem de simplificação para um arquivo. O arquivo
nome é feito anexando .gimple ao nome do arquivo de origem.

cfg Despeje o gráfico de fluxo de controle de cada função em um arquivo. O nome do arquivo é feito por
acrescentando .cfg ao nome do arquivo de origem.

vcg Descarregue o gráfico de fluxo de controle de cada função em um arquivo no formato VCG. O arquivo
nome é feito anexando .vcg ao nome do arquivo de origem. Observe que se o arquivo
contém mais de uma função, o arquivo gerado não pode ser usado diretamente por
VCG. Você precisará cortar e colar o gráfico de cada função em seu próprio gráfico
arquivo primeiro.

ch Despeje cada função após copiar os cabeçalhos do loop. O nome do arquivo é feito anexando
.ch ao nome do arquivo de origem.

ssa Despeje as informações relacionadas ao SSA em um arquivo. O nome do arquivo é feito anexando .ssa
ao nome do arquivo de origem.

aliás
Despeja as informações de aliasing para cada função. O nome do arquivo é feito anexando
.alias ao nome do arquivo de origem.

CCP Despeje cada função após o CCP. O nome do arquivo é feito anexando .ccp ao
nome do arquivo de origem.

Storeccp
Descarregue cada função após STORE-CCP. O nome do arquivo é feito anexando .storeccp
ao nome do arquivo de origem.

pré Despeje as árvores após a eliminação parcial da redundância. O nome do arquivo é feito por
acrescentando .pré ao nome do arquivo de origem.

fre Despeje as árvores após a eliminação total da redundância. O nome do arquivo é feito anexando
.fre ao nome do arquivo de origem.

copyprop
Despeje as árvores após a propagação da cópia. O nome do arquivo é feito anexando .copyprop
ao nome do arquivo de origem.

store_copyprop
Despeje as árvores após a propagação da cópia da loja. O nome do arquivo é feito anexando
.store_copyprop ao nome do arquivo de origem.

dado Despeje cada função após a eliminação do código morto. O nome do arquivo é feito por
acrescentando .dce ao nome do arquivo de origem.

para-lamas
Despeje cada função após adicionar a instrumentação do mudflap. O nome do arquivo é feito por
acrescentando .para-lamas ao nome do arquivo de origem.

sra Despeje cada função após realizar a substituição escalar dos agregados. O arquivo
nome é feito anexando .sra ao nome do arquivo de origem.

lavatório
Despeje cada função após realizar o rastreamento de código. O nome do arquivo é feito por
acrescentando .Pia ao nome do arquivo de origem.

Sol Despeje cada função após aplicar as otimizações da árvore dominadora. O nome do arquivo é
feito anexando .dom ao nome do arquivo de origem.

DSE Despeje cada função após aplicar a eliminação de armazenamento morto. O nome do arquivo é feito
anexando .dse ao nome do arquivo de origem.

fiop
Despeje cada função após otimizar os nós PHI em código linear. O arquivo
nome é feito anexando .phiopt ao nome do arquivo de origem.

Forwprop
Despeje cada função após a propagação direta das variáveis ​​de uso único. O nome do arquivo
é feito anexando .forwprop ao nome do arquivo de origem.

copiar nome
Despeje cada função após aplicar a otimização de renomeação de cópia. O nome do arquivo é
feito anexando .copyrename ao nome do arquivo de origem.

nrv Despeje cada função após aplicar a otimização do valor de retorno nomeado no genérico
árvores. O nome do arquivo é feito anexando .nrv ao nome do arquivo de origem.

vetor
Despeje cada função após aplicar a vetorização de loops. O nome do arquivo é feito
anexando .vect ao nome do arquivo de origem.

slp Despeje cada função após aplicar a vetorização dos blocos básicos. O nome do arquivo é
feito anexando .slp ao nome do arquivo de origem.

vrp Despeje cada função após a propagação do intervalo de valores (VRP). O nome do arquivo é feito por
acrescentando .vrp ao nome do arquivo de origem.

todos os Habilite todos os dumps de árvore disponíveis com os sinalizadores fornecidos nesta opção.

-ftree-vectorizer-verbose =n
Esta opção controla a quantidade de saída de depuração que o vetorizador imprime. Esse
as informações são gravadas no erro padrão, a menos que -fdump-tree-tudo or -fdump-árvore-vecto
é especificado, caso em que é enviado para o arquivo de listagem de despejo usual, .vect. Para
n= 0 nenhuma informação de diagnóstico é relatada. Se n= 1 o vetorizador relata cada loop
que foi vetorizado e o número total de loops que foram vetorizados. Se n= 2 o
o vetorizador também relata loops não vetorizados que passaram a primeira fase de análise
(vect_analyze_loop_form) - ou seja, contável, mais interno, bb único, entrada / saída única
rotações. Este é o mesmo nível de verbosidade que -fdump-tree-vect-stats usa. Superior
níveis de verbosidade significam mais informações despejadas para cada loop relatado, ou o mesmo
quantidade de informações relatadas para mais loops: se n= 3, modelo de custo do vetorizador
a informação é relatada. Se n= 4, informações relacionadas ao alinhamento são adicionadas ao
relatórios. Se n= 5, informações relacionadas a referências de dados (por exemplo, dependências de memória, memória
padrões de acesso) é adicionado aos relatórios. Se n= 6, o vetorizador relata também não
loops mais internos vetorizados que não passaram a primeira fase de análise (ou seja, não podem
ser contável ou pode ter fluxo de controle complicado). Se n= 7, o vetorizador relata
também loops aninhados não vetorizados. Se n= 8, as informações relacionadas ao SLP são adicionadas ao
relatórios. Para n= 9, todas as informações que o vetorizador gera durante sua análise
e a transformação é relatada. Este é o mesmo nível de verbosidade que
-fdump-tree-vect-detalhes usa.

-frandom-seed =corda
Esta opção fornece uma semente que o GCC usa quando, de outra forma, usaria números aleatórios.
É usado para gerar certos nomes de símbolos que devem ser diferentes em cada
arquivo compilado. Também é usado para colocar carimbos exclusivos em arquivos de dados de cobertura e o
arquivos de objetos que os produzem. Você pode usar o -semente-frando opção de produzir
arquivos de objeto reproduzivelmente idênticos.

A corda deve ser diferente para cada arquivo que você compilar.

-fsched-verbose =n
Em alvos que usam programação de instrução, esta opção controla a quantidade de
saída de depuração que o planejador imprime. Esta informação é gravada no erro padrão,
a menos que -fdump-rtl-sched1 or -fdump-rtl-sched2 é especificado, caso em que é a saída
para o arquivo de lista de despejo normal, .sched1 or .sched2 respectivamente. Porém para n
maior que nove, a saída é sempre impressa com erro padrão.

Para n maior que zero, -fsched-detalhado produz as mesmas informações que
-fdump-rtl-sched1 e -fdump-rtl-sched2. Para n maior do que um, também tem saída básica
probabilidades de bloco, informações detalhadas da lista pronta e informações da unidade / insn. Para n
maior que dois, inclui RTL no ponto de aborto, fluxo de controle e informações de regiões. E
for n mais de quatro, -fsched-detalhado também inclui informações de dependência.

-save-tempos
-save-temps = cwd
Armazene os arquivos intermediários "temporários" usuais permanentemente; coloque-os na corrente
e nomeie-os com base no arquivo de origem. Assim, compilar foo.c com -c
-save-tempos produziria arquivos foo.i e foo.s, assim como foo.o. Isso cria um
pré-processado foo.i arquivo de saída, embora o compilador agora normalmente use um
pré-processador integrado.

Quando usado em combinação com o -x opção de linha de comando, -save-tempos é sensato
o suficiente para evitar sobrescrever um arquivo de origem de entrada com a mesma extensão de um
arquivo intermediário. O arquivo intermediário correspondente pode ser obtido renomeando
o arquivo de origem antes de usar -save-tempos.

Se você invocar o GCC em paralelo, compilando vários arquivos de origem diferentes que compartilham um
nome de base comum em subdiretórios diferentes ou o mesmo arquivo de origem compilado para
múltiplos destinos de saída, é provável que os diferentes compiladores paralelos
interferem uns com os outros e sobrescrevem os arquivos temporários. Por exemplo:

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

pode resultar em foo.i e foo.o sendo gravados simultaneamente por ambos os compiladores.

-save-temps = obj
Armazene os arquivos intermediários "temporários" usuais permanentemente. Se o -o opção é usada,
os arquivos temporários são baseados no arquivo objeto. Se o -o opção não é usada, o
-save-temps = obj switch se comporta como -save-tempos.

Por exemplo:

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

criaria foo.i, foo.s, dir / xbar.i, dir / xbar.s, dir2 / yfoobar.i, dir2 / yfoobar.s e
dir2 / yfoobar.o.

-Tempo[=lima]
Relate o tempo de CPU gasto por cada subprocesso na seqüência de compilação. Para C
arquivos de origem, este é o compilador apropriado e assembler (mais o linker se o link for
feito).

Sem a especificação de um arquivo de saída, a saída se parece com isto:

# cc1 0.12 0.01
# como 0.00 0.01

O primeiro número em cada linha é o "tempo do usuário", ou seja, o tempo gasto para executar o
programa em si. O segundo número é "hora do sistema", tempo gasto na execução operacional
rotinas do sistema em nome do programa. Ambos os números estão em segundos.

Com a especificação de um arquivo de saída, a saída é anexada ao arquivo nomeado,
e é assim:

0.12 0.01 cc1
0.00 0.01 como

A "hora do usuário" e a "hora do sistema" são movidas antes do nome do programa, e o
opções passadas para o programa são exibidas, para que se possa saber mais tarde qual arquivo foi
sendo compilado e com quais opções.

-fvar-rastreamento
Execute a passagem de rastreamento variável. Ele calcula onde as variáveis ​​são armazenadas em cada posição
em código. Melhores informações de depuração são então geradas (se as informações de depuração
formato suporta esta informação).

Está habilitado por padrão ao compilar com otimização (-Os, -O, -O2, ...),
informações de depuração (-g) e o formato de informações de depuração o suporta.

-fvar-atribuições de rastreamento
Anote atribuições a variáveis ​​de usuário no início da compilação e tente transportar
as anotações ao longo da compilação até o final, em uma tentativa
para melhorar as informações de depuração durante a otimização. Uso de -gdwarf-4 é recomendado junto
com isto.

Pode ser habilitado mesmo se var-tracking estiver desabilitado, caso em que as anotações serão
criado e mantido, mas descartado no final.

-fvar-tracking-assignments-toggle
Alterne -fvar-atribuições de rastreamento, da mesma maneira que -gtoggle alterna -g.

-print-file-name =biblioteca
Imprime o nome absoluto completo do arquivo de biblioteca biblioteca isso seria usado quando
ligando --- e não faça mais nada. Com esta opção, o GCC não compila ou vincula
nada; apenas imprime o nome do arquivo.

-print-multi-diretório
Imprime o nome do diretório correspondente ao multilib selecionado por qualquer outra opção
presente na linha de comando. Este diretório deve existir em GCC_EXEC_PREFIX.

-print-multi-lib
Imprima o mapeamento de nomes de diretório multilib para opções de compilador que os habilitam.
O nome do diretório é separado das opções por ;, e cada mudança começa com um
@ ao invés de -, sem espaços entre vários interruptores. Isso é suposto
facilitar o processamento do shell.

-print-multi-os-diretório
Imprime o caminho para as bibliotecas do sistema operacional para o multilib selecionado, em relação a alguns lib
subdiretório. Se as bibliotecas do sistema operacional estiverem presentes no lib subdiretório e sem multilibs
são usados, isso geralmente é apenas ., se as bibliotecas do sistema operacional estiverem presentes em libsuffix irmão
diretórios que isso imprime, por exemplo ../ lib64, ../ lib or ../ lib32, ou se as bibliotecas do sistema operacional são
presente em lib / subdir subdiretórios que imprime, por exemplo amd64, sparcv9 or ev6.

-print-multiarca
Imprime o caminho para as bibliotecas do sistema operacional para o multiarch selecionado, em relação a alguns lib
subdiretório.

-print-prog-name =programa
Como -impressão-nome-do-arquivo, mas procura um programa como cpp.

-print-libgcc-nome-do-arquivo
Igual a -print-file-name = libgcc.a.

Isso é útil quando você usa -nostdlib or -nodefaultlibs mas você quer se conectar com
libgcc.a. Você pode fazer

gcc -nostdlib ... `gcc -print-libgcc-file-name`

-print-search-dirs
Imprime o nome do diretório de instalação configurado e uma lista de programas e
diretórios de biblioteca gcc irá pesquisar --- e não fazer mais nada.

Isso é útil quando gcc imprime a mensagem de erro instalação problema, não podes exec
cpp0: Não tal lima or anuário. Para resolver isso, você precisa colocar cpp0 e os votos de
outros componentes do compilador onde gcc espera encontrá-los, ou você pode definir o
variável de ambiente GCC_EXEC_PREFIX para o diretório onde você os instalou. Não
esqueça o rastro /.

-print-sysroot
Imprime o diretório sysroot de destino que será usado durante a compilação. Isto é o
alvo sysroot especificado no tempo de configuração ou usando o --sysroot opção,
possivelmente com um sufixo extra que depende das opções de compilação. Se não houver alvo
sysroot é especificado, a opção não imprime nada.

-print-sysroot-headers-suffix
Imprima o sufixo adicionado ao sysroot de destino ao pesquisar cabeçalhos ou forneça um
erro se o compilador não estiver configurado com esse sufixo --- e não faça nada
outro.

-máquina de despejo
Imprima a máquina alvo do compilador (por exemplo, i686-pc-linux-gnu) --- e não faça
algo mais.

-versão de despejo
Imprima a versão do compilador (por exemplo, 3.0) --- e não faça mais nada.

-dumpspecs
Imprima as especificações internas do compilador --- e não faça mais nada. (Isso é usado quando
O próprio GCC está sendo construído.)

-feliminar-tipos-depuração-não-usados
Normalmente, ao produzir saída DWARF2, o GCC emitirá informações de depuração para todos
tipos declarados em uma unidade de compilação, independentemente de serem ou não
usado nessa unidade de compilação. Às vezes, isso é útil, como se, no depurador,
você deseja converter um valor para um tipo que não é realmente usado em seu programa (mas é
declarado). Mais frequentemente, no entanto, isso resulta em uma quantidade significativa de desperdício de espaço.
Com esta opção, o GCC evitará a produção de saída de símbolo de depuração para tipos que são
em nenhum lugar usado no arquivo fonte sendo compilado.

Opções Êxtase Controle Operacional
Essas opções controlam vários tipos de otimizações.

Sem qualquer opção de otimização, o objetivo do compilador é reduzir o custo de compilação
e fazer com que a depuração produza os resultados esperados. As declarações são independentes: se você
pare o programa com um ponto de interrupção entre as instruções, você pode então atribuir um novo valor para
qualquer variável ou altere o contador do programa para qualquer outra instrução na função e obtenha
exatamente os resultados que você esperaria do código-fonte.

Ativar sinalizadores de otimização faz com que o compilador tente melhorar o desempenho e / ou
tamanho do código em detrimento do tempo de compilação e, possivelmente, a capacidade de depurar o
.

O compilador realiza a otimização com base no conhecimento que possui do programa.
Compilar vários arquivos de uma vez em um único modo de arquivo de saída permite que o compilador use
informações obtidas de todos os arquivos ao compilar cada um deles.

Nem todas as otimizações são controladas diretamente por um sinalizador. Somente otimizações que têm um
sinalizadores estão listados nesta seção.

A maioria das otimizações só são ativadas se um -O nível é definido na linha de comando. De outra forma
eles são desabilitados, mesmo se os sinalizadores de otimização individuais forem especificados.

Dependendo do destino e de como o GCC foi configurado, um conjunto ligeiramente diferente de
otimizações podem ser habilitadas em cada -O nível do que aqueles listados aqui. Você pode invocar o GCC
com -Q --help = otimizadores para descobrir o conjunto exato de otimizações que estão habilitadas em
cada nível.

-O
-O1 Otimize. Otimizar a compilação leva um pouco mais de tempo e muito mais memória para
uma grande função.

Com -O, o compilador tenta reduzir o tamanho do código e o tempo de execução, sem realizar
quaisquer otimizações que demandem muito tempo de compilação.

-O ativa os seguintes sinalizadores de otimização:

-fauto-inc-dec -fcompare-elim -fcprop-registros -fdce -fdefer-pop -framo-atrasado
-fdse -f adivinhar-probabilidade-ramo -fif-conversão2 -fif-conversão -fipa-puro-const
-fipa-perfil -fipa-referência -fmerge-constantes -fsplit-wide-types -ftree-bit-ccp
-ftree-built-in-call-dce -ftree-ccp -ftree-ch -ftree-nome da cópia -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -sem árvores -ftree-phiprop -ftree-sra
-ftree-pta -ftree-ter -Funit-at-a-time

-O também liga -fomit-frame-ponteiro em máquinas onde isso não interfira
com depuração.

-O2 Otimize ainda mais. O GCC realiza quase todas as otimizações com suporte que não
envolvem uma compensação espaço-velocidade. Em comparação com -O, esta opção aumenta tanto
tempo de compilação e o desempenho do código gerado.

-O2 ativa todos os sinalizadores de otimização especificados por -O. Também ativa o seguinte
sinalizadores de otimização: -fthread-salta -falign-funções -falign-saltos -falign-loops
-falign-rótulos -fcaller-salva -f salto cruzado -fcse-follow-jumps -fcse-skip-blocos
-fdelete-null-pointer-checks -fdesvirtualize -otimizações caras -fgcse
-fgcse-lm -finline-pequenas-funções -findirect-inlining -fipa-sra
-foptimize-irmãos-chamadas -f inlining parcial -fpeephole2 -fregmove -freorder-blocos
-funções-freorder -frerun-cse-após-loop -fsched-interbloqueio -fsched-spec
-fschedule-insns -fschedule-insns2 -fstrict-aliasing -fstrict-overflow
-ftree-switch-conversão -ftree-tail-merge -ftree-pré -ftree-vrp

Observe o aviso em -fgcse sobre invocar -O2 em programas que usam computador
Vá para s.

NOTA: No Ubuntu 8.10 e versões posteriores, -D_FORTIFY_SOURCE = 2 é definido por padrão, e é
ativado quando -O é definido como 2 ou superior. Isso permite tempo de compilação adicional e
verificações em tempo de execução para várias funções libc. Para desativar, especifique
-U_FORTIFY_SOURCE or -D_FORTIFY_SOURCE = 0.

-O3 Otimize ainda mais. -O3 ativa todas as otimizações especificadas por -O2 e também liga
da -funções-finline, -funswitch-loops, -fcomunização preditiva, -fgcse-após-recarregar,
-ftree-vetorize, -ftree-parcial-pre e -fipa-cp-clone opções.

-O0 Reduza o tempo de compilação e faça com que a depuração produza os resultados esperados. Isto é o
padrão.

-Os Otimize para o tamanho. -Os habilita todos -O2 otimizações que normalmente não aumentam
tamanho do código. Ele também executa otimizações adicionais projetadas para reduzir o tamanho do código.

-Os desativa os seguintes sinalizadores de otimização: -falign-funções -falign-saltos
-falign-loops -falign-rótulos -freorder-blocos -freorder-blocos e partição
-fprefetch-loop-arrays -ftree-vect-loop-versão

-Rápido
Desconsidere o cumprimento de padrões estritos. -Rápido habilita todos -O3 otimizações. Isso também
permite otimizações que não são válidas para todos os programas compatíveis com o padrão. Isto
liga -rápida matemática e o específico do Fortran -fno-proteger-parens e -fstack-arrays.

Se você usar vários -O opções, com ou sem números de nível, a última dessas opções é
aquele que é eficaz.

Opções do formulário -fbandeira especificar sinalizadores independentes de máquina. A maioria das bandeiras tem ambos
formas positivas e negativas; a forma negativa de -foo seria -fno-foo. Na mesa
abaixo, apenas um dos formulários está listado --- aquele que você normalmente usará. Você pode imaginar
a outra forma removendo no- ou adicionando.

As opções a seguir controlam otimizações específicas. Eles são ativados por -O
opções ou estão relacionadas com as que são. Você pode usar as seguintes sinalizações nas raras
casos em que o "ajuste fino" das otimizações a serem realizadas é desejado.

-fno-default-in-line
Não torne as funções de membro embutidas por padrão simplesmente porque são definidas dentro
o escopo da classe (somente C ++). Caso contrário, quando você especificar -O, funções de membro definidas
dentro do escopo da classe são compilados embutidos por padrão; ou seja, você não precisa adicionar em linha
na frente do nome da função de membro.

-fno-adiar-pop
Sempre coloque os argumentos para cada chamada de função assim que essa função retornar. Para
máquinas que devem exibir argumentos após uma chamada de função, o compilador normalmente permite
argumentos se acumulam na pilha para várias chamadas de função e os exibe todos em
uma vez.

Desativado em níveis -O, -O2, -O3, -Os.

-fforward-propagar
Execute uma propagação direta no RTL. O passe tenta combinar duas instruções
e verifica se o resultado pode ser simplificado. Se o desenrolamento do loop estiver ativo, duas passagens
são executados e o segundo é agendado após o desenrolamento do loop.

Esta opção é habilitada por padrão nos níveis de otimização -O, -O2, -O3, -Os.

-ffp-contract =estilo
-ffp-contract = off desativa a contração da expressão de ponto flutuante. -ffp-contract = fast
permite a contração da expressão de ponto flutuante, como a formação de multiplicação-adição fundida
operações se o destino tiver suporte nativo para eles. -ffp-contract = on permite
contração de expressão de ponto flutuante se permitido pelo padrão de linguagem. Isto é
atualmente não implementado e tratado igual a -ffp-contract = off.

O padrão é -ffp-contract = fast.

-fomit-frame-ponteiro
Não mantenha o ponteiro do frame em um registro para funções que não precisam de um. Esse
evita as instruções para salvar, configurar e restaurar ponteiros de quadro; também faz um
registro extra disponível em muitas funções. It tb faz depuração impossível on
alguns máquinas.

Em algumas máquinas, como o VAX, este sinalizador não tem efeito, porque o padrão
a sequência de chamada lida automaticamente com o ponteiro do quadro e nada é salvo por
fingindo que não existe. A macro de descrição da máquina "FRAME_POINTER_REQUIRED"
controla se uma máquina de destino suporta este sinalizador.

A partir do GCC versão 4.6, a configuração padrão (quando não está otimizando para tamanho) para
Os alvos Linux x32 de 86 bits e Darwin x32 de 86 bits foram alterados para
-fomit-frame-ponteiro. O padrão pode ser revertido para -fno-omitir-frame-ponteiro by
configurar o GCC com o --enable-frame-ponteiro opção de configuração.

Habilitado em níveis -O, -O2, -O3, -Os.

-foptimize-irmãos-chamadas
Otimize chamadas de irmãos e recursivas.

Habilitado em níveis -O2, -O3, -Os.

-fno-inline
Não expanda nenhuma função inline além das marcadas com "always_inline"
atributo. Este é o padrão quando não está otimizando.

Funções únicas podem ser isentas de inlining, marcando-as com "noinline"
atributo.

-finline-pequenas-funções
Integre funções em seus chamadores quando seu corpo for menor do que o esperado
código de chamada de função (para que o tamanho geral do programa fique menor). O compilador
decide heuristicamente quais funções são simples o suficiente para valer a pena integrar em
Por aqui. Esse inline se aplica a todas as funções, mesmo aquelas não declaradas inline.

Ativado no nível -O2.

-findirect-inlining
Inline também chamadas indiretas que são conhecidas em tempo de compilação graças a
inlining anterior. Esta opção só tem efeito quando o próprio inlining está ligado
pelo -funções-finline or -finline-pequenas-funções opções.

Ativado no nível -O2.

-funções-finline
Considere todas as funções para inline, mesmo se não forem declaradas inline. o
O compilador decide heuristicamente quais funções valem a pena integrar dessa maneira.

Se todas as chamadas para uma determinada função são integradas e a função é declarada
"estática", então a função normalmente não é produzida como código assembler por si só.

Ativado no nível -O3.

-funções-finline-chamadas uma vez
Considere todas as funções "estáticas" chamadas uma vez para inlining em seu chamador, mesmo se
eles não são marcados como "embutidos". Se uma chamada para uma determinada função for integrada, o
a função não é produzida como código assembler por si só.

Habilitado em níveis -O1, -O2, -O3 e -Os.

-com medo
Funções embutidas marcadas por "always_inline" e funções cujo corpo parece menor que
a sobrecarga da chamada de função antes de fazer -fprofile-gerar instrumentação e
passe inlining real. Isso torna a criação de perfil significativamente mais barata e geralmente
inlining mais rápido em programas com grandes cadeias de funções de invólucro aninhadas.

Ativado por padrão.

-fipa-sra
Realizar substituição escalar interprocedural de agregados, remoção de parâmetros não utilizados
e substituição de parâmetros passados ​​por referência por parâmetros passados ​​por valor.

Habilitado em níveis -O2, -O3 e -Os.

-finline-limit =n
Por padrão, o GCC limita o tamanho das funções que podem ser embutidas. Esta bandeira permite
controle grosseiro deste limite. n é o tamanho das funções que podem ser embutidas em
número de pseudo instruções.

Inlining é, na verdade, controlado por uma série de parâmetros, que podem ser especificados
individualmente usando --param nome=valor. O -finline-limit =n opção define alguns dos
esses parâmetros da seguinte forma:

max-inline-insns-single
está definido para n/ 2.

max-inline-insns-auto
está definido para n/ 2.

Veja abaixo a documentação dos parâmetros individuais controlando inlining e
para os padrões desses parâmetros.

Nota: pode não haver valor para -finline-limite que resulta em comportamento padrão.

Nota: pseudo instrução representa, neste contexto particular, um resumo
medição do tamanho da função. De forma alguma representa uma contagem de montagem
instruções e, como tal, seu significado exato pode mudar de uma versão para uma
outro.

-fno-keep-inline-dllexport
Esta é uma versão mais refinada de -fkeep-inline-funções, que se aplica apenas a
funções que são declaradas usando o atributo "dllexport" ou declspec

-fkeep-inline-funções
Em C, emita funções "estáticas" que são declaradas "inline" no arquivo de objeto, mesmo se
a função foi embutida em todos os seus chamadores. Esta mudança não afeta
funções usando a extensão "extern inline" no GNU C90. Em C ++, emita todo e qualquer
funções embutidas no arquivo de objeto.

-fkeep-static-consts
Variáveis ​​de emissão declaradas "const estático" quando a otimização não está ativada, mesmo se o
variáveis ​​não são referenciadas.

O GCC habilita essa opção por padrão. Se você quiser forçar o compilador a verificar se o
variável foi referenciada, independentemente de a otimização estar ou não ativada, use
da -fno-keep-static-consts opção.

-fmerge-constantes
Tentar mesclar constantes idênticas (constantes de string e constantes de ponto flutuante)
em unidades de compilação.

Esta opção é o padrão para a compilação otimizada se o montador e o vinculador
apoie isso. Usar -fno-merge-constantes para inibir esse comportamento.

Habilitado em níveis -O, -O2, -O3, -Os.

-fmerge-all-constantes
Tente mesclar constantes idênticas e variáveis ​​idênticas.

Esta opção implica -fmerge-constantes. Além de -fmerge-constantes esse
considera, por exemplo, até matrizes inicializadas constantes ou variáveis ​​constantes inicializadas com
tipos integrais ou de ponto flutuante. Linguagens como C ou C ++ requerem cada variável,
incluindo várias instâncias da mesma variável em chamadas recursivas, para ter
locais, portanto, usar esta opção resultará em comportamento não conforme.

-fmodulo-sched
Execute o agendamento do módulo de swing imediatamente antes da primeira passagem de agendamento. Esse
passar olha para os loops mais internos e reordena suas instruções sobrepondo diferentes
iterações.

-fmodulo-sched-allow-regmoves
Execute um agendamento de módulo baseado em SMS mais agressivo com movimentos de registro permitidos. Por
definindo este sinalizador, certas arestas anti-dependências serão deletadas, o que irá acionar
a geração de movimentos regulares com base na análise do intervalo de vida. Esta opção é
eficaz apenas com -fmodulo-sched ativado.

-fno-branch-count-reg
Não use as instruções de "decremento e desvio" em um registro de contagem, mas em vez disso
gerar uma sequência de instruções que diminuem um registro, compare-o com
zero, então ramifique com base no resultado. Esta opção só é significativa em
arquiteturas que suportam tais instruções, que incluem x86, PowerPC, IA-64 e
S / 390

O padrão é -fbranch-count-reg.

-fno-função-cse
Não coloque endereços de função em registradores; faça cada instrução que chama um
a função constante contém o endereço da função explicitamente.

Esta opção resulta em um código menos eficiente, mas alguns hacks estranhos que alteram o
a saída do assembler pode ser confundida pelas otimizações realizadas quando esta opção é
não usado.

O padrão é -função-cse

-fno-zero-inicializado-em-bss
Se o destino suporta uma seção BSS, o GCC por padrão coloca variáveis ​​que são
inicializado em zero no BSS. Isso pode economizar espaço no código resultante.

Esta opção desativa este comportamento porque alguns programas dependem explicitamente de variáveis
indo para a seção de dados. Por exemplo, para que o executável resultante possa encontrar o
início dessa seção e / ou fazer suposições com base nisso.

O padrão é -fzero-inicializado-em-bss.

-fmudflap -fmudflapth -fmudflapir
Para front-ends que o suportam (C e C ++), instrumentar todos os ponteiros / array arriscados
operações de desreferenciação, algumas funções de string / heap de biblioteca padrão e algumas outras
construtos associados com testes de intervalo / validade. Módulos assim instrumentados devem ser
imune a estouros de buffer, uso de heap inválido e algumas outras classes de C / C ++
erros de programação. A instrumentação depende de uma biblioteca de tempo de execução separada
(libmudflap), que será vinculado a um programa se -fmudflap é fornecido no momento do link.
O comportamento em tempo de execução do programa instrumentado é controlado pelo MUDFLAP_OPTIONS
variável de ambiente. Veja "env MUDFLAP_OPTIONS = -help a.out" para suas opções.

Use -fmudflapth em vez de -fmudflap para compilar e vincular se o seu programa for multi
rosqueado. Usar -fmudflapir, além de -fmudflap or -fmudflapth, Se
a instrumentação deve ignorar as leituras do ponteiro. Isso produz menos instrumentação (e
portanto, execução mais rápida) e ainda fornece alguma proteção contra memória total
corrompe as gravações, mas permite que dados lidos erroneamente se propaguem dentro de um programa.

-fthread-salta
Realizamos otimizações onde verificamos se um salto se ramifica para um local onde
outra comparação incluída pela primeira é encontrada. Em caso afirmativo, o primeiro ramo é
redirecionado para o destino da segunda filial ou um ponto imediatamente
seguindo-o, dependendo se a condição é conhecida como verdadeira ou falsa.

Habilitado em níveis -O2, -O3, -Os.

-fsplit-wide-types
Ao usar um tipo que ocupa vários registros, como "long long" em um de 32 bits
sistema, separar os registros e alocá-los de forma independente. Isso normalmente
gera um código melhor para esses tipos, mas pode tornar a depuração mais difícil.

Habilitado em níveis -O, -O2, -O3, -Os.

-fcse-follow-jumps
Na eliminação de subexpressão comum (CSE), examine as instruções de salto quando o
o alvo do salto não é alcançado por nenhum outro caminho. Por exemplo, quando o CSE encontra
uma declaração "if" com uma cláusula "else", o CSE seguirá o salto quando a condição
testado é falso.

Habilitado em níveis -O2, -O3, -Os.

-fcse-skip-blocos
Isso é semelhante a -fcse-follow-jumps, mas faz com que o CSE siga os saltos que
pular blocos condicionalmente. Quando o CSE encontra uma instrução "if" simples sem
cláusula else, -fcse-skip-blocos faz com que o CSE siga o salto em torno do corpo do
"E se".

Habilitado em níveis -O2, -O3, -Os.

-frerun-cse-após-loop
Execute novamente a eliminação de subexpressão comum após as otimizações de loop terem sido executadas.

Habilitado em níveis -O2, -O3, -Os.

-fgcse
Execute uma passagem de eliminação de subexpressão comum global. Este passe também executa
constante global e propagação de cópia.

Nota: Ao compilar um programa usando gotos computados, uma extensão GCC, você pode obter
melhor desempenho de tempo de execução se você desativar a eliminação de subexpressão comum global
passar adicionando -fno-gcse para a linha de comando.

Habilitado em níveis -O2, -O3, -Os.

-fgcse-lm
Quando -fgcse-lm estiver habilitado, a eliminação da subexpressão comum global tentará
mova para si cargas que só são eliminadas pelas lojas. Isso permite um loop
contendo uma sequência de carga / armazenamento a ser alterada para uma carga fora do loop, e um
copiar / armazenar dentro do loop.

Habilitado por padrão quando o gcse está habilitado.

-fgcse-sm
Quando -fgcse-sm está habilitado, uma passagem de movimento de armazenamento é executada após o comum global
eliminação de subexpressão. Esta passagem tentará mover as lojas para fora dos loops. Quando
usado em conjunto com -fgcse-lm, os loops contendo uma sequência de carregamento / armazenamento podem ser
alterado para uma carga antes do loop e um armazenamento após o loop.

Não habilitado em nenhum nível de otimização.

-fgcse-las
Quando -fgcse-las está habilitado, o passo de eliminação de subexpressão comum global
elimina cargas redundantes que vêm depois de armazenamentos no mesmo local de memória (ambos
redundâncias parciais e totais).

Não habilitado em nenhum nível de otimização.

-fgcse-após-recarregar
Quando -fgcse-após-recarregar está habilitado, uma passagem de eliminação de carga redundante é executada
após recarregar. O objetivo desta passagem é limpar derramamentos redundantes.

-funsafe-loop-otimizations
Se fornecido, o otimizador de loop irá assumir que os índices de loop não estouram, e que
os loops com condição de saída não trivial não são infinitos. Isso permite uma gama mais ampla
de otimizações de loop, mesmo se o próprio otimizador de loop não puder provar que estes
suposições são válidas. Usando -Wunsafe-loop-otimizações, o compilador irá avisá-lo
se encontrar este tipo de loop.

-f salto cruzado
Execute a transformação de salto cruzado. Esta transformação unifica código equivalente e
salvar o tamanho do código. O código resultante pode ou não ter um desempenho melhor do que sem
pulando.

Habilitado em níveis -O2, -O3, -Os.

-fauto-inc-dec
Combine incrementos ou decrementos de endereços com acessos à memória. Este passe é
sempre pulado em arquiteturas que não têm instruções para oferecer suporte a isso.
Ativado por padrão em -O e superior em arquiteturas que suportam isso.

-fdce
Execute a eliminação de código morto (DCE) em RTL. Ativado por padrão em -O e mais alto.

-fdse
Execute a eliminação de armazenamento morto (DSE) em RTL. Ativado por padrão em -O e mais alto.

-fif-conversão
Tente transformar saltos condicionais em equivalentes sem ramificação. Isso inclui o uso
de movimentos condicionais, mín., máx., definir sinalizadores e instruções abdominais, e alguns truques possíveis
pela aritmética padrão. O uso de execução condicional em chips onde é
disponível é controlado por "if-conversion2".

Habilitado em níveis -O, -O2, -O3, -Os.

-fif-conversão2
Use a execução condicional (quando disponível) para transformar saltos condicionais em
equivalentes sem ramificação.

Habilitado em níveis -O, -O2, -O3, -Os.

-fdelete-null-pointer-checks
Suponha que os programas não possam remover a referência de ponteiros nulos com segurança e que nenhum código ou dado
elemento reside lá. Isso permite otimizações simples e constantes de dobra em tudo
níveis de otimização. Além disso, outras passagens de otimização no GCC usam este sinalizador para
controlar análises de fluxo de dados globais que eliminam verificações inúteis de ponteiros nulos;
estes assumem que se um ponteiro for verificado depois de já ter sido desreferenciado, ele
não pode ser nulo.

Observe, entretanto, que em alguns ambientes essa suposição não é verdadeira. Usar
-fno-delete-null-pointer-checks para desativar esta otimização para programas que dependem
sobre esse comportamento.

Alguns destinos, especialmente os incorporados, desabilitam essa opção em todos os níveis. De outra forma
está habilitado em todos os níveis: -O0, -O1, -O2, -O3, -Os. Cartões que usam as informações
são ativados de forma independente em diferentes níveis de otimização.

-fdesvirtualize
Tente converter chamadas em funções virtuais para chamadas diretas. Isso é feito tanto
dentro de um procedimento e interproceduralmente como parte do inlining indireto
("-findirect-inlining") e propagação de constante interprocedural (-fipa-cp) Habilitado
em níveis -O2, -O3, -Os.

-otimizações caras
Execute uma série de pequenas otimizações que são relativamente caras.

Habilitado em níveis -O2, -O3, -Os.

-livre
Tente remover as instruções de extensão redundantes. Isso é especialmente útil para
a arquitetura x86-64 que implicitamente estende-se zero em registros de 64 bits após
gravando na metade inferior de 32 bits.

Ativado para x86 em níveis -O2, -O3.

-foptimize-registrar-mover
-fregmove
Tentar reatribuir números de registro em instruções de movimentação e como operandos de outros
instruções simples para maximizar a quantidade de vinculação de registros. Isto é
especialmente útil em máquinas com instruções de dois operandos.

Note -fregmove e -foptimize-registrar-mover são a mesma otimização.

Habilitado em níveis -O2, -O3, -Os.

-fira-algorithm =algoritmo
Use o algoritmo de coloração especificado para o alocador de registro integrado. o
algoritmo argumento pode ser prioridade, que especifica a coloração prioritária de Chow, ou CB,
que especifica a coloração Chaitin-Briggs. A coloração Chaitin-Briggs não foi implementada
para todas as arquiteturas, mas para aqueles alvos que oferecem suporte, é o padrão
porque gera um código melhor.

-fira-region =região
Use regiões especificadas para o alocador de registro integrado. o região argumento
deve ser um dos seguintes:

todos os Use todos os loops como regiões de alocação de registro. Isso pode dar os melhores resultados para
máquinas com um conjunto de registros pequeno e / ou irregular.

misto
Use todos os loops, exceto os loops com pequena pressão de registro como regiões. Esse
valor geralmente dá os melhores resultados na maioria dos casos e para a maioria das arquiteturas, e
está habilitado por padrão ao compilar com otimização para velocidade (-O, -O2, ...).

um Use todas as funções como uma única região. Isso normalmente resulta no menor código
tamanho, e está habilitado por padrão para -Os or -O0.

-fira-loop-pressão
Use IRA para avaliar a pressão de registro em loops para decisões de mover invariantes de loop.
Esta opção geralmente resulta na geração de código mais rápido e menor em máquinas com
arquivos de registro grandes (> = 32 registros), mas pode tornar o compilador lento.

Esta opção está habilitada no nível -O3 para alguns alvos.

-fno-ira-compartilhar-salvar-slots
Desative o compartilhamento de slots de pilha usados ​​para salvar registros permanentes de chamadas usadas
uma chamada. Cada registro rígido recebe um slot de pilha separado e, como resultado, a pilha de funções
os quadros são maiores.

-Fno-IRA-Share-Spill-Slots
Desative o compartilhamento de slots de pilha alocados para pseudo-registros. Cada pseudo-registro
que não obtém um registro rígido obtém um slot de pilha separado e, como resultado, a função
os frames da pilha são maiores.

-fira-verbose =n
Controle o detalhamento do arquivo de despejo para o alocador de registro integrado. o
o valor padrão é 5. Se o valor n for maior ou igual a 10, a saída de despejo é enviada
para stderr usando o mesmo formato que n menos 10.

-framo-atrasado
Se houver suporte para a máquina de destino, tente reordenar as instruções para explorar
slots de instrução disponíveis após instruções de desvio atrasadas.

Habilitado em níveis -O, -O2, -O3, -Os.

-fschedule-insns
Se compatível com a máquina de destino, tente reordenar as instruções para eliminar
a execução é paralisada devido à indisponibilidade dos dados necessários. Isso ajuda as máquinas que
têm ponto flutuante lento ou instruções de carregamento de memória, permitindo que outras instruções
ser emitido até que o resultado da instrução de carga ou de ponto flutuante seja necessário.

Habilitado em níveis -O2, -O3.

-fschedule-insns2
Semelhante a -fschedule-insns, mas solicita uma passagem adicional de agendamento de instrução
após a alocação do registro. Isso é especialmente útil em máquinas com um
número relativamente pequeno de registros e onde as instruções de carregamento de memória levam mais do que
um ciclo.

Habilitado em níveis -O2, -O3, -Os.

-fno-sched-interblock
Não agende instruções em blocos básicos. Normalmente está habilitado por padrão
ao agendar antes da alocação de registro, ou seja, com -fschedule-insns ou em -O2 or
superior.

-fno-sched-spec
Não permita o movimento especulativo de instruções sem carga. Isso normalmente é habilitado por
padrão ao programar antes da alocação do registro, ou seja, com -fschedule-insns ou em
-O2 ou superior.

-fsched-pressão
Habilite o agendamento insn sensível à pressão do registro antes da alocação do registro.
Isso só faz sentido quando o agendamento antes que a alocação de registro seja habilitada, ou seja, com
-fschedule-insns ou em -O2 ou mais alto. O uso desta opção pode melhorar o
codificar e diminuir seu tamanho, evitando o aumento da pressão de registro acima do número
de registros físicos disponíveis e, como consequência, registrar vazamentos no registro
alocação.

-fsched-spec-load
Permitir movimento especulativo de algumas instruções de carga. Isso só faz sentido quando
agendamento antes da alocação de registro, ou seja, com -fschedule-insns ou em -O2 ou superior.

-fsched-spec-load-perigoso
Permitir movimento especulativo de mais instruções de carga. Isso só faz sentido quando
agendamento antes da alocação de registro, ou seja, com -fschedule-insns ou em -O2 ou superior.

-fsched-stalled-insns
-fsched-stalled-insns =n
Defina quantos insns (se houver) podem ser movidos prematuramente da fila de bloqueados
insns na lista pronta, durante a segunda passagem de agendamento.
-fno-sched-stalled-insns significa que nenhum insns será movido prematuramente,
-fsched-stalled-insns = 0 significa que não há limite de quantos insns enfileirados podem ser movidos
prematuramente. -fsched-stalled-insns sem um valor é equivalente a
-fsched-stalled-insns = 1.

-fsched-stalled-insns-dep
-fsched-stalled-insns-dep =n
Defina quantos grupos insn (ciclos) serão examinados quanto à dependência de um bloqueado
insn que é candidato à remoção prematura da fila de insns paralisados. Esse
tem efeito apenas durante a segunda passagem de agendamento, e somente se
-fsched-stalled-insns é usado. -fno-sched-stalled-insns-dep é equivalente a
-fsched-stalled-insns-dep = 0. -fsched-stalled-insns-dep sem um valor é equivalente
para -fsched-stalled-insns-dep = 1.

-fsched2-use-superblocos
Ao programar após a alocação de registro, use o algoritmo de escalonamento de superbloco.
O agendamento do Superbloco permite o movimento através dos limites do bloco básico, resultando em
horários. Esta opção é experimental, pois nem todas as descrições de máquina usadas pelo GCC
modele a CPU suficientemente perto para evitar resultados não confiáveis ​​do algoritmo.

Isso só faz sentido ao agendar após a alocação de registro, ou seja, com
-fschedule-insns2 ou em -O2 ou superior.

-fsched-group-heurística
Habilite a heurística de grupo no agendador. Esta heurística favorece a instrução
que pertence a um grupo de programação. Isso é habilitado por padrão quando o agendamento é
habilitado, ou seja, com -fschedule-insns or -fschedule-insns2 ou em -O2 ou superior.

-fsched-heurística do caminho crítico
Ative a heurística de caminho crítico no agendador. Esta heurística favorece
instruções sobre o caminho crítico. Isso é habilitado por padrão quando o agendamento é
habilitado, ou seja, com -fschedule-insns or -fschedule-insns2 ou em -O2 ou superior.

-fsched-spec-insn-heurística
Habilite a heurística de instrução especulativa no escalonador. Esta heurística favorece
instruções especulativas com maior fraqueza de dependência. Isto está ativado por padrão
quando o agendamento está habilitado, ou seja, com -fschedule-insns or -fschedule-insns2 ou em -O2
ou superior.

-fsched-rank-heurística
Habilite a heurística de classificação no planejador. Esta heurística favorece a instrução
pertencente a um bloco básico com maior tamanho ou frequência. Isto está ativado por padrão
quando o agendamento está habilitado, ou seja, com -fschedule-insns or -fschedule-insns2 ou em -O2
ou superior.

-fsched-last-insn-heurística
Habilite a heurística da última instrução no escalonador. Esta heurística favorece o
instrução que é menos dependente da última instrução agendada. Isso está habilitado
por padrão, quando o agendamento está habilitado, ou seja, com -fschedule-insns or -fschedule-insns2
ou em -O2 ou superior.

-fsched-dep-count-heurística
Ative a heurística de contagem dependente no agendador. Esta heurística favorece o
instrução que tem mais instruções dependendo dela. Isto está ativado por padrão
quando o agendamento está habilitado, ou seja, com -fschedule-insns or -fschedule-insns2 ou em -O2
ou superior.

-freschedule-modulo-Schedules-loops
O agendamento do módulo vem antes do agendamento tradicional, se um loop for módulo
programado, podemos querer evitar que os passes de programação posteriores alterem seu
horário, usamos esta opção para controlar isso.

- agendamento seletivo
Agende instruções usando algoritmo de agendamento seletivo. Execuções de programação seletiva
em vez da primeira passagem do planejador.

- agendamento seletivo 2
Agende instruções usando algoritmo de agendamento seletivo. Execuções de programação seletiva
em vez da segunda passagem do planejador.

-fsel-sched-pipelining
Habilite o pipelining de software dos loops mais internos durante o agendamento seletivo. Esse
opção não tem efeito até um dos - agendamento seletivo or - agendamento seletivo 2 is
ligadas.

-fsel-sched-pipelining-outer-loops
Ao canalizar loops durante o agendamento seletivo, também canalize os loops externos. Esse
opção não tem efeito até -fsel-sched-pipelining está ligado.

-fshrink-wrap
Emita prólogos de função apenas antes das partes da função que precisam deles, ao invés de
o topo da função. Este sinalizador é habilitado por padrão em -O e mais alto.

-fcaller-salva
Habilite valores a serem alocados em registros que serão substituídos por chamadas de função,
emitindo instruções extras para salvar e restaurar os registros em torno dessas chamadas.
Essa alocação é feita apenas quando parece resultar em um código melhor do que seria
caso contrário, ser produzido.

Esta opção está sempre habilitada por padrão em certas máquinas, geralmente aquelas que têm
nenhum registro preservado de chamada para usar em seu lugar.

Habilitado em níveis -O2, -O3, -Os.

-fcombine-stack-settings
Rastreia ajustes de pilha (pushes e pops) e empilha referências de memória e, em seguida, tenta
para encontrar maneiras de combiná-los.

Ativado por padrão em -O1 e mais alto.

-fconserve-stack
Tente minimizar o uso da pilha. O compilador tentará usar menos espaço de pilha,
mesmo que isso torne o programa mais lento. Esta opção implica definir o pilha grande
quadro parâmetro para 100 e o crescimento de frame de pilha grande parâmetro para 400.

-ftree-reassoc
Realize a reassociação nas árvores. Este sinalizador é habilitado por padrão em -O e mais alto.

-ftree-pré
Execute a eliminação de redundância parcial (PRE) nas árvores. Este sinalizador é habilitado por
padrão em -O2 e -O3.

-ftree-parcial-pre
Torne a eliminação de redundância parcial (PRE) mais agressiva. Este sinalizador é habilitado por
padrão em -O3.

-ftree-forwprop
Realize a propagação direta nas árvores. Este sinalizador é habilitado por padrão em -O e
superior.

-sem árvores
Execute a eliminação total de redundância (FRE) nas árvores. A diferença entre FRE e
PRE é que FRE considera apenas expressões que são calculadas em todos os caminhos que levam a
a computação redundante. Esta análise é mais rápida do que PRE, embora exponha menos
redundâncias. Este sinalizador é habilitado por padrão em -O e mais alto.

-ftree-phiprop
Realize o içamento de cargas a partir de ponteiros condicionais nas árvores. Este passe é habilitado por
padrão em -O e mais alto.

-ftree-copiar-prop
Execute a propagação de cópias nas árvores. Essa passagem elimina operações de cópia desnecessárias.
Este sinalizador é habilitado por padrão em -O e mais alto.

-fipa-puro-const
Descubra quais funções são puras ou constantes. Ativado por padrão em -O e mais alto.

-fipa-referência
Descobrir quais variáveis ​​estáticas não escapam não pode escapar da unidade de compilação.
Ativado por padrão em -O e mais alto.

-fipa-pta
Realizar análise de ponteiro interprocedural e modificação interprocedural e
análise de referência. Esta opção pode causar memória excessiva e uso de tempo de compilação em
grandes unidades de compilação. Não é habilitado por padrão em nenhum nível de otimização.

-fipa-perfil
Realize a propagação do perfil interprocedural. As funções chamadas apenas a partir do frio
funções são marcadas como frias. Também funções executadas uma vez (como "frio",
"noreturn", construtores estáticos ou destruidores) são identificados. Funções frias e
Loop menos partes das funções executadas uma vez são então otimizadas para tamanho. Ativado por
padrão em -O e mais alto.

-fipa-cp
Execute a propagação da constante interprocedural. Esta otimização analisa o programa
para determinar quando os valores passados ​​para as funções são constantes e, em seguida, otimiza
adequadamente. Esta otimização pode aumentar substancialmente o desempenho se o
aplicativo tem constantes passadas para funções. Este sinalizador é habilitado por padrão em
-O2, -Os e -O3.

-fipa-cp-clone
Execute a clonagem de funções para tornar a propagação da constante interprocedural mais forte. Quando
ativada, a propagação da constante interprocedural executará a clonagem de funções quando
função externamente visível pode ser chamada com argumentos constantes. Porque isso
a otimização pode criar várias cópias de funções, pode aumentar significativamente
tamanho do código (ver --param ipcp-unit-growth =valor) Este sinalizador é habilitado por padrão em
-O3.

-fipa-matriz-reorg
Execute o aplainamento e transposição da matriz. O achatamento da matriz tenta substituir um
matriz m-dimensional com sua matriz n-dimensional equivalente, onde n <m. Esse
reduz o nível de indireção necessário para acessar os elementos da matriz. o
a segunda otimização é a transposição da matriz, que tenta mudar a ordem do
dimensões da matriz para melhorar a localidade do cache. Ambas as otimizações precisam do
-fwhole-programa bandeira. A transposição é ativada apenas se as informações de perfil forem
disponíveis.

-ftree-pia
Execute o movimento de armazenamento para a frente nas árvores. Este sinalizador é habilitado por padrão em -O e
superior.

-ftree-bit-ccp
Executa propagação de constante de bit condicional esparsa em árvores e ponteiro de propagação
informações de alinhamento. Esta passagem opera apenas em variáveis ​​escalares locais e é
habilitado por padrão em -O e mais alto. Requer que -ftree-ccp está ativado.

-ftree-ccp
Execute propagação constante condicional esparsa (CCP) nas árvores. Este passe apenas
opera em variáveis ​​escalares locais e é habilitado por padrão em -O e mais alto.

-ftree-switch-conversão
Realize a conversão de inicializações simples em um switch para inicializações de um
matriz escalar. Este sinalizador é habilitado por padrão em -O2 e mais alto.

-ftree-tail-merge
Procure sequências de código idênticas. Quando encontrado, substitua um com um salto para o outro.
Essa otimização é conhecida como fusão de cauda ou salto cruzado. Este sinalizador é habilitado por
padrão em -O2 e mais alto. O tempo de compilação neste passo pode ser limitado usando
max-tail-merge-comparations parâmetro e max-tail-merge-iterações parâmetro.

-ftree-dce
Execute a eliminação de código morto (DCE) nas árvores. Este sinalizador é habilitado por padrão em -O
e mais alto.

-ftree-built-in-call-dce
Realizar eliminação condicional de código morto (DCE) para chamadas para funções integradas que
podem definir "errno", mas, de outra forma, não têm efeitos colaterais. Este sinalizador está habilitado por padrão
at -O2 e superior se -Os também não é especificado.

-ftree-dominator-opts
Execute uma variedade de limpezas escalares simples (propagação constante / cópia, redundância
eliminação, propagação de alcance e simplificação de expressão) com base em um dominador
travessia de árvore. Isso também executa jump threading (para reduzir saltos em saltos). Esse
sinalizador é habilitado por padrão em -O e mais alto.

-ftree-dse
Execute a eliminação de armazenamento morto (DSE) nas árvores. Uma loja morta é uma loja em uma memória
local que é posteriormente substituído por outra loja sem quaisquer cargas intermediárias. No
neste caso, o armazenamento anterior pode ser excluído. Este sinalizador é habilitado por padrão em -O e
superior.

-ftree-ch
Execute a cópia do cabeçalho do loop nas árvores. Isso é benéfico, pois aumenta
eficácia das otimizações de movimento do código. Ele também economiza um salto. Esta bandeira é
habilitado por padrão em -O e mais alto. Não está habilitado para -Os, uma vez que normalmente
aumenta o tamanho do código.

-ftree-loop-otimizar
Realize otimizações de loop em árvores. Este sinalizador é habilitado por padrão em -O e
superior.

-ftree-loop-linear
Execute transformações de intercâmbio de loop na árvore. Igual a -intercâmbio-floop. Usar
esta transformação de código, o GCC deve ser configurado com --com-ppl e --com-cloog para
habilitar a infraestrutura de transformação de loop de grafite.

-intercâmbio-floop
Execute transformações de intercâmbio de loop em loops. Intercâmbio de dois loops aninhados
alterna os loops interno e externo. Por exemplo, dado um loop como:

FAZER J = 1, M
FAÇO eu = 1, N
A (J, I) = A (J, I) * C
FIM
FIM

o intercâmbio de loop transformará o loop como se o usuário tivesse escrito:

FAÇO eu = 1, N
FAZER J = 1, M
A (J, I) = A (J, I) * C
FIM
FIM

o que pode ser benéfico quando "N" é maior do que os caches, porque em Fortran, o
elementos de uma matriz são armazenados na memória de forma contígua por coluna, e o original
o loop itera sobre as linhas, potencialmente criando a cada acesso um erro de cache. Esse
a otimização se aplica a todos os idiomas suportados pelo GCC e não se limita a
Fortran. Para usar esta transformação de código, o GCC deve ser configurado com --com-ppl
e --com-cloog para habilitar a infraestrutura de transformação de loop de grafite.

-flop-strip-mine
Execute transformações de mineração de loop strip em loops. A mineração strip divide um loop em
dois loops aninhados. O loop externo tem passadas iguais ao tamanho da tira e o interno
loop tem passadas do loop original dentro de uma faixa. O comprimento da tira pode ser alterado
usando o tamanho do bloco de loop parâmetro. Por exemplo, dado um loop como:

FAÇO eu = 1, N
A (I) = A (I) + C
FIM

a mineração de loop strip transformará o loop como se o usuário tivesse escrito:

FAZER II = 1, N, 51
DO I = II, min (II + 50, N)
A (I) = A (I) + C
FIM
FIM

Esta otimização se aplica a todos os idiomas suportados pelo GCC e não se limita a
Fortran. Para usar esta transformação de código, o GCC deve ser configurado com --com-ppl
e --com-cloog para habilitar a infraestrutura de transformação de loop de grafite.

-bloop-block
Execute transformações de bloqueio de loop em loops. A tira de bloqueio extrai cada ciclo no
aninhamento de loops de forma que os acessos à memória dos loops do elemento caibam dentro dos caches. o
o comprimento da tira pode ser alterado usando o tamanho do bloco de loop parâmetro. Por exemplo,
dado um loop como:

FAÇO eu = 1, N
FAZER J = 1, M
A (J, I) = B (I) + C (J)
FIM
FIM

o bloqueio de loop transformará o loop como se o usuário tivesse escrito:

FAZER II = 1, N, 51
FAÇA 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)
FIM
FIM
FIM
FIM

o que pode ser benéfico quando "M" é maior do que os caches, porque o loop mais interno
irá iterar sobre uma quantidade menor de dados que podem ser mantidos nos caches. Esse
a otimização se aplica a todos os idiomas suportados pelo GCC e não se limita a
Fortran. Para usar esta transformação de código, o GCC deve ser configurado com --com-ppl
e --com-cloog para habilitar a infraestrutura de transformação de loop de grafite.

-fgrafite-identidade
Ative a transformação de identidade para grafite. Para cada SCoP, geramos o
representação poliédrica e transformá-la novamente em gimple. Usando -fgrafite-identidade
podemos verificar os custos ou benefícios da transformação GIMPLE -> GRAFITE -> GIMPLE.
Algumas otimizações mínimas também são realizadas pelo gerador de código CLooG, como índice
divisão e eliminação de código morto em loops.

-flat-flat
Remove a estrutura de aninhamento de loop: transforma o aninhamento de loop em um único loop. Esse
transformação pode ser útil como uma transformação de habilitação para vetorização e
paralelização. Este recurso é experimental. Para usar esta transformação de código, GCC
tem que ser configurado com --com-ppl e --com-cloog para habilitar o loop Graphite
infraestrutura de transformação.

-floop-paralelize-tudo
Use a análise de dependência de dados Graphite para identificar loops que podem ser paralelizados.
Paralelizar todos os loops que podem ser analisados ​​para não conter dependências transportadas pelo loop
sem verificar se é lucrativo paralelizar os loops.

-fcheck-data-deps
Compare os resultados de vários analisadores de dependência de dados. Esta opção é usada para
depurar os analisadores de dependência de dados.

-ftree-loop-se-converter
Tentar transformar saltos condicionais nos loops mais internos em sem ramificações
equivalentes. A intenção é remover o fluxo de controle dos loops mais internos para
para melhorar a capacidade do passo de vetorização para lidar com esses loops. Isto é
habilitado por padrão se a vetorização estiver habilitada.

-ftree-loop-if-convert-lojas
Tente também if-converter saltos condicionais contendo gravações de memória. Esse
transformação pode ser insegura para programas multi-threaded, pois transforma condicional
a memória grava em gravações de memória incondicional. Por exemplo,

para (i = 0; i <N; i ++)
se (cond.)
A [i] = expr;

seria transformado em

para (i = 0; i <N; i ++)
A [i] = cond? expr: A [i];

potencialmente produzindo corridas de dados.

-ftree-loop-distribuição
Execute a distribuição do loop. Este sinalizador pode melhorar o desempenho do cache em grandes corpos de loop
e permitir que outras otimizações de loop, como paralelização ou vetorização, tomem
Lugar, colocar. Por exemplo, o loop

FAÇO eu = 1, N
A (I) = B (I) + C
D (I) = E (I) * F
FIM

é transformado em

FAÇO eu = 1, N
A (I) = B (I) + C
FIM
FAÇO eu = 1, N
D (I) = E (I) * F
FIM

-ftree-loop-distrib-patterns
Execute a distribuição de loop de padrões que podem ser gerados por código com chamadas para um
biblioteca. Este sinalizador é habilitado por padrão em -O3.

Esta passagem distribui os loops de inicialização e gera uma chamada para o conjunto memset zero.
Por exemplo, o loop

FAÇO eu = 1, N
A (I) = 0
B (I) = A (I) + I
FIM

é transformado em

FAÇO eu = 1, N
A (I) = 0
FIM
FAÇO eu = 1, N
B (I) = A (I) + I
FIM

e o loop de inicialização é transformado em uma chamada para o conjunto memset zero.

-ftree-loop-im
Execute o movimento invariável do loop nas árvores. Este passe move apenas invariantes que seriam
difícil de manusear no nível RTL (chamadas de função, operações que se expandem para não triviais
sequências de insns). Com -funswitch-loops também move operandos de condições que
são invariantes fora do loop, de modo que podemos usar apenas análises de invariância triviais
em loop unswitching. O passe também inclui o movimento da loja.

-ftree-loop-ivcanon
Crie um contador canônico para o número de iterações em loops para os quais
número de iterações requer uma análise complicada. Otimizações posteriores podem
determine o número facilmente. Útil especialmente em conexão com o desenrolamento.

-cincopts
Realize otimizações de variáveis ​​de indução (redução de força, variável de indução
fusão e eliminação da variável de indução) nas árvores.

-ftree-parallelize-loops = n
Paralelizar loops, ou seja, dividir seu espaço de iteração para rodar em n threads. Isto é
só é possível para loops cujas iterações são independentes e podem ser arbitrariamente
reordenado. A otimização só é lucrativa em máquinas com multiprocessador, para loops
que consomem muita CPU, em vez de serem limitados, por exemplo, pela largura de banda da memória. Esta opção
implica -pthreade, portanto, só é compatível com destinos que tenham suporte para
-pthread.

-ftree-pta
Execute a análise de pontos locais de função nas árvores. Este sinalizador está habilitado por padrão
at -O e mais alto.

-ftree-sra
Execute a substituição escalar de agregados. Este passe substitui referências de estrutura
com escalares para evitar a confirmação de estruturas na memória muito cedo. Esta bandeira é
habilitado por padrão em -O e mais alto.

-ftree-nome da cópia
Execute a renomeação de cópias nas árvores. Esta passagem tenta renomear os temporários do compilador para
outras variáveis ​​em locais de cópia, geralmente resultando em nomes de variáveis ​​que mais
assemelham-se muito às variáveis ​​originais. Este sinalizador é habilitado por padrão em -O e
superior.

-ftree-coalesce-inline-vars
Diga a passagem do copyrename (veja -ftree-nome da cópia) para tentar combinar pequenos usuários
variáveis ​​definidas também, mas apenas se elas forem sequenciadas de outras funções. É um
forma mais limitada de -ftree-coalesce-vars. Isso pode prejudicar as informações de depuração de tais
variáveis ​​embutidas, mas manterá as variáveis ​​da função embutida separadas de
uns aos outros, de modo que sejam mais propensos a conter os valores esperados em um
sessão de depuração. Este era o padrão nas versões do GCC anteriores a 4.7.

-ftree-coalesce-vars
Diga a passagem do copyrename (veja -ftree-nome da cópia) para tentar combinar pequenos usuários
variáveis ​​definidas também, em vez de apenas temporárias do compilador. Isso pode limitar severamente
a capacidade de depurar um programa otimizado compilado com -fno-var-atribuições de rastreamento.
Na forma negada, este sinalizador impede a coalescência SSA de variáveis ​​de usuário, incluindo
os inline. Essa opção é ativada por padrão.

-ftree-ter
Realize a substituição temporária da expressão durante a fase SSA-> normal. Solteiro
temporários de uso / definição única são substituídos em seu local de uso com sua definição
expressão. Isso resulta em um código não-GIMPLE, mas dá aos expansores muito mais
árvores complexas para trabalhar resultando em uma melhor geração de RTL. Isso é habilitado por
padrão em -O e mais alto.

-ftree-vetorize
Execute a vetorização em loop nas árvores. Este sinalizador é habilitado por padrão em -O3.

-ftree-slp-vetorize
Execute a vetorização de blocos básicos em árvores. Este sinalizador é habilitado por padrão em -O3 e
quando -ftree-vetorize está ativado.

-ftree-vect-loop-versão
Execute o controle de versão do loop ao fazer a vetorização do loop em árvores. Quando um loop aparece
para ser vetorizável, exceto que o alinhamento dos dados ou a dependência dos dados não podem ser determinados
em tempo de compilação, as versões vetorizadas e não vetorizadas do loop são geradas
junto com verificações de tempo de execução para alinhamento ou dependência para controlar qual versão é
executado. Esta opção está habilitada por padrão, exceto no nível -Os onde está desativado.

-fvect-modelo de custo
Habilite o modelo de custo para vetorização.

-ftree-vrp
Execute a propagação do intervalo de valores nas árvores. Isso é semelhante à propagação constante
passar, mas em vez de valores, intervalos de valores são propagados. Isso permite que o
otimizadores para remover verificações de intervalo desnecessárias, como verificações de limite de matriz e ponteiro nulo
Verificações. Isso é habilitado por padrão em -O2 e mais alto. Eliminação de verificação de ponteiro nulo
só é feito se -fdelete-null-pointer-checks está ativado.

-ftracer
Execute a duplicação da cauda para aumentar o tamanho do superbloco. Esta transformação simplifica
o fluxo de controle da função permitindo que outras otimizações façam um trabalho melhor.

-funroll-loops
Loops de desenrolamento cujo número de iterações pode ser determinado em tempo de compilação ou após
entrada para o loop. -funroll-loops implica -frerun-cse-após-loop. Esta opção torna
código maior e pode ou não torná-lo executado mais rápido.

-funroll-todos-loops
Desenrole todos os loops, mesmo se o número de iterações for incerto quando o loop for
entrou. Isso geralmente faz com que os programas sejam executados mais lentamente. -funroll-todos-loops implica o
mesmas opções que -funroll-loops,

-fsplit-ivs-no-desenrolamento
Permite a expressão de valores de variáveis ​​de indução em iterações posteriores do
loop desenrolado usando o valor na primeira iteração. Isso quebra a longa dependência
correntes, melhorando assim a eficiência das passagens de programação.

Combinação de -fweb e o CSE costuma ser suficiente para obter o mesmo efeito. Contudo
nos casos em que o corpo do loop é mais complicado do que um único bloco básico, isso não é
de confiança. Também não funciona em algumas das arquiteturas devido a
restrições no passe CSE.

Esta otimização é habilitada por padrão.

-fexpansão-da-variável-no-desenrolador
Com esta opção, o compilador irá criar várias cópias de algumas variáveis ​​locais
ao desenrolar um loop que pode resultar em um código superior.

-f inlining parcial
Partes embutidas de funções. Esta opção tem qualquer efeito apenas quando o próprio inlining é
ligado pelo -funções-finline or -finline-pequenas-funções opções.

Ativado no nível -O2.

-fcomunização preditiva
Realize a otimização de commoning preditiva, ou seja, reutilizando cálculos (especialmente
cargas e armazenamentos de memória) realizados em iterações anteriores de loops.

Esta opção está habilitada no nível -O3.

-fprefetch-loop-arrays
Se compatível com a máquina de destino, gere instruções para pré-buscar memória para
melhorar o desempenho de loops que acessam grandes arrays.

Esta opção pode gerar código melhor ou pior; os resultados são altamente dependentes do
estrutura de loops dentro do código-fonte.

Desativado no nível -Os.

-fno-olho mágico
-fno-olho mágico2
Desative todas as otimizações de olho mágico específicas da máquina. A diferença entre
-fno-olho mágico e -fno-olho mágico2 está em como eles são implementados no compilador; algum
alvos usam um, alguns usam o outro, alguns usam ambos.

-f olho mágico está habilitado por padrão. -fpeephole2 habilitado em níveis -O2, -O3, -Os.

-fno-adivinha-probabilidade-ramo
Não adivinhe as probabilidades do ramo usando heurísticas.

O GCC usará heurísticas para adivinhar as probabilidades do ramo, se não forem fornecidas por
feedback de perfil (-fprofile-arcos) Essas heurísticas são baseadas no fluxo de controle
gráfico. Se algumas probabilidades de ramificação são especificadas por __builtin_expect, Em seguida, o
heurísticas serão usadas para adivinhar probabilidades de ramificação para o resto do fluxo de controle
gráfico, tomando o __builtin_expect informações em conta. As interações entre o
heurísticas e __builtin_expect pode ser complexo e, em alguns casos, pode ser útil para
desabilite as heurísticas para que os efeitos de __builtin_expect são mais fáceis de
Compreendo.

O padrão é -f adivinhar-probabilidade-ramo em níveis -O, -O2, -O3, -Os.

-freorder-blocos
Reordene os blocos básicos na função compilada, a fim de reduzir o número de tomadas
ramos e melhorar a localidade do código.

Habilitado em níveis -O2, -O3.

-freorder-blocos e partição
Além de reordenar blocos básicos na função compilada, a fim de reduzir
número de ramos retirados, partições de blocos básicos quentes e frios em seções separadas
dos arquivos assembly e .o, para melhorar a paginação e o desempenho de localidade do cache.

Essa otimização é automaticamente desativada na presença de tratamento de exceções,
para seções linkonce, para funções com um atributo de seção definido pelo usuário e em qualquer
arquitetura que não oferece suporte a seções nomeadas.

-funções-freorder
Reordene funções no arquivo de objeto para melhorar a localidade do código. Isto é
implementado usando subseções especiais ".text.hot" para executadas com mais freqüência
funções e ".texto.unlprovável" para funções executadas improváveis. O reordenamento é feito por
o vinculador, de modo que o formato do arquivo de objeto deve oferecer suporte a seções nomeadas e o vinculador deve colocar
de uma forma razoável.

Além disso, o feedback do perfil deve estar disponível para tornar esta opção efetiva. Ver
-fprofile-arcos para obter detalhes.

Habilitado em níveis -O2, -O3, -Os.

-fstrict-aliasing
Permitir que o compilador assuma as regras de alias mais estritas aplicáveis ​​à linguagem
sendo compilado. Para C (e C ++), isso ativa otimizações com base no tipo de
expressões. Em particular, presume-se que um objeto de um tipo nunca resida no
mesmo endereço de um objeto de um tipo diferente, a menos que os tipos sejam quase os mesmos.
Por exemplo, um "unsigned int" pode ser apelidado de "int", mas não um "void *" ou "double". UMA
tipo de caractere pode ser apelido de qualquer outro tipo.

Preste atenção especial a códigos como este:

união a_union {
int i;
duplo d;
};

int f () {
união a_union t;
td = 3.0;
return ti;
}

A prática de ler de um sindicalista diferente do mais recente
escrito para (chamado de "trocadilho") é comum. Mesmo com -fstrict-aliasing, modelo-
trocadilhos é permitido, desde que a memória seja acessada através do tipo união. Então o
o código acima funcionará conforme o esperado. No entanto, este código pode não:

int f () {
união a_union t;
int * ip;
td = 3.0;
ip = & t.i;
return * ip;
}

Da mesma forma, acesse pegando o endereço, lançando o ponteiro resultante e
desreferenciar o resultado tem um comportamento indefinido, mesmo se o elenco usar um tipo de união,
por exemplo:

int f () {
duplo d = 3.0;
return ((união a_union *) & d) -> i;
}

A -fstrict-aliasing opção está habilitada em níveis -O2, -O3, -Os.

-fstrict-overflow
Permitir que o compilador assuma regras estritas de estouro de assinatura, dependendo do idioma
sendo compilado. Para C (e C ++), isso significa que estouro ao fazer aritmética com
números com sinais são indefinidos, o que significa que o compilador pode assumir que não
acontecer. Isso permite várias otimizações. Por exemplo, o compilador irá assumir
que uma expressão como "i + 10> i" sempre será verdadeira para "i" com sinal. Esse
suposição só é válida se estouro de sinal for indefinido, pois a expressão é falsa
se "i + 10" estourar ao usar aritmética de complemento de dois. Quando esta opção está em
efetuar qualquer tentativa de determinar se uma operação em números assinados irá transbordar
deve ser escrito com cuidado para não envolver transbordamento.

Esta opção também permite que o compilador assuma semântica estrita de ponteiro: dado um
ponteiro para um objeto, se adicionar um deslocamento a esse ponteiro não produz um ponteiro
para o mesmo objeto, a adição é indefinida. Isso permite que o compilador conclua
que "p + u> p" é sempre verdadeiro para um ponteiro "p" e um inteiro sem sinal "u". Esse
suposição só é válida porque o contorno do ponteiro é indefinido, pois a expressão é
falso se "p + u" estourar usando aritmética de complemento de dois.

Veja também o -fwrapv opção. Usando -fwrapv significa que o estouro de sinal inteiro é
totalmente definido: ele envolve. Quando -fwrapv é usado, não há diferença entre
-fstrict-overflow e -fno-estrito-estouro para inteiros. Com -fwrapv certos tipos
de estouro são permitidos. Por exemplo, se o compilador obtiver um estouro ao fazer
aritmética em constantes, o valor transbordado ainda pode ser usado com -fwrapv, Mas não
de outra forma.

A -fstrict-overflow opção está habilitada em níveis -O2, -O3, -Os.

-falign-funções
-falign-functions =n
Alinha o início das funções com a próxima potência de dois maior que n, pulando para n
bytes. Por exemplo, -falign-functions = 32 alinha funções para os próximos 32 bytes
limite, mas -falign-functions = 24 alinharia com o próximo limite de 32 bytes apenas se
isso pode ser feito pulando 23 bytes ou menos.

-fno-align-funções e -falign-functions = 1 são equivalentes e significam que funções
não será alinhado.

Alguns montadores só suportam este sinalizador quando n é uma potência de dois; nesse caso, é
arredondado.

If n não for especificado ou for zero, use um padrão dependente da máquina.

Habilitado em níveis -O2, -O3.

-falign-rótulos
-falign-labels =n
Alinha todos os alvos de ramificação a um limite de potência de dois, pulando até n bytes como
-falign-funções. Esta opção pode facilmente tornar o código mais lento, porque deve inserir
operações fictícias para quando o destino da ramificação é alcançado no fluxo normal do código.

-fno-align-labels e -falign-labels = 1 são equivalentes e significam que os rótulos não serão
alinhado.

If -falign-loops or -falign-saltos são aplicáveis ​​e são maiores do que este valor, então
seus valores são usados ​​em seu lugar.

If n não é especificado ou é zero, use um padrão dependente da máquina que é muito provável
ser 1, significando nenhum alinhamento.

Habilitado em níveis -O2, -O3.

-falign-loops
-falign-loops =n
Alinha os loops para um limite de potência de dois, pulando até n bytes como -falign-funções.
A esperança é que o loop seja executado muitas vezes, o que compensará qualquer
execução das operações fictícias.

-fno-align-loops e -falign-loops = 1 são equivalentes e significam que os loops não serão
alinhado.

If n não for especificado ou for zero, use um padrão dependente da máquina.

Habilitado em níveis -O2, -O3.

-falign-saltos
-falign-jumps =n
Alinha alvos ramificados a um limite de potência de dois, para alvos ramificados onde os alvos
só pode ser alcançado saltando, saltando até n bytes como -falign-funções. em
neste caso, nenhuma operação fictícia precisa ser executada.

-fno-align-jumps e -falign-jumps = 1 são equivalentes e significam que os loops não serão
alinhado.

If n não for especificado ou for zero, use um padrão dependente da máquina.

Habilitado em níveis -O2, -O3.

-Funit-at-a-time
Esta opção foi deixada por motivos de compatibilidade. -Funit-at-a-time não tem efeito, enquanto
-fnenhuma unidade por vez implica -fno-reordenação de nível superior e -fno-seção-âncoras.

Ativado por padrão.

-fno-reordenação de nível superior
Não reordene funções de nível superior, variáveis ​​e instruções "asm". Produzi-los em
na mesma ordem em que aparecem no arquivo de entrada. Quando esta opção é usada,
variáveis ​​estáticas não referenciadas não serão removidas. Esta opção destina-se a apoiar
código existente que depende de uma ordem específica. Para novo código, é melhor usar
atributos.

Ativado no nível -O0. Quando desativado explicitamente, também implica -fno-seção-âncoras,
que de outra forma está habilitado em -O0 em alguns alvos.

-fweb
Constrói web como comumente usado para fins de alocação de registro e atribui cada web
pseudo-registro individual. Isso permite que a passagem de alocação de registro opere
pseudos diretamente, mas também fortalece vários outros passos de otimização, como CSE,
otimizador de loop e removedor de código morto trivial. Pode, no entanto, fazer a depuração
impossível, uma vez que as variáveis ​​não ficarão mais em um "registro doméstico".

Ativado por padrão com -funroll-loops.

-fwhole-programa
Suponha que a unidade de compilação atual represente todo o programa sendo compilado.
Todas as funções e variáveis ​​públicas, com exceção de "principal" e aquelas mescladas por
atributo "externally_visible" tornam-se funções estáticas e, de fato, são otimizadas
mais agressivamente por otimizadores interprocedurais. Se ouro é usado como o plug-in do vinculador,
Os atributos "externally_visible" são adicionados automaticamente às funções (ainda não variáveis
devido a uma corrente ouro problema) que são acessados ​​fora dos objetos LTO de acordo com
arquivo de resolução produzido por ouro. Para outros vinculadores que não podem gerar resolução
arquivo, atributos "externally_visible" explícitos ainda são necessários. Embora esta opção
é equivalente ao uso adequado da palavra-chave "estática" para programas que consistem em um
arquivo único, em combinação com a opção -flto esta sinalização pode ser usada para compilar muitos
programas de menor escala, uma vez que as funções e variáveis ​​tornam-se locais para o todo
unidade de compilação combinada, não para o próprio arquivo de origem.

Esta opção implica -ftodo-arquivo para programas Fortran.

-flto [=n]
Esta opção executa o otimizador de tempo de link padrão. Quando invocado com o código-fonte,
gera GIMPLE (uma das representações internas do GCC) e grava em ELF especial
seções no arquivo de objeto. Quando os arquivos de objeto estão vinculados, todos os
corpos de função são lidos a partir dessas seções ELF e instanciados como se tivessem sido
parte da mesma unidade de tradução.

Para usar o otimizador de tempo de link, -flto precisa ser especificado em tempo de compilação e durante
o link final. Por exemplo:

gcc -c -O2 -flto foo.c
gcc -c -O2 -flto barra.c
gcc -o meuprog -flto -O2 foo.o bar.o

As duas primeiras invocações para o GCC salvam uma representação bytecode do GIMPLE em especial
Seções ELF dentro foo.o e bar.o. A invocação final lê o bytecode GIMPLE
da foo.o e bar.o, mescla os dois arquivos em uma única imagem interna e compila
o resultado, como de costume. Desde ambos foo.o e bar.o são mesclados em uma única imagem, este
faz com que todas as análises e otimizações interprocedurais no GCC funcionem em todo o
dois arquivos como se fossem um só. Isso significa, por exemplo, que o inliner é
capaz de incorporar funções em bar.o em funções em foo.o e vice versa.

Outra maneira (mais simples) de habilitar a otimização de tempo de link é:

gcc -o meuprog -flto -O2 foo.c bar.c

O código acima gera bytecode para foo.c e bar.c, os mescla em um único
Representação GIMPLE e otimiza-os como de costume para produzir myprog.

A única coisa importante a ter em mente é que, para permitir otimizações de tempo de link, o
-flto sinalizador precisa ser passado para os comandos de compilação e link.

Para tornar a otimização de todo o programa eficaz, é necessário certificar-se de que todo
suposições do programa. O compilador precisa saber quais funções e variáveis ​​podem ser
acessado por bibliotecas e tempo de execução fora da unidade otimizada de tempo de link. Quando
suportado pelo vinculador, o plug-in do vinculador (consulte -plug-in de ligação de fusível) passa
informações para o compilador sobre símbolos usados ​​e visíveis externamente. Quando o
o plugin do vinculador não está disponível, -fwhole-programa deve ser usado para permitir que o compilador
fazer essas suposições, o que leva a decisões de otimização mais agressivas.

Observe que quando um arquivo é compilado com -flto, o arquivo de objeto gerado é maior que
um arquivo de objeto regular porque contém bytecodes GIMPLE e o código final usual.
Isso significa que os arquivos de objetos com informações LTO podem ser vinculados como objetos normais
arquivos; E se -flto não é passado para o vinculador, nenhuma otimização interprocedural é
aplicado.

Além disso, os sinalizadores de otimização usados ​​para compilar arquivos individuais não são
necessariamente relacionados aos usados ​​no momento do link. Por exemplo,

gcc -c -O0 -flto foo.c
gcc -c -O0 -flto barra.c
gcc -o meuprog -flto -O3 foo.o bar.o

Isso produz arquivos de objeto individuais com código assembler não otimizado, mas o
binário resultante myprog é otimizado em -O3. Se, em vez disso, o binário final for
gerado sem -flto, Em seguida myprog não é otimizado.

Ao produzir o binário final com -flto, O GCC aplica apenas otimizações de tempo de link
para aqueles arquivos que contêm bytecode. Portanto, você pode misturar e combinar arquivos de objetos
e bibliotecas com bytecodes GIMPLE e código de objeto final. GCC seleciona automaticamente
quais arquivos otimizar no modo LTO e quais arquivos vincular sem mais
processamento.

Existem alguns sinalizadores de geração de código preservados pelo GCC ao gerar bytecodes, como
eles precisam ser usados ​​durante o estágio final do link. Atualmente, as seguintes opções
são salvos nos arquivos de bytecode do GIMPLE: -fPIC, -fcomum e todo o -m sinalizadores de destino.

No momento do link, essas opções são lidas e reaplicadas. Observe que o atual
implementação não faz nenhuma tentativa de reconhecer valores conflitantes para essas opções. Se
arquivos diferentes têm valores de opção conflitantes (por exemplo, um arquivo é compilado com -fPIC
e outro não), o compilador simplesmente usa o último valor lido do bytecode
arquivos. Recomenda-se, então, que você compile todos os arquivos que participam do
mesmo link com as mesmas opções.

Se o LTO encontrar objetos com ligação C declarada com tipos incompatíveis em separado
unidades de tradução a serem ligadas entre si (comportamento indefinido de acordo com ISO C99
6.2.7), um diagnóstico não fatal pode ser emitido. O comportamento ainda é indefinido na execução
tempo.

Outra característica do LTO é que é possível aplicar otimizações interprocedurais
em arquivos escritos em diferentes idiomas. Isso requer suporte na frente do idioma
fim. Atualmente, os front-ends C, C ++ e Fortran são capazes de emitir GIMPLE
bytecodes, então algo assim deve funcionar:

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

Observe que o link final é feito com g ++ para obter as bibliotecas de tempo de execução C ++ e
-lgfortran é adicionado para obter as bibliotecas de tempo de execução Fortran. Em geral, ao misturar
idiomas no modo LTO, você deve usar as mesmas opções de comando de link de quando mixar
linguagens em uma compilação regular (não LTO); tudo que você precisa adicionar é -flto a todos os
compilar e vincular comandos.

Se os arquivos de objeto contendo bytecode GIMPLE forem armazenados em um arquivo de biblioteca, digamos
libfoo.a, é possível extraí-los e usá-los em um link LTO se você estiver usando um
vinculador com suporte a plug-ins. Para habilitar este recurso, use a bandeira -plug-in de ligação de fusível
no momento do link:

gcc -o myprog -O2 -flto -fuse-linker-plugin ao bo -lfoo

Com o plug-in do vinculador ativado, o vinculador extrai os arquivos GIMPLE necessários de
libfoo.a e os passa para o GCC em execução para torná-los parte do agregado
Imagem GIMPLE a ser otimizada.

Se você não estiver usando um vinculador com suporte para plug-in e / ou não habilite o vinculador
plugin, então os objetos dentro libfoo.a são extraídos e vinculados como de costume, mas eles
não participe do processo de otimização LTO.

As otimizações de tempo de link não requerem a presença de todo o programa para operar.
Se o programa não requer a exportação de nenhum símbolo, é possível combinar
-flto e -fwhole-programa para permitir que os otimizadores interprocedurais usem mais
suposições agressivas que podem levar a melhores oportunidades de otimização. Uso de
-fwhole-programa não é necessário quando o plugin do linker está ativo (veja -plug-in de ligação de fusível).

A implementação atual de LTO não faz nenhuma tentativa de gerar bytecode que seja
portátil entre diferentes tipos de hosts. Os arquivos bytecode são versionados e aí
é uma verificação de versão estrita, portanto, os arquivos bytecode gerados em uma versão do GCC não
trabalhar com uma versão mais antiga / mais recente do GCC.

A otimização de tempo de link não funciona bem com a geração de informações de depuração.
Combinando -flto com -g é atualmente experimental e espera-se que produza errado
resultados.

Se você especificar o opcional n, a otimização e geração de código feita no momento do link
é executado em paralelo usando n trabalhos paralelos, utilizando um instalado fazer .
A variável de ambiente FAÇA pode ser usado para substituir o programa usado. O padrão
valor para n é 1.

Você também pode especificar -flto = jobserver usar o modo de servidor de trabalho do GNU make para determinar
o número de trabalhos paralelos. Isso é útil quando o Makefile que chama o GCC já está
executando em paralelo. Você deve preceder um + para a receita do comando no pai
Makefile para que isso funcione. Esta opção provavelmente só funciona se FAÇA é GNU make.

Esta opção está desativada por padrão

-flto-partição =alg
Especifique o algoritmo de particionamento usado pelo otimizador de tempo de link. O valor é
"1to1" para especificar um particionamento que espelhe os arquivos de origem originais ou
"balanceado" para especificar o particionamento em blocos de tamanhos iguais (sempre que possível).
Especificar "nenhum" como um algoritmo desativa o particionamento e o streaming completamente. o
o valor padrão é "balanceado".

-flto-compression-level =n
Esta opção especifica o nível de compressão usado para linguagem intermediária escrita
para arquivos de objeto LTO, e só é significativo em conjunto com o modo LTO (-flto).
Os valores válidos são 0 (sem compactação) a 9 (compactação máxima). Valores fora deste
intervalo são fixados em 0 ou 9. Se a opção não for fornecida, um padrão balanceado
configuração de compressão é usada.

-flto-reportar
Imprime um relatório com detalhes internos sobre o funcionamento do otimizador de tempo de link. o
o conteúdo deste relatório varia de versão para versão. Destina-se a ser útil para o GCC
desenvolvedores ao processar arquivos de objeto no modo LTO (via -flto).

Desativado por padrão.

-plug-in de ligação de fusível
Permite o uso de um plug-in de vinculação durante a otimização de tempo de link. Esta opção depende
no suporte a plugins no linker, que está disponível em ouro ou em GNU ld 2.21 ou
mais recente.

Esta opção permite a extração de arquivos de objeto com bytecode GIMPLE fora da biblioteca
arquivos. Isso melhora a qualidade da otimização, expondo mais código para o link
otimizador de tempo. Esta informação especifica quais símbolos podem ser acessados ​​externamente
(por objeto não-LTO ou durante a vinculação dinâmica). Melhorias de qualidade de código resultantes em
binários (e bibliotecas compartilhadas que usam visibilidade oculta) são semelhantes a
"-fwhole-program". Ver -flto para uma descrição do efeito deste sinalizador e como
use-o.

Esta opção é habilitada por padrão quando o suporte LTO no GCC está habilitado e o GCC estava
configurado para uso com um linker que suporte plug-ins (GNU ld 2.21 ou mais recente ou ouro).

-ffat-lto-objetos
Objetos Fat LTO são arquivos-objeto que contêm tanto a linguagem intermediária quanto a
código do objeto. Isso os torna utilizáveis ​​para vinculação LTO e vinculação normal. Esse
opção é eficaz apenas ao compilar com -flto e é ignorado no momento do link.

-fno-fat-lto-objetos melhora o tempo de compilação em relação ao LTO simples, mas requer o
conjunto de ferramentas completo para estar ciente do LTO. Requer um vinculador com suporte para plug-in de vinculação
para funcionalidades básicas. Além disso, nm, ar e ranlib precisam oferecer suporte ao linker
plug-ins para permitir um ambiente de construção completo (capaz de construir
bibliotecas, etc.).

O padrão é -ffat-lto-objetos mas esse padrão deve ser alterado no futuro
lançamentos quando os ambientes habilitados para plug-ins de vinculação se tornam mais comuns.

-fcompare-elim
Após a alocação de registro e divisão de instrução de alocação pós-registro, identifique
instruções aritméticas que calculam sinalizadores de processador semelhantes a uma operação de comparação
com base nessa aritmética. Se possível, elimine a operação de comparação explícita.

Esta passagem se aplica apenas a certos alvos que não podem representar explicitamente o
operação de comparação antes que a alocação de registro seja concluída.

Habilitado em níveis -O, -O2, -O3, -Os.

-fuse-ld = ouro
Use o ouro vinculador em vez do vinculador padrão.

-fuse-ld = bfd
Use o ld.bfd vinculador em vez do vinculador padrão.

-fcprop-registros
Após a alocação de registro e divisão de instrução de alocação pós-registro, nós
execute uma passagem de propagação de cópia para tentar reduzir as dependências de programação e
ocasionalmente elimine a cópia.

Habilitado em níveis -O, -O2, -O3, -Os.

- correção de perfil
Perfis coletados usando um binário instrumentado para programas multi-threaded podem ser
inconsistente devido a atualizações do contador perdidas. Quando esta opção é especificada, o GCC irá
use heurísticas para corrigir ou suavizar tais inconsistências. Por padrão, o GCC irá
emite uma mensagem de erro quando um perfil inconsistente é detectado.

-fprofile-dir =caminho
Defina o diretório para pesquisar os arquivos de dados de perfil em caminho. Esta opção
afeta apenas os dados de perfil gerados por -fprofile-gerar, -teste-cobertura,
-fprofile-arcos e usado por -fprofile-use e -fbranch-probabilidades e seus relacionados
opções. Ambos os caminhos absolutos e relativos podem ser usados. Por padrão, o GCC usará o
diretório atual como caminho, assim, o arquivo de dados do perfil aparecerá no mesmo
diretório como o arquivo de objeto.

-fprofile-gerar
-fprofile-generate =caminho
Habilite as opções normalmente usadas para o aplicativo de instrumentação para produzir um perfil útil
para posterior recompilação com otimização baseada em feedback de perfil. Você deve usar
-fprofile-gerar tanto ao compilar quanto ao vincular seu programa.

As seguintes opções estão habilitadas: "-fprofile-arcs", "-fprofile-values", "-fvpt".

If caminho for especificado, o GCC examinará o caminho para encontrar os dados de feedback do perfil
arquivos. Ver -fprofile-dir.

-fprofile-use
-fprofile-use =caminho
Permitir otimizações direcionadas de feedback de perfil e otimizações geralmente lucrativas
apenas com feedback de perfil disponível.

As seguintes opções estão ativadas: "-fbranch-probabilities", "-fvpt",
"-funroll-loops", "-fpeel-loops", "-ftracer"

Por padrão, o GCC emite uma mensagem de erro se os perfis de feedback não corresponderem ao
Código fonte. Este erro pode ser transformado em um aviso usando -Wcoverage-inmatch.
Observe que isso pode resultar em um código mal otimizado.

If caminho for especificado, o GCC examinará o caminho para encontrar os dados de feedback do perfil
arquivos. Ver -fprofile-dir.

As opções a seguir controlam o comportamento do compilador em relação à aritmética de ponto flutuante.
Essas opções são negociadas entre velocidade e correção. Todos devem ser ativados especificamente.

-loat-store
Não armazene variáveis ​​de ponto flutuante em registros e iniba outras opções que
pode alterar se um valor de ponto flutuante é obtido de um registro ou memória.

Esta opção evita excesso de precisão indesejável em máquinas como a 68000 onde
os registradores flutuantes (do 68881) mantêm mais precisão do que um "duplo" é suposto
Ter. Da mesma forma para a arquitetura x86. Para a maioria dos programas, o excesso de precisão
só funciona bem, mas alguns programas dependem da definição precisa de flutuação IEEE
apontar. Usar -loat-store para tais programas, depois de modificá-los para armazenar todos
cálculos intermediários pertinentes em variáveis.

-fexcess-precision =estilo
Esta opção permite maior controle sobre o excesso de precisão em máquinas onde
registradores de ponto têm mais precisão do que os tipos IEEE "float" e "double" e os
o processador não suporta operações de arredondamento para esses tipos. Por padrão,
-fexcess-precision = fast está em vigor; isso significa que as operações são realizadas em
a precisão dos registros e que é imprevisível ao arredondar para os tipos
especificado no código-fonte ocorre. Ao compilar C, se
-fexcess-precision = standard for especificado, então o excesso de precisão seguirá as regras
especificado na ISO C99; em particular, tanto as projeções quanto as atribuições fazem com que os valores sejam
arredondado para seus tipos semânticos (enquanto -loat-store afeta apenas as atribuições).
Esta opção é habilitada por padrão para C se uma opção de conformidade estrita, como
-std = c99 é usado.

-fexcess-precision = standard não é implementado para linguagens diferentes de C e não tem
efeito se -funsafe-math-otimizations or -rápida matemática é especificado. No x86,
também não tem efeito se -mfpmath = sse or -mfpmath = sse + 387 é especificado; na antiga
caso, a semântica IEEE se aplica sem precisão excessiva, e no último, o arredondamento é
imprevisível.

-rápida matemática
Conjuntos -fno-matemática-errno, -funsafe-math-otimizations, -finite-matemática-apenas,
-não-arredondamento-matemática, -fno-sinalização-nans e -fcx-intervalo limitado.

Esta opção faz com que a macro do pré-processador "__FAST_MATH__" seja definida.

Esta opção não é ativada por nenhum -O opção além de -Rápido uma vez que pode resultar em
saída incorreta para programas que dependem de uma implementação exata de IEEE ou ISO
regras / especificações para funções matemáticas. Pode, no entanto, gerar um código mais rápido para
programas que não requerem as garantias dessas especificações.

-fno-matemática-errno
Não defina ERRNO depois de chamar funções matemáticas que são executadas com um único
instrução, por exemplo, sqrt. Um programa que se baseia em exceções IEEE para erros matemáticos
manipulação pode querer usar este sinalizador para velocidade enquanto mantém a aritmética IEEE
compatibilidade.

Esta opção não é ativada por nenhum -O opção, pois pode resultar em saída incorreta
para programas que dependem de uma implementação exata de IEEE ou ISO
regras / especificações para funções matemáticas. Pode, no entanto, gerar um código mais rápido para
programas que não requerem as garantias dessas especificações.

O padrão é -fmath-errno.

Em sistemas Darwin, a biblioteca matemática nunca define "errno". Portanto, não há razão
para o compilador considerar a possibilidade de que possa, e -fno-matemática-errno é o
padrão.

-funsafe-math-otimizations
Permitir otimizações para aritmética de ponto flutuante que (a) assume que os argumentos e
os resultados são válidos e (b) podem violar os padrões IEEE ou ANSI. Quando usado no link-time,
pode incluir bibliotecas ou arquivos de inicialização que alteram a palavra de controle FPU padrão ou
outras otimizações semelhantes.

Esta opção não é ativada por nenhum -O opção, pois pode resultar em saída incorreta
para programas que dependem de uma implementação exata de IEEE ou ISO
regras / especificações para funções matemáticas. Pode, no entanto, gerar um código mais rápido para
programas que não requerem as garantias dessas especificações. Possibilita
-não-zeros assinados, -fno-trapping-matemática, -fassociativa-matemática e -frecíproca-matemática.

O padrão é -fno-unsafe-math-otimizations.

-fassociativa-matemática
Permite a reassociação de operandos em uma série de operações de ponto flutuante. Esse
viola o padrão de linguagem ISO C e C ++, possivelmente alterando o resultado do cálculo.
NOTA: o reordenamento pode alterar o sinal de zero, bem como ignorar NaNs e inibir ou
criar underflow ou overflow (e, portanto, não pode ser usado em código que depende de arredondamento
comportamento como "(x + 2 ** 52) - 2 ** 52". Também pode reordenar comparações de ponto flutuante e
portanto, não pode ser usado quando comparações ordenadas são necessárias. Esta opção requer que
ambos -não-zeros assinados e -fno-trapping-matemática estar em vigor. Além disso, não faz
muito sentido com -matriz-matemática. Para Fortran, a opção é ativada automaticamente quando
ambos -não-zeros assinados e -fno-trapping-matemática estão em vigor.

O padrão é -não-matemática-associativa.

-frecíproca-matemática
Permitir que o recíproco de um valor seja usado em vez de dividir pelo valor se este
permite otimizações. Por exemplo, "x / y" pode ser substituído por "x * (1 / y)", que é
útil se "(1 / y)" estiver sujeito à eliminação de subexpressão comum. Observe que este
perde a precisão e aumenta o número de flops operando no valor.

O padrão é -fno-matemática-recíproca.

-finite-matemática-apenas
Permitir otimizações para aritmética de ponto flutuante que assume que os argumentos e
os resultados não são NaNs ou + -Infs.

Esta opção não é ativada por nenhum -O opção, pois pode resultar em saída incorreta
para programas que dependem de uma implementação exata de IEEE ou ISO
regras / especificações para funções matemáticas. Pode, no entanto, gerar um código mais rápido para
programas que não requerem as garantias dessas especificações.

O padrão é -não-finito-matemática-apenas.

-não-zeros assinados
Permitir otimizações para aritmética de ponto flutuante que ignora a sinalização de zero.
A aritmética IEEE especifica o comportamento de valores distintos de +0.0 e -0.0, que então
proíbe a simplificação de expressões como x + 0.0 ou 0.0 * x (mesmo com
-finite-matemática-apenas) Esta opção implica que o sinal de um resultado zero não é
significativo.

O padrão é -fsignificado-zeros.

-fno-trapping-matemática
Compile o código presumindo que as operações de ponto flutuante não podem gerar dados visíveis ao usuário
armadilhas. Essas armadilhas incluem divisão por zero, estouro, estouro negativo, resultado inexato e
operação inválida. Esta opção requer que -fno-sinalização-nans estar em vigor.
Definir esta opção pode permitir um código mais rápido se depender da aritmética IEEE "ininterrupta",
por exemplo.

Esta opção nunca deve ser ativada por qualquer -O opção, uma vez que pode resultar em
saída incorreta para programas que dependem de uma implementação exata de IEEE ou ISO
regras / especificações para funções matemáticas.

O padrão é -fttrapping-matemática.

-matriz-matemática
Desative as transformações e otimizações que assumem o arredondamento de ponto flutuante padrão
comportamento. Isso é arredondado para zero para todas as conversões de ponto flutuante para inteiros, e
arredondar para o mais próximo para todos os outros truncamentos aritméticos. Esta opção deve ser
especificado para programas que alteram o modo de arredondamento FP dinamicamente, ou que podem ser
executado com um modo de arredondamento não padrão. Esta opção desativa o dobramento constante de
expressões de ponto flutuante em tempo de compilação (que podem ser afetadas pelo modo de arredondamento)
e transformações aritméticas que não são seguras na presença de
modos de arredondamento.

O padrão é -não-arredondamento-matemática.

Esta opção é experimental e atualmente não garante a desativação de todos os GCC
otimizações que são afetadas pelo modo de arredondamento. Versões futuras do GCC podem fornecer
controle mais preciso dessa configuração usando o pragma "FENV_ACCESS" do C99. Esta linha de comando
opção será usada para especificar o estado padrão para "FENV_ACCESS".

-fsinalização-nans
Compilar o código assumindo que os NaNs de sinalização IEEE podem gerar armadilhas visíveis ao usuário durante
operações de ponto flutuante. Definir esta opção desativa otimizações que podem mudar
o número de exceções visíveis com NaNs de sinalização. Esta opção implica
-fttrapping-matemática.

Esta opção faz com que a macro do pré-processador "__SUPPORT_SNAN__" seja definida.

O padrão é -fno-sinalização-nans.

Esta opção é experimental e atualmente não garante a desativação de todos os GCC
otimizações que afetam o comportamento da sinalização do NaN.

-fconstante de precisão única
Trate constantes de ponto flutuante como precisão única em vez de converter implicitamente
-los para constantes de precisão dupla.

-fcx-intervalo limitado
Quando ativada, esta opção afirma que uma etapa de redução de faixa não é necessária quando
realizando divisão complexa. Além disso, não há como verificar se o resultado de um
multiplicação ou divisão complexa é "NaN + I * NaN", com uma tentativa de resgatar o
situação nesse caso. O padrão é -fno-cx-intervalo limitado, mas é habilitado por
-rápida matemática.

Esta opção controla a configuração padrão do pragma ISO C99 "CX_LIMITED_RANGE".
No entanto, a opção se aplica a todos os idiomas.

-fcx-fortran-regras
A multiplicação e divisão complexa seguem as regras do Fortran. A redução do intervalo é feita como
parte da divisão complexa, mas não há verificação se o resultado de uma divisão complexa
multiplicação ou divisão é "NaN + I * NaN", com uma tentativa de resgatar a situação
nesse caso.

O padrão é -fno-cx-fortran-regras.

As seguintes opções controlam otimizações que podem melhorar o desempenho, mas não são
habilitado por qualquer -O opções. Esta seção inclui opções experimentais que podem produzir
código quebrado.

-fbranch-probabilidades
Depois de executar um programa compilado com -fprofile-arcos, você pode compilá-lo uma segunda vez
utilização -fbranch-probabilidades, para melhorar as otimizações com base no número de vezes
cada ramo foi tomado. Quando o programa compilado com -fprofile-arcos sai salva
a execução do arco conta para um arquivo chamado nome de origem.gcda para cada arquivo de origem. o
as informações neste arquivo de dados são muito dependentes da estrutura do
código, então você deve usar o mesmo código-fonte e as mesmas opções de otimização para ambos
compilações.

Com -fbranch-probabilidades, O GCC coloca um REG_BR_PROB nota em cada JUMP_INSN e
CALL_INSN. Eles podem ser usados ​​para melhorar a otimização. Atualmente, eles são usados ​​apenas
em um lugar: em reorg.c, em vez de adivinhar qual caminho um ramo tem mais probabilidade de
levar a REG_BR_PROB os valores são usados ​​para determinar exatamente qual caminho é seguido mais
frequentemente.

-fprofile-valores
Se combinado com -fprofile-arcos, adiciona código para que alguns dados sobre valores de
expressões no programa são reunidas.

Com -fbranch-probabilidades, ele lê de volta os dados coletados a partir de valores de criação de perfil de
expressões para uso em otimizações.

Habilitado com -fprofile-gerar e -fprofile-use.

-fvpt
Se combinado com -fprofile-arcos, ele instrui o compilador a adicionar um código para reunir
informações sobre valores de expressões.

Com -fbranch-probabilidades, ele lê de volta os dados coletados e realmente executa o
otimizações com base neles. Atualmente, as otimizações incluem especialização de
operação de divisão usando o conhecimento sobre o valor do denominador.

-frename-registros
Tentar evitar dependências falsas no código programado, usando os registros restantes
após a alocação do registro. Esta otimização irá beneficiar a maioria dos processadores com
muitos registros. Dependendo do formato de informações de depuração adotado pelo destino,
no entanto, pode tornar a depuração impossível, uma vez que as variáveis ​​não ficarão mais em um
"registro residencial".

Ativado por padrão com -funroll-loops e -fpeel-loops.

-ftracer
Execute a duplicação da cauda para aumentar o tamanho do superbloco. Esta transformação simplifica
o fluxo de controle da função permitindo que outras otimizações façam um trabalho melhor.

Habilitado com -fprofile-use.

-funroll-loops
Loops de desenrolamento cujo número de iterações pode ser determinado em tempo de compilação ou após
entrada para o loop. -funroll-loops implica -frerun-cse-após-loop, -fweb e
-frename-registros. Ele também ativa o peeling de loop completo (ou seja, a remoção completa de
loops com pequeno número constante de iterações). Esta opção torna o código maior e
pode ou não fazer com que funcione mais rápido.

Habilitado com -fprofile-use.

-funroll-todos-loops
Desenrole todos os loops, mesmo se o número de iterações for incerto quando o loop for
entrou. Isso geralmente faz com que os programas sejam executados mais lentamente. -funroll-todos-loops implica o
mesmas opções que -funroll-loops.

-fpeel-loops
Loops de casca para os quais há informações suficientes para que eles não rolem muito (de
feedback do perfil). Ele também ativa o peeling de loop completo (ou seja, a remoção completa de
loops com pequeno número constante de iterações).

Habilitado com -fprofile-use.

-fmove-loop-invariantes
Ativa a passagem de movimento invariante do loop no otimizador de loop RTL. Ativado no nível
-O1

-funswitch-loops
Mova ramos com condições invariantes de loop para fora do loop, com duplicatas do
loop em ambos os ramos (modificado de acordo com o resultado da condição).

-funções-seções
-fdata-seções
Coloque cada função ou item de dados em sua própria seção no arquivo de saída se o alvo
suporta seções arbitrárias. O nome da função ou o nome do item de dados
determina o nome da seção no arquivo de saída.

Use essas opções em sistemas onde o vinculador pode realizar otimizações para melhorar
localidade de referência no espaço de instrução. A maioria dos sistemas usando o objeto ELF
format e processadores SPARC executando Solaris 2 têm linkers com essas otimizações.
O AIX pode ter essas otimizações no futuro.

Use essas opções apenas quando houver benefícios significativos em fazê-lo. Quando você
especificar essas opções, o montador e o vinculador criarão um objeto maior e
arquivos executáveis ​​e também serão mais lentos. Você não poderá usar "gprof" em todos
sistemas se você especificar esta opção e você pode ter problemas com a depuração se você
especifique esta opção e -g.

-fbranch-target-load-optimize
Execute a otimização da carga do registro de destino do branch antes do encadeamento do prólogo / epílogo.
O uso de registradores de destino normalmente pode ser exposto apenas durante a recarga, elevando assim
carrega fora de loops e fazer o agendamento entre blocos precisa de uma otimização separada
passar.

-fbranch-target-load-optimize2
Execute a otimização de carregamento de registro de destino de ramificação após o encadeamento de prólogo / epílogo.

-fbtr-bb-exclusivo
Ao realizar a otimização de carga de registro de destino de ramificação, não reutilize destino de ramificação
registra em qualquer bloco básico.

-fstack-protetor
Emita código extra para verificar estouros de buffer, como ataques de destruição de pilha. Esse
é feito adicionando uma variável de guarda às funções com objetos vulneráveis. Esse
inclui funções que chamam alloca e funções com buffers maiores que 8 bytes.
Os protetores são inicializados quando uma função é inserida e, em seguida, verificados quando o
saídas de função. Se uma verificação de guarda falhar, uma mensagem de erro é impressa e o programa
saídas.

NOTA: No Ubuntu 6.10 e versões posteriores, esta opção é habilitada por padrão para C, C ++,
ObjC, ObjC ++, se nenhum dos -fno-stack-protetor, -nostdlibnem -freestanding e guarante que os mesmos estão
encontrado.

-fstack-protetor-tudo
Como -fstack-protetor exceto que todas as funções são protegidas.

- âncoras de seção
Tente reduzir o número de cálculos de endereços simbólicos usando "âncora" compartilhada
símbolos para abordar objetos próximos. Essa transformação pode ajudar a reduzir o número
de entradas GOT e acessos GOT em alguns destinos.

Por exemplo, a implementação da seguinte função "foo":

estático int a, b, c;
int foo (vazio) {return a + b + c; }

normalmente calcularia os endereços de todas as três variáveis, mas se você compilá-lo
com - âncoras de seção, ele irá acessar as variáveis ​​de um ponto de ancoragem comum
em vez de. O efeito é semelhante ao seguinte pseudocódigo (que não é válido C):

int foo (vazio)
{
registrar int * xr = & x;
return xr [& a - & x] + xr [& b - & x] + xr [& c - & x];
}

Nem todos os destinos oferecem suporte a essa opção.

--param nome=valor
Em alguns lugares, o GCC usa várias constantes para controlar a quantidade de otimização que
é feito. Por exemplo, o GCC não irá incorporar funções que contenham mais do que um certo
número de instruções. Você pode controlar algumas dessas constantes na linha de comando
usando o --param opção.

Os nomes de parâmetros específicos e o significado dos valores estão vinculados ao
internos do compilador e estão sujeitos a alterações sem aviso no futuro
Lançamentos.

Em cada caso, o valor é um número inteiro. As escolhas permitidas para nome são dados em
a seguinte tabela:

resultado previsível do ramo
Quando a ramificação está prevista para ser tomada com probabilidade menor do que este limite
(em porcentagem), então é considerado bem previsível. O padrão é 10.

max-crossjump-bordas
O número máximo de arestas de entrada a considerar para salto cruzado. O algoritmo
utilizado pelo -f salto cruzado é O (N ^ 2) no número de arestas que chegam a cada bloco.
Valores crescentes significam otimização mais agressiva, tornando o tempo de compilação
aumentar com provavelmente uma pequena melhoria no tamanho do executável.

min-crossjump-insns
O número mínimo de instruções que devem ser combinadas no final de dois blocos
antes do salto cruzado será executado neles. Este valor é ignorado no caso
onde todas as instruções no bloco do qual está sendo feito o salto cruzado são correspondidas. o
o valor padrão é 5.

max-grow-copy-bb-insns
O fator de expansão de tamanho de código máximo ao copiar blocos básicos em vez de
pulando. A expansão é relativa a uma instrução de salto. o valor padrão é
8.

max-goto-duplicação-insns
O número máximo de instruções para duplicar para um bloco que salta para um
goto calculado. Para evitar o comportamento O (N ^ 2) em uma série de passagens, os fatores GCC
computou gotos no início do processo de compilação e desatualizou-os tão tarde quanto
possível. Apenas saltos computados no final de blocos básicos com não mais do que max-
goto-duplication-insns não são fatorados. O valor padrão é 8.

max-delay-slot-insn-pesquisa
O número máximo de instruções a considerar ao procurar uma instrução para
preencher um slot de atraso. Se mais do que este número arbitrário de instruções for
pesquisado, a economia de tempo para preencher o slot de atraso será mínima, então pare
procurando. Valores crescentes significam otimização mais agressiva, tornando o
aumento do tempo de compilação com provavelmente uma pequena melhoria no tempo de execução.

max-delay-slot-live-search
Ao tentar preencher slots de atraso, o número máximo de instruções a considerar
ao pesquisar um bloco com informações de registro ao vivo válidas. Aumentando isso
valor escolhido arbitrariamente significa otimização mais agressiva, aumentando o
tempo de compilação. Este parâmetro deve ser removido quando o código de slot de atraso é
reescrito para manter o gráfico de fluxo de controle.

memória max-gcse
A quantidade máxima aproximada de memória que será alocada para
realizar a otimização de eliminação de subexpressão comum global. Se mais memória
do que o especificado for necessário, a otimização não será feita.

taxa de inserção max-gcse
Se a proporção de inserções de expressão para exclusões for maior do que este valor para
qualquer expressão, então RTL PRE irá inserir ou remover a expressão e, assim, deixar
cálculos parcialmente redundantes no fluxo de instrução. o valor padrão é
20.

comprimento máximo da lista pendente
O número máximo de agendamento de dependências pendentes permitirá antes de descarregar
o estado atual e recomeçar. Grandes funções com poucos ramos ou chamadas
pode criar listas excessivamente grandes que consomem memória e recursos desnecessariamente.

max-modulo-backtrack-tentativas
O número máximo de tentativas de retrocesso que o planejador deve fazer quando o módulo
agendar um loop. Valores maiores podem aumentar exponencialmente o tempo de compilação.

max-inline-insns-single
Vários parâmetros controlam o inliner da árvore usado no gcc. Este número define o
número máximo de instruções (contadas na representação interna do GCC) em um
função única que o inliner da árvore considerará para inlining. Apenas este
afeta funções declaradas inline e métodos implementados em uma declaração de classe
(C ++). O valor padrão é 400.

max-inline-insns-auto
Quando você usa -funções-finline (incluído em -O3), muitas funções que seriam
caso contrário, não será considerado para embutir pelo compilador será investigado. Para
essas funções, um limite diferente (mais restritivo) em comparação com as funções
declarado embutido pode ser aplicado. O valor padrão é 40.

grande-função-insns
O limite que especifica funções realmente grandes. Para funções maiores que este limite
após o inlining, o inlining é restringido por --param crescimento de grande função. Este
parâmetro é útil principalmente para evitar tempo de compilação extremo causado por
algoritmos lineares usados ​​pelo back end. O valor padrão é 2700.

crescimento de grande função
Especifica o crescimento máximo de função grande causada pelo inlining em porcentagens. o
o valor padrão é 100, o que limita o crescimento da função grande a 2.0 vezes o original
tamanho.

Insns de unidades grandes
O limite que especifica uma grande unidade de tradução. Crescimento causado pelo inlining de unidades
maior do que este limite é limitado por --param crescimento da unidade em linha. Para unidades pequenas
isso pode ser muito restrito (considere a unidade consistindo na função A que está em linha e
B que apenas chama A três vezes. Se B é pequeno em relação a A, o crescimento da unidade
é 300 \% e, no entanto, esse inlining é muito lógico. Para unidades muito grandes consistindo em
pequenas funções embutidas; no entanto, o limite geral de crescimento da unidade é necessário para
evite a explosão exponencial do tamanho do código. Assim, para unidades menores, o tamanho é
aumentada para --param Insns de unidades grandes antes de aplicar --param crescimento da unidade em linha.
O padrão é 10000

crescimento da unidade em linha
Especifica o crescimento geral máximo da unidade de compilação causado pelo inlining. o
o valor padrão é 30, o que limita o crescimento da unidade a 1.3 vezes o tamanho original.

crescimento da unidade ipcp
Especifica o crescimento geral máximo da unidade de compilação causado por interpretações interpretativas
propagação constante. O valor padrão é 10, o que limita o crescimento da unidade a 1.1
vezes o tamanho original.

estrutura de pilha grande
O limite que especifica quadros de pilha grandes. Enquanto inlining, o algoritmo está tentando
para não crescer muito além desse limite. O valor padrão é 256 bytes.

crescimento de frame de pilha grande
Especifica o crescimento máximo de quadros de pilha grandes causados ​​por inlining em porcentagens.
O valor padrão é 1000, o que limita o grande crescimento do frame da pilha a 11 vezes o
tamanho original.

max-inline-insns-recursivo
max-inline-insns-recursivo-auto
Especifica o número máximo de instruções de cópia fora da linha de auto recursiva embutida
função pode crescer executando inlining recursivo.

Para funções declaradas inline --param max-inline-insns-recursivo é levado para
conta. Para funções não declaradas inline, inlining recursivo acontece apenas quando
-funções-finline (incluído em -O3) está habilitado e --param max-inline-insns-
auto recursivo é usado. O valor padrão é 450.

profundidade máxima em linha recursiva
max-inline-recursivo-profundidade-automática
Especifica a profundidade de recursão máxima usada pelo inlining recursivo.

Para funções declaradas inline --param profundidade máxima em linha recursiva é levado para
conta. Para funções não declaradas inline, inlining recursivo acontece apenas quando
-funções-finline (incluído em -O3) está habilitado e --param max-inline-recursivo-
profundidade auto é usado. O valor padrão é 8.

probabilidade mínima recursiva em linha
O inlining recursivo é lucrativo apenas para funções com recursão profunda em
média e pode prejudicar a função com pouca profundidade de recursão, aumentando o
tamanho do prólogo ou complexidade do corpo da função para outros otimizadores.

Quando o feedback do perfil estiver disponível (consulte -fprofile-gerar) a recursão real
a profundidade pode ser adivinhada a partir da probabilidade de que a função retorne por meio de uma determinada chamada
expressão. Este parâmetro limita o inlining apenas para chamar a expressão cujo
a probabilidade excede o limite determinado (em porcentagens). O valor padrão é 10.

inlining-insns antecipados
Especifique o crescimento que o inliner inicial pode gerar. Com efeito, aumenta a quantidade de
inlining para código com grande penalidade de abstração. O valor padrão é 10.

iterações max-early-inliner
iterações max-early-inliner
Limite de iterações do inliner inicial. Basicamente, isso limita o número de
chamadas indiretas iniciais do inliner podem ser resolvidas. Cadeias mais profundas ainda são tratadas tarde
embutimento.

probabilidade de compartilhamento de comdat
probabilidade de compartilhamento de comdat
Probabilidade (em porcentagem) de que a função inline C ++ com visibilidade comdat será
compartilhado em várias unidades de compilação. O valor padrão é 20.

limite de min-vect-loop
O número mínimo de iterações sob as quais um loop não será vetorizado quando
-ftree-vetorize é usado. O número de iterações após a vetorização deve
ser maior que o valor especificado por esta opção para permitir a vetorização. o
o valor padrão é 0.

relação custo-distância-gcse
Fator de escala no cálculo da distância máxima pela qual uma expressão pode ser movida
Otimizações GCSE. No momento, isso é compatível apenas com a passagem de içamento de código.
Quanto maior a proporção, mais agressivo será o içamento do código com
expressões, ou seja, as expressões que custam menos do que gcse-irrestrito-
custo. Especificar 0 desabilitará o levantamento de expressões simples. O padrão
o valor é 10.

custo irrestrito do gcse
Custo, medido aproximadamente como o custo de uma única instrução de máquina típica, em
quais otimizações de GCSE não restringirão a distância que uma expressão pode viajar.
No momento, isso é compatível apenas com a passagem de içamento de código. Quanto menor o custo,
o içamento de código mais agressivo será. Especificar 0 permitirá que todos
expressões para viajar distâncias irrestritas. O valor padrão é 3.

profundidade máxima de elevação
A profundidade da pesquisa na árvore dominadora por expressões a serem levantadas. Isso é usado
para evitar o comportamento quadrático no algoritmo de içamento. O valor de 0 evitará
limitando a pesquisa, mas pode retardar a compilação de funções enormes. O padrão
o valor é 30.

max-tail-merge-comparations
A quantidade máxima de bbs semelhantes com os quais comparar um bb. Isso é usado para evitar
comportamento quadrático na fusão da cauda da árvore. O valor padrão é 10.

max-tail-merge-iterações
A quantidade máxima de iterações da passagem sobre a função. Isso é usado para
limite o tempo de compilação na fusão da cauda da árvore. O valor padrão é 2.

max-unrolled-insns
O número máximo de instruções que um loop deve ter se esse loop for
desenrolado, e se o loop for desenrolado, ele determina quantas vezes o código do loop
é desenrolado.

max-average-unrolled-insns
O número máximo de instruções influenciadas pelas probabilidades de sua execução que
um loop deve ter se esse loop for desenrolado, e se o loop for desenrolado,
determina quantas vezes o código do loop é desenrolado.

tempos máximos de desenrolamento
O número máximo de desdobramentos de um único loop.

max-peeled-insns
O número máximo de instruções que um loop deve ter se esse loop for descascado,
e se o loop for descascado, ele determina quantas vezes o código do loop é descascado.

tempos máximos de descamação
O número máximo de peelings de um único loop.

max-completamente-descascado-insns
O número máximo de insns de um loop completamente descascado.

tempos máximos de remoção completa
O número máximo de iterações de um loop adequado para o peeling completo.

max-completamente-peel-loop-nest-depth
A profundidade máxima de um ninho de loop adequado para o peeling completo.

max-unswitch-insns
O número máximo de insns de um loop não comutado.

nível máximo de desconexão
O número máximo de ramificações não comutadas em um único loop.

lim-caro
O custo mínimo de uma expressão cara no movimento invariante do loop.

iv-considerar-todos-os-candidatos-vinculados
Limite no número de candidatos para variáveis ​​de indução abaixo de todos os candidatos
são considerados para cada uso em otimizações de variáveis ​​de indução. Apenas o mais
candidatos relevantes são considerados se houver mais candidatos, para evitar
complexidade quadrática de tempo.

iv-máx-considerado-usa
As otimizações da variável de indução desistem de loops que contêm mais indução
usos de variáveis.

iv-sempre-podar-cand-conjunto-limitado
Se o número de candidatos no conjunto for menor do que este valor, sempre tentamos
remover ivs desnecessários do conjunto durante sua otimização quando um novo iv é adicionado
para o conjunto.

scev-max-expr-tamanho
Limite no tamanho das expressões usadas no analisador de evoluções escalares. Grande
expressões tornam o analisador mais lento.

complexidade scev-max-expr
Vinculado à complexidade das expressões no analisador de evoluções escalares.
Expressões complexas tornam o analisador mais lento.

ômega-max-vars
O número máximo de variáveis ​​em um sistema de restrição Omega. O valor padrão
é 128.

ômega-max-geqs
O número máximo de desigualdades em um sistema de restrição Omega. O padrão
o valor é 256.

ômega-max-eqs
O número máximo de igualdades em um sistema de restrição Omega. O valor padrão
é 128.

curingas ômega-max
O número máximo de variáveis ​​curinga que o solucionador Omega será capaz de
inserir. O valor padrão é 18.

ômega-hash-table-size
O tamanho da tabela hash no solucionador Omega. O valor padrão é 550.

chaves ômega-max
O número máximo de chaves usadas pelo solucionador Omega. O valor padrão é 500.

omega-eliminar-redundant-constraints
Quando definido como 1, use métodos caros para eliminar todas as restrições redundantes. o
o valor padrão é 0.

vect-max-versão-para-verificações de alinhamento
O número máximo de verificações de tempo de execução que podem ser realizadas ao fazer o loop
controle de versão para alinhamento no vetorizador. Veja a opção ftree-vect-loop-version
para entender melhor.

vect-max-version-for-alias-checks
O número máximo de verificações de tempo de execução que podem ser realizadas ao fazer o loop
controle de versão para alias no vetorizador. Veja a opção ftree-vect-loop-version para
Mais Informações.

máximo de iterações para rastrear
O número máximo de iterações de um loop, o algoritmo de força bruta para análise
de # de iterações do loop tenta avaliar.

fração de contagem quente-bb
Selecione a fração da contagem máxima de repetições do bloco básico no programa
determinado bloco básico precisa ser considerado quente.

fração de frequência quente-bb
Selecione a fração da frequência do bloco de entrada de execuções do bloco básico em
a função dada ao bloco básico precisa ser considerada quente.

iterações máximas preditas
O número máximo de iterações de loop que prevemos estaticamente. Isso é útil em
casos em que a função contém um único loop com limite conhecido e outro loop com
desconhecido. Prevemos o número conhecido de iterações corretamente, enquanto o desconhecido
número de iterações em média para cerca de 10. Isso significa que o loop sem
os limites pareceriam artificialmente frios em relação ao outro.

alinhar-limiar
Selecione a fração da frequência máxima de execuções do bloco básico em função
dado bloco básico será alinhado.

alinhar-loop-iterações
Espera-se que um loop itere, a menos que o número selecionado de iterações chegue
alinhado.

tracer-dynamic-cobertura
tracer-dynamic-cobertura-feedback
Este valor é usado para limitar a formação do superbloco, uma vez que a porcentagem dada de
as instruções executadas são abordadas. Isso limita a expansão desnecessária do tamanho do código.

A tracer-dynamic-cobertura-feedback é usado apenas quando o feedback do perfil é
acessível. Os perfis reais (em oposição aos estimados estaticamente) são muito
menos equilibrado, permitindo que o limite seja um valor maior.

tracer-max-code-growth
Pare a duplicação da cauda assim que o crescimento do código atingir uma determinada porcentagem. Isto é
argumento bastante piegas, já que a maioria das duplicatas serão eliminadas mais tarde no cruzamento
pulando, por isso pode ser definido com valores muito mais altos do que o crescimento de código desejado.

razão traçador-min-ramo
Pare o crescimento reverso quando a probabilidade reversa da melhor borda for menor que isso
limite (em porcentagem).

razão traçador-min-ramo
rastreador-min-branch-ratio-feedback
Pare o crescimento para frente se a melhor borda tiver probabilidade menor do que isso
limite.

similarmente a tracer-dynamic-cobertura dois valores estão presentes, um para compilação
para feedback do perfil e outro para compilação sem. O valor para compilação
com o feedback do perfil precisa ser mais conservador (mais alto), a fim de tornar
traçador eficaz.

comprimento máximo do caminho cse
Número máximo de blocos básicos no caminho que o cse considera. O padrão é 10.

max-cse-insns
As instruções máximas do processo CSE antes da lavagem. O padrão é 1000.

ggc-min-expandir
O GCC usa um coletor de lixo para gerenciar sua própria alocação de memória. Este parâmetro
especifica a porcentagem mínima pela qual o heap do coletor de lixo deve ser
permissão para expandir entre as coleções. Ajustar isso pode melhorar a velocidade de compilação;
não tem efeito na geração de código.

O padrão é 30% + 70% * (RAM / 1GB) com um limite superior de 100% quando RAM> = 1GB.
Se "getrlimit" estiver disponível, a noção de "RAM" é o menor da RAM real e
"RLIMIT_DATA" ou "RLIMIT_AS". Se o GCC não for capaz de calcular RAM em um determinado
plataforma, o limite inferior de 30% é usado. Definir este parâmetro e ggc-min-
tamanho da pilha para zero faz com que uma coleta completa ocorra em todas as oportunidades. Isto é
extremamente lento, mas pode ser útil para depuração.

ggc-min-heapsize
Tamanho mínimo da pilha do coletor de lixo antes de começar a se preocupar em coletar
lixo. A primeira coleta ocorre depois que o heap se expande por ggc-min-expandir%
para além ggc-min-heapsize. Novamente, ajustar isso pode melhorar a velocidade de compilação, e
não tem efeito na geração de código.

O padrão é o menor de RAM / 8, RLIMIT_RSS ou um limite que tenta garantir
que RLIMIT_DATA ou RLIMIT_AS não são excedidos, mas com um limite inferior de 4096
(quatro megabytes) e um limite superior de 131072 (128 megabytes). Se o GCC não for capaz
para calcular a RAM em uma plataforma específica, o limite inferior é usado. Configurando isso
parâmetro muito grande desabilita efetivamente a coleta de lixo. Configurando isso
parâmetro e ggc-min-expandir a zero faz com que uma coleção completa ocorra a cada
uma vez na vida.

max-reload-search-insns
O número máximo de recarga de instrução deve olhar para trás para obter o equivalente
registro. Valores crescentes significam otimização mais agressiva, tornando o
aumento do tempo de compilação com desempenho provavelmente um pouco melhor. O padrão
o valor é 100.

locais de memória max-cselib
O número máximo de localizações de memória que o cselib deve levar em consideração.
Valores crescentes significam otimização mais agressiva, tornando o tempo de compilação
aumentar com desempenho provavelmente ligeiramente melhor. O valor padrão é 500.

reordenar-blocos-duplicar
reordenar-bloquear-duplicar-feedback
Usado pelo passe de reordenação de bloco básico para decidir se deve usar o branch incondicional
ou duplique o código em seu destino. O código é duplicado quando é estimado
o tamanho é menor do que este valor multiplicado pelo tamanho estimado do incondicional
saltar nos pontos quentes do programa.

A reordenar-bloquear-duplicar-feedback é usado apenas quando o feedback do perfil é
disponível e pode ser definido com valores maiores do que reordenar-bloquear-duplicar desde
as informações sobre os pontos críticos são mais precisas.

max-sched-ready-insns
O número máximo de instruções prontas para serem emitidas, o planejador deve
considere a qualquer momento durante a primeira passagem de agendamento. Valores crescentes
significa pesquisas mais completas, fazendo com que o tempo de compilação aumente com provavelmente
pouco benefício. O valor padrão é 100.

blocos de região agendada máxima
O número máximo de blocos em uma região a ser considerada para interbloqueio
agendamento. O valor padrão é 10.

max-pipeline-region-blocos
O número máximo de blocos em uma região a ser considerado para pipelining no
agendador seletivo. O valor padrão é 15.

max-sched-region-insns
O número máximo de insns em uma região a ser considerado para interbloqueio
agendamento. O valor padrão é 100.

max-pipeline-region-insns
O número máximo de insns em uma região a ser considerado para pipelining no
agendador seletivo. O valor padrão é 200.

min-spec-prob
A probabilidade mínima (em porcentagens) de alcançar um bloco de origem para interbloco
programação especulativa. O valor padrão é 40.

max-sched-extend-region-iters
O número máximo de iterações por meio de CFG para estender regiões. 0 - desabilitar
extensão de região, N - faça no máximo N iterações. O valor padrão é 0.

atraso máximo de agendamento-insn
O atraso máximo de conflito para um insn a ser considerado para moção especulativa.
O valor padrão é 3.

sched-spec-prob-cutoff
A probabilidade mínima de sucesso da especulação (em porcentagens), de modo que especulativo
insn será agendado. O valor padrão é 40.

custo agendado-mem-true-dep
Distância mínima (em ciclos de CPU) entre armazenamento e carga visando a mesma memória
Localizações. O valor padrão é 1.

selsched-max-lookahead
O tamanho máximo da janela de antevisão da programação seletiva. É uma profundidade
de pesquisa para obter as instruções disponíveis. O valor padrão é 50.

selsched-max-sched-times
O número máximo de vezes que uma instrução será agendada durante a seletiva
agendamento. Este é o limite do número de iterações através das quais o
a instrução pode ser canalizada. O valor padrão é 2.

selsched-max-insns-para-renomear
O número máximo de melhores instruções na lista pronta que são consideradas para
renomear no agendador seletivo. O valor padrão é 2.

sms-min-sc
O valor mínimo da contagem de estágios que o agendador do módulo de oscilação irá gerar. o
o valor padrão é 2.

max-último-valor-rtl
O tamanho máximo medido como o número de RTLs que podem ser registrados em uma expressão
no combinador para um pseudo-registro como o último valor conhecido desse registro. o
o padrão é 10000.

limite de compartilhamento inteiro
Pequenas constantes inteiras podem usar uma estrutura de dados compartilhada, reduzindo o compilador
uso de memória e aumentando sua velocidade. Isso define o valor máximo de um compartilhamento
constante inteira. O valor padrão é 256.

min-mapeamentos virtuais
Especifica o número mínimo de mapeamentos virtuais no atualizador SSA incremental
que deve ser registrado para acionar a heurística de mapeamentos virtuais definida por
proporção de mapeamentos virtuais. O valor padrão é 100.

proporção de mapeamentos virtuais
Se o número de mapeamentos virtuais for maior que o número
de símbolos virtuais a serem atualizados, então o atualizador SSA incremental muda para um
atualização completa para esses símbolos. A proporção padrão é 3.

tamanho do buffer ssp
O tamanho mínimo dos buffers (ou seja, arrays) que receberão o esmagamento de pilha
proteção quando -fstack-proteção é usado.

Este padrão antes do Ubuntu 10.10 era "8". Atualmente é "4", para aumentar o
número de funções protegidas pelo protetor de pilha.

max-jump-thread-duplicação-stmts
Número máximo de declarações permitidas em um bloco que precisa ser duplicado quando
threading saltos.

máximo de campos por campo sensível
Número máximo de campos em uma estrutura que trataremos de maneira sensível aos campos
durante a análise do ponteiro. O padrão é zero para -O0 e -O1 e 100 para -Os,
-O2 e -O3.

pré-busca-latência
Estimar o número médio de instruções que são executadas antes da pré-busca
termina. A distância que pré-buscamos à frente é proporcional a essa constante.
Aumentar este número também pode levar a menos fluxos sendo pré-buscados (consulte
pré-buscas simultâneas).

pré-buscas simultâneas
Número máximo de pré-buscas que podem ser executadas ao mesmo tempo.

tamanho da linha de cache l1
O tamanho da linha do cache no cache L1, em bytes.

tamanho do cache l1
O tamanho do cache L1, em kilobytes.

tamanho do cache l2
O tamanho do cache L2, em kilobytes.

proporção de min-insn para pré-busca
A proporção mínima entre o número de instruções e o número de pré-buscas
para ativar a pré-busca em um loop.

proporção pré-busca-min-insn-para-mem
A proporção mínima entre o número de instruções e o número de memória
referências para ativar a pré-busca em um loop.

usar tipos canônicos
Se o compilador deve usar o sistema de tipo "canônico". Por padrão, este
deve ser sempre 1, que usa um mecanismo interno mais eficiente para comparar
tipos em C ++ e Objective-C ++. No entanto, se os bugs no sistema de tipo canônico são
causando falhas de compilação, defina este valor como 0 para desabilitar os tipos canônicos.

switch-conversão-max-branch-ratio
A conversão de inicialização do switch se recusará a criar matrizes maiores que
switch-conversão-max-branch-ratio vezes o número de ramos no switch.

comprimento parcial máximo
Comprimento máximo do conjunto antic parcial calculado durante a árvore parcial
otimização de eliminação de redundância (-ftree-pré) ao otimizar em -O3 e acima.
Para alguns tipos de código-fonte, a eliminação de redundância parcial aprimorada
a otimização pode fugir, consumindo toda a memória disponível no host
máquina. Este parâmetro define um limite para o comprimento dos conjuntos que são calculados,
o que impede o comportamento de fuga. Definir um valor de 0 para este parâmetro irá
permitir um comprimento de conjunto ilimitado.

sccvn-max-scc-tamanho
Tamanho máximo de um componente fortemente conectado (SCC) durante o processamento SCCVN. Se
este limite for atingido, o processamento SCCVN para toda a função não será feito e
otimizações dependendo dele serão desabilitadas. O tamanho máximo padrão do SCC é
10000.

ira-max-loops-num
O IRA usa a alocação de registro regional por padrão. Se uma função contém mais
loops do que o número dado por este parâmetro, apenas no máximo o número dado de
os loops executados com mais frequência formam regiões para alocação de registro regional.
O valor padrão do parâmetro é 100.

ira-max-conflito-tabela-tamanho
Embora o IRA use um algoritmo sofisticado para compactar a tabela de conflitos, o
A mesa ainda pode exigir uma quantidade excessiva de memória para funções enormes. Se o
tabela de conflito para uma função pode ser maior do que o tamanho em MB dado por este
parâmetro, o alocador de registro, em vez disso, usa um parâmetro mais rápido, simples e
algoritmo de qualidade que não requer a construção de uma tabela de conflitos de pseudo-registro.
O valor padrão do parâmetro é 2000.

ira-loop-reservado-regs
IRA pode ser usado para avaliar pressão de registro mais precisa em loops para decisões
para mover invariantes de loop (veja -O3) O número de registros disponíveis reservados para
algumas outras finalidades são fornecidas por este parâmetro. O valor padrão do
parâmetro é 2, que é o número mínimo de registros necessários para um típico
instruções. Este valor é o melhor encontrado em vários experimentos.

loop-invariante-max-bbs-in-loop
Movimento invariante de loop pode ser muito caro, tanto em tempo de compilação quanto em
quantidade de memória de tempo de compilação necessária, com loops muito grandes. Loops com mais
blocos básicos do que este parâmetro não terão otimização de movimento invariável de loop
realizada sobre eles. O valor padrão do parâmetro é 1000 para -O1 e 10000
para -O2 e acima.

loop-max-datarefs-para-datadeps
Construir dapendências de dados é caro para loops muito grandes. Este parâmetro
limita o número de referências de dados em loops que são considerados para dados
análise de dependência. Esses grandes loops não serão manipulados pelo
otimizações usando dependências de dados de loop. O valor padrão é 1000.

tamanho máximo do vartrack
Define um número máximo de slots de hash table para usar durante o fluxo de dados de rastreamento variável
análise de qualquer função. Se este limite for excedido com rastreamento variável em
atribuições habilitadas, a análise para essa função é repetida sem ela, após
removendo todos os insns de depuração da função. Se o limite for excedido mesmo sem
debug insns, a análise de rastreamento de var é completamente desabilitada para a função.
Definir o parâmetro como zero o torna ilimitado.

max-vartrack-expr-profundidade
Define um número máximo de níveis de recursão ao tentar mapear nomes de variáveis ​​ou
depurar temporários para expressões de valor. Isso troca o tempo de compilação por mais
informações completas de depuração. Se for definido muito baixo, expressões de valor que são
disponível e poderia ser representado em informações de depuração pode acabar não sendo usado;
definir este valor mais alto pode permitir que o compilador encontre depurações mais complexas
expressões, mas o tempo de compilação e o uso de memória podem aumentar. O padrão é 12.

min-nondebug-insn-uid
Use uids começando com este parâmetro para insns não depurados. O intervalo abaixo do
parâmetro é reservado exclusivamente para debug insns criado por
-fvar-atribuições de rastreamento, mas os insns de depuração podem obter uids (não sobrepostos) acima
se o intervalo reservado for esgotado.

ipa-sra-ptr-fator de crescimento
O IPA-SRA substituirá um ponteiro para um agregado com um ou mais novos parâmetros
apenas quando seu tamanho cumulativo é menor ou igual a ipa-sra-ptr-fator de crescimento
vezes o tamanho do parâmetro do ponteiro original.

tm-max-tamanho agregado
Ao fazer cópias de variáveis ​​locais de thread em uma transação, este parâmetro
especifica o tamanho em bytes após o qual as variáveis ​​serão salvas com o registro
funções em oposição a salvar / restaurar pares de sequência de código. Esta opção apenas
aplica-se ao usar -fgnu-tm.

grafite-max-nb-scop-params
Para evitar efeitos exponenciais nas transformações do loop Graphite, o número de
parâmetros em uma parte de controle estático (SCoP) são limitados. O valor padrão é 10
parâmetros. Uma variável cujo valor é desconhecido no momento da compilação e definido
fora de um SCoP é um parâmetro do SCoP.

grafite-max-bbs-por-função
Para evitar efeitos exponenciais na detecção de SCoPs, o tamanho das funções
analisado por grafite é limitado. O valor padrão é 100 blocos básicos.

tamanho do bloco de loop
Bloqueio de loop ou transformações de mineração de faixa, habilitadas com -bloop-block or
-flop-strip-mine, extrai cada loop no aninhamento de loop por um determinado número de
iterações. O comprimento da tira pode ser alterado usando o tamanho do bloco de loop
parâmetro. O valor padrão é 51 iterações.

ipa-cp-valor-lista-tamanho
O IPA-CP tenta rastrear todos os valores e tipos possíveis passados ​​para uma função
parâmetro para propagá-los e realizar a desvirtualização. valor-ipa-cp-
tamanho da lista é o número máximo de valores e tipos que ele armazena por um formal
parâmetro de uma função.

lto-partições
Especifique o número desejado de partições produzidas durante a compilação WHOPR. o
o número de partições deve exceder o número de CPUs usadas para compilação. o
o valor padrão é 32.

partição lto-min
Tamanho da partição mínima para WHOPR (nas instruções estimadas). Isso evita
despesas de dividir programas muito pequenos em muitas partições.

cxx-max-namespaces-para-ajuda de diagnóstico
O número máximo de namespaces a serem consultados para sugestões ao pesquisar nomes em C ++
falha para um identificador. O padrão é 1000.

dissipador-frequência-limiar
A frequência de execução relativa máxima (em porcentagens) do bloco alvo
em relação ao bloco original de uma instrução para permitir o afundamento da instrução de um
demonstração. Números maiores resultam em afundamento de declarações mais agressivo. o
o valor padrão é 75. Um pequeno ajuste positivo é aplicado para declarações com
operandos de memória como esses são ainda mais lucrativos, então afundam.

max-store-to-sink
O número máximo de pares de lojas condicionais que podem ser afundadas. Defina como 0 se
qualquer vetorização (-ftree-vetorize) ou if-conversão (-ftree-loop-se-converter)
está desabilitado. O padrão é 2.

permitir-carregar-dados-corridas
Permita que os otimizadores introduzam novas disputas de dados nas cargas. Defina como 1 para permitir,
caso contrário, para 0. Esta opção é habilitada por padrão, a menos que seja definida implicitamente pelo
-fmemory-model = opção.

permitir-armazenar-dados-corridas
Permita que os otimizadores introduzam novas disputas de dados nas lojas. Defina como 1 para permitir,
caso contrário, para 0. Esta opção é habilitada por padrão, a menos que seja definida implicitamente pelo
-fmemory-model = opção.

allow-pack-load-data-races
Permita que os otimizadores introduzam novas corridas de dados em cargas de dados empacotadas. Definir como 1 para
permitir, caso contrário, para 0. Esta opção é habilitada por padrão, a menos que seja configurada implicitamente por
da -fmemory-model = opção.

permitir corridas de dados de armazenamento empacotado
Permita que os otimizadores introduzam novas corridas de dados em armazenamentos de dados compactados. Definir como 1 para
permitir, caso contrário, para 0. Esta opção é habilitada por padrão, a menos que seja configurada implicitamente por
da -fmemory-model = opção.

caso-valores-limite
O menor número de valores diferentes para os quais é melhor usar uma tabela de salto
em vez de uma árvore de ramos condicionais. Se o valor for 0, use o padrão para
a máquina. O padrão é 0.

árvore-reassoc-largura
Defina o número máximo de instruções executadas em paralelo na árvore reassociada.
Este parâmetro substitui heurísticas dependentes de destino usadas por padrão se não tiver
valor zero.

Opções Controlador da Pré-processador
Essas opções controlam o pré-processador C, que é executado em cada arquivo de origem C antes de
compilação.

Se você usar o -E opção, nada é feito, exceto o pré-processamento. Algumas dessas opções
faz sentido apenas junto com -E porque eles fazem com que a saída do pré-processador seja
inadequado para compilação real.

-Wp,opção
Você pode usar -Wp,opção para ignorar o driver do compilador e passar opção diretamente através
para o pré-processador. Se opção contém vírgulas, é dividido em várias opções em
as vírgulas. No entanto, muitas opções são modificadas, traduzidas ou interpretadas pelo
driver do compilador antes de ser passado para o pré-processador, e -Wp ignora à força
esta fase. A interface direta do pré-processador não é documentada e está sujeita a
mudar, então, sempre que possível, você deve evitar usar -Wp e deixe o motorista cuidar do
opções em vez disso.

-Xpré-processador opção
Passar opção como uma opção para o pré-processador. Você pode usar isso para fornecer sistema
opções específicas do pré-processador que o GCC não sabe como reconhecer.

Se você quiser passar uma opção que leva um argumento, você deve usar -Xpré-processador
duas vezes, uma para a opção e uma vez para o argumento.

-D nome
Predefinir nome como uma macro, com a definição 1.

-D nome=definição
O conteúdo de definição são tokenizados e processados ​​como se tivessem aparecido durante
fase de tradução três em um #define diretiva. Em particular, a definição será
truncado por caracteres de nova linha incorporados.

Se você está invocando o pré-processador a partir de um shell ou programa semelhante a um shell, você pode precisar
para usar a sintaxe de citação do shell para proteger caracteres como espaços que têm um
significado na sintaxe do shell.

Se você deseja definir uma macro do tipo função na linha de comando, escreva seu argumento
lista com parênteses antes do sinal de igual (se houver). Parênteses são
significativo para a maioria dos shells, portanto, você precisará citar a opção. Com sh e csh,
-D 'nome(args ...)=definição' obras.

-D e -U as opções são processadas na ordem em que são fornecidas na linha de comando. Tudo
-imacros lima e -incluir lima as opções são processadas afinal -D e -U opções.

-U nome
Cancelar qualquer definição anterior de nome, embutido ou fornecido com um -D opção.

-undef
Não predefinir macros específicas do sistema ou específicas do GCC. O padrão predefinido
macros permanecem definidas.

-I dir
Adicione o diretório dir à lista de diretórios a serem pesquisados ​​para arquivos de cabeçalho.
Diretórios nomeados por -I são pesquisados ​​antes que o sistema padrão inclua diretórios.
Se o diretório dir é um diretório de inclusão de sistema padrão, a opção é ignorada para
garantir que a ordem de pesquisa padrão para os diretórios do sistema e o tratamento especial
de cabeçalhos de sistema não são derrotados. Se dir começa com "=", então o "=" será
substituído pelo prefixo sysroot; Vejo --sysroot e -isysroot.

-o lima
Grave a saída para lima. Isso é o mesmo que especificar lima como a segunda não opção
argumento para cpp. gcc tem uma interpretação diferente de um segundo argumento de não opção,
então você deve usar -o para especificar o arquivo de saída.

-Parede
Liga todos os avisos opcionais desejáveis ​​para o código normal. No momento isso
is -Comentário, -Wtrigraphs, -Wmultichar e um aviso sobre promoção de inteiro causando um
mudança de sinal nas expressões "#if". Observe que muitos dos avisos do pré-processador
estão ativados por padrão e não têm opções para controlá-los.

-Comentário
-Wcomentários
Avisar sempre que uma sequência de início de comentário /* aparece em um /* comentário, ou sempre que um
barra invertida-nova linha aparece em um // Comente. (Ambas as formas têm o mesmo efeito.)

-Wtrigraphs
A maioria dos trigraphs nos comentários não pode afetar o significado do programa. No entanto, um
trígrafo que formaria uma nova linha de escape (?? / no final de uma linha) pode, por
alterando onde o comentário começa ou termina. Portanto, apenas trígrafos que formariam
novas linhas escapadas produzem avisos dentro de um comentário.

Esta opção está implícita em -Parede. Se -Parede não é fornecido, esta opção ainda está habilitada
a menos que trigraphs estejam habilitados. Para obter a conversão de trígrafo sem avisos, mas obtenha
o outro -Parede avisos, use -trígrafos -Parede -Wno-trígrafos.

-Wtradicional
Avise sobre certas construções que se comportam de maneira diferente no tradicional e no ISO C. Também
avisar sobre construções ISO C que não têm equivalente C tradicional e problemático
construções que devem ser evitadas.

-Wundef
Avisar sempre que um identificador que não seja uma macro for encontrado em um #E se directiva,
fora de definido. Esses identificadores são substituídos por zero.

-Wunused-macros
Avisar sobre macros definidas no arquivo principal que não são utilizadas. Uma macro é usava se é
expandido ou testado para existência pelo menos uma vez. O pré-processador também irá avisar se
a macro não foi usada no momento em que foi redefinida ou indefinida.

Macros incorporadas, macros definidas na linha de comando e macros definidas em include
os arquivos não são avisados.

Nota: Se uma macro for realmente usada, mas usada apenas em blocos condicionais ignorados, então
O CPP irá reportá-lo como não utilizado. Para evitar o aviso em tal caso, você pode melhorar
o escopo da definição da macro, por exemplo, movendo-a para a primeira
bloquear. Como alternativa, você pode fornecer um uso fictício com algo como:

#if definido the_macro_causing_the_warning
#fim se

-Etiquetas Wendif
Avisar sempre que um #else ou um #fim se são seguidos por texto. Isso geralmente acontece em
código do formulário

#se FOO
...
#elseFOO
...
#endif FOO

O segundo e o terceiro "FOO" devem estar nos comentários, mas geralmente não estão em programas mais antigos.
Este aviso está ativado por padrão.

-Erro
Transforme todos os avisos em erros graves. O código-fonte que aciona os avisos será
rejeitado.

-Wsystem-cabeçalhos
Emita avisos para o código nos cabeçalhos do sistema. Normalmente, eles são inúteis para encontrar
bugs em seu próprio código, portanto suprimidos. Se você é responsável pelo sistema
biblioteca, você pode querer vê-los.

-w Suprime todos os avisos, incluindo aqueles que o GNU CPP emite por padrão.

-pedante
Emita todos os diagnósticos obrigatórios listados no padrão C. Alguns deles são deixados
por padrão, uma vez que eles disparam freqüentemente em código inofensivo.

-erros-pedantes
Emita todos os diagnósticos obrigatórios e transforme todos os diagnósticos obrigatórios em erros.
Isso inclui diagnósticos obrigatórios que o GCC emite sem -pedante mas trata como
avisos.

-M Em vez de produzir o resultado do pré-processamento, produza uma regra adequada para fazer
descrevendo as dependências do arquivo de origem principal. O pré-processador produz um
fazer regra que contém o nome do arquivo de objeto para esse arquivo de origem, dois pontos e os nomes
de todos os arquivos incluídos, incluindo aqueles provenientes de -incluir or -imacros comando
opções de linha.

A menos que especificado explicitamente (com -MT or -MQ), o nome do arquivo do objeto consiste no
nome do arquivo de origem com qualquer sufixo substituído pelo sufixo do arquivo objeto e por qualquer
partes principais do diretório removidas. Se houver muitos arquivos incluídos, a regra é
dividido em várias linhas usando \-nova linha. A regra não tem comandos.

Esta opção não suprime a saída de depuração do pré-processador, como -dM. Evitar
misturando essa saída de depuração com as regras de dependência, você deve especificar explicitamente o
arquivo de saída de dependência com -MFou use uma variável de ambiente como
DEPENDENCES_OUTPUT. A saída de depuração ainda será enviada para o fluxo de saída regular como
normal.

Passagem -M para o motorista implica -E, e suprime avisos com um implícito -w.

-MILÍMETROS Como -M mas não mencione os arquivos de cabeçalho encontrados nos diretórios de cabeçalho do sistema,
nem arquivos de cabeçalho que são incluídos, direta ou indiretamente, de tal cabeçalho.

Isso implica que a escolha de colchetes angulares ou aspas duplas em um #include
diretiva por si só não determina se esse cabeçalho aparecerá em -MILÍMETROS
saída de dependência. Esta é uma pequena mudança na semântica do GCC versões 3.0 e
mais cedo.

-MF lima
Quando usado com -M or -MILÍMETROS, especifica um arquivo para gravar as dependências. Se não -MF
chave é fornecida, o pré-processador envia as regras para o mesmo lugar que teria enviado
saída pré-processada.

Quando usado com as opções do driver -MD or -MMD, -MF substitui a dependência padrão
arquivo de saída.

-MG Em conjunto com uma opção como -M solicitando a geração de dependência, -MG assume
arquivos de cabeçalho ausentes são arquivos gerados e os adiciona à lista de dependências sem
levantando um erro. O nome do arquivo de dependência é obtido diretamente de "#include"
diretiva sem prefixar nenhum caminho. -MG também suprime a saída pré-processada, como um
arquivo de cabeçalho ausente o torna inútil.

Este recurso é usado na atualização automática de makefiles.

-MP Esta opção instrui o CPP a adicionar um alvo falso para cada dependência diferente de
arquivo principal, fazendo com que cada um não dependa de nada. Essas regras fictícias contornam os erros
fazer dá se você remover arquivos de cabeçalho sem atualizar o Makefile para combinar.

Esta é uma saída típica:

teste.o: teste.c teste.h

teste.h:

-MT alvo
Altere o destino da regra emitida pela geração de dependência. Por padrão, o CPP leva
o nome do arquivo de entrada principal, exclui todos os componentes do diretório e qualquer sufixo de arquivo
tais como .ce anexa o sufixo de objeto usual da plataforma. O resultado é o alvo.

An -MT opção irá definir o destino para ser exatamente a string que você especificar. Se você quiser
vários alvos, você pode especificá-los como um único argumento para -MT, ou use vários
-MT opções.

Por exemplo, nos -MT '$ (objpfx) foo.o' pode dar

$ (objpfx) foo.o: foo.c

-MQ alvo
Igual a -MT, mas cita quaisquer caracteres que sejam especiais para o Make.
-MQ '$ (objpfx) foo.o' dá

$$ (objpfx) foo.o: foo.c

O destino padrão é cotado automaticamente, como se fosse fornecido com -MQ.

-MD -MD é equivalente a -M -MF lima, exceto que -E não está implícito. O motorista
determina lima com base em se um -o opção é fornecida. Se for, o driver usa seu
argumento, mas com um sufixo de .d, caso contrário, leva o nome do arquivo de entrada,
remove qualquer componente de diretório e sufixo e aplica um .d sufixo.

If -MD é usado em conjunto com -E, qualquer -o interruptor é entendido para especificar o
arquivo de saída de dependência, mas se usado sem -E, Cada -o é entendido para especificar um
arquivo de objeto de destino.

Como -E não está implícito, -MD pode ser usado para gerar um arquivo de saída de dependência como um
efeito colateral do processo de compilação.

-MMD
Como -MD exceto mencionar apenas os arquivos de cabeçalho do usuário, não os arquivos de cabeçalho do sistema.

-fpch-deps
Ao usar cabeçalhos pré-compilados, este sinalizador fará com que os sinalizadores de saída de dependência
também liste os arquivos das dependências do cabeçalho pré-compilado. Se não for especificado apenas
o cabeçalho pré-compilado seria listado e não os arquivos que foram usados ​​para criá-lo
porque esses arquivos não são consultados quando um cabeçalho pré-compilado é usado.

-fpch-pré-processo
Esta opção permite o uso de um cabeçalho pré-compilado junto com -E. Insere um especial
"#pragma", "#pragma GCC pch_preprocess"nome do arquivo"" na saída para marcar o lugar
onde o cabeçalho pré-compilado foi encontrado, e seu nome do arquivo. Quando -processado é em
usar, o GCC reconhece este "#pragma" e carrega o PCH.

Esta opção está desativada por padrão, porque a saída pré-processada resultante é apenas
realmente adequado como entrada para o GCC. É ligado por -save-tempos.

Você não deve escrever este "#pragma" em seu próprio código, mas é seguro editar o
nome do arquivo se o arquivo PCH estiver disponível em um local diferente. O nome do arquivo pode ser
absoluto ou relativo ao diretório atual do GCC.

-x c
-x c ++
-x objetivo-c
-x montador-com-cpp
Especifique o idioma de origem: C, C ++, Objective-C ou assembly. Isso não tem nada a ver
com conformidade de padrões ou extensões; simplesmente seleciona qual sintaxe base para
Espero. Se você não fornecer nenhuma dessas opções, o cpp irá deduzir o idioma do
extensão do arquivo de origem: .c, . Cc, .mou .S. Algumas outras extensões comuns para
C ++ e assembly também são reconhecidos. Se o cpp não reconhecer a extensão, ele
tratará o arquivo como C; este é o modo mais genérico.

Nota: As versões anteriores do cpp aceitaram um -longo opção que selecionou tanto o
idioma e o nível de conformidade com os padrões. Esta opção foi removida porque
entra em conflito com o -l opção.

-std =padrão
-ansi
Especifique o padrão com o qual o código deve estar em conformidade. Atualmente o CPP sabe sobre C
e padrões C ++; outros podem ser adicionados no futuro.

padrão pode ser um de:

"c90"
"c89"
"iso9899: 1990"
O padrão ISO C de 1990. c90 é a abreviatura usual para esta versão de
o padrão.

A -ansi opção é equivalente a -std = c90.

"iso9899: 199409"
O padrão C de 1990, conforme alterado em 1994.

"iso9899: 1999"
"c99"
"iso9899: 199x"
"c9x"
O padrão ISO C revisado, publicado em dezembro de 1999. Antes da publicação, este
era conhecido como C9X.

"iso9899: 2011"
"c11"
"c1x"
O padrão ISO C revisado, publicado em dezembro de 2011. Antes da publicação, este
era conhecido como C1X.

"gnu90"
"gnu89"
O padrão C de 1990 mais as extensões GNU. Este é o padrão.

"gnu99"
"gnu9x"
O padrão C de 1999 mais as extensões GNU.

"gnu11"
"gnu1x"
O padrão C de 2011 mais as extensões GNU.

"c ++ 98"
O padrão ISO C ++ de 1998 mais emendas.

"gnu ++ 98"
O mesmo que -std = c ++ 98 além de extensões GNU. Este é o padrão para o código C ++.

-I- Divida o caminho de inclusão. Quaisquer diretórios especificados com -I opções antes -I- e guarante que os mesmos estão
pesquisou apenas cabeçalhos solicitados com "#include"Arquivo""; eles não são procurados
"#incluirarquivo> ". Se diretórios adicionais forem especificados com -I opções após o
-I-, esses diretórios são pesquisados ​​por todos #include directivas.

Além disso, -I- inibe o uso do diretório do diretório de arquivo atual como
o primeiro diretório de pesquisa por "#include"Arquivo"". Esta opção está obsoleta.

-nostdinc
Não pesquise os diretórios do sistema padrão para arquivos de cabeçalho. Apenas os diretórios
você especificou com -I opções (e o diretório do arquivo atual, se
apropriado) são pesquisados.

-nostdinc ++
Não procure por arquivos de cabeçalho nos diretórios padrão específicos de C ++, mas ainda
pesquise os outros diretórios padrão. (Esta opção é usada ao construir o C ++
biblioteca.)

-incluir lima
Extração lima como se "#include" arquivo "" aparecesse como a primeira linha da fonte primária
Arquivo. No entanto, o primeiro diretório procurou por lima é o pré-processador funcionando
anuário em vez disso of o diretório que contém o arquivo de origem principal. Se não for encontrado
lá, ele é pesquisado no restante da cadeia de pesquisa "#include" ... "" como
normal.

Se múltiplo -incluir opções são fornecidas, os arquivos são incluídos na ordem em que
aparecem na linha de comando.

-imacros lima
Exatamente como -incluir, exceto que qualquer saída produzida pela digitalização lima é jogado
longe. As macros que ele define permanecem definidas. Isso permite que você adquira todas as macros
de um cabeçalho sem também processar suas declarações.

Todos os arquivos especificados por -imacros são processados ​​antes de todos os arquivos especificados por -incluir.

-dirijo dir
Pesquisar dir para arquivos de cabeçalho, mas faça isso depois de todos os diretórios especificados com -I e os votos de
os diretórios padrão do sistema foram esgotados. dir é tratado como um sistema inclui
diretório. Se dir começa com "=", então o "=" será substituído pelo sysroot
prefixo; Vejo --sysroot e -isysroot.

-iprefixo prefixo
Especificar prefixo como o prefixo para o subsequente -i com prefixo opções. Se o prefixo
representa um diretório, você deve incluir o final /.

-i com prefixo dir
- com o prefixo antes dir
Acrescentar dir para o prefixo especificado anteriormente com -iprefixo, e adicione o resultado
diretório para incluir o caminho de pesquisa. - com o prefixo antes coloca no mesmo lugar -I
seria; -i com prefixo coloca onde -dirijo seria.

-isysroot dir
Esta opção é como o --sysroot opção, mas se aplica apenas a arquivos de cabeçalho (exceto para
Alvos Darwin, onde se aplica a arquivos de cabeçalho e bibliotecas). Veja o
--sysroot opção para obter mais informações.

-imultilib dir
Use dir como um subdiretório do diretório contendo cabeçalhos C ++ específicos do destino.

-isistema dir
Pesquisar dir para arquivos de cabeçalho, depois de todos os diretórios especificados por -I mas antes do
diretórios de sistema padrão. Marque-o como um diretório do sistema, para que seja o mesmo
tratamento especial aplicado aos diretórios do sistema padrão. Se dir começa
com "=", então o "=" será substituído pelo prefixo sysroot; Vejo --sysroot e
-isysroot.

-Eu cito dir
Pesquisar dir apenas para arquivos de cabeçalho solicitados com "#include"Arquivo""; eles não são
procurou por "#includearquivo> ", antes de todos os diretórios especificados por -I e antes do
diretórios de sistema padrão. Se dir começa com "=", então o "=" será substituído por
o prefixo sysroot; Vejo --sysroot e -isysroot.

-fdirectives-somente
Ao pré-processar, manipule as diretivas, mas não expanda as macros.

O comportamento da opção depende do -E e -processado opções.

Com -E, o pré-processamento é limitado ao tratamento de diretivas como "#define",
"#ifdef" e "#error". Outras operações de pré-processador, como expansão de macro e
conversão trigraph não são realizadas. Além disso, o -dD opção é implicitamente
ativado.

Com -processado, a predefinição da linha de comando e a maioria das macros integradas é
Desativado. Macros como "__LINE__", que são contextualmente dependentes, são manipuladas
normalmente. Isso permite a compilação de arquivos previamente pré-processados ​​com "-E
-fdirectives-only ".

Com ambos -E e -processado, as regras para -processado têm precedência. Esse
permite o pré-processamento completo de arquivos previamente pré-processados ​​com "-E
-fdirectives-only ".

-fdollars-em-identificadores
ACEITAR $ em identificadores.

-identificadores-fextended
Aceite nomes de caracteres universais em identificadores. Esta opção é experimental; em um
versão futura do GCC, ele será habilitado por padrão para C99 e C ++.

-processado
Indique ao pré-processador que o arquivo de entrada já foi pré-processado. Esse
suprime coisas como expansão de macro, conversão de trígrafo, splicing de nova linha de escape,
e processamento da maioria das diretivas. O pré-processador ainda reconhece e remove
comentários, para que você possa passar um arquivo pré-processado com -C para o compilador sem
problemas. Neste modo, o pré-processador integrado é pouco mais do que um tokenizador
para as extremidades frontais.

-processado está implícito se o arquivo de entrada tiver uma das extensões .i, .ii or .mi.
Estas são as extensões que o GCC usa para arquivos pré-processados ​​criados por -save-tempos.

-ftabstop =largura
Defina a distância entre as paradas de tabulação. Isso ajuda o pré-processador a relatar a coluna correta
números em avisos ou erros, mesmo que apareçam guias na linha. Se o valor for menor
que 1 ou maior que 100, a opção é ignorada. O padrão é 8.

-fdebug-cpp
Esta opção só é útil para depurar GCC. Quando usado com -E, depuração de despejos
informações sobre mapas de localização. Cada token na saída é precedido pelo despejo de
o mapa ao qual sua localização pertence. O despejo do mapa contendo a localização de um token
seria:

{"P": F ; "F": F ;"EU": ; "C": ; "S": ; "M": ; "E": , "loc": }

Quando usado sem -E, esta opção não tem efeito.

-ftrack-macro-expansão[=nível]
Rastreie a localização de tokens em expansões de macro. Isso permite que o compilador emita
diagnóstico sobre a pilha de expansão de macro atual quando ocorre um erro de compilação em
uma expansão macro. Usar esta opção faz com que o pré-processador e o compilador consumam
mais memória. o nível parâmetro pode ser usado para escolher o nível de precisão do token
rastreamento de localização diminuindo assim o consumo de memória, se necessário. Valor 0 of
nível desativa esta opção como se não -ftrack-macro-expansão esteve presente em
a linha de comando. Valor 1 rastreia locais de tokens em um modo degradado por causa de
sobrecarga de memória mínima. Neste modo, todos os tokens resultantes da expansão de um
argumento de uma macro do tipo função tem a mesma localização. Valor 2 rastreia tokens
locais completamente. Este valor é o que mais consome memória. Quando esta opção é fornecida
sem argumento, o valor do parâmetro padrão é 2.

-fexec-charset =conjunto de caracteres
Defina o conjunto de caracteres de execução, usado para constantes de string e caracteres. O padrão
é UTF-8. conjunto de caracteres pode ser qualquer codificação compatível com a biblioteca "iconv" do sistema
rotina.

-fwide-exec-charset =conjunto de caracteres
Defina o conjunto de caracteres de execução ampla, usado para cadeias largas e constantes de caracteres.
O padrão é UTF-32 ou UTF-16, o que corresponder à largura de "wchar_t". Como
com -fexec-charset, conjunto de caracteres pode ser qualquer codificação compatível com o "iconv" do sistema
rotina da biblioteca; no entanto, você terá problemas com codificações que não se encaixam
exatamente em "wchar_t".

-finput-charset =conjunto de caracteres
Defina o conjunto de caracteres de entrada, usado para tradução do conjunto de caracteres da entrada
arquivo para o conjunto de caracteres de origem usado pelo GCC. Se a localidade não especificar, ou GCC
não pode obter essas informações do local, o padrão é UTF-8. Isso pode ser
substituído pelo local ou por esta opção de linha de comando. Atualmente o comando
a opção de linha tem precedência se houver um conflito. conjunto de caracteres pode ser qualquer codificação
suportado pela rotina de biblioteca "iconv" do sistema.

-diretório-fworking
Habilita a geração de marcadores de linha na saída do pré-processador que permitirá ao compilador
conhecer o diretório de trabalho atual no momento do pré-processamento. Quando esta opção é
habilitado, o pré-processador irá emitir, após o marcador de linha inicial, um segundo marcador de linha
com o diretório de trabalho atual seguido por duas barras. GCC vai usar isso
diretório, quando está presente na entrada pré-processada, como o diretório emitido como
o diretório de trabalho atual em alguns formatos de informações de depuração. Esta opção é
habilitado implicitamente se as informações de depuração estiverem habilitadas, mas isso pode ser inibido com
a forma negada -fno-diretório de trabalho. Se o -P bandeira está presente no comando
linha, esta opção não tem efeito, uma vez que nenhuma diretiva "#line" é emitida.

-fno-show-coluna
Não imprima os números das colunas nos diagnósticos. Isso pode ser necessário se os diagnósticos forem
sendo verificado por um programa que não entende os números das colunas, como
Dejagnu.

-A predicado=responder
Faça uma afirmação com o predicado predicado e responda responder. Este formulário é
preferido à forma mais antiga -A predicado(responder), que ainda é compatível, porque
não usa caracteres especiais de shell.

-A -predicado=responder
Cancelar uma afirmação com o predicado predicado e responda responder.

-dCHARS
PERSONAGENS é uma sequência de um ou mais dos seguintes caracteres e não deve ser
precedido por um espaço. Outros caracteres são interpretados pelo próprio compilador, ou
reservados para versões futuras do GCC e, portanto, são silenciosamente ignorados. Se você especificar
personagens cujo comportamento conflita, o resultado é indefinido.

M Em vez da saída normal, gere uma lista de #define diretivas para todos os
macros definidas durante a execução do pré-processador, incluindo predefinidas
macros. Isso lhe dá uma maneira de descobrir o que está predefinido em sua versão do
o pré-processador. Supondo que você não tenha nenhum arquivo foo.h, o comando

toque em foo.h; cpp -dM foo.h

irá mostrar todas as macros predefinidas.

Se você usar -dM sem o -E opção, -dM é interpretado como sinônimo de
-fdump-rtl-mach.

D Como M exceto em dois aspectos: não incluem as macros predefinidas e
outputs ambos da #define diretivas e o resultado do pré-processamento. Ambos os tipos
de saída vá para o arquivo de saída padrão.

N Como D, mas emitem apenas os nomes das macros, não suas expansões.

I saída #include além do resultado do pré-processamento.

U Como D exceto que apenas macros que são expandidas, ou cuja definição é testada
nas diretivas do pré-processador, são produzidos; a saída é atrasada até o uso ou
teste da macro; e #undef diretivas também são geradas para macros testadas, mas
indefinido na época.

-P Inibe a geração de marcadores de linha na saída do pré-processador. Isso pode ser
útil ao executar o pré-processador em algo que não é código C, e será enviado
para um programa que pode ser confundido pelos marcadores de linha.

-C Não descarte comentários. Todos os comentários são passados ​​para o arquivo de saída, exceto
para comentários em diretivas processadas, que são suprimidos juntamente com a diretiva.

Você deve estar preparado para os efeitos colaterais ao usar -C; faz com que o pré-processador
tratar comentários como tokens em seu próprio direito. Por exemplo, comentários que aparecem no
início do que seria uma linha diretiva tem o efeito de transformar essa linha em um
linha de origem comum, uma vez que o primeiro token na linha não é mais um #.

-CC Não descarte comentários, inclusive durante a expansão da macro. Isto é como -C, exceto
que os comentários contidos nas macros também são passados ​​para o arquivo de saída, onde
a macro é expandida.

Além dos efeitos colaterais do -C opção, o -CC opção faz com que todo o estilo C ++
comentários dentro de uma macro a serem convertidos em comentários de estilo C. Isso é para prevenir mais tarde
uso dessa macro de comentar inadvertidamente o restante da linha de origem.

A -CC opção geralmente é usada para oferecer suporte a comentários lint.

-tradicional-cpp
Tente imitar o comportamento dos pré-processadores C antiquados, em oposição ao ISO C
pré-processadores.

-trígrafos
Processar sequências de trígrafos. Estas são sequências de três caracteres, todas começando com
??, que são definidos pela ISO C para representar caracteres únicos. Por exemplo, ?? / fica
for \, assim '?? / n' é uma constante de caractere para uma nova linha. Por padrão, o GCC ignora
trigraphs, mas em modos em conformidade com o padrão, ele os converte. Veja o -std e -ansi
opções.

Os nove trígrafos e suas substituições são

Trígrafo: ?? (??) ?? <??> ?? = ?? / ?? ' ??! ?? -
Substituição: [] {} # \ ^ | ~

-remapear
Habilite um código especial para contornar os sistemas de arquivos que só permitem arquivos muito curtos
nomes, como MS-DOS.

--Socorro
--alvo-ajuda
Imprime o texto que descreve todas as opções da linha de comando em vez de pré-processar qualquer coisa.

-v Modo detalhado. Imprima o número da versão do GNU CPP no início da execução e
relatar a forma final do caminho de inclusão.

-H Imprime o nome de cada arquivo de cabeçalho utilizado, além de outras atividades normais. Cada
o nome é recuado para mostrar o quão profundo no #include empilhar é. Cabeçalho pré-compilado
os arquivos também são impressos, mesmo se forem considerados inválidos; um pré-compilado inválido
arquivo de cabeçalho é impresso com ... x e um válido com ! ... .

-versão
--versão
Imprima o número da versão do GNU CPP. Com um traço, prossiga para o pré-processamento normalmente.
Com dois travessões, saia imediatamente.

Passagem Opções para da Assembler
Você pode passar opções para o montador.

-Uau,opção
Passar opção como opção para o montador. Se opção contém vírgulas, está dividido
em várias opções nas vírgulas.

-Xassembler opção
Passar opção como opção para o montador. Você pode usar isso para fornecer sistemas específicos
opções de assembler que o GCC não sabe reconhecer.

Se você quiser passar uma opção que leva um argumento, você deve usar -Xassembler duas vezes,
uma vez para a opção e uma vez para o argumento.

Opções for Linkagem
Essas opções entram em jogo quando o compilador vincula arquivos-objeto em um executável
arquivo de saída. Eles não terão sentido se o compilador não estiver executando uma etapa de link.

nome-do-arquivo-objeto
Um nome de arquivo que não termina com um sufixo especial reconhecido é considerado para nomear um
arquivo de objeto ou biblioteca. (Os arquivos de objeto são diferenciados das bibliotecas pelo vinculador
de acordo com o conteúdo do arquivo.) Se a vinculação for feita, esses arquivos objeto são usados ​​como
entrada para o vinculador.

-c
-S
-E Se qualquer uma dessas opções for usada, o vinculador não será executado e os nomes dos arquivos de objetos
não deve ser usado como argumento.

-lbiblioteca
-l biblioteca
Pesquise a biblioteca chamada biblioteca ao vincular. (A segunda alternativa com o
biblioteca como um argumento separado é apenas para conformidade com POSIX e não é recomendada.)

Faz diferença onde você escreve esta opção no comando; o vinculador procura
e processa bibliotecas e arquivos de objeto na ordem em que são especificados. Assim, foo.o
-lz bar.o pesquisa biblioteca z depois do arquivo foo.o mas depois bar.o. Se bar.o refere-se a
funções em z, essas funções podem não ser carregadas.

O vinculador procura uma lista padrão de diretórios para a biblioteca, que é na verdade
um arquivo chamado biblioteca.a. O vinculador então usa este arquivo como se tivesse sido especificado
precisamente pelo nome.

Os diretórios pesquisados ​​incluem vários diretórios padrão do sistema, além de qualquer um que você
especificar com -L.

Normalmente os arquivos encontrados desta forma são arquivos de biblioteca --- arquivos de arquivos cujos membros são
arquivos de objeto. O vinculador lida com um arquivo compactado examinando-o em busca de membros
que definem símbolos que até agora foram referenciados, mas não definidos. Mas se o
O arquivo encontrado é um arquivo de objeto comum e está vinculado da maneira usual. o
única diferença entre usar um -l opção e especificando um nome de arquivo é que -l
rodeia biblioteca com lib e .a e pesquisa vários diretórios.

-lobjc
Você precisa deste caso especial de -l opção para vincular um Objective-C ou
Programa Objective-C ++.

-nostartfiles
Não use os arquivos de inicialização do sistema padrão ao vincular. O sistema padrão
bibliotecas são usadas normalmente, a menos que -nostdlib or -nodefaultlibs é usado.

-nodefaultlibs
Não use as bibliotecas padrão do sistema ao vincular. Apenas as bibliotecas que você especificar
serão passados ​​para o vinculador, opções que especificam a ligação das bibliotecas do sistema, como
como "-static-libgcc" ou "-shared-libgcc", será ignorado. Os arquivos de inicialização padrão
são usados ​​normalmente, a menos que -nostartfiles é usado. O compilador pode gerar chamadas para
"memcmp", "memset", "memcpy" e "memmove". Essas entradas geralmente são resolvidas por
entradas em libc. Esses pontos de entrada devem ser fornecidos por meio de algum outro mecanismo
quando esta opção é especificada.

-nostdlib
Não use os arquivos ou bibliotecas de inicialização do sistema padrão ao vincular. Sem inicialização
arquivos e apenas as bibliotecas que você especificar serão passadas para o vinculador, opções
especificando a ligação das bibliotecas do sistema, como "-static-libgcc" ou
"-shared-libgcc", será ignorado. O compilador pode gerar chamadas para "memcmp",
"memset", "memcpy" e "memmove". Essas entradas são geralmente resolvidas por entradas em
libc. Esses pontos de entrada devem ser fornecidos por meio de algum outro mecanismo quando este
opção é especificada.

Uma das bibliotecas padrão ignoradas por -nostdlib e -nodefaultlibs is libgcc.a, um
biblioteca de sub-rotinas internas que o GCC usa para superar deficiências de particular
máquinas ou necessidades especiais para alguns idiomas.

Na maioria dos casos, você precisa libgcc.a mesmo quando você deseja evitar outras bibliotecas padrão.
Em outras palavras, quando você especifica -nostdlib or -nodefaultlibs você deveria normalmente
especificamos -lgcc também. Isso garante que você não tenha referências não resolvidas a
sub-rotinas internas da biblioteca GCC. (Por exemplo, __a Principal, usado para garantir C ++
construtores serão chamados.)

-torta
Produza um executável independente de posição nos alvos que o suportam. Para previsível
resultados, você também deve especificar o mesmo conjunto de opções que foram usadas para gerar o código
(-fpie, -fPIEou subopções de modelo) ao especificar esta opção.

-rdinâmica
Passe a bandeira -exportação dinâmica para o linker ELF, em alvos que o suportam. Esse
instrui o vinculador a adicionar todos os símbolos, não apenas os usados, ao símbolo dinâmico
tabela. Esta opção é necessária para alguns usos de "dlopen" ou para permitir a obtenção
backtraces de dentro de um programa.

-s Remova todas as tabelas de símbolos e informações de realocação do executável.

-estático
Em sistemas que suportam vínculo dinâmico, isso impede a vinculação com o
bibliotecas. Em outros sistemas, esta opção não tem efeito.

-compartilhado
Produz um objeto compartilhado que pode ser vinculado a outros objetos para formar um
executável. Nem todos os sistemas oferecem suporte a essa opção. Para resultados previsíveis, você deve
também especifica o mesmo conjunto de opções que foram usadas para gerar o código (-fpic, -fPICou
subopções do modelo) ao especificar esta opção. [1]

-shared-libgcc
-static-libgcc
Em sistemas que fornecem libgcc como uma biblioteca compartilhada, essas opções forçam o uso de
a versão compartilhada ou estática, respectivamente. Se nenhuma versão compartilhada de libgcc foi
construído quando o compilador foi configurado, essas opções não têm efeito.

Existem várias situações em que um aplicativo deve usar o compartilhamento libgcc
em vez da versão estática. O mais comum deles é quando o aplicativo
deseja lançar e capturar exceções em diferentes bibliotecas compartilhadas. Nesse caso,
cada uma das bibliotecas, bem como o próprio aplicativo deve usar o libgcc.

Portanto, os drivers G ++ e GCJ adicionam automaticamente -shared-libgcc sempre que você construir
uma biblioteca compartilhada ou um executável principal, porque os programas C ++ e Java normalmente usam
exceções, então esta é a coisa certa a fazer.

Se, em vez disso, você usar o driver GCC para criar bibliotecas compartilhadas, você pode descobrir que eles
nem sempre estará vinculado ao compartilhado libgcc. Se o GCC encontrar, em sua configuração
vez, que você tem um vinculador não GNU ou um vinculador GNU que não oferece suporte a opção
--eh-frame-hdr, ele vinculará a versão compartilhada de libgcc em bibliotecas compartilhadas por
predefinição. Caso contrário, ele aproveitará o vinculador e otimizará o
vinculando com a versão compartilhada de libgcc, vinculando com a versão estática de libgcc
por padrão. Isso permite que as exceções se propaguem por meio dessas bibliotecas compartilhadas,
sem incorrer em custos de realocação no tempo de carregamento da biblioteca.

No entanto, se uma biblioteca ou executável principal deve lançar ou capturar exceções, você
deve vinculá-lo usando o driver G ++ ou GCJ, conforme apropriado para os idiomas usados ​​no
programa, ou usando a opção -shared-libgcc, de modo que esteja vinculado ao
libgcc.

-static-libstdc ++
Quando o g ++ programa é usado para vincular um programa C ++, ele normalmente automaticamente
link contra libstdc ++. Se libstdc ++ está disponível como uma biblioteca compartilhada, e o
-estático opção não for usada, então isso irá vincular a versão compartilhada de
libstdc ++. Isso normalmente está bem. No entanto, às vezes é útil congelar o
versão do libstdc ++ usado pelo programa sem ir até um ponto totalmente estático
ligação. o -static-libstdc ++ opção direciona o g ++ motorista para link libstdc ++
estaticamente, sem necessariamente vincular outras bibliotecas estaticamente.

-simbólico
Vincule referências a símbolos globais ao construir um objeto compartilhado. Avisar sobre qualquer
referências não resolvidas (a menos que sejam substituídas pela opção do editor de links -Xlinker -z
-Xlinker defesas) Apenas alguns sistemas oferecem suporte a essa opção.

-T escrita
Use escrita como o script do vinculador. Esta opção é suportada pela maioria dos sistemas que usam o
Vinculador GNU. Em alguns alvos, como alvos de placa nua sem um sistema operacional,
da -T pode ser necessária a opção ao vincular para evitar referências a símbolos indefinidos.

-Xlinker opção
Passar opção como uma opção para o vinculador. Você pode usar isso para fornecer sistemas específicos
opções de vinculador que o GCC não reconhece.

Se você quiser passar uma opção que leva um argumento separado, você deve usar -Xlinker
duas vezes, uma para a opção e uma vez para o argumento. Por exemplo, para passar -afirmar
definições, você deve escrever -Xlinker -afirmar -Xlinker definições. Não funciona
escrever -Xlinker "-afirmar definições ", porque isso passa a string inteira como um
único argumento, que não é o que o vinculador espera.

Ao usar o vinculador GNU, geralmente é mais conveniente passar argumentos para o vinculador
opções usando o opção=valor sintaxe do que como argumentos separados. Por exemplo, você
pode especificar -Xlinker -Map = output.map em vez de -Xlinker -Mapa -Xlinker saída.map.
Outros vinculadores podem não oferecer suporte a essa sintaxe para opções de linha de comando.

-Wl,opção
Passar opção como uma opção para o vinculador. Se opção contém vírgulas, é dividido em
várias opções nas vírgulas. Você pode usar esta sintaxe para passar um argumento para o
opção. Por exemplo, -Wl, -Map, output.map passes -Mapa saída.map para o vinculador. Quando
usando o vinculador GNU, você também pode obter o mesmo efeito com -Wl, -Map = output.map.

NOTA: No Ubuntu 8.10 e versões posteriores, para LDFLAGS, a opção -Wl, -z, relro é usado.
Para desativar, use -Wl, -z, norelro.

-u símbolo
Finja o símbolo símbolo é indefinido, para forçar a ligação dos módulos da biblioteca para definir
isto. Você pode usar -u várias vezes com símbolos diferentes para forçar o carregamento de
módulos de biblioteca adicionais.

Opções for Diretório Pesquisar
Essas opções especificam diretórios para pesquisar arquivos de cabeçalho, bibliotecas e peças
do compilador:

-Idir
Adicione o diretório dir para o topo da lista de diretórios a serem pesquisados ​​para o cabeçalho
arquivos. Isso pode ser usado para substituir um arquivo de cabeçalho do sistema, substituindo o seu próprio
versão, uma vez que esses diretórios são pesquisados ​​antes do arquivo de cabeçalho do sistema
diretórios. No entanto, você não deve usar esta opção para adicionar diretórios que contenham
arquivos de cabeçalho do sistema fornecidos pelo fornecedor (use -isistema por isso). Se você usar mais de um
-I opção, os diretórios são verificados na ordem da esquerda para a direita; o sistema padrão
os diretórios vêm depois.

Se um sistema padrão incluir diretório, ou um diretório especificado com -isistema, É
também especificado com -I, -I opção será ignorada. O diretório ainda será
pesquisado, mas como um diretório do sistema em sua posição normal na cadeia de inclusão do sistema.
Isso é para garantir que o procedimento do GCC para corrigir cabeçalhos de sistema com erros e o pedido
para a diretiva include_next não são alteradas inadvertidamente. Se você realmente precisa
altere a ordem de pesquisa dos diretórios do sistema, use o -nostdinc e / ou -isistema
opções.

-iplugindir =dir
Defina o diretório para procurar plug-ins que são passados ​​por -fplugin =nome em vez de
-fplugin =caminho/nome.assim. Esta opção não deve ser usada pelo usuário, mas apenas
passou pelo motorista.

-Eu citodir
Adicione o diretório dir para o topo da lista de diretórios a serem pesquisados ​​para o cabeçalho
arquivos apenas para o caso de #include "lima"; eles não são procurados #include <lima>,
caso contrário, apenas como -I.

-Ldir
Adicionar diretório dir à lista de diretórios a serem pesquisados -l.

-Bprefixo
Esta opção especifica onde encontrar os executáveis, bibliotecas, arquivos de inclusão e
arquivos de dados do próprio compilador.

O programa do driver do compilador executa um ou mais dos subprogramas cpp, cc1, as e ld.
Tenta prefixo como um prefixo para cada programa que tenta executar, com e sem
máquina/versão/.

Para cada subprograma a ser executado, o driver do compilador primeiro tenta o -B prefixo, se houver.
Se esse nome não for encontrado, ou se -B não foi especificado, o driver tenta dois padrões
prefixos, / usr / lib / gcc / e / usr / local / lib / gcc /. Se nenhum desses resultar em um
nome do arquivo encontrado, o nome do programa não modificado é pesquisado usando o
diretórios especificados em seu PATH variável de ambiente.

O compilador irá verificar se o caminho fornecido pelo -B refere-se a um diretório,
e, se necessário, adicionará um caractere separador de diretório no final do caminho.

-B prefixos que efetivamente especificam nomes de diretório também se aplicam a bibliotecas no
vinculador, porque o compilador traduz essas opções em -L opções para o vinculador.
Eles também se aplicam a arquivos de inclusão no pré-processador, porque o compilador traduz
essas opções em -isistema opções para o pré-processador. Neste caso, o compilador
acrescenta incluir para o prefixo.

O arquivo de suporte de tempo de execução libgcc.a também pode ser pesquisado usando o -B prefixo, se
precisava. Se não for encontrado lá, os dois prefixos padrão acima são tentados, e que
é tudo. O arquivo é omitido do link se não for encontrado por esses meios.

Outra maneira de especificar um prefixo muito parecido com o -B prefixo é usar o ambiente
variável GCC_EXEC_PREFIX.

Como um kludge especial, se o caminho fornecido por -B is [dir /] estágioN /, Onde N é um número
no intervalo de 0 a 9, ele será substituído por [dir /] incluir. Isso é para ajudar com
inicializando o compilador.

-specs =lima
Extração lima depois que o compilador lê o padrão óculos arquivo, a fim de substituir
os padrões que o gcc programa de driver usa ao determinar quais interruptores passarão
para cc1, cc1plus, as, ld, etc. Mais de um -specs =lima pode ser especificado no
linha de comando, e eles são processados ​​em ordem, da esquerda para a direita.

--sysroot =dir
Use dir como o diretório raiz lógico para cabeçalhos e bibliotecas. Por exemplo, se o
o compilador normalmente procura cabeçalhos em / usr / include e bibliotecas em / usr / lib,
ao invés disso irá pesquisar dir / usr / include e dir / usr / lib.

Se você usar esta opção e o -isysroot opção, então o --sysroot opção vai
se aplicam a bibliotecas, mas o -isysroot opção será aplicada a arquivos de cabeçalho.

O vinculador GNU (começando com a versão 2.16) tem o suporte necessário para isso
opção. Se o seu vinculador não suportar esta opção, o aspecto do arquivo de cabeçalho de
--sysroot ainda funcionará, mas o aspecto da biblioteca não.

-I- Esta opção está obsoleta. Por favor, use -Eu cito em vez de -I diretórios antes
da -I- e remova o -I-. Quaisquer diretórios que você especificar com -I opções antes do
-I- opção são pesquisadas apenas para o caso de #include "lima"; eles não são revistados
for #include <lima>.

Se diretórios adicionais forem especificados com -I opções após o -I-, Estes
os diretórios são pesquisados ​​por todos #include diretivas. (Normalmente todos os -I diretórios
são usados ​​desta forma.)

Além disso, o -I- opção inibe o uso do diretório atual (onde o
arquivo de entrada atual veio) como o primeiro diretório de pesquisa para #include "lima".
Não há como substituir esse efeito de -I-. Com -EU. você pode especificar a busca
o diretório que era atual quando o compilador foi chamado. Isso não é exatamente o
igual ao que o pré-processador faz por padrão, mas geralmente é satisfatório.

-I- não inibe o uso dos diretórios padrão do sistema para arquivos de cabeçalho.
Assim, -I- e -nostdinc são independentes.

Especificando Alvo Lavagem e Compilador Versão
A maneira usual de executar o GCC é rodar o executável chamado gccou máquina-gcc quando cruzar
compilando, ou máquina-gcc-versão para executar uma versão diferente da que foi instalada
último.

Hardware Modelos e configurações
Cada tipo de máquina alvo pode ter suas próprias opções especiais, começando com -m, escolher
entre vários modelos de hardware ou configurações --- por exemplo, 68010 vs 68020, flutuante
coprocessador ou nenhum. Uma única versão instalada do compilador pode compilar para qualquer modelo
ou configuração, de acordo com as opções especificadas.

Algumas configurações do compilador também suportam opções especiais adicionais, geralmente para
compatibilidade com outros compiladores na mesma plataforma.

Adaptava Epifania Opções

Este -m as opções são definidas para Adapteva Epiphany:

-meia-reg-arquivo
Não aloque nenhum registro no intervalo "r32" ... "r63". Isso permite que o código seja executado em
variantes de hardware que não possuem esses registros.

-mprefer-short-insn-regs
Aloque preferencialmente registradores que permitam a geração de instruções curtas. Isso pode
resultar em aumentos na contagem de instruções, portanto, se isso reduzir ou aumentar o tamanho do código
pode variar de caso para caso.

-mbranch-cost =Números
Defina o custo das filiais para aproximadamente Números instruções "simples". Este custo é apenas um
heurística e não é garantido que produza resultados consistentes em todas as versões.

-mcmove
Habilite a geração de movimentos condicionais.

-mnops =Números
Emitir Números nops antes de qualquer outra instrução gerada.

-mno-soft-cmpsf
Para comparações de ponto flutuante de precisão única, emita uma instrução fsub e teste o
bandeiras. Isso é mais rápido do que uma comparação de software, mas pode obter resultados incorretos em
a presença de NaNs, ou quando dois pequenos números diferentes são comparados de modo que seus
a diferença é calculada como zero. O padrão é -msoft-cmpsf, que usa mais devagar, mas
Comparações de software em conformidade com IEEE.

-mstack-offset =Números
Defina o deslocamento entre o topo da pilha e o ponteiro da pilha. Por exemplo, um valor de 8
significa que os oito bytes no intervalo sp + 0 ... sp + 7 podem ser usados ​​por funções de folha
sem alocação de pilha. Valores diferentes de 8 or 16 não são testados e improváveis ​​de
trabalhar. Observe também que esta opção altera a ABI, compilando um programa com um
deslocamento de pilha diferente daquele com o qual as bibliotecas foram compiladas geralmente não
trabalhar. Esta opção pode ser útil se você deseja avaliar se um deslocamento de pilha diferente
daria a você um código melhor, mas realmente usar um deslocamento de pilha diferente para construir
programas de trabalho, é recomendado configurar o conjunto de ferramentas com o apropriado
--with-stack-offset =Números opção.

-mno-round-mais próximo
Faça o planejador assumir que o modo de arredondamento foi definido como truncado. o
padrão é -modo-mais próximo.

-muito chamadas
Se não for especificado de outra forma por um atributo, suponha que todas as chamadas podem estar além do
intervalo de deslocamento das instruções b / bl e, portanto, carregue o endereço da função em
um registro antes de realizar uma chamada (de outra forma direta). Este é o padrão.

-mshort-chamadas
Se não for especificado de outra forma por um atributo, suponha que todas as chamadas diretas estejam no intervalo
das instruções b / bl, portanto, use essas instruções para chamadas diretas. O padrão
is -muito chamadas.

-msmall16
Suponha que os endereços podem ser carregados como valores não assinados de 16 bits. Isso não se aplica a
endereços de função para os quais -muito chamadas a semântica está em vigor.

-mfp-mode =modo
Defina o modo predominante da unidade de ponto flutuante. Isso determina o flutuante
modo de ponto que é fornecido e esperado na chamada de função e tempo de retorno. Fazer
este modo corresponde ao modo que você precisa predominantemente no início da função pode tornar o seu
programas menores e mais rápidos, evitando trocas de modo desnecessárias.

modo pode ser definido com um dos seguintes valores:

chamador
Qualquer modo na entrada da função é válido e retido ou restaurado quando a função
retorna e quando chama outras funções. Este modo é útil para compilar
bibliotecas ou outras unidades de compilação que você pode querer incorporar em diferentes
programas com diferentes modos FPU prevalecentes e a conveniência de ser capaz de
usar um único arquivo de objeto supera o tamanho e a sobrecarga de velocidade para qualquer modo extra
troca que pode ser necessária, em comparação com o que seria necessário com mais
escolha específica do modo FPU prevalecente.

truncar
Este é o modo usado para cálculos de ponto flutuante com truncamento (ou seja, redondo
em direção a zero) modo de arredondamento. Isso inclui a conversão de ponto flutuante para
inteiro.

mais próximo
Este é o modo usado para cálculos de ponto flutuante com arredondamento para o mais próximo ou
modo de arredondamento uniforme.

int Este é o modo usado para realizar cálculos inteiros na FPU, por exemplo, inteiro
multiplique, ou multiplique e acumule inteiro.

O padrão é -mfp-mode = caller

-mnosplit-lohi
-mno-postinc
-mno-postmodificar
Ajustes de geração de código que desabilitam, respectivamente, a divisão de cargas de 32 bits,
geração de endereços pós-incremento e geração de endereços pós-modificação. o
padrões são msplit-lohi, -mpost-inc e -mpost-modificar.

-mnovect-duplo
Altere o modo SIMD preferido para SImode. O padrão é -mvect-duplo, Que usa
DImode como modo SIMD preferido.

-max-vect-align =Números
O alinhamento máximo para tipos de modo de vetor SIMD. Números pode ser 4 ou 8. O padrão é
8. Observe que esta é uma alteração de ABI, embora muitas interfaces de função de biblioteca
não serão afetados, se não usarem modos de vetor SIMD em lugares onde afetam o tamanho
e / ou alinhamento de tipos relevantes.

-msplit-vecmove-cedo
O vetor dividido se move em movimentos de uma única palavra antes de recarregar. Em teoria, isso poderia dar
melhor alocação de registros, mas até agora o inverso parece ser geralmente o caso.

-m1reg-reg
Especifique um registro para manter a constante -1, o que torna o carregamento pequeno negativo
constantes e certas bitmasks mais rápido. Os valores permitidos para reg são r43 e r63,
que especificam usar esse registro como um registro fixo, e nenhum, o que significa que nenhum
registrar é usado para este propósito. O padrão é -m1reg-nenhum.

AAArch64 Opções

Essas opções são definidas para implementações AArch64:

-mbi-endian
Gere código big-endian. Este é o padrão quando o GCC é configurado para um
aarch64_be - * - * alvo.

-mgeneral-regs-somente
Gere código que usa apenas os registros gerais.

-mlittle-endian
Gere o código little-endian. Este é o padrão quando o GCC é configurado para um
aarch64 - * - * mas não um aarch64_be - * - * alvo.

-mcmodel = tiny
Gere código para o modelo de código minúsculo. O programa e seus símbolos definidos estaticamente
devem estar a 1 GB um do outro. Os ponteiros têm 64 bits. Os programas podem ser estaticamente
ou vinculado dinamicamente. Este modelo não está totalmente implementado e principalmente tratado como
"pequena".

-mcmodel = pequeno
Gere código para o modelo de código pequeno. O programa e está estaticamente definido
os símbolos devem estar a 4 GB um do outro. Os ponteiros têm 64 bits. Os programas podem ser
vinculado estaticamente ou dinamicamente. Este é o modelo de código padrão.

-mcmodel = grande
Gere código para o modelo de código grande. Isso não faz suposições sobre endereços e
tamanhos de seções. Os ponteiros têm 64 bits. Os programas podem ser vinculados apenas estaticamente.

-mstrict-align
Não presuma que referências de memória não alinhadas serão tratadas pelo sistema.

-momit-folha-frame-ponteiro
-mno-omitir-ponteiro-quadro-folha
Omita ou mantenha o ponteiro do quadro nas funções de folha. O primeiro comportamento é o
padrão.

-mtls-dialect = desc
Use descritores TLS como o mecanismo de armazenamento local de thread para acessos dinâmicos de TLS
variáveis. Este é o padrão.

-mtls-dialect = tradicional
Use o TLS tradicional como o mecanismo de armazenamento local de thread para acessos dinâmicos de TLS
variáveis.

-march =nome
Especifique o nome da arquitetura de destino, opcionalmente sufixado por um ou mais
modificadores de recursos. Esta opção tem o formato -march =arco{+[não]integrado}*, onde o
único valor para arco is armv8-a. Os valores possíveis para integrado estão documentados no
subseção abaixo.

Onde modificadores de recurso conflitantes são especificados, o recurso mais à direita é usado.

O GCC usa este nome para determinar que tipo de instruções ele pode emitir ao gerar
código de montagem. Esta opção pode ser usada em conjunto com ou em vez do -mcpu =
opção.

-mcpu =nome
Especifique o nome do processador de destino, opcionalmente sufixado por um ou mais recursos
modificadores. Esta opção tem o formato -mcpu =cpu{+[não]integrado} *, onde for possível
valores para cpu e guarante que os mesmos estão genérico, grande. Os valores possíveis para integrado estão documentados em
a subseção abaixo.

Onde modificadores de recurso conflitantes são especificados, o recurso mais à direita é usado.

O GCC usa este nome para determinar que tipo de instruções ele pode emitir ao gerar
código de montagem.

-mtune =nome
Especifique o nome do processador para o qual ajustar o desempenho. O código será ajustado
como se o processador de destino fosse do tipo especificado nesta opção, mas ainda usando
instruções compatíveis com o processador de destino especificado por um -mcpu = opção. Isto
opção não pode ser sufixada por modificadores de recurso.

-marchar e -mcpu modificadores de recursos

Modificadores de recursos usados ​​com -marchar e -mcpu pode ser um dos seguintes:

cripto
Habilite a extensão Crypto. Isso significa que o SIMD avançado está ativado.

fp Habilite as instruções de ponto flutuante.

sim
Ative as instruções SIMD avançadas. Isso implica que as instruções de ponto flutuante são
ativado. Este é o padrão para todos os valores atuais possíveis para as opções -marchar e
-mcpu =.

ARM Opções

Este -m as opções são definidas para arquiteturas de máquinas RISC avançadas (ARM):

-mabi =nome
Gerar código para o ABI especificado. Os valores permitidos são: apcs-gnu, atpcs, aapcs,
aapcs-linux e iwmmxt.

-mapcs-quadro
Gere um frame de pilha que seja compatível com o ARM Procedure Call Standard para todos
funções, mesmo que isso não seja estritamente necessário para a execução correta do código.
Especificando -fomit-frame-ponteiro com esta opção fará com que os stack frames não sejam
gerado para funções de folha. O padrão é -mno-apcs-quadro.

-mapcs
Este é um sinônimo para -mapcs-quadro.

-mthumb-intertrabalho
Gere código que ofereça suporte a chamadas entre os conjuntos de instruções ARM e Thumb.
Sem esta opção, em arquiteturas pré-v5, os dois conjuntos de instruções não podem ser
usado de forma confiável dentro de um programa. O padrão é -mno-thumb-interwork, já que ligeiramente
código maior é gerado quando -mthumb-intertrabalho é especificado. Em configurações AAPCS
esta opção não faz sentido.

-mno-sched-prolog
Impedir a reordenação de instruções no prólogo da função, ou a fusão de
essas instruções com as instruções no corpo da função. Isso significa que todos
funções começarão com um conjunto reconhecível de instruções (ou de fato um de um
escolha de um pequeno conjunto de prólogos de funções diferentes), e esta informação pode ser
usado para localizar as funções start if dentro de um trecho executável de código. O padrão
is -msched-prólogo.

-mfloat-abi =nome
Especifica qual ABI de ponto flutuante usar. Os valores permitidos são: macio, softfp e
difícil.

Especificando macio faz com que o GCC gere saída contendo chamadas de biblioteca para flutuante
operações pontuais. softfp permite a geração de código usando hardware de ponto flutuante
instruções, mas ainda usa as convenções de chamada de soft-float. difícil permite
geração de instruções de ponto flutuante e usa convenções de chamada específicas de FPU.

O padrão depende da configuração de destino específica. Observe que o hard-float
e ABIs soft-float não são compatíveis com link; você deve compilar todo o seu programa com
a mesma ABI e vincular a um conjunto compatível de bibliotecas.

-mlittle-endian
Gere código para um processador em execução no modo little-endian. Este é o padrão para
todas as configurações padrão.

-mbi-endian
Gerar código para um processador rodando no modo big-endian; o padrão é compilar
código para um processador little-endian.

-mwords-little-endian
Esta opção se aplica apenas ao gerar código para processadores big-endian. Gerar
código para uma ordem de palavras little-endian, mas uma ordem de bytes big-endian. Ou seja, um byte
ordem do formulário 32107654. Nota: esta opção só deve ser usada se você precisar
compatibilidade com código para processadores ARM big-endian gerados por versões do
compilador anterior a 2.8. Esta opção está obsoleta.

-march =nome
Isso especifica o nome da arquitetura ARM de destino. GCC usa este nome para
determinar que tipo de instruções ele pode emitir ao gerar o código de montagem. Esse
opção pode ser usada em conjunto com ou em vez do -mcpu = opção. Permitida
nomes são: braçov2, armv2a, braçov3, braçov3m, braçov4, armv4t, braçov5, armv5t, braçov5e,
armv5te, braçov6, armv6j, braçov6t2, armv6z, armv6zk, braçov6-m, braçov7, armv7-a, armv7-r,
braçov7-m, armv7e-m, iwmmxt, iwmmxt2, ep9312.

-march = nativo faz com que o compilador detecte automaticamente a arquitetura da construção
computador. No momento, esse recurso é compatível apenas com Linux, e nem todos
arquiteturas são reconhecidas. Se a detecção automática não for bem-sucedida, a opção não tem
efeito.

-mtune =nome
Esta opção especifica o nome do processador ARM de destino para o qual o GCC deve ajustar
o desempenho do código. Para algumas implementações de ARM, um melhor desempenho pode ser
obtidos usando esta opção. Os nomes permitidos são: arm2, arm250, arm3, arm6,
arm60, arm600, arm610, arm620, arm7, braço7m, braço7d, braço7dm, arm7di, braço7dmi, arm70,
arm700, arm700i, arm710, braço710c, arm7100, arm720, arm7500, braço7500fe, arm7tdmi,
arm7tdmi-s, braço710t, braço720t, braço740t, braço forte, Strongarm110, Strongarm1100,
Strongarm1110, arm8, arm810, arm9, braço9e, arm920, braço920t, braço922t, arm946e-s,
arm966e-s, arm968e-s, arm926ej-s, braço940t, arm9tdmi, arm10tdmi, braço1020t, arm1026ej-s,
braço10e, braço1020e, braço1022e, braço1136j-s, braço1136jf-s, mpcore, mpcorenovfp, braço1156t2-s,
arm1156t2f-s, braço1176jz-s, arm1176jzf-s, córtex-a5, córtex-a7, córtex-a8, córtex-a9,
córtex-a15, córtex-r4, córtex-r4f, córtex-r5, córtex-m4, córtex-m3, córtex-m1,
córtex-m0, escala x, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626,
fa726te.

-mtune = genérico-arco especifica que o GCC deve ajustar o desempenho para uma mistura de
processadores dentro da arquitetura arco. O objetivo é gerar código que funcione bem no
processadores mais populares atuais, balanceamento entre otimizações que beneficiam alguns
CPUs na faixa e evitando armadilhas de desempenho de outras CPUs. Os efeitos de
esta opção pode mudar em futuras versões do GCC conforme os modelos de CPU vêm e vão.

-mtune = nativo faz com que o compilador detecte automaticamente a CPU do computador de construção. No
presente, este recurso só é compatível com Linux, e nem todas as arquiteturas são
reconhecido. Se a detecção automática não for bem-sucedida, a opção não terá efeito.

-mcpu =nome
Isso especifica o nome do processador ARM de destino. GCC usa este nome para derivar o
nome da arquitetura ARM de destino (como se especificado por -marchar) e o processador ARM
tipo para o qual ajustar para desempenho (como se especificado por -mtune) Onde esta opção
é usado em conjunto com -marchar or -mtune, essas opções têm precedência sobre o
parte apropriada desta opção.

Os nomes permitidos para esta opção são iguais àqueles para -mtune.

-mcpu = genérico-arco também é permitido e é equivalente a -march =arco
-mtune = genérico-arco. Ver -mtune para entender melhor.

-mcpu = nativo faz com que o compilador detecte automaticamente a CPU do computador de construção. No
presente, este recurso só é compatível com Linux, e nem todas as arquiteturas são
reconhecido. Se a detecção automática não for bem-sucedida, a opção não terá efeito.

-mfpu =nome
-mfpe =número
-mfp =número
Isso especifica em qual hardware de ponto flutuante (ou emulação de hardware) está disponível
o alvo. Os nomes permitidos são: fpa, fpe2, fpe3, dissidente, vfp, vfpv3, vfpv3-fp16,
vfpv3-d16, vfpv3-d16-fp16, vfpv3xd, vfpv3xd-fp16, néon, néon-fp16, vfpv4, vfpv4-d16,
fpv4-sp-d16 e néon-vfpv4. -mfp e -mfpe são sinônimos para -mfpu=fpenúmero, Por
compatibilidade com versões mais antigas do GCC.

If -msoft-float é especificado, especifica o formato dos valores de ponto flutuante.

Se o hardware de ponto flutuante selecionado inclui a extensão NEON (por exemplo -mfpu=néon),
observe que as operações de ponto flutuante não serão usadas pela passagem de autovetorização do GCC
a menos que -funsafe-math-otimizations também é especificado. Isso ocorre porque o hardware NEON
não implementa totalmente o padrão IEEE 754 para aritmética de ponto flutuante (em
valores desnormais particulares são tratados como zero), portanto, o uso de instruções NEON pode
levar a uma perda de precisão.

-mfp16-format =nome
Especifique o formato do tipo de ponto flutuante de meia precisão "__fp16". Permitida
nomes são Nenhum, heee e alternativa; o padrão é Nenhum, nesse caso o "__fp16"
tipo não está definido.

-mstructure-size-boundary =n
O tamanho de todas as estruturas e uniões será arredondado para um múltiplo do número
de bits definidos por esta opção. Os valores permitidos são 8, 32 e 64. O valor padrão
varia para diferentes conjuntos de ferramentas. Para o conjunto de ferramentas direcionado COFF, o valor padrão é
8. Um valor de 64 só é permitido se a ABI subjacente o suportar.

Especificar um número maior pode produzir um código mais rápido e eficiente, mas também pode
aumentar o tamanho do programa. Valores diferentes são potencialmente incompatíveis.
O código compilado com um valor não pode necessariamente esperar funcionar com código ou bibliotecas
compilados com outro valor, se trocam informações por meio de estruturas ou sindicatos.

-mabort-on-noreturn
Gere uma chamada para a função "abortar" no final de uma função "noreturn". Será
ser executado se a função tentar retornar.

-muito chamadas
-mno-long-chamadas
Diz ao compilador para realizar chamadas de função, primeiro carregando o endereço do
função em um registro e, em seguida, executar uma chamada de sub-rotina neste registro. Esse
switch é necessário se a função de destino ficar fora do endereçamento de 64 megabytes
intervalo da versão baseada em deslocamento da instrução de chamada de sub-rotina.

Mesmo se essa chave estiver habilitada, nem todas as chamadas de função serão transformadas em chamadas longas.
A heurística é que funções estáticas, funções que têm o chamada curta atributo,
funções que estão dentro do escopo de um #pragma sem_longas_chamadas diretiva e funções
cujas definições já foram compiladas na unidade de compilação atual,
não ser transformado em chamadas longas. A exceção a esta regra é que a função fraca
definições, funções com o longa chamada atributo ou o seção atributo, e
funções que estão dentro do escopo de um #pragma chamadas_longas diretriz, sempre será
se transformou em chamadas longas.

Este recurso não é habilitado por padrão. Especificando -mno-long-chamadas irá restaurar o
comportamento padrão, assim como colocar as chamadas de função dentro do escopo de um #pragma
chamadas_longas_desligadas diretiva. Observe que essas opções não têm efeito sobre como o compilador
gera código para lidar com chamadas de função por meio de ponteiros de função.

-msingle-pic-base
Trate o registro usado para endereçamento PIC como somente leitura, em vez de carregá-lo no
prólogo para cada função. O sistema de tempo de execução é responsável por inicializar este
registrar com um valor apropriado antes do início da execução.

-mpic-register =reg
Especifique o registro a ser usado para endereçamento PIC. O padrão é R10, a menos que stack-
a verificação é habilitada, quando R9 é usado.

-mcirrus-fix-insns inválidos
Insira NOPs no fluxo de instrução para, a fim de contornar problemas com
combinações de instruções Maverick inválidas. Esta opção só é válida se o
-mcpu = ep9312 opção foi usada para permitir a geração de instruções para o Cirrus
Coprocessador independente de ponto flutuante. Esta opção não está habilitada por padrão, uma vez que
o problema está presente apenas em implementações mais antigas do Maverick. O padrão pode ser re-
habilitado pelo uso do -mno-cirrus-fix-insns inválidos interruptor.

-mpoke-nome-função
Escreva o nome de cada função na seção de texto, diretamente antes da função
prólogo. O código gerado é semelhante a este:

t0
.ascii "arm_poke_function_name", 0
.alinhar
t1
.palavra 0xff000000 + (t1 - t0)
arm_poke_function_name
mov ip, sp
stmfd sp !, {fp, ip, lr, pc}
sub fp, ip, # 4

Ao realizar um rastreamento de pilha, o código pode inspecionar o valor de "pc" armazenado em "fp +
0 ". Se a função de rastreamento olhar para a localização" pc - 12 "e os 8 bits principais são
definido, então sabemos que há um nome de função embutido imediatamente antes deste
localização e tem comprimento "((pc [-3]) & 0xff000000)".

-mthumb
-marm
Selecione entre a geração de código que executa nos estados ARM e Thumb. O padrão para
a maioria das configurações é para gerar código que executa no estado ARM, mas o padrão
pode ser alterado configurando o GCC com o --with-mode =estado opção de configuração.

-mtpcs-quadro
Gere um frame de pilha que seja compatível com o Thumb Procedure Call Standard para
todas as funções não-folha. (Uma função folha é aquela que não chama nenhum outro
funções.) O padrão é -mno-tpcs-quadro.

-mtpcs-folha-quadro
Gere um frame de pilha que seja compatível com o Thumb Procedure Call Standard para
todas as funções de folha. (Uma função folha é aquela que não chama nenhuma outra função.)
O padrão é -mno-apcs-folha-quadro.

-mcallee-superinterworking
Dá a todas as funções externamente visíveis no arquivo que está sendo compilado uma instrução ARM
definir o cabeçalho que muda para o modo Thumb antes de executar o resto da função.
Isso permite que essas funções sejam chamadas a partir de um código não interoperável. Esta opção é
não é válido em configurações AAPCS porque o interfuncionamento está habilitado por padrão.

-mcaller-superinterworking
Permite que chamadas por meio de ponteiros de função (incluindo funções virtuais) sejam executadas corretamente
independentemente de o código de destino ter sido compilado para interoperação ou não.
Há uma pequena sobrecarga no custo de execução de um ponteiro de função se esta opção
está ativado. Esta opção não é válida em configurações AAPCS porque o interfuncionamento é
habilitado por padrão.

-mtp =nome
Especifique o modelo de acesso para o ponteiro de armazenamento local do encadeamento. Os modelos válidos são
macio, que gera chamadas para "__aeabi_read_tp", cp15, que busca o tópico
ponteiro de "cp15" diretamente (compatível com a arquitetura arm6k), e auto, o qual
usa o melhor método disponível para o processador selecionado. A configuração padrão é
auto.

-mtls-dialect =dialeto
Especifique o dialeto a ser usado para acessar o armazenamento local do thread. Dois dialetos são
suportado --- gnu e gnu2. O gnu dialeto seleciona o esquema GNU original para
suportando modelos TLS dinâmicos locais e globais. o gnu2 dialeto seleciona o GNU
esquema descritor, que fornece melhor desempenho para bibliotecas compartilhadas. O GNU
o esquema do descritor é compatível com o esquema original, mas requer novos
suporte a assembler, linker e biblioteca. Os modelos TLS executivos iniciais e locais são
não é afetado por esta opção e sempre usa o esquema original.

-mword-relocações
Apenas gere realocações absolutas em valores de tamanho de palavra (ou seja, R_ARM_ABS32). Isto é
habilitado por padrão em alvos (uClinux, SymbianOS) onde o carregador de tempo de execução impõe
esta restrição, e quando -fpic or -fPIC é especificado.

-mfix-córtex-m3-ldrd
Alguns núcleos Cortex-M3 podem causar corrupção de dados quando as instruções "ldrd" com
destino sobreposto e registros de base são usados. Esta opção evita gerar
essas instruções. Esta opção é habilitada por padrão quando -mcpu = cortex-m3 is
Especificadas.

-acesso-imunalinhado
-mno-acesso não alinhado
Ativa (ou desativa) a leitura e gravação de valores de 16 e 32 bits de endereços
que não estão alinhados a 16 ou 32 bits. Por padrão, o acesso não alinhado está desabilitado para todos
pré-ARMv6 e todas as arquiteturas ARMv6-M, e habilitado para todas as outras arquiteturas. Se
o acesso não alinhado não está habilitado, então as palavras em estruturas de dados compactadas serão acessadas
um byte de cada vez.

O atributo ARM "Tag_CPU_unaligned_access" será definido no arquivo objeto gerado
como verdadeiro ou falso, dependendo da configuração desta opção. Se não alinhado
o acesso for habilitado, então o símbolo do pré-processador "__ARM_FEATURE_UNALIGNED" também será
definiram.

-mneon-para-64bits
Habilita o uso do Neon para lidar com operações escalares de 64 bits. Isto está desabilitado por padrão
uma vez que o custo de mover dados dos registros centrais para o Neon é alto.

AVR Opções

-mmcu =MCU
Especifique arquiteturas de conjunto de instruções Atmel AVR (ISA) ou tipo de MCU.

O padrão para esta opção é @ tie {} "avr2".

O GCC é compatível com os seguintes dispositivos AVR e ISAs:

"avr2"
Dispositivos "clássicos" com até 8 @ tie {} KiB de memória de programa. MCU@tie {} = "attiny22",
"attiny26", "at90c8534", "at90s2313", "at90s2323", "at90s2333", "at90s2343",
"at90s4414", "at90s4433", "at90s4434", "at90s8515", "at90s8535".

"avr25"
Dispositivos "clássicos" com até 8 @ tie {} KiB de memória de programa e com o "MOVW"
instrução. 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"
Dispositivos "clássicos" com 16 @ tie {} KiB até 64 @ tie {} KiB de memória de programa.
MCU@tie {} = "at43usb355", "at76c711".

"avr31"
Dispositivos "clássicos" com 128 @ tie {} KiB de memória de programa. MCU@tie {} = "atmega103",
"at43usb320".

"avr35"
Dispositivos "clássicos" com 16 @ tie {} KiB até 64 @ tie {} KiB de memória de programa e com
a instrução "MOVW". MCU@tie {} = "atmega16u2", "atmega32u2", "atmega8u2",
"attiny167", "at90usb162", "at90usb82".

"avr4"
Dispositivos "aprimorados" com até 8 @ tie {} KiB de memória de programa. MCU@tie {} =
"atmega48", "atmega48a", "atmega48p", "atmega8", "atmega8hva", "atmega8515",
"atmega8535", "atmega88", "atmega88a", "atmega88p", "atmega88pa", "at90pwm1",
"at90pwm2", "at90pwm2b", "at90pwm3", "at90pwm3b", "at90pwm81".

"avr5"
Dispositivos "aprimorados" com 16 @ tie {} KiB até 64 @ tie {} KiB de memória de programa.
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"
Dispositivos "aprimorados" com 128 @ tie {} KiB de memória de programa. MCU@tie {} = "atmega128",
"atmega128rfa1", "atmega1280", "atmega1281", "atmega1284p", "at90can128",
"at90usb1286", "at90usb1287".

"avr6"
Dispositivos "aprimorados" com PC de 3 bytes, ou seja, com mais de 128 @ tie {} KiB de programa
memória. MCU@tie {} = "atmega2560", "atmega2561".

"avrxmega2"
Dispositivos "XMEGA" com mais de 8 @ tie {} KiB e até 64 @ tie {} KiB de memória de programa.
MCU@tie {} = "atxmega16a4", "atxmega16d4", "atxmega16x1", "atxmega32a4",
"atxmega32d4", "atxmega32x1".

"avrxmega4"
Dispositivos "XMEGA" com mais de 64 @ tie {} KiB e até 128 @ tie {} KiB de programa
memória. MCU@tie {} = "atxmega64a3", "atxmega64d3".

"avrxmega5"
Dispositivos "XMEGA" com mais de 64 @ tie {} KiB e até 128 @ tie {} KiB de programa
memória e mais de 64 @ tie {} KiB de RAM. MCU@tie {} = "atxmega64a1",
"atxmega64a1u".

"avrxmega6"
Dispositivos "XMEGA" com mais de 128 @ tie {} KiB de memória de programa. MCU@tie {} =
"atxmega128a3", "atxmega128d3", "atxmega192a3", "atxmega192d3", "atxmega256a3",
"atxmega256a3b", "atxmega256a3bu", "atxmega256d3".

"avrxmega7"
Dispositivos "XMEGA" com mais de 128 @ tie {} KiB de memória de programa e mais de
64 @ tie {} KiB de RAM. MCU@tie {} = "atxmega128a1", "atxmega128a1u".

"avr1"
Este ISA é implementado pelo núcleo AVR mínimo e com suporte apenas para assembler.
MCU@tie {} = "attiny11", "attiny12", "attiny15", "attiny28", "at90s1200".

-maccumulate-args
Acumule argumentos de função de saída e adquira / libere o espaço de pilha necessário para
argumentos de função de saída uma vez no prólogo / epílogo da função. Sem esta opção,
os argumentos de saída são enviados antes de chamar uma função e exibidos posteriormente.

Colocar os argumentos após a chamada da função pode ser caro no AVR, de modo que
acumular o espaço da pilha pode levar a executáveis ​​menores porque os argumentos precisam
não deve ser removido da pilha após tal chamada de função.

Esta opção pode reduzir o tamanho do código para funções que realizam várias chamadas para
funções que obtêm seus argumentos na pilha, como chamadas para funções semelhantes a printf.

-mbranch-cost =custo
Defina os custos de ramificação para instruções de ramificação condicional para custo. Valores razoáveis
for custo são números inteiros pequenos e não negativos. O custo da filial padrão é 0.

-mcall-prólogos
Os prólogos / epílogos das funções são expandidos como chamadas para as sub-rotinas apropriadas. Código
o tamanho é menor.

-hortelã8
Suponha que "int" seja um número inteiro de 8 bits. Isso afeta os tamanhos de todos os tipos: um "char" é 1
byte, um "int" tem 1 byte, um "long" tem 2 bytes e "long long" tem 4 bytes. Por favor
observe que esta opção não está em conformidade com os padrões C, mas resulta em menores
tamanho do código.

-mno-interrupções
O código gerado não é compatível com interrupções de hardware. O tamanho do código é menor.

-mrelax
Tente substituir "CALL" resp. A instrução "JMP" pela resp. Mais curta "RCALL". "RJMP"
instrução, se aplicável. Definir "-mrelax" apenas adiciona a opção "--relax" ao
linha de comando do vinculador quando o vinculador é chamado.

O relaxamento do salto é realizado pelo vinculador porque os deslocamentos do salto não são conhecidos antes
o código está localizado. Portanto, o código assembler gerado pelo compilador é o mesmo,
mas as instruções no executável podem diferir das instruções no assembler
código.

O relaxamento deve ser ativado se os stubs do linker forem necessários, consulte a seção "EIND" e
linker stubs abaixo.

-mshort-chamadas
Esta opção se tornou obsoleta e será removida no GCC 4.8. Consulte "-mrelax" para um
substituição.

Use as instruções "RCALL" / "RJMP" mesmo em dispositivos com 16 @ tie {} KiB ou mais do programa
memória, ou seja, em dispositivos que possuem as instruções "CALL" e "JMP".

-msp8
Trate o registro do ponteiro da pilha como um registro de 8 bits, ou seja, assume o byte alto de
o ponteiro da pilha é zero. Em geral, você não precisa definir essa opção manualmente.

Esta opção é usada internamente pelo compilador para selecionar e construir multilibs para
arquiteturas "avr2" e "avr25". Essas arquiteturas misturam dispositivos com e sem
"SPH". Para qualquer configuração diferente de "-mmcu = avr2" ou "-mmcu = avr25" o driver do compilador
irá adicionar ou remover esta opção da linha de comando do compilador apropriado, porque o
o compilador sabe se o dispositivo ou arquitetura tem um ponteiro de pilha de 8 bits e, portanto,
sem registro "SPH" ou não.

-mstrict-X
Use o registro de endereço "X" da forma proposta pelo hardware. Isso significa que "X" é
usado apenas em endereçamento indireto, pós-incremento ou pré-decremento.

Sem esta opção, o registro "X" pode ser usado da mesma forma que "Y" ou "Z" que
então é emulado por instruções adicionais. Por exemplo, carregar um valor com
"X + const" endereçando com um pequeno não negativo "const <64" para um registrador Rn is
realizado como

adiw r26, const; X + = const
ld , X; = * X
sbiw r26, const; X - = const

-mtiny-pilha
Altere apenas os 8 bits @ tie {} inferiores do ponteiro da pilha.

"EIND" e dispositivos com mais de 128 Ki Bytes de Flash

Os ponteiros na implementação têm 16 bits @ tie {} de largura. O endereço de uma função ou rótulo
é representado como endereço de palavra para que chamadas e saltos indiretos possam direcionar a qualquer código
endereço no intervalo de 64 @ tie {} palavras Ki.

Para facilitar o salto indireto em dispositivos com mais de 128 @ tie {} Ki bytes de
espaço de memória do programa, há um registro de função especial chamado "EIND" que serve como
parte mais significativa do endereço de destino quando as instruções "EICALL" ou "EIJMP" são
usava.

Saltos indiretos e chamadas nesses dispositivos são tratados da seguinte forma pelo compilador e são
sujeito a algumas limitações:

· O compilador nunca define "EIND".

· O compilador usa "EIND" implicitamente nas instruções "EICALL" / "EIJMP" ou pode ler
"EIND" diretamente para emular uma chamada / salto indireto por meio de um "RET"
instrução.

· O compilador assume que "EIND" nunca muda durante o código de inicialização ou durante o
aplicativo. Em particular, "EIND" não é salvo / restaurado em função ou interrupção
prólogo / epílogo de rotina de serviço.

· Para chamadas indiretas para funções e goto calculado, o vinculador gera tocos. Tocos
são almofadas de salto às vezes também chamadas trampolins. Assim, a chamada / salto indireto salta para
tal esboço. O stub contém um salto direto para o endereço desejado.

· O relaxamento do vinculador deve ser ativado para que o vinculador gere os stubs
corretamente e todos os situaltion. Veja a opção do compilador "-mrelax" e a opção linler
"--relaxar". Existem casos em que o vinculador deve gerar stubs, mas
aborta sem relaxamento e sem uma mensagem de erro útil.

· O script do vinculador padrão é organizado para o código com "EIND = 0". Se o código é suposto
para trabalhar para uma configuração com "EIND! = 0", um script de vinculador personalizado deve ser usado para
para colocar as seções cujo nome começa com ".trampolins" no segmento onde
"EIND" aponta para.

· O código de inicialização de libgcc nunca define "EIND". Observe que o código de inicialização é uma mistura
de código de libgcc e AVR-LibC. Para o impacto do AVR-LibC em "EIND", consulte o AVR-
Manual do usuário LibC ("http://nongnu.org/avr-libc/user-manual/").

· É legítimo que o código de inicialização específico do usuário configure o "EIND" antecipadamente, por exemplo, por
meio de código de inicialização localizado na seção ".init3". Esse código é executado antes de
código de inicialização geral que inicializa RAM e chama construtores, mas depois de um pouco de
código de inicialização de AVR-LibC que define "EIND" para o segmento onde a tabela de vetor está
localizado.

#incluir

vazio estático
__attribute __ ((seção (". init3"), naked, used, no_instrument_function))
init3_set_eind (vazio)
{
__asm ​​volatile ("ldi r24, pm_hh8 (__ trampolines_start) \ n \ t"
"fora% i0, r24" :: "n" (& EIND): "r24", "memória");
}

O símbolo "__trampolines_start" é definido no script do vinculador.

· Os stubs são gerados automaticamente pelo vinculador se as duas condições a seguir forem
conheceu:

-
(abreviatura de gerar tocos) igual a:

LDI r24, lo8 (gs ( ))
LDI r25, hi8 (gs ( ))

-
lado de fora o segmento onde os stubs estão localizados.

· O compilador emite esses modificadores "gs" para rótulos de código nas seguintes situações:

-
-
- -mcall-prólogos>
opção de linha de comando.

-
tabelas você pode especificar o -fno-jump-tables opção de linha de comando.

-
-
· Saltar para endereços não simbólicos como está não suportado:

int main (vazio)
{
/ * Função de chamada no endereço de palavra 0x2 * /
return ((int (*) (void)) 0x2) ();
}

Em vez disso, um esboço deve ser configurado, ou seja, a função deve ser chamada por meio de um símbolo
("func_4" no exemplo):

int main (vazio)
{
extern int func_4 (vazio);

/ * Função de chamada no endereço de byte 0x4 * /
return func_4 ();
}

e o aplicativo deve ser vinculado a "-Wl, - defsym, func_4 = 0x4". Alternativamente, "func_4"
pode ser definido no script do vinculador.

Tratamento dos registros de funções especiais "RAMPD", "RAMPX", "RAMPY" e "RAMPZ"

Alguns dispositivos AVR suportam memórias maiores que o intervalo de 64 @ tie {} KiB que pode ser acessado
com ponteiros de 16 bits. Para acessar locais de memória fora deste intervalo de 64 @ tie {} KiB, o
o conteúdo de um registro "RAMP" é usado como parte superior do endereço: O "X", "Y", "Z"
registro de endereço é concatenado com a função especial "RAMPX", "RAMPY", "RAMPZ"
registrar, respectivamente, para obter um endereço amplo. Da mesma forma, "RAMPD" é usado junto com
endereçamento direto.

· O código de inicialização inicializa os registros da função especial "RAMP" com zero.

· Se um AVR Nomeado Endereço Espaços, nomeados endereço espaço diferente de genérico ou "__flash" é
usado, então "RAMPZ" é definido conforme necessário antes da operação.

· Se o dispositivo suporta RAM maior que 64 @ tie {KiB} e o compilador precisa ser alterado
"RAMPZ" para realizar uma operação, "RAMPZ" é zerado após a operação.

· Se o dispositivo vier com um registro "RAMP" específico, o prólogo / epílogo ISR
salva / restaura esse SFR e inicializa-o com zero caso o código ISR possa
(implicitamente) use-o.

· RAM maior que 64 @ tie {KiB} não é compatível com GCC para alvos AVR. Se você usar
assembler inline para ler de locais fora da faixa de endereço de 16 bits e mudar
um dos registradores "RAMP", deve-se zerar após o acesso.

Macros incorporados de AVR

O GCC define várias macros integradas para que o código do usuário possa testar a presença ou
ausência de recursos. Quase qualquer uma das seguintes macros embutidas são deduzidas do dispositivo
recursos e, portanto, acionado pela opção de linha de comando "-mmcu =".

Para ainda mais macros integradas específicas de AVR, consulte AVR Nomeado Endereço Espaços e AVR Autenticador
Funções.

"__AVR_ARCH__"
Macro embutido que resolve para um número decimal que identifica a arquitetura e
depende do "-mmcu =mcu " opção. Os valores possíveis são:

2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107

for MCU= "avr2", "avr25", "avr3", "avr31", "avr35", "avr4", "avr5", "avr51", "avr6",
"avrxmega2", "avrxmega4", "avrxmega5", "avrxmega6", "avrxmega7", respectivamente. Se MCU
especifica um dispositivo, esta macro embutida é configurada de acordo. Por exemplo, com
"-mmcu = atmega8" a macro será definida para 4.

"__AVR_dispositivo__"
Configurando "-mmcu =dispositivo" define esta macro embutida que reflete o nome do dispositivo.
Por exemplo, "-mmcu = atmega8" define a macro integrada "__AVR_ATmega8__",
"-mmcu = attiny261a" define "__AVR_ATtiny261A__", etc.

Os nomes das macros integradas seguem o esquema "__AVR_dispositivo__" onde dispositivo é o
nome do dispositivo de acordo com o manual do usuário do AVR. A diferença entre dispositivo no embutido
macro e dispositivo em "-mmcu =dispositivo" é que o último está sempre em minúsculas.

If dispositivo não é um dispositivo, mas apenas uma arquitetura central como "avr51", esta macro irá
não ser definido.

"__AVR_XMEGA__"
O dispositivo / arquitetura pertence à família de dispositivos XMEGA.

"__AVR_HAVE_ELPM__"
O dispositivo possui a instrução "ELPM".

"__AVR_HAVE_ELPMX__"
O dispositivo tem o "ELPM Rn, Z " e "ELPM Rn, Z + " instruções.

"__AVR_HAVE_MOVW__"
O dispositivo possui a instrução "MOVW" para realizar movimentos de registro-registro de 16 bits.

"__AVR_HAVE_LPMX__"
O dispositivo tem o "LPM Rn, Z " e "LPM Rn, Z + " instruções.

"__AVR_HAVE_MUL__"
O dispositivo possui um multiplicador de hardware.

"__AVR_HAVE_JMP_CALL__"
O dispositivo possui as instruções "JMP" e "CALL". Este é o caso de dispositivos com
pelo menos 16 @ tie {} KiB de memória do programa e se "-mshort-calls" não estiver definido.

"__AVR_HAVE_EIJMP_EICALL__"
"__AVR_3_BYTE_PC__"
O dispositivo possui as instruções "EIJMP" e "EICALL". Este é o caso de dispositivos
com mais de 128 @ tie {} KiB de memória de programa. Isso também significa que o programa
contador (PC) tem 3 @ tie {} bytes de largura.

"__AVR_2_BYTE_PC__"
O contador do programa (PC) tem 2 @ tie {} bytes de largura. Este é o caso de dispositivos com até
128 @ tie {} KiB de memória de programa.

"__AVR_HAVE_8BIT_SP__"
"__AVR_HAVE_16BIT_SP__"
O registro de ponteiro de pilha (SP) é tratado como 8 bits, respectivamente, registro de 16 bits por
o compilador. A definição dessas macros é afetada por "-mtiny-stack".

"__AVR_HAVE_SPH__"
"__AVR_SP8__"
O dispositivo tem o registro de função especial SPH (parte alta do ponteiro da pilha) ou tem
um ponteiro de pilha de 8 bits, respectivamente. A definição dessas macros é afetada por
"-mmcu =" e nos casos de "-mmcu = avr2" e "-mmcu = avr25" também por "-msp8".

"__AVR_HAVE_RAMPD__"
"__AVR_HAVE_RAMPX__"
"__AVR_HAVE_RAMPY__"
"__AVR_HAVE_RAMPZ__"
O dispositivo tem o registro de função especial "RAMPD", "RAMPX", "RAMPY", "RAMPZ",
respectivamente.

"__NO_INTERRUPTS__"
Esta macro reflete a opção de linha de comando "-mno-interrupts".

"__AVR_ERRATA_SKIP__"
"__AVR_ERRATA_SKIP_JMP_CALL__"
Alguns dispositivos AVR (AT90S8515, ATmega103) não devem pular as instruções de 32 bits devido a um
errata de hardware. As instruções para ignorar são "SBRS", "SBRC", "SBIS", "SBIC" e "CPSE".
A segunda macro é definida apenas se "__AVR_HAVE_JMP_CALL__" também estiver definido.

"__AVR_SFR_OFFSET __ =Deslocamento"
Instruções que podem endereçar registros de função especial de E / S diretamente como "IN",
"OUT", "SBI", etc. podem usar um endereço diferente como se fosse endereçado por uma instrução para
acesse a RAM como "LD" ou "STS". Este deslocamento depende da arquitetura do dispositivo e tem
a ser subtraído do endereço RAM para obter o respectivo endereço I / O @ tie {}.

"__WITH_AVRLIBC__"
O compilador é configurado para ser usado junto com o AVR-Libc. Veja o
Opção de configuração "--with-avrlibc".

Blackfin Opções

-mcpu =cpu[-revisão]
Especifica o nome do processador Blackfin de destino. Atualmente, cpu pode ser um de
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. O opcional revisão especifica o
revisão de silício do processador Blackfin de destino. Quaisquer soluções alternativas disponíveis para o
a revisão de silício direcionada será habilitada. Se revisão is Nenhum, nenhuma solução alternativa é
ativado. Se revisão is qualquer, todas as soluções alternativas para o processador de destino serão
ativado. A macro "__SILICON_REVISION__" é definida para dois dígitos hexadecimais
representando os números maiores e menores na revisão do silício. Se revisão is
Nenhum, o "__SILICON_REVISION__" não está definido. Se revisão is qualquer,
"__SILICON_REVISION__" é definido como 0xffff. Se for opcional revisão não é
usado, o GCC assume a última revisão de silício conhecida do Blackfin alvo
processador.

Suporte para bf561 está incompleto. Para bf561, Apenas a macro do processador é definida.
Sem esta opção, bf532 é usado como processador por padrão. O correspondente
macros de processador predefinidas para cpu está para ser definido. E para elfo-bfin conjunto de ferramentas,
isso faz com que o BSP de hardware fornecido pela libgloss seja vinculado se -msim não é
dado.

-msim
Especifica que o programa será executado no simulador. Isso faz com que o simulador
BSP fornecido pela libgloss para ser vinculado. Esta opção tem efeito apenas para elfo-bfin
conjunto de ferramentas. Algumas outras opções, como -mid-biblioteca compartilhada e -mfdpic, implica
-msim.

-momit-folha-frame-ponteiro
Não mantenha o ponteiro do quadro em um registro para funções folha. Isso evita o
instruções para salvar, configurar e restaurar ponteiros de quadro e fazer um registro extra
disponível nas funções de folha. A opção -fomit-frame-ponteiro remove a moldura
ponteiro para todas as funções, o que pode tornar a depuração mais difícil.

-mspeld-anomalia
Quando habilitado, o compilador irá garantir que o código gerado não contenha
cargas especulativas após instruções de salto. Se esta opção for usada,
"__WORKAROUND_SPECULATIVE_LOADS" está definido.

-mno-specld-anomalia
Não gere código extra para evitar que ocorram cargas especulativas.

-mcsync-anomalia
Quando habilitado, o compilador irá garantir que o código gerado não contenha CSYNC
ou instruções SSYNC logo após os desvios condicionais. Se esta opção for usada,
"__WORKAROUND_SPECULATIVE_SYNCS" está definido.

-mno-csync-anomalia
Não gere código extra para evitar que as instruções CSYNC ou SSYNC ocorram também
logo após um desvio condicional.

-mlow-64k
Quando ativado, o compilador é livre para aproveitar o conhecimento de que todo o
programa se encaixa em 64k de memória baixa.

-mno-baixo-64k
Suponha que o programa seja arbitrariamente grande. Este é o padrão.

-mstack-check-l1
Faça a verificação de pilha usando informações colocadas na memória de rascunho L1 pelo uClinux
núcleo.

-mid-biblioteca compartilhada
Gere código que ofereça suporte a bibliotecas compartilhadas por meio do método de ID de biblioteca. Isso permite
para executar no local e bibliotecas compartilhadas em um ambiente sem memória virtual
gestão. Esta opção implica -fPIC. Com um elfo-bfin alvo, esta opção implica
-msim.

-mno-id-biblioteca compartilhada
Gere código que não presuma que bibliotecas compartilhadas baseadas em ID estão sendo usadas. Isto é
o padrão.

-mleaf-id-biblioteca compartilhada
Gerar código que ofereça suporte a bibliotecas compartilhadas por meio do método de ID de biblioteca, mas assume
que esta biblioteca ou executável não se vinculará a nenhuma outra biblioteca compartilhada de ID.
Isso permite que o compilador use código mais rápido para saltos e chamadas.

-mno-leaf-id-biblioteca compartilhada
Não assuma que o código que está sendo compilado não vinculará a nenhuma biblioteca compartilhada de ID.
Um código mais lento será gerado para jump e call insns.

-mshared-library-id = n
Especificado o número de identificação da biblioteca compartilhada baseada em ID que está sendo compilada.
Especificar um valor de 0 irá gerar um código mais compacto, especificar outros valores irá
forçar a alocação desse número para a biblioteca atual, mas não há mais espaço ou
eficiente em termos de tempo do que omitir esta opção.

-msep-dados
Gerar código que permite que o segmento de dados seja localizado em uma área diferente da memória
do segmento de texto. Isso permite a execução no local em um ambiente sem
gerenciamento de memória virtual, eliminando realocações na seção de texto.

-mno-sep-dados
Gere código que assume que o segmento de dados segue o segmento de texto. Isto é
o padrão.

-muito chamadas
-mno-long-chamadas
Diz ao compilador para realizar chamadas de função, primeiro carregando o endereço do
função em um registro e, em seguida, executar uma chamada de sub-rotina neste registro. Esse
switch é necessário se a função alvo estiver fora da faixa de endereçamento de 24 bits de
a versão baseada em deslocamento da instrução de chamada de sub-rotina.

Este recurso não é habilitado por padrão. Especificando -mno-long-chamadas irá restaurar o
comportamento padrão. Observe que essas opções não têm efeito sobre como o compilador gera
código para lidar com chamadas de função por meio de ponteiros de função.

-mfast-fp
Faça o link com a biblioteca de ponto flutuante rápida. Esta biblioteca relaxa um pouco do IEEE
regras do padrão de ponto flutuante para verificar entradas em relação a Não-um-Número (NAN), no
interesse de desempenho.

-minline-plt
Habilite o inlining de entradas PLT em chamadas de função para funções que não são conhecidas por
vincular localmente. Não tem efeito sem -mfdpic.

-mmulticore
Crie um aplicativo independente para o processador Blackfin multicore. Arquivos de início adequados e
scripts de link serão usados ​​para oferecer suporte a vários núcleos. Esta opção define
"__BFIN_MULTICORE". Só pode ser usado com -mcpu = bf561[-revisão] Isso pode ser usado
com -mcorea or -mcoreb. Se for usado sem -mcorea or -mcoreb, Solteiro
modelo de programação de aplicativo / dual core é usado. Neste modelo, a função principal de
O núcleo B deve ser nomeado como coreb_main. Se for usado com -mcorea or -mcoreb, um
aplicativo por modelo de programação principal é usado. Se esta opção não for usada, único
modelo de programação de aplicativo principal é usado.

-mcorea
Crie um aplicativo autônomo para o núcleo A do BF561 ao usar um aplicativo por núcleo
modelo de programação. Arquivos de início adequados e scripts de link serão usados ​​para dar suporte ao Núcleo A.
Esta opção define "__BFIN_COREA". Deve ser usado com -mmulticore.

-mcoreb
Crie um aplicativo independente para o Núcleo B do BF561 ao usar um aplicativo por núcleo
modelo de programação. Arquivos de início adequados e scripts de link serão usados ​​para dar suporte ao Núcleo B.
Esta opção define "__BFIN_COREB". Quando esta opção é usada, coreb_main deve ser
usado em vez de principal. Deve ser usado com -mmulticore.

-msdram
Crie um aplicativo independente para SDRAM. Arquivos de início adequados e scripts de link serão
usado para colocar o aplicativo em SDRAM. O carregador deve inicializar SDRAM antes de carregar
o aplicativo em SDRAM. Esta opção define "__BFIN_SDRAM".

-micplb
Suponha que os ICPLBs estejam habilitados no tempo de execução. Isso tem um efeito em certas anomalias
soluções alternativas. Para destinos Linux, o padrão é assumir que os ICPLBs estão ativados; para
aplicativos autônomos, o padrão é desativado.

C6X Opções

-march =nome
Isso especifica o nome da arquitetura de destino. GCC usa este nome para determinar
que tipo de instruções ele pode emitir ao gerar o código assembly. Permitida
nomes são: c62x, c64x, c64x +, c67x, c67x +, c674x.

-mbi-endian
Gere código para um alvo big-endian.

-mlittle-endian
Gere código para um target little-endian. Este é o padrão.

-msim
Escolha os arquivos de inicialização e o script do vinculador adequados para o simulador.

-msdata = padrão
Coloque pequenos dados globais e estáticos no .neardata seção, que é apontada por
registrar "B14". Coloque pequenos dados globais e estáticos não inicializados no .bss seção,
que é adjacente ao .neardata seção. Coloque pequenos dados somente leitura no .rodata
seção. As seções correspondentes usadas para grandes pedaços de dados são .fardata, .far
e .const.

-msdata = all
Coloque todos os dados, não apenas pequenos objetos, nas seções reservadas para pequenos dados, e
use o endereçamento relativo ao registro "B14" para acessá-los.

-msdata = nenhum
Não faça uso das seções reservadas para pequenos dados e use endereços absolutos para
acessar todos os dados. Coloque todos os dados globais e estáticos inicializados no .fardata seção,
e todos os dados não inicializados no .far seção. Coloque todos os dados constantes no .const
seção.

CRIS Opções

Essas opções são definidas especificamente para as portas CRIS.

-march =tipo de arquitetura
-mcpu =tipo de arquitetura
Gerar código para a arquitetura especificada. As escolhas para tipo de arquitetura e guarante que os mesmos estão
v3, v8 e v10 para ETRAX 4, ETRAX 100 e ETRAX 100 LX, respectivamente. O padrão é v0
exceto para cris-axis-linux-gnu, onde o padrão é v10.

-mtune =tipo de arquitetura
Sintonizar para tipo de arquitetura tudo aplicável sobre o código gerado, exceto para
a ABI e o conjunto de instruções disponíveis. As escolhas para tipo de arquitetura e guarante que os mesmos estão
o mesmo que para -march =tipo de arquitetura.

-mmax-stack-frame =n
Avisa quando o frame da pilha de uma função excede n bytes.

-metrax4
-metrax100
As opções -metrax4 e -metrax100 são sinônimos para -march = v3 e -march = v8
respectivamente.

-mmul-bug-solução
-mno-mul-bug-solução
Contorne um bug nas instruções "muls" e "mulu" para modelos de CPU onde
se aplica. Esta opção está ativa por padrão.

-mpdebug
Habilite informações detalhadas relacionadas à depuração específica do CRIS no código do assembly. Esse
opção também tem o efeito de desligar o #NO_APP indicador de código formatado para o
assembler no início do arquivo de montagem.

-mcc-init
Não use resultados de código de condição da instrução anterior; sempre emita compare e
instruções de teste antes do uso dos códigos de condição.

-mno-efeitos colaterais
Não emita instruções com efeitos colaterais em modos de endereçamento diferentes de pós-
incremento.

-mstack-align
-mno-stack-align
-mdata-align
-mno-alinhamento de dados
-mconst-alinhar
-mno-const-alinhar
Essas opções (sem opções) organizam (eliminam disposições) para a estrutura da pilha,
dados individuais e constantes a serem alinhados para o tamanho máximo de acesso a dados individuais
para o modelo de CPU escolhido. O padrão é organizar o alinhamento de 32 bits. ABI
detalhes como o layout da estrutura não são afetados por essas opções.

-m32 bits
-m16 bits
-m8 bits
Semelhante às opções stack-data- e const-align acima, essas opções organizam para
stack-frame, dados graváveis ​​e constantes para todos estarem alinhados a 32, 16 ou 8 bits.
O padrão é alinhamento de 32 bits.

-mno-prólogo-epílogo
-prólogo-epílogo
Com -mno-prólogo-epílogo, o prólogo e epílogo da função normal que configurou
o frame da pilha é omitido e nenhuma instrução de retorno ou sequências de retorno são
gerado no código. Use esta opção apenas em conjunto com a inspeção visual do
código compilado: nenhum aviso ou erro é gerado quando os registros salvos de chamadas devem ser
salvo, ou o armazenamento para a variável local precisa ser alocado.

-mno-gotplt
-mgotplt
Com -fpic e -fPIC, não gere (gere) sequências de instrução que carregam
endereços para funções da parte PLT do GOT em vez de (tradicional em outro
arquiteturas) chamadas para o PLT. O padrão é -mgotplt.

-me
Opção legada sem operação reconhecida apenas com cris-axis-elf e cris-axis-linux-gnu
alvos.

-mlinux
Opção legada sem operação reconhecida apenas com o destino cris-axis-linux-gnu.

-sim
Esta opção, reconhecida para o elfo do eixo cris organiza para vincular com entrada-saída
funções de uma biblioteca de simulador. Código, dados inicializados e dados inicializados com zero
são alocados consecutivamente.

-sim2
Como -sim, mas passe as opções do linker para localizar os dados inicializados em 0x40000000 e zero-
dados inicializados em 0x80000000.

CR16 Opções

Essas opções são definidas especificamente para as portas CR16.

-mmac
Habilite o uso de instruções de multiplicação-acumulação. Desativado por padrão.

-mcr16cplus
-mcr16c
Gere código para a arquitetura CR16C ou CR16C +. A arquitetura CR16C + é padrão.

-msim
Vincula a biblioteca libsim.a que é compatível com o simulador. Aplicável a elfo
compilador apenas.

-hortelã32
Escolha o tipo de número inteiro com largura de 32 bits.

-mbit-ops
Gera instruções sbit / cbit para manipulações de bits.

-mdata-model =modelo
Escolha um modelo de dados. As escolhas para modelo e guarante que os mesmos estão perto, longe or média. média é o padrão.
O Mercado Pago não havia executado campanhas de Performance anteriormente nessas plataformas. Alcançar uma campanha de sucesso exigiria longe não é válido quando a opção -mcr16c é escolhida porque a arquitetura CR16C não
suporte modelo de dados distante.

Darwin Opções

Essas opções são definidas para todas as arquiteturas que executam o sistema operacional Darwin.

O FSF GCC no Darwin não cria arquivos de objeto "gordos"; ele criará um arquivo de objeto para
a arquitetura única que foi construída para atingir. O GCC da Apple em Darwin cria
arquivos "gordos" se múltiplos -arco opções são usadas; ele faz isso executando o compilador ou
vinculador várias vezes e juntando os resultados com lipo.

O subtipo do arquivo criado (como ppc7400 or ppc970 or i686) é determinado pelo
sinalizadores que especificam o ISA que o GCC está direcionando, como -mcpu or -marchar. O
-force_cpusubtype_ALL opção pode ser usada para substituir isso.

As ferramentas Darwin variam em seu comportamento quando apresentadas com uma incompatibilidade de ISA. o
montador, as, só permitirá o uso de instruções válidas para o subtipo de
o arquivo que está gerando, então você não pode colocar instruções de 64 bits em um ppc750 arquivo de objeto.
O vinculador para bibliotecas compartilhadas, / usr / bin / libtool, irá falhar e imprimir um erro se solicitado
para criar uma biblioteca compartilhada com um subtipo menos restritivo do que seus arquivos de entrada (para
exemplo, tentando colocar um ppc970 arquivo de objeto em um ppc7400 biblioteca). O vinculador para
executáveis, ld, fornecerá ao executável o subtipo mais restritivo de qualquer um dos
seus arquivos de entrada.

-Fdir
Adicione o diretório da estrutura dir para o topo da lista de diretórios a serem pesquisados
para arquivos de cabeçalho. Esses diretórios são intercalados com aqueles especificados por -I
opções e são verificados na ordem da esquerda para a direita.

Um diretório de estrutura é um diretório com estruturas nele. Uma estrutura é um
diretório com um "Cabeçalhos" e / ou "PrivateHeaders" diretório contido diretamente nele
que termina em ".estrutura". O nome de uma estrutura é o nome deste diretório
excluindo o ".estrutura". Os cabeçalhos associados à estrutura são encontrados em um dos
esses dois diretórios, com "Cabeçalhos" sendo pesquisado primeiro. Um subframework é um
diretório do framework que está em um framework "Frameworks" diretório. Inclui de
cabeçalhos subframework só podem aparecer em um cabeçalho de um framework que contém o
subframework, ou em um cabeçalho de subframework irmão. Dois subframeworks são irmãos se
eles ocorrem na mesma estrutura. Um subframework não deve ter o mesmo nome que um
estrutura, um aviso será emitido se isso for violado. Atualmente uma subestrutura
não pode ter subframeworks, no futuro, o mecanismo pode ser estendido para apoiar
isto. Os frameworks padrão podem ser encontrados em "/ Sistema / Biblioteca / Frameworks" e
"/ Biblioteca / Frameworks". Um exemplo include parece "#include ",
onde Quadro denota o nome da estrutura e header.h é encontrado no
"PrivateHeaders" or "Cabeçalhos" diretório.

-iframeworkdir
Como -F exceto que o diretório é tratado como um diretório do sistema. A principal diferença
entre isso -iframework e -F é isso com -iframework o compilador não avisa
sobre construções contidas em arquivos de cabeçalho encontrados por meio de dir. Esta opção é válida
apenas para a família C de linguagens.

-sentiu
Emita informações de depuração para os símbolos usados. Para o formato de depuração STABS,
isso permite -feliminar-símbolos-de-depuração-não-usados. Por padrão, está LIGADO.

-g cheio
Emita informações de depuração para todos os símbolos e tipos.

-mmacosx-version-min =versão
A versão mais antiga do MacOS X em que este executável será executado é versão. Típica
valores de versão incluem 10.1, 10.2 e 10.3.9.

Se o compilador foi construído para usar os cabeçalhos do sistema por padrão, o padrão para
esta opção é a versão do sistema no qual o compilador está sendo executado, caso contrário, o
o padrão é fazer escolhas que sejam compatíveis com tantos sistemas e bases de código quanto
possível.

-mkernel
Habilite o modo de desenvolvimento do kernel. o -mkernel conjuntos de opções -estático, -fno-comum,
-fno-cxa-atexit, -fno-exceções, -fno-exceções sem chamada, -fapple-kext, -não-fraco
e -fno-rtti onde aplicável. Este modo também define -mno-altivec, -msoft-float,
-fno-construído e -mlong-ramo para destinos PowerPC.

-mon-byte-bool
Substituir os padrões para bool de modo a sizeof (bool) == 1. Por padrão sizeof (bool) is 4
ao compilar para Darwin / PowerPC e 1 ao compilar para Darwin / x86, então esta opção
não tem efeito no x86.

Atenção: A -mon-byte-bool switch faz com que o GCC gere um código que não é binário
compatível com o código gerado sem esse switch. Usar esta opção pode exigir
recompilar todos os outros módulos em um programa, incluindo bibliotecas do sistema. Usa isto
mude para estar em conformidade com um modelo de dados não padrão.

-mfix-e-continue
-fixar e continuar
-findirect-dados
Gere código adequado para desenvolvimento rápido. Necessário para habilitar o gdb para
carregue dinamicamente arquivos ".o" em programas já em execução. -findirect-dados e
-fixar e continuar são fornecidos para compatibilidade com versões anteriores.

-all_load
Carrega todos os membros das bibliotecas de arquivo estático. Ver homem ld(1) para mais informações.

-arch_errors_fatal
Faz com que os erros relacionados com arquivos que possuem a arquitetura errada sejam fatais.

-bind_at_load
Faz com que o arquivo de saída seja marcado de forma que o vinculador dinâmico vincule todos
referências indefinidas quando o arquivo é carregado ou iniciado.

-agrupar
Produza um arquivo de formato de pacote Mach-o. Ver homem ld(1) para mais informações.

-bundle_loader executável
Esta opção especifica o executável que carregará o arquivo de saída da compilação sendo
vinculado. Ver homem ld(1) para mais informações.

-dinamiclib
Quando passada esta opção, o GCC irá produzir uma biblioteca dinâmica em vez de um executável
ao vincular, usando o Darwin ferramentalib comando.

-force_cpusubtype_ALL
Isso faz com que o arquivo de saída do GCC tenha o TODAS subtipo, em vez de um controlado por
da -mcpu or -marchar opção.

-allowable_client Nome do cliente
-Nome do cliente
-compatibilidade_versão
-Versão Atual
-dead_strip
-arquivo de dependência
-dylib_file
-dylinker_install_name
-dinâmico
-lista_de_símbolos_exportados
-lista de arquivos
-flat_namespace
-force_flat_namespace
-headerpad_max_install_names
-imagem_base
-iniciar
-nome_instalação
-keep_private_externs
-multi_módulo
-multiplicar_definido
-multiply_definido_não utilizado
-noall_load
-no_dead_strip_inits_and_terms
-nofixprebinding
-nomultidefs
-noprebind
-noseglinkedit
-pagezero_size
-pré-ligar
-prebind_all_twolevel_modules
-private_bundle
-read_only_relocs
-sectalign
-símbolos de objeto da seita
-porque
-seg1addr
-sectcriar
-símbolos de objeto da seita
-ordem do setor
-segaddr
-segs_read_only_addr
-segs_read_write_addr
-seg_addr_table
-seg_addr_table_filename
-seglinkedit
-Segripor.
-segs_read_only_addr
-segs_read_write_addr
-módulo_único
-estático
-sub_library
-sub_guarda-chuva
-dois níveis_namespace
- guarda-chuva
-Indefinido
-lista_de_símbolos_uexportados
-weak_reference_mismatches
- o que foi carregado
Essas opções são passadas para o vinculador Darwin. A página do manual do linker Darwin descreve
detalhadamente.

Dezembro alfa Opções

Este -m opções são definidas para as implementações DEC Alpha:

-mno-soft-float
-msoft-float
Use (não use) as instruções de ponto flutuante de hardware para ponto flutuante
operações. Quando -msoft-float é especificado, funções em libgcc.a será usado para
realizar operações de ponto flutuante. A menos que sejam substituídos por rotinas que emulam
as operações de ponto flutuante, ou compiladas de forma a chamar tais emulações
rotinas, essas rotinas irão emitir operações de ponto flutuante. Se você está compilando
para um Alpha sem operações de ponto flutuante, você deve garantir que a biblioteca é
construído de forma a não chamá-los.

Observe que as implementações Alpha sem operações de ponto flutuante são obrigadas a ter
registradores de ponto flutuante.

-mfp-reg
-mno-fp-regs
Gere código que usa (não usa) o conjunto de registros de ponto flutuante. -mno-fp-regs
implica -msoft-float. Se o conjunto de registros de ponto flutuante não for usado,
operandos são passados ​​em registradores inteiros como se fossem inteiros e ponto flutuante
os resultados são passados ​​em $ 0 em vez de $ f0. Esta é uma sequência de chamada não padrão, então
qualquer função com um argumento de ponto flutuante ou valor de retorno chamado pelo código compilado
com -mno-fp-regs também deve ser compilado com essa opção.

Um uso típico desta opção é construir um kernel que não usa e, portanto, precisa
não salvar e restaurar, quaisquer registros de ponto flutuante.

-meee
A arquitetura Alpha implementa hardware de ponto flutuante otimizado para o máximo
atuação. É principalmente compatível com o padrão de ponto flutuante IEEE. Contudo,
para conformidade total, é necessária assistência de software. Esta opção gera código
código totalmente compatível com IEEE exceto que o inexata-bandeira não é mantido (veja abaixo).
Se esta opção estiver ativada, a macro de pré-processador "_IEEE_FP" é definida durante
compilação. O código resultante é menos eficiente, mas é capaz de suportar corretamente
números desnormalizados e valores IEEE excepcionais, como não-um-número e mais / menos
infinidade. Outros compiladores Alpha chamam esta opção -ieee_with_no_inexact.

-mieee-com-inexato
Isto é como -meee exceto que o código gerado também mantém o IEEE inexata-bandeira.
Ativar esta opção faz com que o código gerado implemente IEEE totalmente compatível
matemática. Além de "_IEEE_FP", "_IEEE_FP_EXACT" é definido como uma macro de pré-processador.
Em algumas implementações Alpha, o código resultante pode ser executado significativamente mais lento do que
o código gerado por padrão. Uma vez que há muito pouco código que depende do
inexata-bandeira, você normalmente não deve especificar esta opção. Outra chamada de compiladores Alpha
esta opção -ieee_with_inexact.

-mfp-trap-mode =modo de armadilha
Esta opção controla quais armadilhas relacionadas a ponto flutuante são habilitadas. Outro Alpha
compiladores chamam esta opção -fptm modo de armadilha. O modo de armadilha pode ser definido para um de quatro
valores:

n Esta é a configuração padrão (normal). As únicas armadilhas habilitadas são as
aqueles que não podem ser desabilitados no software (por exemplo, divisão por armadilha zero).

u Além das armadilhas habilitadas por n, as armadilhas de underflow também estão habilitadas.

su Como u, mas as instruções são marcadas como seguras para a conclusão do software (consulte
Manual de arquitetura Alpha para detalhes).

em Como su, mas armadilhas inexatas também estão habilitadas.

-mfp-rounding-mode =modo de arredondamento
Seleciona o modo de arredondamento IEEE. Outros compiladores Alpha chamam esta opção -fprm
modo de arredondamento. O modo de arredondamento pode ser um dos seguintes:

n Modo de arredondamento IEEE normal. Os números de vírgula flutuante são arredondados para o mais próximo
número da máquina ou para o número da máquina par em caso de empate.

m Arredonde para menos infinito.

c Modo de arredondamento cortado. Os números de vírgula flutuante são arredondados para zero.

d Modo de arredondamento dinâmico. Um campo no registro de controle de ponto flutuante (fpcr, Ver
Manual de referência da arquitetura Alpha) controla o modo de arredondamento em vigor. O C
A biblioteca inicializa este registro para arredondamento para mais infinito. Assim,
a menos que seu programa modifique o fpcr, d corresponde a arredondar para mais
infinidade.

-mtrap-precision =precisão de armadilha
Na arquitetura Alpha, as armadilhas de ponto flutuante são imprecisas. Isso significa sem
assistência de software é impossível recuperar de uma armadilha flutuante e programa
a execução normalmente precisa ser encerrada. GCC pode gerar código que pode ajudar
manipuladores de armadilhas do sistema operacional para determinar a localização exata que causou um
armadilha de ponto flutuante. Dependendo dos requisitos de um aplicativo, diferentes
níveis de precisão podem ser selecionados:

p Precisão do programa. Esta opção é o padrão e significa que um manipulador de trap só pode
identificar qual programa causou uma exceção de ponto flutuante.

f Precisão da função. O manipulador de trap pode determinar a função que causou um
exceção de ponto flutuante.

i Precisão da instrução. O manipulador de trap pode determinar a instrução exata que
causou uma exceção de ponto flutuante.

Outros compiladores Alpha fornecem as opções equivalentes chamadas -scope_safe e
-retomada_segura.

-mieee-conformante
Esta opção marca o código gerado como compatível com IEEE. Você não deve usar esta opção
a menos que você também especifique -mtrap-precision = i e também -mfp-trap-mode = su or
-mfp-trap-mode = sui. Seu único efeito é emitir a linha .eflag 48 na função
prólogo do arquivo de montagem gerado. No DEC Unix, isso tem o efeito de que
Rotinas de biblioteca matemática em conformidade com o IEEE serão vinculadas em.

-mbuild-constantes
Normalmente o GCC examina uma constante inteira de 32 ou 64 bits para ver se pode construí-la
de constantes menores em duas ou três instruções. Se não puder, ele produzirá o
constante como um literal e gerar código para carregá-lo do segmento de dados em tempo de execução.

Use esta opção para exigir que o GCC construa todos os constantes inteiras usando código, mesmo se
leva mais instruções (o máximo é seis).

Você normalmente usaria esta opção para construir um carregador dinâmico de biblioteca compartilhada. Em si
uma biblioteca compartilhada, ela deve se realocar na memória antes de encontrar as variáveis
e constantes em seu próprio segmento de dados.

-malpha-as
-mgas
Selecione se deseja gerar o código a ser montado pelo montador fornecido pelo fornecedor
(-malpha-as) ou pelo GNU assembler -mgas.

-mbwx
-mno-bwx
-mcix
-mno-cix
-mfix
-mno-consertar
-mmax
-mno-max
Indique se o GCC deve gerar código para usar BWX, CIX, FIX e MAX opcionais
conjuntos de instruções. O padrão é usar os conjuntos de instruções suportados pela CPU
tipo especificado via -mcpu = opção ou da CPU em que o GCC foi construído, se nenhuma
Especificadas.

-mfloat-vax
-mfloat-ieee
Gere código que usa (não usa) VAX F e G aritmética de ponto flutuante em vez disso
de precisão simples e dupla IEEE.

-mexplícito-relocs
-mno-explícito-relocs
Os montadores Alpha mais antigos não forneciam nenhuma maneira de gerar realocações de símbolo, exceto por meio de
macros assembler. O uso dessas macros não permite um planejamento de instrução ideal.
GNU binutils a partir da versão 2.12 suporta uma nova sintaxe que permite ao compilador
marque explicitamente quais realocações devem ser aplicadas a quais instruções. Esta opção é
principalmente útil para depuração, já que o GCC detecta os recursos do montador quando ele
é construído e define o padrão de acordo.

-msmall-dados
-mlarge-dados
Quando -mexplícito-relocs está em vigor, os dados estáticos são acessados ​​via relativo a gp
deslocalizações. Quando -msmall-dados é usado, objetos de 8 bytes ou menores são colocados em
a pequeno dados, área (as seções ".sdata" e ".sbss") e são acessados ​​via 16 bits
relocações fora do registro $ gp. Isso limita o tamanho da pequena área de dados para
64 KB, mas permite que as variáveis ​​sejam acessadas diretamente por meio de uma única instrução.

O padrão é -mlarge-dados. Com esta opção, a área de dados é limitada logo abaixo
2 GB. Programas que requerem mais de 2 GB de dados devem usar "malloc" ou "mmap" para
alocar os dados no heap em vez de no segmento de dados do programa.

Ao gerar código para bibliotecas compartilhadas, -fpic implica -msmall-dados e -fPIC
implica -mlarge-dados.

-msmall-texto
-texto-grande
Quando -msmall-texto é usado, o compilador assume que o código de todo o programa
(ou biblioteca compartilhada) cabe em 4 MB e, portanto, é acessível com uma instrução de desvio.
Quando -msmall-dados é usado, o compilador pode assumir que todos os símbolos locais compartilham o
mesmo valor de $ gp, e assim reduzir o número de instruções necessárias para uma função
ligue de 4 para 1.

O padrão é -texto-grande.

-mcpu =tipo_cpu
Defina o conjunto de instruções e os parâmetros de programação de instruções para o tipo de máquina
tipo_cpu. Você pode especificar o EV nome do estilo ou o número do chip correspondente.
GCC suporta parâmetros de programação para a família de processadores EV4, EV5 e EV6 e
irá escolher os valores padrão para o conjunto de instruções do processador que você especificar.
Se você não especificar um tipo de processador, o GCC assumirá como padrão o processador no qual o
compilador foi construído.

Valores suportados para tipo_cpu e guarante que os mesmos estão

ev4
ev45
21064
Programa como um EV4 e não tem extensões de conjunto de instruções.

ev5
21164
Programa como um EV5 e não tem extensões de conjunto de instruções.

ev56
21164a
Programa como EV5 e oferece suporte à extensão BWX.

pca56
21164pc
21164PC
Programa como um EV5 e oferece suporte às extensões BWX e MAX.

ev6
21264
Programa como EV6 e oferece suporte às extensões BWX, FIX e MAX.

ev67
21264a
Programa como EV6 e oferece suporte às extensões BWX, CIX, FIX e MAX.

Conjuntos de ferramentas nativos também suportam o valor nativo, que seleciona a melhor arquitetura
opção para o processador host. -mcpu = nativo não tem efeito se o GCC não reconhecer
o processador.

-mtune =tipo_cpu
Defina apenas os parâmetros de agendamento de instrução para o tipo de máquina tipo_cpu. O
conjunto de instruções não é alterado.

Conjuntos de ferramentas nativos também suportam o valor nativo, que seleciona a melhor arquitetura
opção para o processador host. -mtune = nativo não tem efeito se o GCC não reconhecer
o processador.

-mmemory-latency =tempo
Define a latência que o planejador deve assumir para referências de memória típicas, conforme visto por
a aplicação. Este número é altamente dependente dos padrões de acesso à memória usados
pelo aplicativo e pelo tamanho do cache externo na máquina.

Opções válidas para tempo e guarante que os mesmos estão

número
Um número decimal que representa os ciclos do clock.

L1
L2
L3
principal
O compilador contém estimativas do número de ciclos de clock para EV4 e "típico"
Hardware EV5 para os caches de Nível 1, 2 e 3 (também chamado Dcache, Scache e
Bcache), bem como para a memória principal. Observe que L3 é válido apenas para EV5.

Dezembro Alpha / VMS Opções

Este -m as opções são definidas para as implementações DEC Alpha / VMS:

-mvms-códigos de retorno
Retorne os códigos de condição VMS do principal. O padrão é retornar a condição de estilo POSIX
(por exemplo, códigos de erro).

-mdebug-main =prefixo
Sinalize a primeira rotina cujo nome começa com prefixo como a rotina principal para o
depurador.

-mmalloc64
Padrão para rotinas de alocação de memória de 64 bits.

FR30 Opções

Essas opções são definidas especificamente para a porta FR30.

-modelo msmall
Use o modelo de espaço de endereço pequeno. Isso pode produzir um código menor, mas pressupõe
que todos os valores e endereços simbólicos caberão em um intervalo de 20 bits.

-mno-lsim
Suponha que o suporte de tempo de execução foi fornecido e, portanto, não há necessidade de incluir o
biblioteca de simulador (libsim.a) na linha de comando do vinculador.

FRV Opções

-mgpr-32
Use apenas os primeiros 32 registradores de uso geral.

-mgpr-64
Use todos os 64 registradores de uso geral.

-mfpr-32
Use apenas os primeiros 32 registradores de ponto flutuante.

-mfpr-64
Use todos os 64 registradores de ponto flutuante.

-mhard-float
Use as instruções de hardware para operações de ponto flutuante.

-msoft-float
Use rotinas de biblioteca para operações de ponto flutuante.

-malloc-cc
Alocar registros de código de condição dinamicamente.

-mfixo-cc
Não tente alocar dinamicamente registros de código de condição, use apenas "icc0" e
"fcc0".

-mdpalavra
Altere ABI para usar insns de palavra dupla.

-mno-dword
Não use instruções com palavras duplas.

-duplo
Use instruções duplas de ponto flutuante.

-mno-duplo
Não use instruções duplas de ponto flutuante.

-mídia
Use as instruções de mídia.

-mno-mídia
Não use as instruções da mídia.

-mmulad
Use as instruções de multiplicação e adição / subtração.

-mno-mulad
Não use as instruções de multiplicação e adição / subtração.

-mfdpic
Selecione o FDPIC ABI, que usa descritores de função para representar ponteiros para
funções. Sem quaisquer opções relacionadas a PIC / PIE, isso implica -fPIE. Com -fpic or
-fpie, ele assume que as entradas GOT e pequenos dados estão dentro de um intervalo de 12 bits do GOT
endereço de base; com -fPIC or -fPIE, Os deslocamentos GOT são calculados com 32 bits. Com um
elfo-bfin alvo, esta opção implica -msim.

-minline-plt
Habilite o inlining de entradas PLT em chamadas de função para funções que não são conhecidas por
vincular localmente. Não tem efeito sem -mfdpic. É habilitado por padrão se
otimizar para velocidade e compilar para bibliotecas compartilhadas (ou seja, -fPIC or -fpic), ou
quando uma opção de otimização como -O3 ou acima está presente na linha de comando.

-mTLS
Suponha um grande segmento TLS ao gerar código de segmento local.

-mtls
Não presuma um grande segmento TLS ao gerar código de segmento local.

-mgprel-ro
Habilite o uso de realocações "GPREL" no FDPIC ABI para dados que são conhecidos por estarem em
seções somente leitura. É habilitado por padrão, exceto para -fpic or -fpie: Apesar de
pode ajudar a tornar a tabela de deslocamento global menor, ele troca 1 instrução por 4. Com
-fPIC or -fPIE, ele troca 3 instruções por 4, uma das quais pode ser compartilhada por vários
símbolos, e evita a necessidade de uma entrada GOT para o símbolo referenciado, por isso é
é mais provável que seja uma vitória. Se não é, -mno-gprel-ro pode ser usado para desativá-lo.

-multilib-biblioteca-pic
Link com as bibliotecas de imagens (biblioteca, não FD). Está implícito por -mlibrary-pic, também
como por -fPIC e -fpic sem -mfdpic. Você nunca deve ter que usá-lo explicitamente.

-mlinked-fp
Siga o requisito EABI de sempre criar um ponteiro de quadro sempre que um quadro de pilha
é alocado. Esta opção é habilitada por padrão e pode ser desabilitada com
-mno-linkado-fp.

-muito chamadas
Use o endereçamento indireto para chamar funções fora da unidade de compilação atual. Esse
permite que as funções sejam colocadas em qualquer lugar dentro do espaço de endereço de 32 bits.

-rótulos malignos
Tente alinhar os rótulos a um limite de 8 bytes inserindo nops no pacote anterior.
Esta opção só tem efeito quando a embalagem VLIW está ativada. Não cria novos
pacotes; ele simplesmente adiciona nops aos existentes.

-mlibrary-pic
Gere o código EABI independente da posição.

-macc-4
Use apenas os primeiros quatro registros do acumulador de mídia.

-macc-8
Use todos os oito registradores de acumulador de mídia.

-mpack
Embale as instruções VLIW.

-mno-pack
Não embale as instruções VLIW.

-mno-flags
Não marque as chaves ABI em e_flags.

-mcond-movimento
Habilite o uso de instruções de movimentação condicional (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-cond-movimento
Desative o uso de instruções de movimentação condicional.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mscc
Habilite o uso de instruções de conjunto condicional (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-scc
Desative o uso de instruções de conjunto condicional.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mcond-exec
Habilite o uso de execução condicional (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-cond-exec
Desative o uso de execução condicional.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mvliw-ramo
Execute uma passagem para empacotar ramificações nas instruções VLIW (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-vliw-branch
Não execute uma passagem para empacotar ramificações nas instruções VLIW.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-multi-cond-exec
Habilite a otimização de "&&" e "||" em execução condicional (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-multi-cond-exec
Desative a otimização de "&&" e "||" em execução condicional.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mnested-cond-exec
Habilite otimizações de execução condicional aninhadas (padrão).

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-mno-nested-cond-exec
Desative as otimizações de execução condicional aninhadas.

Esta opção é principalmente para depurar o compilador e provavelmente será removida em um
versão futura.

-moptimize-membar
Essa opção remove instruções "membar" redundantes do código gerado pelo compilador.
Está habilitado por padrão.

-mno-optimize-membar
Esta opção desativa a remoção automática de instruções "membar" redundantes do
código gerado.

-mtomcat-estatísticas
Faça com que o gás imprima as estatísticas do Tomcat.

-mcpu =cpu
Selecione o tipo de processador para o qual deseja gerar o código. Os valores possíveis são frv, fr550,
tomcat, fr500, fr450, fr405, fr400, fr300 e simples.

GNU / Linux Opções

Este -m as opções são definidas para destinos GNU / Linux:

-mglibc
Use a biblioteca GNU C. Este é o padrão, exceto em * - * - linux- * uclibc * e
* - * - linux- * android * alvos.

-muclibc
Use a biblioteca uClibc C. Este é o padrão em * - * - linux- * uclibc * alvos.

-mbiônico
Use a biblioteca Bionic C. Este é o padrão em * - * - linux- * android * alvos.

-mandróide
Compile o código compatível com a plataforma Android. Este é o padrão em
* - * - linux- * android * alvos.

Ao compilar, esta opção habilita -mbiônico, -fPIC, -fno-exceções e -fno-rtti by
predefinição. Ao vincular, esta opção faz com que o driver GCC passe por opções específicas do Android
para o vinculador. Finalmente, esta opção faz com que a macro de pré-processador "__ANDROID__" seja
definiram.

-tno-android-cc
Desativar efeitos de compilação de -mandróide, ou seja, não habilite -mbiônico, -fPIC,
-fno-exceções e -fno-rtti por padrão.

-tno-android-ld
Desativar efeitos de vinculação de -mandróide, ou seja, passar opções de vinculação do Linux padrão para o
vinculador.

H8 / 300 Opções

Este -m as opções são definidas para as implementações H8 / 300:

-mrelax
Encurte algumas referências de endereço no momento do link, quando possível; usa a opção de vinculador
-relaxar.

-mh Gere código para o H8 / 300H.

-em Gere código para o H8S.

-mn Gere código para o H8S e H8 / 300H no modo normal. Este interruptor deve ser usado
quer com -mh or -em.

-ms2600
Gere o código para o H8S / 2600. Esta opção deve ser usada com -em.

-hortelã32
Torne os dados "int" de 32 bits por padrão.

-maligno-300
No H8 / 300H e no H8S, use as mesmas regras de alinhamento do H8 / 300. O padrão
para o H8 / 300H e o H8S é alinhar longos e flutuantes em limites de 4 bytes.
-maligno-300 faz com que eles sejam alinhados em limites de 2 bytes. Esta opção não tem efeito
no H8 / 300.

HPPA Opções

Este -m as opções são definidas para a família de computadores HPPA:

-march =tipo de arquitetura
Gerar código para a arquitetura especificada. As escolhas para tipo de arquitetura e guarante que os mesmos estão
1.0 para PA 1.0, 1.1 para PA 1.1, e 2.0 para processadores PA 2.0. Referir-se
/usr/lib/sched.models em um sistema HP-UX para determinar a opção de arquitetura adequada
para sua máquina. O código compilado para arquiteturas com números inferiores será executado em arquiteturas superiores
arquiteturas numeradas, mas não o contrário.

-mpa-risc-1-0
-mpa-risc-1-1
-mpa-risc-2-0
Sinônimos para -march = 1.0, -march = 1.1 e -march = 2.0 respectivamente.

-big-switch
Gere código adequado para grandes tabelas de comutação. Use esta opção apenas se o
assembler / linker reclama sobre ramificações fora do intervalo dentro de uma mesa de switch.

-mjump-in-atraso
Preencha slots de atraso de chamadas de função com instruções de salto incondicional, modificando
o ponteiro de retorno para a chamada de função ser o alvo do salto condicional.

-mdisable-fpregs
Impedir que os registros de ponto flutuante sejam usados ​​de qualquer maneira. Isso é necessário para
compilar kernels que realizam alternância lenta de contexto de registradores de ponto flutuante. Se
você usa esta opção e tenta realizar operações de ponto flutuante, o compilador
aborta.

-mdisable-indexação
Evita que o compilador use modos de endereço de indexação. Isso evita um pouco
problemas obscuros ao compilar o código gerado pelo MIG no MACH.

-mno-espaço-regs
Gere um código que presuma que o destino não possui registradores de espaço. Isso permite que o GCC
gere chamadas indiretas mais rápidas e use modos de endereço de índice fora de escala.

Esse código é adequado para sistemas PA e kernels de nível 0.

-mrápido-indireto-chamadas
Gere código que assume que as chamadas nunca cruzam os limites do espaço. Isso permite que o GCC
emitir código que executa chamadas indiretas mais rápidas.

Esta opção não funcionará na presença de bibliotecas compartilhadas ou funções aninhadas.

-mfixed-range =intervalo de registro
Gere o código tratando o intervalo de registro fornecido como registros fixos. Um registro fixo
é aquele que o alocador de registro não pode usar. Istoéútil ao compilar o kernel
código. Um intervalo de registro é especificado como dois registros separados por um traço. Múltiplo
os intervalos de registro podem ser especificados separados por uma vírgula.

-mlong-load-store
Gerar carga de 3 instruções e armazenar sequências conforme às vezes exigido pelo HP-UX 10
vinculador. Isso é equivalente ao +k opção para os compiladores HP.

-mportável-tempo de execução
Use as convenções de chamadas portáteis propostas pela HP para sistemas ELF.

-mgas
Permitir o uso de diretivas de montador que apenas GAS entende.

-mschedule =tipo cpu
Código de programação de acordo com as restrições para o tipo de máquina tipo cpu. As escolhas
for tipo cpu e guarante que os mesmos estão 700 7100, 7100LC, 7200, 7300 e 8000. Referir-se
/usr/lib/sched.models em um sistema HP-UX para determinar a opção de agendamento adequada para
sua máquina. A programação padrão é 8000.

-mlinker-opt
Habilite a passagem de otimização no vinculador HP-UX. Observe que isso torna a depuração simbólica
impossível. Ele também aciona um bug nos linkers HP-UX 8 e HP-UX 9 nos quais eles
dar mensagens de erro falsas ao vincular alguns programas.

-msoft-float
Gerar saída contendo chamadas de biblioteca para ponto flutuante. Atenção: o requisito
as bibliotecas não estão disponíveis para todos os destinos HPPA. Normalmente as instalações do
o compilador C usual da máquina é usado, mas isso não pode ser feito diretamente em
compilação. Você deve tomar suas próprias providências para fornecer uma biblioteca adequada
funções para compilação cruzada.

-msoft-float altera a convenção de chamada no arquivo de saída; portanto, é apenas
útil se você compilar todos os de um programa com esta opção. Em particular, você precisa
compilar libgcc.a, a biblioteca que vem com o GCC, com -msoft-float em ordem para isso
trabalhar.

-msio
Gere a predefinição, "_SIO", para o servidor IO. O padrão é -mwsio. Isso gera
as predefinições, "__hp9000s700", "__hp9000s700__" e "_WSIO", para estação de trabalho IO.
Essas opções estão disponíveis em HP-UX e HI-UX.

-mgnu-ld
Use opções específicas do GNU ld. Isso passa -compartilhado para ld ao construir um
biblioteca. É o padrão quando o GCC é configurado, explícita ou implicitamente, com o
Vinculador GNU. Esta opção não tem efeito sobre a chamada do ld, apenas
altera quais parâmetros são passados ​​para aquele ld. O ld chamado é determinado por
da --com-ld opção de configuração, caminho de pesquisa do programa GCC e, finalmente, pelo usuário
PATH. O vinculador usado pelo GCC pode ser impresso usando qual `gcc -print-prog-name = ld`.
Esta opção está disponível apenas no GCC HP-UX de 64 bits, ou seja, configurado com
hppa * 64 * - * - hpux *.

-mhp-ld
Use opções específicas do HP ld. Isso passa -b para ld ao construir uma biblioteca compartilhada e
passes + Aceitar Tipo de incompatibilidade para ld em todos os links. É o padrão quando o GCC é
configurado, explícita ou implicitamente, com o linker HP. Esta opção não tem
qualquer efeito sobre o qual ld é chamado, ele apenas altera quais parâmetros são passados ​​para aquele
ld. O ld chamado é determinado pelo --com-ld opção de configuração, GCC's
caminho de pesquisa do programa e, finalmente, pelo usuário PATH. O vinculador usado pelo GCC pode ser
impresso usando qual `gcc -print-prog-name = ld`. Esta opção está disponível apenas no
GCC HP-UX de 64 bits, ou seja, configurado com hppa * 64 * - * - hpux *.

-muito chamadas
Gere código que usa longas sequências de chamadas. Isso garante que uma chamada esteja sempre disponível
para alcançar os stubs gerados pelo vinculador. O padrão é gerar chamadas longas apenas quando o
distância do local da chamada ao início da função ou unidade de tradução, como
o caso pode ser, excede um limite predefinido definido pelo tipo de ramificação que está sendo usado. o
limites para chamadas normais são 7,600,000 e 240,000 bytes, respectivamente para o PA 2.0
e arquiteturas PA 1.X. Sibcalls são sempre limitados a 240,000 bytes.

As distâncias são medidas desde o início das funções ao usar o
-funções-seções opção, ou ao usar a -mgas e -mno-tempo de execução portátil opções
juntos no HP-UX com o vinculador SOM.

Normalmente não é desejável usar essa opção, pois isso prejudicará o desempenho.
No entanto, pode ser útil em grandes aplicações, particularmente quando a ligação parcial é
usado para construir o aplicativo.

Os tipos de chamadas longas usados ​​dependem dos recursos do montador e do vinculador,
e o tipo de código que está sendo gerado. O impacto nos sistemas que suportam por muito tempo
chamadas absolutas e chamadas de diferença de símbolo de imagem longa ou relativas ao PC devem ser
relativamente pequeno. No entanto, uma chamada indireta é usada em sistemas ELF de 32 bits no código de imagem
e é bastante longo.

-munix =unix-std
Gere predefinições do compilador e selecione um arquivo de início para o padrão UNIX especificado.
As escolhas para unix-std e guarante que os mesmos estão 93, 95 e 98. 93 é compatível com todas as versões do HP-UX.
95 está disponível no HP-UX 10.10 e posterior. 98 está disponível no HP-UX 11.11 e posterior.
Os valores padrão são 93 para HP-UX 10.00, 95 para HP-UX 10.10 até 11.00, e 98
para HP-UX 11.11 e posterior.

-munix = 93 fornece as mesmas predefinições do GCC 3.3 e 3.4. -munix = 95 fornece
predefinições adicionais para "XOPEN_UNIX" e "_XOPEN_SOURCE_EXTENDED", e o arquivo de início
unix95.o. -munix = 98 fornece predefinições adicionais para "_XOPEN_UNIX",
"_XOPEN_SOURCE_EXTENDED", "_INCLUDE__STDC_A1_SOURCE" e "_INCLUDE_XOPEN_SOURCE_500",
e o startfile unix98.o.

É importante notar que esta opção muda as interfaces para várias bibliotecas
rotinas. Também afeta o comportamento operacional da biblioteca C. Assim, extremo
é necessário cuidado ao usar esta opção.

O código da biblioteca que se destina a operar com mais de um padrão UNIX deve ser testado,
definir e restaurar a variável __xpg4_extended_mask como apropriado. A maioria dos softwares GNU
não oferece esse recurso.

-nolibdld
Suprime a geração de opções de link para pesquisar libdld.sl quando o -estático opção
especificado no HP-UX 10 e posterior.

-estático
A implementação HP-UX de setlocale em libc depende de libdld.sl. Lá
não é uma versão de arquivo de libdld.sl. Assim, quando o -estático opção é especificada,
opções especiais de link são necessárias para resolver essa dependência.

No HP-UX 10 e posterior, o driver GCC adiciona as opções necessárias para vincular
libdld.sl quando o -estático opção é especificada. Isso faz com que o binário resultante para
seja dinâmico. Na porta de 64 bits, os vinculadores geram binários dinâmicos por padrão em
qualquer caso. o -nolibdld opção pode ser usada para evitar que o driver GCC adicione
essas opções de link.

-tópicos
Adicione suporte para multithreading com o dado fio biblioteca em HP-UX. Esta opção
define sinalizadores para o pré-processador e o vinculador.

Intel 386 e AMD x86-64 Opções

Este -m as opções são definidas para a família de computadores i386 e x86-64:

-mtune =tipo cpu
Sintonizar para tipo cpu tudo aplicável sobre o código gerado, exceto para o ABI
e o conjunto de instruções disponíveis. As escolhas para tipo cpu como:

genérico
Produza código otimizado para os processadores IA32 / AMD64 / EM64T mais comuns. Se você
conhecer a CPU na qual seu código será executado, então você deve usar o correspondente
-mtune opção em vez de -mtune = genérico. Mas, se você não sabe exatamente o que CPU
usuários de seu aplicativo terão, então você deve usar esta opção.

Conforme novos processadores são implantados no mercado, o comportamento desta opção
vai mudar. Portanto, se você atualizar para uma versão mais recente do GCC, o código
opção gerada mudará para refletir os processadores que eram mais comuns quando
essa versão do GCC foi lançada.

Não há -march = genérico opção porque -marchar indica o conjunto de instruções do
o compilador pode usar, e não há um conjunto de instruções genérico aplicável a todos
processadores. Em contraste, -mtune indica o processador (ou, neste caso,
coleção de processadores) para os quais o código é otimizado.

nativo
Isso seleciona a CPU a ser ajustada no momento da compilação, determinando o processador
tipo de máquina de compilação. Usando -mtune = nativo irá produzir código otimizado
para a máquina local sob as restrições do conjunto de instruções selecionado.
utilização -march = nativo irá habilitar todos os subconjuntos de instrução suportados pelo local
máquina (portanto, o resultado pode não funcionar em máquinas diferentes).

i386
CPU i386 original da Intel.

i486
CPU i486 da Intel. (Nenhum agendamento é implementado para este chip.)

i586, pentium
CPU Intel Pentium sem suporte MMX.

Pentium-mmx
CPU Intel PentiumMMX com base no núcleo Pentium com suporte para conjunto de instruções MMX.

PentiumPro
CPU Intel PentiumPro.

i686
Igual a "genérico", mas quando usado como opção de "marcha", conjunto de instruções PentiumPro
será usado, então o código será executado em todos os chips da família i686.

Pentium2
CPU Intel Pentium2 com base no núcleo PentiumPro com suporte para conjunto de instruções MMX.

Pentium3, pentium 3m
CPU Intel Pentium3 com base no núcleo PentiumPro com conjunto de instruções MMX e SSE
.

Pentium-m
Versão de baixa potência da CPU Intel Pentium3 com conjunto de instruções MMX, SSE e SSE2
Apoio, suporte. Usado por notebooks Centrino.

Pentium4, pentium 4m
CPU Intel Pentium4 com suporte para conjunto de instruções MMX, SSE e SSE2.

Prescott
Versão aprimorada da CPU Intel Pentium4 com instruções MMX, SSE, SSE2 e SSE3
conjunto de suporte.

nocona
Versão aprimorada da CPU Intel Pentium4 com extensões de 64 bits, MMX, SSE, SSE2 e
Suporte ao conjunto de instruções SSE3.

core2
CPU Intel Core2 com extensões de 64 bits, instrução MMX, SSE, SSE2, SSE3 e SSSE3
conjunto de suporte.

corei7
CPU Intel Core i7 com extensões de 64 bits, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 e
Suporte ao conjunto de instruções SSE4.2.

corei7-avx
CPU Intel Core i7 com extensões de 64 bits, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suporte ao conjunto de instruções SSE4.2, AVX, AES e PCLMUL.

núcleo-avx-i
CPU Intel Core com extensões de 64 bits, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
Suporte ao conjunto de instruções SSE4.2, AVX, AES, PCLMUL, FSGSBASE, RDRND e F16C.

átomo
CPU Intel Atom com extensões de 64 bits, instrução MMX, SSE, SSE2, SSE3 e SSSE3
conjunto de suporte.

k6 CPU AMD K6 com suporte para conjunto de instruções MMX.

k6-2, k6-3
Versões aprimoradas de CPU AMD K6 com MMX e 3DNow! suporte de conjunto de instruções.

Athlon, Athlon-Tbird
CPU AMD Athlon com MMX, 3dNOW !, 3DNow! e instruções de pré-busca SSE
.

Athlon-4, Athlon-XP, Athlon-mp
CPU AMD Athlon aprimorada com MMX, 3DNow !, 3DNow! e instrução SSE completa
conjunto de suporte.

k8, opteron, Athlon64, Athlon-Fx
CPUs baseadas em núcleo AMD K8 com suporte a conjunto de instruções x86-64. (Este superconjuntos MMX,
SSE, SSE2, 3DNow !, 3DNow! e extensões de conjunto de instruções de 64 bits.)

k8-sse3, opteron-sse3, Athlon64-sse3
Versões aprimoradas de k8, opteron e Athlon64 com suporte a conjunto de instruções SSE3.

amdfam10, Barcelona
CPUs com núcleo de 10h da família AMD com suporte a conjunto de instruções x86-64. (Esse
superconjuntos MMX, SSE, SSE2, SSE3, SSE4A, 3DNow !, 3DNow! aprimorado, ABM e 64 bits
extensões do conjunto de instruções.)

bdver1
CPUs com núcleo de 15h da família AMD com suporte a conjunto de instruções x86-64. (Esse
superconjuntos FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A,
SSSE3, SSE4.1, SSE4.2, ABM e extensões de conjunto de instruções de 64 bits.)

bdver2
CPUs com núcleo de 15h da família AMD com suporte a conjunto de instruções x86-64. (Esse
superconjuntos BMI, TBM, F16C, FMA, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2,
SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM e extensões de conjunto de instruções de 64 bits.)

btver1
CPUs com núcleo de 14h da família AMD com suporte a conjunto de instruções x86-64. (Esse
superconjuntos MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM e conjunto de instruções de 64 bits
extensões.)

guincho-c6
CPU IDT Winchip C6, tratado da mesma maneira que i486 com conjunto de instruções MMX adicional
.

winchip2
CPU IDT Winchip2, tratada da mesma forma que i486 com MMX adicional e 3DNow!
suporte de conjunto de instruções.

c3 Via CPU C3 com MMX e 3DNow! suporte de conjunto de instruções. (Sem programação é
implementado para este chip.)

c3-2
Via CPU C3-2 com suporte para conjunto de instruções MMX e SSE. (Sem programação é
implementado para este chip.)

geode
CPU AMD incorporada com MMX e 3DNow! suporte de conjunto de instruções.

Ao escolher um específico tipo cpu irá agendar as coisas apropriadamente para isso
chip específico, o compilador não gerará nenhum código que não seja executado no
tipo de máquina padrão sem o -march =tipo cpu opção que está sendo usada. Por exemplo, se
GCC é configurado para i686-pc-linux-gnu e então -mtune = pentium4 irá gerar um código que
está ajustado para Pentium4, mas ainda funcionará em máquinas i686.

-march =tipo cpu
Gerar instruções para o tipo de máquina tipo cpu. As escolhas para tipo cpu são o
o mesmo que para -mtune. Além disso, especificando -march =tipo cpu implica -mtune =tipo cpu.

-mcpu =tipo cpu
Um sinônimo obsoleto para -mtune.

-mfpmath =unidade
Gerar aritmética de ponto flutuante para a unidade selecionada unidade. As escolhas para unidade como:

387 Use o coprocessador de ponto flutuante 387 padrão presente na maioria dos chips
e emulado de outra forma. O código compilado com essa opção é executado em quase todos os lugares.
Os resultados temporários são calculados com a precisão de 80 bits em vez da precisão
especificado pelo tipo, resultando em resultados ligeiramente diferentes em comparação com a maioria dos
outros chips. Ver -loat-store para uma descrição mais detalhada.

Esta é a escolha padrão para o compilador i386.

ess Use as instruções escalares de ponto flutuante presentes no conjunto de instruções SSE. Esse
conjunto de instruções é suportado pelo Pentium3 e chips mais recentes, na linha AMD da
Chips Athlon-4, Athlon-xp e Athlon-mp. A versão anterior da instrução SSE
conjunto suporta apenas aritmética de precisão simples, portanto, o duplo e estendido
aritmética de precisão ainda é feita usando 387. Uma versão posterior, presente apenas em
Pentium4 e os futuros chips AMD x86-64 suportam aritmética de precisão dupla
demasiado.

Para o compilador i386, você precisa usar -march =tipo cpu, -msse or -msse2 interruptores
para habilitar extensões SSE e tornar esta opção efetiva. Para o compilador x86-64,
essas extensões são ativadas por padrão.

O código resultante deve ser consideravelmente mais rápido na maioria dos casos e
evitar os problemas de instabilidade numérica do código 387, mas pode quebrar alguns
código que espera que os temporários sejam de 80 bits.

Esta é a escolha padrão para o compilador x86-64.

sse, 387
sse + 387
ambos
Tente utilizar os dois conjuntos de instruções ao mesmo tempo. Isso efetivamente duplica o
quantidade de registros disponíveis e em chips com unidades de execução separadas para 387
e SSE os recursos de execução também. Use esta opção com cuidado, pois ainda é
experimental, porque o alocador de registro GCC não modela separadamente
unidades funcionais bem resultando em desempenho instável.

-masm =dialeto
Instruções de saída de conjunto usando selecionado dialeto. As escolhas com suporte são intel or para
(o padrão). Darwin não suporta intel.

-miee-fp
-mno-ieee-fp
Controle se o compilador usa ou não comparações de ponto flutuante IEEE. Esses
tratar corretamente o caso em que o resultado de uma comparação não está ordenado.

-msoft-float
Gerar saída contendo chamadas de biblioteca para ponto flutuante. Atenção: o requisito
bibliotecas não fazem parte do GCC. Normalmente, as instalações do C usual da máquina
compilador são usados, mas isso não pode ser feito diretamente na compilação cruzada. Você deve
faça seus próprios arranjos para fornecer funções de biblioteca adequadas para
compilação.

Em máquinas onde uma função retorna resultados de ponto flutuante no registro 80387
pilha, alguns opcodes de ponto flutuante podem ser emitidos mesmo se -msoft-float é usado.

-mno-fp-ret-in-387
Não use os registradores FPU para retornar valores de funções.

A convenção de chamada usual tem funções que retornam valores dos tipos "float" e "double"
em um registro de FPU, mesmo que não haja FPU. A ideia é que o sistema operacional
deve emular um FPU.

A opção -mno-fp-ret-in-387 faz com que tais valores sejam retornados na CPU comum
registra em vez disso.

-mno-fantasia-matemática-387
Alguns 387 emuladores não suportam as instruções "sin", "cos" e "sqrt" para o
387. Especifique esta opção para evitar a geração dessas instruções. Esta opção é a
padrão no FreeBSD, OpenBSD e NetBSD. Esta opção é substituída quando -marchar
indica que a CPU de destino sempre terá uma FPU e, portanto, a instrução não
precisa de emulação. A partir da revisão 2.6.1, essas instruções não são geradas a menos que você
também use o -funsafe-math-otimizations interruptor.

-malign-duplo
-mno-align-duplo
Controle se o GCC alinha as variáveis ​​"double", "long double" e "long long" em um
limite de duas palavras ou um limite de uma palavra. Alinhando variáveis ​​"duplas" em um modelo de duas palavras
limite produz código que é executado um pouco mais rápido em um Pentium à custa de mais
memória.

Em x86-64, -malign-duplo está habilitado por padrão.

Atenção: se você usar o -malign-duplo switch, estruturas contendo os tipos acima
será alinhado de forma diferente da interface binária do aplicativo publicado
especificações para o 386 e não serão binários compatíveis com estruturas no código
compilado sem essa opção.

-m96bit-longo-duplo
-m128bit-longo-duplo
Essas opções controlam o tamanho do tipo "duplo longo". O binário do aplicativo i386
interface especifica o tamanho em 96 bits, então -m96bit-longo-duplo é o padrão em
Modo de 32 bits.

Arquiteturas modernas (Pentium e mais recentes) preferem "long double" para ser alinhado a um 8-
ou limite de 16 bytes. Em matrizes ou estruturas em conformidade com a ABI, isso não é
possível. Então, especificando -m128bit-longo-duplo alinha "long double" a 16 bytes
limite preenchendo o "duplo longo" com um zero adicional de 32 bits.

No compilador x86-64, -m128bit-longo-duplo é a escolha padrão como seu ABI
especifica que "long double" deve ser alinhado no limite de 16 bytes.

Observe que nenhuma dessas opções permite qualquer precisão extra sobre o padrão x87
de 80 bits para um "duplo longo".

Atenção: se você substituir o valor padrão para sua ABI de destino, as estruturas e
arrays contendo variáveis ​​"long double" mudarão de tamanho e função
a convenção de chamada para função que leva "long double" será modificada. Daí eles
não será binário compatível com matrizes ou estruturas em código compilado sem isso
interruptor.

-mlarge-data-threshold =número
Quando -mcmodel = medium é especificado, os dados são maiores que limiar são colocados em grandes
seção de dados. Este valor deve ser o mesmo em todos os objetos vinculados ao binário
e o padrão é 65535.

-mrtd
Use uma convenção de chamada de função diferente, na qual funções que levam um
número de argumentos retorna com o "ret" Números instrução, que exibe seus argumentos
ao retornar. Isso economiza uma instrução do chamador, pois não há necessidade de
pop os argumentos lá.

Você pode especificar que uma função individual seja chamada com esta sequência de chamada com
o atributo da função stdcall. Você também pode substituir o -mrtd opção usando o
atributo de função cdecl.

Atenção: esta convenção de chamada é incompatível com a normalmente usada no Unix,
portanto, você não pode usá-lo se precisar chamar bibliotecas compiladas com o compilador Unix.

Além disso, você deve fornecer protótipos de função para todas as funções que variam
número de argumentos (incluindo "printf"); caso contrário, um código incorreto será gerado
para chamadas para essas funções.

Além disso, um código seriamente incorreto resultará se você chamar uma função com muitos
argumentos. (Normalmente, argumentos extras são ignorados inofensivamente.)

-mregparm =Números
Controle quantos registros são usados ​​para passar argumentos inteiros. Por padrão, não
registradores são usados ​​para passar argumentos, e no máximo 3 registradores podem ser usados. Você pode
controlar este comportamento para uma função específica usando o atributo function regular.

Atenção: se você usar esta opção, e Números é diferente de zero, então você deve construir todos os módulos
com o mesmo valor, incluindo quaisquer bibliotecas. Isso inclui as bibliotecas do sistema e
módulos de inicialização.

-msseregparm
Use convenções de passagem de registro SSE para argumentos flutuantes e duplos e valores de retorno.
Você pode controlar este comportamento para uma função específica usando o atributo function
seregparm.

Atenção: se você usar esta opção, você deve construir todos os módulos com o mesmo valor,
incluindo quaisquer bibliotecas. Isso inclui as bibliotecas do sistema e módulos de inicialização.

-mvect8-ret-in-mem
Retorna vetores de 8 bytes na memória em vez de registros MMX. Este é o padrão em
Solaris @ tie {} 8 e 9 e VxWorks para corresponder à ABI dos compiladores Sun Studio até
versão 12. Versões posteriores do compilador (começando com Studio 12 Update @ tie {} 1) seguem
a ABI usada por outros destinos x86, que é o padrão no Solaris @ tie {} 10 e posterior.
Preço: use esta opção se precisar permanecer compatível com o código existente produzido por
aquelas versões anteriores do compilador ou versões mais antigas do GCC.

-mpc32
-mpc64
-mpc80
Defina a precisão de ponto flutuante 80387 como 32, 64 ou 80 bits. Quando -mpc32 é especificado,
os significandos dos resultados das operações de ponto flutuante são arredondados para 24 bits
(precisão simples); -mpc64 arredonda os significandos dos resultados de ponto flutuante
operações para 53 bits (precisão dupla) e -mpc80 arredonda os significandos dos resultados
de operações de ponto flutuante para 64 bits (precisão dupla estendida), que é o
predefinição. Quando esta opção é usada, as operações de ponto flutuante em precisões mais altas são
não disponível para o programador sem definir a palavra de controle da FPU explicitamente.

Definir o arredondamento das operações de ponto flutuante para menos do que os 80 bits padrão pode
acelerar alguns programas em 2% ou mais. Observe que algumas bibliotecas matemáticas assumem que
operações de ponto flutuante de precisão estendida (80 bits) são habilitadas por padrão; rotinas
em tais bibliotecas pode sofrer perda significativa de precisão, normalmente por meio de
chamado de "cancelamento catastrófico", quando esta opção é usada para definir a precisão para
menos do que a precisão estendida.

-mstackrealign
Realinhe a pilha na entrada. No Intel x86, o -mstackrealign opção irá gerar
um prólogo e epílogo alternativos que realinha a pilha de tempo de execução, se necessário.
Isso suporta a combinação de códigos legados que mantêm uma pilha alinhada de 4 bytes com códigos modernos
que mantém uma pilha de 16 bytes para compatibilidade com SSE. Veja também o atributo
"force_align_arg_pointer", aplicável a funções individuais.

-mpreferred-stack-boundary =Números
Tente manter o limite da pilha alinhado a 2 elevado para Números limite de byte. Se
-mpreferred-stack-limite não for especificado, o padrão é 4 (16 bytes ou 128 bits).

Atenção: Ao gerar código para a arquitetura x86-64 com extensões SSE
Desativado, -mpreferred-stack-boundary = 3 pode ser usado para manter o limite da pilha alinhado
até limite de 8 bytes. Você deve construir todos os módulos com -mpreferred-stack-boundary = 3,
incluindo quaisquer bibliotecas. Isso inclui as bibliotecas do sistema e módulos de inicialização.

-mincoming-stack-boundary =Números
Suponha que a pilha de entrada esteja alinhada a 2 elevado a Números limite de byte. Se
-limite de pilha mincoming não é especificado, aquele especificado por
-mpreferred-stack-limite será usada.

No Pentium e PentiumPro, os valores "double" e "long double" devem ser alinhados a um
Limite de 8 bytes (ver -malign-duplo) ou sofrer um desempenho de tempo de execução significativo
penalidades. No Pentium III, o tipo de dados Streaming SIMD Extension (SSE) "__m128" pode
não funcionará corretamente se não estiver alinhado com 16 bytes.

Para garantir o alinhamento adequado desses valores na pilha, o limite da pilha deve ser tão
alinhado conforme exigido por qualquer valor armazenado na pilha. Além disso, cada função
deve ser gerado de forma a manter a pilha alinhada. Assim chamando uma função
compilado com um limite de pilha preferencial superior a partir de uma função compilada com um limite inferior
o limite de pilha preferido provavelmente desalinhará a pilha. É recomendado que
bibliotecas que usam callbacks sempre usam a configuração padrão.

Este alinhamento extra consome espaço de pilha extra e geralmente aumenta o código
Tamanho. Código que é sensível ao uso do espaço da pilha, como sistemas embarcados e
kernels do sistema operacional, pode querer reduzir o alinhamento preferido para
-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
-m3dagora
-mno-3dnow
-mpopct
-mno-popcnt
-mabm
-mno-abm
-mbmi
-mbmi2
-mno-bmi
-mno-bmi2
-mlzcnt
-mno-lzcnt
-mtbm
-mno-tbm
Essas chaves habilitam ou desabilitam o uso de instruções no MMX, SSE, SSE2, SSE3,
SSSE3, SSE4.1, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, F16C, FMA, SSE4A, FMA4, XOP,
LWP, ABM, BMI, BMI2, LZCNT ou 3DNow!
conjuntos de instruções estendidas. Essas extensões também estão disponíveis como integradas
funções: ver X86 Autenticador Funções, para obter detalhes das funções ativadas e
desativado por esses interruptores.

Para ter instruções SSE / SSE2 geradas automaticamente a partir de código de ponto flutuante (como
em oposição a 387 instruções), consulte -mfpmath = sse.

GCC deprime as instruções SSEx quando -mavx é usado. Em vez disso, ele gera um novo AVX
instruções ou equivalência AVX para todas as instruções SSEx quando necessário.

Essas opções permitirão ao GCC usar essas instruções estendidas no código gerado,
mesmo sem -mfpmath = sse. Os aplicativos que realizam detecção de CPU em tempo de execução devem
compilar arquivos separados para cada arquitetura suportada, usando os sinalizadores apropriados.
Em particular, o arquivo que contém o código de detecção da CPU deve ser compilado sem
essas opções.

-mcld
Esta opção instrui o GCC a emitir uma instrução "cld" no prólogo das funções
que usam instruções de string. As instruções da string dependem do sinalizador DF para selecionar
entre o modo de incremento automático ou autodecremento. Enquanto a ABI especifica o sinalizador DF para
ser limpo na entrada da função, alguns sistemas operacionais violam esta especificação por não
limpar o sinalizador DF em seus despachantes de exceção. O manipulador de exceções pode ser
invocado com o sinalizador DF definido, o que leva ao modo de direção errada quando a string
instruções são usadas. Esta opção pode ser habilitada por padrão em destinos x32 de 86 bits por
configurar o GCC com o --enable-cld opção de configuração. Geração de "cld"
as instruções podem ser suprimidas com o -mno-cld opção do compilador neste caso.

-mvzeroupper
Esta opção instrui o GCC a emitir uma instrução "vzeroupper" antes de uma transferência de
controle de fluxo fora da função para minimizar AVX para penalidade de transição SSE, bem como
remover intrínsecos zeroupper desnecessários.

-mprefer-avx128
Esta opção instrui o GCC a usar instruções AVX de 128 bits em vez de AVX de 256 bits
instruções no autovetorizador.

-mcx16
Esta opção permitirá que o GCC use a instrução CMPXCHG16B no código gerado.
CMPXCHG16B permite operações atômicas em dados de duas palavras quádruplas (ou oword) de 128 bits
tipos. Isso é útil para contadores de alta resolução que podem ser atualizados por vários
processadores (ou núcleos). Esta instrução é gerada como parte do atômico integrado
funções: ver __sincronizar Integrados or __atômico Integrados para obter detalhes.

-msahf
Esta opção permitirá que o GCC use a instrução SAHF no código de 64 bits gerado. Cedo
CPUs Intel com Intel 64 não tinham instruções LAHF e SAHF suportadas por AMD64 até
introdução da etapa Pentium 4 G1 em dezembro de 2005. LAHF e SAHF são carregar e armazenar
instruções, respectivamente, para determinados sinalizadores de status. No modo de 64 bits, SAHF
a instrução é usada para otimizar as funções integradas "fmod", "drem" ou "resto": consulte
Outros Integrados para obter detalhes.

-mmovbe
Esta opção permitirá que o GCC use a instrução movbe para implementar "__builtin_bswap32"
e "__builtin_bswap64".

-mcrc32
Esta opção habilitará funções integradas, "__builtin_ia32_crc32qi",
"__builtin_ia32_crc32hi". "__builtin_ia32_crc32si" e "__builtin_ia32_crc32di" para
gere a instrução de máquina crc32.

-mreceita
Esta opção permitirá que o GCC use as instruções RCPSS e RSQRTSS (e seus
variantes vetorizadas RCPPS e RSQRTPS) com uma etapa Newton-Raphson adicional para
aumentar a precisão em vez de DIVSS e SQRTSS (e suas variantes vetorizadas) para
argumentos de ponto flutuante de precisão única. Estas instruções são geradas apenas quando
-funsafe-math-otimizations está habilitado junto com -finite-matemática-only e
-fno-trapping-matemática. Observe que, embora a taxa de transferência da sequência seja maior do que o
rendimento da instrução não recíproca, a precisão da sequência pode ser
diminuiu em até 2 ulp (ou seja, o inverso de 1.0 é igual a 0.99999994).

Observe que o GCC implementa "1.0f / sqrtf (x) " em termos de RSQRTSS (ou RSQRTPS) já com
-rápida matemática (ou a combinação de opções acima) e não precisa -mreceita.

Observe também que o GCC emite a sequência acima com a etapa Newton-Raphson adicional para
divisão de flutuação única vetorizada e "sqrtf (x) " já com -rápida matemática
(ou a combinação de opções acima) e não precisa -mreceita.

-mrecip =optar
Esta opção permite controlar quais instruções de estimativa recíproca podem ser usadas. optar
é uma lista de opções separada por vírgulas, que pode ser precedida por um "!" para inverter o
opção: "all": habilita todas as instruções de estimativa, "default": habilita o default
instruções, equivalente a -mreceita, "nenhum": desativa todas as instruções de estimativa,
equivalente a -mno-receita, "div": permite a aproximação para divisão escalar,
"vec-div": habilita a aproximação para divisão vetorial, "sqrt": habilita o
aproximação para raiz quadrada escalar, "vec-sqrt": permite a aproximação para
raiz quadrada vetorizada.

Então, por exemplo, -mrecip = all,! sqrt permitiria todas as aproximações recíprocas,
exceto para raiz quadrada.

-mveclibabi =tipo
Especifica o tipo de ABI a ser usado para vetorizar intrínsecos usando uma biblioteca externa.
Os tipos suportados são "svml" para a biblioteca de matemática vetorial abreviada da Intel e "acml" para o
Estilo de interface da biblioteca do núcleo de matemática da AMD. O GCC atualmente emitirá chamadas para
"vmldExp2", "vmldLn2", "vmldLog102", "vmldLog102", "vmldPow2", "vmldTanh2",
"vmldTan2", "vmldAtan2", "vmldAtanh2", "vmldCbrt2", "vmldSinh2", "vmldSin2",
"vmldAsinh2", "vmldAsin2", "vmldCosh2", "vmldCos2", "vmldAcosh2", "vmldAcos2",
"vmlsExp4", "vmlsLn4", "vmlsLog104", "vmlsLog104", "vmlsPow4", "vmlsTanh4",
"vmlsTan4", "vmlsAtan4", "vmlsAtanh4", "vmlsCbrt4", "vmlsSinh4", "vmlsSin4",
"vmlsAsinh4", "vmlsAsin4", "vmlsCosh4", "vmlsCos4", "vmlsAcosh4" e "vmlsAcos4" para
tipo de função correspondente quando -mveclibabi = svml é usado e "__vrd2_sin",
"__vrd2_cos", "__vrd2_exp", "__vrd2_log", "__vrd2_log2", "__vrd2_log10",
"__vrs4_sinf", "__vrs4_cosf", "__vrs4_expf", "__vrs4_logf", "__vrs4_log2f",
"__vrs4_log10f" e "__vrs4_powf" para o tipo de função correspondente quando
-mveclibabi = acml é usado. Ambos -ftree-vetorize e -funsafe-math-otimizations
para ser habilitado. Uma biblioteca compatível com SVML ou ACML ABI terá que ser especificada no link
tempo.

-mabi =nome
Gerar código para a convenção de chamada especificada. Os valores permitidos são: sysv for
a ABI usada em GNU / Linux e outros sistemas e ms para o Microsoft ABI. O padrão
é usar a ABI da Microsoft ao direcionar o Windows. Em todos os outros sistemas, o padrão
é o SYSV ABI. Você pode controlar esse comportamento para uma função específica usando o
atributo de função ms_abi/sysv_abi.

-mtls-dialect =tipo
Gere o código para acessar o armazenamento local do thread usando o gnu or gnu2 convenções. gnu
é o padrão conservador; gnu2 é mais eficiente, mas pode adicionar compilar- e executar-
requisitos de tempo que não podem ser satisfeitos em todos os sistemas.

-mpus-args
-mno-push-args
Use as operações PUSH para armazenar os parâmetros de saída. Este método é mais curto e geralmente
igualmente rápido como o método que usa operações SUB / MOV e é habilitado por padrão. Em alguns
casos, desativá-lo pode melhorar o desempenho devido ao agendamento aprimorado e à redução
dependências.

-maccumulate-args de saída
Se ativado, a quantidade máxima de espaço necessária para argumentos de saída será
calculado no prólogo da função. Isso é mais rápido na maioria das CPUs modernas por causa de
dependências reduzidas, agendamento melhorado e uso reduzido da pilha quando pilha preferida
limite não é igual a 2. A desvantagem é um aumento notável no tamanho do código. Esse
mudar implica -mno-push-args.

-mthreads
Suporte a manipulação de exceção thread-safe em Mingw32. Código que depende de thread-safe
tratamento de exceção deve compilar e vincular todo o código com o -mthreads opção. Quando
compilando, -mthreads define -D_MT; ao vincular, ele se conecta a um auxiliar de discussão especial
biblioteca -lmingwthrd que limpa os dados de manipulação de exceção de thread.

-mno-align-stringops
Não alinhe o destino das operações de sequência inline. Esta opção reduz o tamanho do código
e melhora o desempenho caso o destino já esteja alinhado, mas o GCC não
sabe disso.

-minline-all-stringops
Por padrão, o GCC alinha as operações de string apenas quando o destino é conhecido como
alinhado a pelo menos um limite de 4 bytes. Isso permite mais inlining, aumenta o tamanho do código,
mas pode melhorar o desempenho do código que depende de memcpy rápido, strlen e memset para
comprimentos curtos.

-minline-stringops-dinamicamente
Para operações de string de tamanho desconhecido, use verificações de tempo de execução com código embutido para pequenas
blocos e uma chamada de biblioteca para grandes blocos.

-mstringop-strategy =alg
Sobrescrever heurística de decisão interna sobre algoritmo particular para string inline
operação com. Os valores permitidos são "rep_byte", "rep_4byte", "rep_8byte" para
expandindo usando o prefixo i386 "rep" do tamanho especificado, "byte_loop", "loop",
"unrolled_loop" para expandir o loop embutido, "libcall" para sempre expandir a biblioteca
ligar.

-momit-folha-frame-ponteiro
Não mantenha o ponteiro do quadro em um registro para funções folha. Isso evita o
instruções para salvar, configurar e restaurar ponteiros de quadro e fazer um registro extra
disponível nas funções de folha. A opção -fomit-frame-ponteiro remove a moldura
ponteiro para todas as funções, o que pode tornar a depuração mais difícil.

-mtls-direct-seg-refs
-mno-tls-direct-seg-refs
Controla se as variáveis ​​TLS podem ser acessadas com deslocamentos do segmento TLS
registrar (% gs para 32 bits,% fs para 64 bits), ou se o ponteiro da base do thread deve ser
adicionado. Se isso é legal ou não depende do sistema operacional e se
mapeia o segmento para cobrir toda a área TLS.

Para sistemas que usam GNU libc, o padrão é ativado.

-msse2avx
-mno-sse2avx
Especifique que o montador deve codificar as instruções SSE com o prefixo VEX. A opção
-mavx ativa isso por padrão.

-mfentry
-mno-fentry
Se o perfil estiver ativo -pg coloque a chamada do contador de criação de perfil antes do prólogo. Nota: Ligado
arquiteturas x86, o atributo "ms_hook_prologue" não é possível no momento para
-mfentry e -pg.

-m8bit-idiv
-mno-8bit-idiv
Em alguns processadores, como Intel Atom, a divisão de inteiros sem sinal de 8 bits é muito mais rápida do que
Divisão inteira de 32 bits / 64 bits. Esta opção gera uma verificação de tempo de execução. Se ambos
dividendo e divisor estão dentro do intervalo de 0 a 255, a divisão de inteiro sem sinal de 8 bits é
usado em vez da divisão de inteiros de 32/64 bits.

-mavx256-carga não alinhada dividida
-mavx256-split-unaligned-store
Divida o carregamento e armazenamento não alinhado do AVX de 32 bytes.

Este -m opções são suportadas além das acima nos processadores AMD x86-64 em
Ambientes de 64 bits.

-m32
-m64
-mx32
Gere código para um ambiente de 32 ou 64 bits. o -m32 opção define int, long e
aponta para 32 bits e gera código que é executado em qualquer sistema i386. o -m64 opção
define int em 32 bits e long e ponteiro em 64 bits e gera código para AMD's
arquitetura x86-64. o -mx32 opção define int, long e ponteiro para 32 bits e
gera código para a arquitetura x86-64 da AMD. Para darwin apenas o -m64 opção vira
fora da -fno-pic e -mdynamic-no-pic opções.

-mno-zona vermelha
Não use a chamada zona vermelha para o código x86-64. A zona vermelha é determinada pelo
x86-64 ABI, é uma área de 128 bytes além da localização do ponteiro da pilha que irá
não pode ser modificado por manipuladores de sinal ou interrupção e, portanto, pode ser usado para
dados temporários sem ajustar o ponteiro da pilha. A bandeira -mno-zona vermelha desabilita
esta zona vermelha.

-mcmodel = pequeno
Gere código para o modelo de código pequeno: o programa e seus símbolos devem ser vinculados em
os 2 GB inferiores do espaço de endereço. Os ponteiros têm 64 bits. Os programas podem ser
vinculado estaticamente ou dinamicamente. Este é o modelo de código padrão.

-mcmodel = kernel
Gere código para o modelo de código do kernel. O kernel é executado em 2 GB negativos do
espaço de endereço. Este modelo deve ser usado para o código do kernel Linux.

-mcmodel = medium
Gerar código para o modelo médio: O programa está vinculado nos 2 GB inferiores do
espaço de endereço. Pequenos símbolos também são colocados lá. Símbolos com tamanhos maiores que
-mlarge-data-threshold são colocados em grandes seções de dados ou bss e podem ser localizados
acima de 2 GB. Os programas podem ser vinculados estática ou dinamicamente.

-mcmodel = grande
Gere código para o modelo grande: este modelo não faz suposições sobre endereços e
tamanhos de seções.

-maddress-mode = long
Gere código para o modo de endereço longo. Isso só é compatível com 64 bits e x32
ambientes. É o modo de endereço padrão para ambientes de 64 bits.

-maddress-mode = short
Gere código para o modo de endereço curto. Isso só é compatível com 32 bits e x32
ambientes. É o modo de endereço padrão para ambientes de 32 bits e x32.

i386 e x86-64 Windows Opções

Estas opções adicionais estão disponíveis para destinos Windows:

-mconsole
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que um console
aplicativo deve ser gerado, instruindo o vinculador a definir o cabeçalho PE
tipo de subsistema necessário para aplicativos de console. Este é o comportamento padrão para
Alvos Cygwin e MinGW.

-mdll
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que um DLL - um
biblioteca de vínculo dinâmico - deve ser gerada, permitindo a seleção dos
objeto de inicialização do tempo de execução e ponto de entrada.

-mnop-fun-dllimportar
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que o
O atributo dllimport deve ser ignorado.

-mthread
Esta opção está disponível para destinos MinGW. Ele especifica que o segmento específico do MinGW
suporte deve ser usado.

-municódigo
Esta opção está disponível para destinos mingw-w64. Ele especifica que a macro UNICODE
está sendo pré-definido e que o código de inicialização do tempo de execução compatível com Unicode foi escolhido.

-mwin32
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que o típico
As macros predefinidas do Windows devem ser definidas no pré-processador, mas não influenciam
a escolha da biblioteca de tempo de execução / código de inicialização.

- janelas
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que um GUI
o aplicativo deve ser gerado instruindo o vinculador a definir o cabeçalho PE
tipo de subsistema apropriadamente.

-fno-set-stack-executável
Esta opção está disponível para destinos MinGW. Ele especifica que o sinalizador executável para
pilha usada por funções aninhadas não está definida. Isso é necessário para binários em execução em
modo kernel do Windows, pois existe a API user32, que é usada para definir
privilégios, não está disponível.

-mpe-align-commons
Esta opção está disponível para destinos Cygwin e MinGW. Ele especifica que o GNU
extensão para o formato de arquivo PE que permite o alinhamento correto das variáveis ​​COMUNS
deve ser usado ao gerar código. Será habilitado por padrão se o GCC detectar
que o assembler de destino encontrado durante a configuração suporta o recurso.

Veja também em i386 e x86-64 Opções para opções padrão.

IA-64 Opções

Estes são o -m opções definidas para a arquitetura Intel IA-64.

-mbi-endian
Gere código para um alvo big-endian. Este é o padrão para HP-UX.

-mlittle-endian
Gere código para um target little-endian. Este é o padrão para AIX5 e GNU / Linux.

-mgnu-as
-mno-gnu-as
Gere (ou não) código para o assembler GNU. Este é o padrão.

-mgnu-ld
-mno-gnu-ld
Gere (ou não) código para o vinculador GNU. Este é o padrão.

-mno-pic
Gere código que não usa um registro de ponteiro global. O resultado não é posição
código independente e viola o IA-64 ABI.

-mvolátil-asm-stop
-mno-volátil-asm-stop
Gere (ou não) um bit de parada imediatamente antes e depois das instruções asm voláteis.

-mregister-nomes
-mno-registrar-nomes
Gerar (ou não) in, loc e Fora nomes de registro para os registros empilhados. Esse
pode tornar a saída do assembler mais legível.

-mno-sdata
-msdados
Desabilite (ou habilite) otimizações que usam a pequena seção de dados. Isso pode ser útil
para contornar bugs do otimizador.

-mconstante-gp
Gere código que usa um único valor de ponteiro global constante. Isso é útil quando
compilar o código do kernel.

-mauto-pic
Gere código que seja auto-realocável. Isso implica -mconstante-gp. Isso é útil
ao compilar o código do firmware.

-minline-float-divide-min-latência
Gerar código para divisões em linha de valores de ponto flutuante usando a latência mínima
algoritmo.

-minline-float-divide-max-rendimento
Gerar código para divisões em linha de valores de ponto flutuante usando a taxa de transferência máxima
algoritmo.

-mno-inline-float-divide
Não gere código embutido para divisões de valores de ponto flutuante.

-minline-int-divide-min-latência
Gerar código para divisões em linha de valores inteiros usando a latência mínima
algoritmo.

-minline-int-divide-max-rendimento
Gerar código para divisões em linha de valores inteiros usando a taxa de transferência máxima
algoritmo.

-mno-inline-int-divide
Não gere código embutido para divisões de valores inteiros.

-minline-sqrt-min-latência
Gere código para raízes quadradas embutidas usando o algoritmo de latência mínima.

-minline-sqrt-max-rendimento
Gere código para raízes quadradas em linha usando o algoritmo de taxa de transferência máxima.

-mno-inline-sqrt
Não gere código embutido para sqrt.

-mfuso-louco
-mno-fundido-madd
Faça (não) gere o código que usa a multiplicação / adição fundida ou multiplica / subtrai
instruções. O padrão é usar essas instruções.

-mno-anão2-asm
-mdwarf2-asm
Não gere (ou gere) código assembler para as informações de depuração do número da linha DWARF2. Esse
pode ser útil quando não estiver usando o GNU assembler.

-poucos-stop-bits
-mno-early-stop-bits
Permitir que bits de parada sejam colocados antes do imediatamente anterior à instrução que
acionou o bit de parada. Isso pode melhorar o agendamento de instruções, mas nem sempre
faça isso.

-mfixed-range =intervalo de registro
Gere o código tratando o intervalo de registro fornecido como registros fixos. Um registro fixo
é aquele que o alocador de registro não pode usar. Istoéútil ao compilar o kernel
código. Um intervalo de registro é especificado como dois registros separados por um traço. Múltiplo
os intervalos de registro podem ser especificados separados por uma vírgula.

-mtls-size =tamanho tls
Especifique o tamanho do bit dos deslocamentos TLS imediatos. Os valores válidos são 14, 22 e 64.

-mtune =tipo cpu
Ajuste o agendamento de instrução para uma CPU particular, os valores válidos são itanium,
itanium1, merced, itanium2 e mckinley.

-milp32
-mlp64
Gere código para um ambiente de 32 ou 64 bits. O ambiente de 32 bits define int,
longo e ponteiro para 32 bits. O ambiente de 64 bits define int para 32 bits e long e
ponteiro para 64 bits. Esses são sinalizadores específicos do HP-UX.

-mno-sched-br-data-spec
-msched-br-data-spec
(Des / En) capaz de agendamento especulativo de dados antes de recarregar. Isso resultará em
geração das instruções ld.a e as instruções de verificação correspondentes (ld.c /
chk.a). O padrão é 'desativar'.

-msched-ar-data-spec
-mno-sched-ar-data-spec
(En / Des) capaz de agendamento especulativo de dados após a recarga. Isso resultará em geração
das instruções ld.a e as instruções de verificação correspondentes (ld.c / chk.a). o
o padrão é 'habilitar'.

-mno-sched-control-spec
-msched-control-spec
(Des / En) capaz de controlar a programação especulativa. Este recurso está disponível apenas durante
programação de região (ou seja, antes de recarregar). Isso resultará na geração do ld.s
instruções e as instruções de verificação correspondentes chk.s. O padrão é
'desativar'.

-msched-br-in-data-spec
-mno-sched-br-in-data-spec
(En / Des) capaz de agendamento especulativo das instruções que são dependentes dos dados
cargas especulativas antes de recarregar. Isso é eficaz apenas com -msched-br-data-spec
ativado. O padrão é 'habilitar'.

-msched-ar-in-data-spec
-mno-sched-ar-in-data-spec
(En / Des) capaz de agendamento especulativo das instruções que são dependentes dos dados
cargas especulativas após a recarga. Isso é eficaz apenas com -msched-ar-data-spec
ativado. O padrão é 'habilitar'.

-msched-in-control-spec
-mno-sched-in-control-spec
(En / Des) capaz de agendamento especulativo das instruções que são dependentes do
controlar cargas especulativas. Isso é eficaz apenas com -msched-control-spec ativado.
O padrão é 'habilitar'.

-mno-sched-prefer-non-data-spec-insns
-msched-prefer-non-data-spec-insns
Se ativado, as instruções especulativas de dados serão escolhidas para agendamento apenas se houver
não há outras opções no momento. Isso fará com que o uso da especulação de dados
muito mais conservador. O padrão é 'desativar'.

-mno-sched-prefer-non-control-spec-insns
-msched-prefer-non-control-spec-insns
Se habilitado, as instruções especulativas de controle serão escolhidas para agendamento apenas se houver
não há outras opções no momento. Isso fará com que o uso da especulação de controle
muito mais conservador. O padrão é 'desativar'.

-mno-sched-count-spec-in-critical-path
-msched-count-spec-in-critical-path
Se ativado, as dependências especulativas serão consideradas durante o cálculo do
prioridades de instruções. Isso tornará o uso da especulação um pouco mais
conservador. O padrão é 'desativar'.

-msched-spec-ldc
Use uma verificação de especulação de dados simples. Essa opção está ativada por padrão.

-msched-control-spec-ldc
Use uma verificação simples para especulação de controle. Essa opção está ativada por padrão.

-msched-stop-bits-after-ever-cycle
Coloque um bit de parada após cada ciclo ao programar. Essa opção está ativada por padrão.

-msched-fp-mem-deps-zero-custo
Suponha que carregamentos e armazenamentos de ponto flutuante provavelmente não causem um conflito quando
colocados no mesmo grupo de instrução. Esta opção está desativada por padrão.

-msel-sched-dont-check-control-spec
Gere verificações para especulação de controle em programação seletiva. Esta bandeira é
desativado por padrão.

-msched-max-memory-insns =max-insns
Limite no número de insns de memória por grupo de instrução, dando prioridade mais baixa para
memória subseqüente insns tentando agendar no mesmo grupo de instrução.
Freqüentemente útil para evitar conflitos de banco de cache. O valor padrão é 1.

-msched-max-memory-insns-hard-limit
Proibir mais do que `msched-max-memory-insns 'no grupo de instrução. Caso contrário, limite
é `suave ', o que significa que preferiríamos operações sem memória quando o limite é atingido, mas
ainda pode agendar operações de memória.

IA-64 / VMS Opções

Este -m as opções são definidas para as implementações IA-64 / VMS:

-mvms-códigos de retorno
Retorne os códigos de condição VMS do principal. O padrão é retornar a condição de estilo POSIX
(por exemplo, códigos de erro).

-mdebug-main =prefixo
Sinalize a primeira rotina cujo nome começa com prefixo como a rotina principal para o
depurador.

-mmalloc64
Padrão para rotinas de alocação de memória de 64 bits.

LM32 Opções

Este -m as opções são definidas para a arquitetura Lattice Mico32:

-barrel-shift-habilitado
Habilite as instruções de deslocamento de barril.

-mdivide habilitado
Habilite as instruções de divisão e módulo.

-multiply ativado
Ative as instruções de multiplicação.

-msign-extend-habilitado
Habilite as instruções de extensão de sinal.

-muser ativado
Habilite as instruções definidas pelo usuário.

M32C Opções

-mcpu =nome
Selecione a CPU para a qual o código é gerado. nome pode ser um de r8c para o R8C / Tiny
série, m16c para a série M16C (até / 60), m32cm para a série M16C / 80, ou m32c
para a série M32C / 80.

-msim
Especifica que o programa será executado no simulador. Isso causa uma alternativa
biblioteca de tempo de execução a ser vinculada na qual suporta, por exemplo, E / S de arquivo. Você não deve
use esta opção ao gerar programas que serão executados em hardware real; você deve
fornecer sua própria biblioteca de tempo de execução para quaisquer funções de E / S necessárias.

-memregs =número
Especifica o número de pseudo-registros baseados em memória que o GCC usará durante o código
geração. Esses pseudo-registros serão usados ​​como registros reais, então há um
compensação entre a capacidade do GCC de ajustar o código aos registros disponíveis e o
penalidade de desempenho de usar memória em vez de registros. Observe que todos os módulos em um
o programa deve ser compilado com o mesmo valor para esta opção. Por causa disso, você
não deve usar esta opção com as compilações gcc de bibliotecas de tempo de execução padrão.

M32R / D Opções

Este -m opções são definidas para arquiteturas Renesas M32R / D:

-m32r2
Gere código para o M32R / 2.

-m32rx
Gere código para o M32R / X.

-m32r
Gere código para o M32R. Este é o padrão.

-mmodel = pequeno
Suponha que todos os objetos vivam nos 16 MB inferiores de memória (de modo que seus endereços possam ser
carregado com a instrução "ld24"), e assume que todas as sub-rotinas são alcançáveis ​​com o
instrução "bl". Este é o padrão.

A endereçabilidade de um determinado objeto pode ser definida com o atributo "modelo".

-mmodel = medium
Suponha que os objetos podem estar em qualquer lugar no espaço de endereço de 32 bits (o compilador irá gerar
instruções "seth / add3" para carregar seus endereços), e assumir que todas as sub-rotinas são
acessível com a instrução "bl".

-mmodel = grande
Suponha que os objetos podem estar em qualquer lugar no espaço de endereço de 32 bits (o compilador irá gerar
instruções "seth / add3" para carregar seus endereços), e assumir que as sub-rotinas podem não ser
alcançável com a instrução "bl" (o compilador irá gerar o muito mais lento
sequência de instruções "seth / add3 / jl").

-msdata = nenhum
Desative o uso da pequena área de dados. As variáveis ​​serão colocadas em um de .dados, bssou
.rodata (a menos que o atributo "seção" tenha sido especificado). Este é o padrão.

A pequena área de dados consiste em seções .sdata e .sbss. Objetos podem ser explicitamente
coloque na pequena área de dados com o atributo "seção" usando uma dessas seções.

-msdata = sdata
Coloque pequenos dados globais e estáticos na pequena área de dados, mas não gere dados especiais
código para referenciá-los.

-msdata = use
Coloque pequenos dados globais e estáticos na pequena área de dados e gere
instruções para referenciá-los.

-G Números
Coloque objetos globais e estáticos menores ou iguais a Números bytes em pequenos dados ou
seções bss em vez dos dados normais ou seções bss. O valor padrão de Números is
8. A -msdados opção deve ser definida para um de dados or usar para esta opção ter qualquer
efeito.

Todos os módulos devem ser compilados com o mesmo -G Números valor. Compilando com diferentes
valores de Números pode ou não funcionar; se não o fizer, o linker apresentará um erro
mensagem --- código incorreto não será gerado.

-mdebug
Faz com que o código específico do M32R no compilador exiba algumas estatísticas que podem ajudar
em programas de depuração.

-loops malignos
Alinhe todos os loops a um limite de 32 bytes.

-mno-align-loops
Não imponha um alinhamento de 32 bytes para loops. Este é o padrão.

- taxa de emissão =número
Questão número instruções por ciclo. número só pode ser 1 ou 2.

-mbranch-cost =número
número só pode ser 1 ou 2. Se for 1, os ramos terão preferência sobre
código condicional, se for 2, o oposto se aplicará.

-mflush-trap =número
Especifica o número do trap a ser usado para liberar o cache. O padrão é 12. Válido
os números estão entre 0 e 15, inclusive.

-mno-flush-trap
Especifica que o cache não pode ser liberado usando um trap.

-mflush-func =nome
Especifica o nome da função do sistema operacional a ser chamada para liberar o cache. o
padrão é _flush_cache, mas uma chamada de função só será usada se uma armadilha não for
disponíveis.

-mno-flush-func
Indica que não há função do sistema operacional para limpar o cache.

M680x0 Opções

Estes são o -m opções definidas para processadores M680x0 e ColdFire. As configurações padrão
dependem de qual arquitetura foi selecionada quando o compilador foi configurado; os padrões
para as opções mais comuns são fornecidas abaixo.

-march =arco
Gere código para uma arquitetura de conjunto de instruções M680x0 ou ColdFire específica.
Valores permitidos de arco para arquiteturas M680x0 são: 68000, 68010, 68020, 68030,
68040, 68060 e CPU32. As arquiteturas ColdFire são selecionadas de acordo com a Freescale
A classificação ISA e os valores permitidos são: iSAA, isaaplus, Isabel e isac.

gcc define uma macro __mcfarco__ sempre que estiver gerando código para um alvo ColdFire.
A arco nesta macro é um dos -marchar argumentos dados acima.

Quando usados ​​juntos, -marchar e -mtune selecione o código que roda em uma família de semelhantes
processadores, mas que é otimizado para uma microarquitetura específica.

-mcpu =cpu
Gere código para um processador M680x0 ou ColdFire específico. O M680x0 cpus são:
68000, 68010, 68020, 68030, 68040, 68060, 68302, 68332 e CPU32. O Fogo Frio cpus
são dados pela tabela abaixo, que também classifica as CPUs em famílias:

Família: -mcpu argumentos
51 : 51 51ac 51cn 51em 51 qe
5206 : 5202 5204 5206
5206e : 5206e
5208 : 5207 5208
5211a : 5210a 5211a
5213 : 5211 5212 5213
5216 : 5214 5216
52235 : 52230 52231 52232 52233 52234 52235
5225 : 5224 5225
52259 : 52252 52254 52255 52256 52258 52259
5235 : 5232 5233 5234 5235 523x
5249 : 5249
5250 : 5250
5271 : 5270 5271
5272 : 5272
5275 : 5274 5275
5282 : 5280 5281 5282 528x
53017 : 53011 53012 53013 53014 53015 53016 53017
5307 : 5307
5329 : 5327 5328 5329 532x
5373 : 5372 5373 537x
5407 : 5407
5475 : 5470 5471 5472 5473 5474 5475 547x 5480 5481 5482 5483 5484 5485

-mcpu =cpu Substitui -march =arco if arco é compatível com cpu. Outras combinações de
-mcpu e -marchar são rejeitados.

gcc define a macro __mcf_cpu_cpu quando o alvo ColdFire cpu é selecionado. Isso também
define __mcf_família_família, onde o valor de família é dado pela tabela acima.

-mtune =afinação
Ajuste o código para uma microarquitetura específica, dentro das restrições definidas por -marchar
e -mcpu. As microarquitetura M680x0 são: 68000, 68010, 68020, 68030, 68040,
68060 e CPU32. As microarquitetura ColdFire são: cfv1, cfv2, cfv3, cfv4 e
cfv4e.

Você também pode usar -mtune = 68020-40 para código que precisa ser executado relativamente bem no 68020,
68030 e 68040 alvos. -mtune = 68020-60 é semelhante, mas inclui 68060 alvos como
Nós vamos. Essas duas opções selecionam as mesmas decisões de ajuste que -m68020-40 e -m68020-60
respectivamente.

gcc define as macros __mcarco e __mcarco__ ao ajustar para arquitetura 680x0
arco. Também define mcarco a menos que qualquer um -ansi ou um não GNU -std opção é usada.
Se o gcc estiver ajustando para uma variedade de arquiteturas, conforme selecionado por -mtune = 68020-40 or
-mtune = 68020-60, ele define as macros para cada arquitetura no intervalo.

gcc também define a macro __muarca__ ao ajustar para microarquitetura ColdFire
uarca, Onde uarca é um dos argumentos dados acima.

-m68000
-mc68000
Gere saída para um 68000. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68000. É equivalente a -march = 68000.

Use esta opção para microcontroladores com um núcleo 68000 ou EC000, incluindo o 68008,
68302, 68306, 68307, 68322, 68328 e 68356.

-m68010
Gere saída para um 68010. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68010. É equivalente a -march = 68010.

-m68020
-mc68020
Gere saída para um 68020. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68020. É equivalente a -march = 68020.

-m68030
Gere saída para um 68030. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68030. É equivalente a -march = 68030.

-m68040
Gere saída para um 68040. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68040. É equivalente a -march = 68040.

Esta opção inibe o uso de instruções 68881/68882 que devem ser emuladas por
software no 68040. Use esta opção se o seu 68040 não tiver código para emular
essas instruções.

-m68060
Gere saída para um 68060. Este é o padrão quando o compilador é configurado para
Sistemas baseados em 68060. É equivalente a -march = 68060.

Esta opção inibe o uso das instruções 68020 e 68881/68882 que devem ser
emulado pelo software no 68060. Use esta opção se o seu 68060 não tiver código
para emular essas instruções.

-mcpu32
Gere saída para uma CPU32. Este é o padrão quando o compilador é configurado para
Sistemas baseados em CPU32. É equivalente a -march = cpu32.

Use esta opção para microcontroladores com núcleo CPU32 ou CPU32 +, incluindo o 68330,
68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 e 68360.

-m5200
Gerar saída para uma CPU ColdFire 520X. Este é o padrão quando o compilador é
configurado para sistemas baseados em 520X. É equivalente a -mcpu = 5206e agora é
preterido em favor dessa opção.

Use esta opção para microcontrolador com um núcleo 5200, incluindo o MCF5202, MCF5203,
MCF5204 e MCF5206.

-m5206e
Gerar saída para uma CPU ColdFire 5206e. A opção agora está obsoleta em favor de
o equivalente -mcpu = 5206e.

-m528x
Gere saída para um membro da família ColdFire 528X. A opção é agora
preterido em favor do equivalente -mcpu = 528x.

-m5307
Gerar saída para uma CPU ColdFire 5307. A opção agora está obsoleta em favor do
equivalente -mcpu = 5307.

-m5407
Gerar saída para uma CPU ColdFire 5407. A opção agora está obsoleta em favor do
equivalente -mcpu = 5407.

-mcfv4e
Gere saída para uma CPU da família ColdFire V4e (por exemplo, 547x / 548x). Isso inclui o uso de
instruções de ponto flutuante de hardware. A opção é equivalente a -mcpu = 547x, e é
agora obsoleto em favor dessa opção.

-m68020-40
Gere saída para um 68040, sem usar nenhuma das novas instruções. Estes resultados
em um código que pode ser executado de forma relativamente eficiente em um 68020/68881 ou 68030 ou um
68040. O código gerado usa as instruções 68881 que são emuladas no
68040.

A opção é equivalente a -march = 68020 -mtune = 68020-40.

-m68020-60
Gere saída para um 68060, sem usar nenhuma das novas instruções. Estes resultados
em um código que pode ser executado de forma relativamente eficiente em um 68020/68881 ou 68030 ou um
68040. O código gerado usa as instruções 68881 que são emuladas no
68060.

A opção é equivalente a -march = 68020 -mtune = 68020-60.

-mhard-float
-m68881
Gere instruções de ponto flutuante. Este é o padrão para 68020 e acima, e
para dispositivos ColdFire que possuem uma FPU. Define a macro __TER_68881__ em M680x0
alvos e __mcffpu__ em alvos ColdFire.

-msoft-float
Não gere instruções de ponto flutuante; em vez disso, use chamadas de biblioteca. Isto é o
padrão para 68000, 68010 e 68832 destinos. Também é o padrão para ColdFire
dispositivos que não possuem FPU.

-mdiv
-mno-div
Gerar (não gerar) instruções de divisão e restante do hardware ColdFire. Se
-marchar é usado sem -mcpu, o padrão é "on" para arquiteturas ColdFire e "off"
para arquiteturas M680x0. Caso contrário, o padrão é obtido da CPU de destino (ou
a CPU padrão, ou aquela especificada por -mcpu) Por exemplo, o padrão é "desligado"
for -mcpu = 5206 e "on" para -mcpu = 5206e.

gcc define a macro __mcfhwdiv__ quando esta opção está habilitada.

-mcurto
Considere o tipo "int" com 16 bits de largura, como "short int". Além disso, parâmetros
transmitidos na pilha também são alinhados a um limite de 16 bits, mesmo em alvos cuja API
exige promoção para 32 bits.

-mno-curto
Não considere o tipo "int" com 16 bits de largura. Este é o padrão.

-mnobitfield
-mno-bitfield
Não use as instruções do campo de bits. o -m68000, -mcpu32 e -m5200 opções implicam
-mnobitfield.

-mbitcampo
Use as instruções do campo de bits. o -m68020 opção implica -mbitcampo. Isto é
o padrão se você usar uma configuração projetada para um 68020.

-mrtd
Use uma convenção de chamada de função diferente, na qual funções que levam um
número de argumentos retorna com a instrução "rtd", que exibe seus argumentos
ao retornar. Isso economiza uma instrução do chamador, pois não há necessidade de
pop os argumentos lá.

Esta convenção de chamada é incompatível com a normalmente usada no Unix, então você
não pode usá-lo se você precisar chamar bibliotecas compiladas com o compilador Unix.

Além disso, você deve fornecer protótipos de função para todas as funções que variam
número de argumentos (incluindo "printf"); caso contrário, um código incorreto será gerado
para chamadas para essas funções.

Além disso, um código seriamente incorreto resultará se você chamar uma função com muitos
argumentos. (Normalmente, argumentos extras são ignorados inofensivamente.)

A instrução "rtd" é compatível com 68010, 68020, 68030, 68040, 68060 e CPU32
processadores, mas não pelos 68000 ou 5200.

-mno-rtd
Não use as convenções de chamada selecionadas por -mrtd. Este é o padrão.

-maligno-int
-mno-align-int
Controle se o GCC alinha "int", "long", "long long", "float", "double" e "long
variáveis ​​double "em um limite de 32 bits (-maligno-int) ou um limite de 16 bits
(-mno-align-int) O alinhamento de variáveis ​​em limites de 32 bits produz um código que executa
um pouco mais rápido em processadores com barramentos de 32 bits ao custo de mais memória.

Atenção: se você usar o -maligno-int switch, o GCC irá alinhar as estruturas que contêm o
tipos acima de maneira diferente da interface binária de aplicativos mais publicada
especificações para o m68k.

-mpcrel
Use o modo de endereçamento relativo ao PC do 68000 diretamente, em vez de usar um global
mesa de compensação. No momento, esta opção implica -fpic, permitindo no máximo um deslocamento de 16 bits
para endereçamento relativo a pc. -fPIC atualmente não é compatível com -mpcrel, embora
isso pode ser compatível com processadores 68020 e superiores.

-mno-strict-align
-mstrict-align
Não (faça) supor que referências de memória não alinhadas serão tratadas pelo sistema.

-msep-dados
Gerar código que permite que o segmento de dados seja localizado em uma área diferente da memória
do segmento de texto. Isso permite a execução no local em um ambiente sem
gerenciamento de memória virtual. Esta opção implica -fPIC.

-mno-sep-dados
Gere código que assume que o segmento de dados segue o segmento de texto. Isto é
o padrão.

-mid-biblioteca compartilhada
Gere código que ofereça suporte a bibliotecas compartilhadas por meio do método de ID de biblioteca. Isso permite
para executar no local e bibliotecas compartilhadas em um ambiente sem memória virtual
gestão. Esta opção implica -fPIC.

-mno-id-biblioteca compartilhada
Gere código que não presuma que bibliotecas compartilhadas baseadas em ID estão sendo usadas. Isto é
o padrão.

-mshared-library-id = n
Especificado o número de identificação da biblioteca compartilhada baseada em ID que está sendo compilada.
Especificar um valor de 0 irá gerar um código mais compacto, especificar outros valores irá
forçar a alocação desse número para a biblioteca atual, mas não há mais espaço ou
eficiente em termos de tempo do que omitir esta opção.

-mxgot
-mno-xgot
Ao gerar código independente de posição para ColdFire, gere código que funcione se
o GOT tem mais de 8192 entradas. Este código é maior e mais lento que o código
gerado sem esta opção. Em processadores M680x0, esta opção não é necessária; -fPIC
é suficiente.

O GCC normalmente usa uma única instrução para carregar valores do GOT. Enquanto isso é
relativamente eficiente, ele só funciona se o GOT for menor do que cerca de 64k. Nada
maior faz com que o vinculador relate um erro como:

relocação truncada para caber: R_68K_GOT16O foobar

Se isso acontecer, você deve recompilar seu código com -mxgot. Deve então funcionar com
GOTs muito grandes. No entanto, o código gerado com -mxgot é menos eficiente, uma vez que
leva 4 instruções para buscar o valor de um símbolo global.

Observe que alguns vinculadores, incluindo versões mais recentes do vinculador GNU, podem criar
vários GOTs e classifique as entradas do GOT. Se você tiver esse linker, só precisará
usar -mxgot ao compilar um único arquivo de objeto que acessa mais de 8192 GOT
entradas. Muito poucos o fazem.

Essas opções não têm efeito, a menos que o GCC esteja gerando código independente de posição.

MCore Opções

Estes são o -m opções definidas para os processadores Motorola M * Core.

-mhardlit
-mno-hardlit
Constantes embutidas no fluxo de código, se isso puder ser feito em duas instruções ou menos.

-mdiv
-mno-div
Use a instrução de divisão. (Ativado por padrão).

-mrelax-imediato
-mno-relax-imediato
Permitir imediatos de tamanho arbitrário em operações de bits.

-mwide-bitfields
-mno-wide-bitfields
Sempre trate os campos de bits como tamanho interno.

-m4byte-funções
-mno-4byte-funções
Força todas as funções a serem alinhadas a um limite de 4 bytes.

-mcallgraph-dados
-mno-callgraph-dados
Emita informações de callgraph.

-mslow-bytes
-mno-bytes lentos
Prefira o acesso por palavra ao ler quantidades de bytes.

-mlittle-endian
-mbi-endian
Gere código para um target little-endian.

-m210
-m340
Gere código para o processador 210.

-mno-lsim
Suponha que o suporte de tempo de execução foi fornecido e, portanto, omita a biblioteca do simulador
(libsim.a) na linha de comando do vinculador.

-mstack-increment =tamanho
Defina a quantidade máxima para uma única operação de incremento de pilha. Valores grandes podem
aumentar a velocidade de programas que contêm funções que precisam de uma grande quantidade de
espaço de pilha, mas também podem desencadear uma falha de segmentação se a pilha for estendida
demais. O valor padrão é 0x1000.

EuP Opções

-mabsdiff
Habilita a instrução "abs", que é a diferença absoluta entre dois registradores.

-pequenas opções
Ativa todas as instruções opcionais - operações de média, multiplicação, divisão, bit,
zero à esquerda, diferença absoluta, mín. / máx., clipe e saturação.

-maédia
Ativa a instrução "ave", que calcula a média de dois registradores.

-mbasado =n
Variáveis ​​de tamanho n bytes ou menores serão colocados na seção ".based" por
predefinição. Variáveis ​​baseadas usam o registro $ tp como um registro base, e há um
Limite de 128 bytes para a seção ".based".

-mbitops
Ativa as instruções de operação de bit - teste de bit ("btstm"), set ("bsetm"), clear
("bclrm"), invert ("bnotm") e test-and-set ("tas").

-mc =nome
Seleciona em qual seção os dados constantes serão colocados. nome pode ser "minúsculo", "próximo" ou
"longe".

-mclip
Ativa a instrução "clip". Observe que "-mclip" não é útil a menos que você também
forneça "-mminmax".

-mconfig =nome
Seleciona uma das configurações básicas integradas. Cada chip MeP tem um ou mais
módulos nele; cada módulo possui uma CPU central e uma variedade de coprocessadores, opcionais
instruções e periféricos. A ferramenta "MeP-Integrator", que não faz parte do GCC, fornece
essas configurações por meio desta opção; usar esta opção é o mesmo que usar todos
as opções de linha de comando correspondentes. A configuração padrão é "default".

-mcop
Ativa as instruções do coprocessador. Por padrão, este é um coprocessador de 32 bits. Observação
que o coprocessador está normalmente ativado por meio da opção "-mconfig =".

-mcop32
Ativa as instruções do coprocessador de 32 bits.

-mcop64
Ativa as instruções do coprocessador de 64 bits.

-mivc2
Ativa o agendamento IVC2. IVC2 é um coprocessador VLIW de 64 bits.

-mdc
Faz com que as variáveis ​​constantes sejam colocadas na seção ".near".

-mdiv
Ativa as instruções "div" e "divu".

-meb
Gere código big-endian.

-mel
Gere o código little-endian.

-mio-volátil
Diz ao compilador que qualquer variável marcada com o atributo "io" deve ser
considerado volátil.

-ml Faz com que as variáveis ​​sejam atribuídas à seção ".far" por padrão.

-mleadz
Ativa a instrução "leadz" (zero à esquerda).

-milímetros Faz com que as variáveis ​​sejam atribuídas à seção ".near" por padrão.

-mminmax
Ativa as instruções "min" e "max".

-multo
Ativa as instruções de multiplicação e multiplicação-acumulação.

-mno-opções
Desativa todas as instruções opcionais ativadas por "-mall-opts".

-repetir
Ativa as instruções "repeat" e "erepeat", usadas para looping de baixa sobrecarga.

-em Faz com que todas as variáveis ​​sejam padronizadas para a seção ".tiny". Observe que há um
Limite de 65536 bytes para esta seção. Os acessos a essas variáveis ​​usam a base% gp
registre-se.

-msatur
Ativa as instruções de saturação. Observe que o compilador atualmente não
gerá-los sozinho, mas esta opção está incluída para compatibilidade com outras ferramentas,
como".

-msdram
Vincule o tempo de execução baseado em SDRAM em vez do tempo de execução padrão baseado em ROM.

-msim
Vincule as bibliotecas de tempo de execução do simulador.

-msimnovec
Vincule as bibliotecas de tempo de execução do simulador, excluindo o suporte integrado para redefinição e
vetores e tabelas de exceção.

-mtf
Faz com que todas as funções sejam padronizadas para a seção ".far". Sem esta opção, funções
padrão para a seção ".near".

-mtiny =n
Variáveis ​​que são n bytes ou menores serão alocados para a seção ".tiny". Esses
variáveis ​​usam o registro base $ gp. O padrão para esta opção é 4, mas observe que
há um limite de 65536 bytes para a seção ".tiny".

MicroBlaze Opções

-msoft-float
Use a emulação de software para ponto flutuante (padrão).

-mhard-float
Use as instruções de ponto flutuante do hardware.

-mmemcpy
Não otimize movimentos de bloco, use "memcpy".

-mno-clearbss
Esta opção está obsoleta. Usar -fno-zero-inicializado-em-bss ao invés.

-mcpu =tipo cpu
Use recursos e código de programação para determinada CPU. Os valores suportados estão no formato
vX.YY.Z, Onde X é uma versão principal, YY é a versão secundária, e Z é compatibilidade
código. Valores de exemplo são v3.00.a, v4.00.b, v5.00.a, v5.00.b, v5.00.b, v6.00.a.

-mxl-soft-mul
Use emulação de multiplicação de software (padrão).

-mxl-soft-div
Use a emulação de software para divisões (padrão).

-mxl-barril-shift
Use o deslocador de barril de hardware.

-mxl-padrão-comparar
Use as instruções de comparação de padrões.

-msmall-divide
Use a otimização de pesquisa de tabela para pequenas divisões inteiras com sinal.

-mxl-stack-check
Esta opção está obsoleta. Use -fstack-check em vez disso.

-mxl-gp-opt
Use seções sdata / sbss relativas ao GP.

-mxl-multiplicar-alto
Use as instruções de multiplicação alta para a parte alta da multiplicação de 32x32.

-mxl-float-converter
Use as instruções de conversão de ponto flutuante de hardware.

-mxl-float-sqrt
Use a instrução de raiz quadrada de ponto flutuante de hardware.

-mxl-modo-modelo de aplicativo
Selecione o modelo de aplicativo modelo de aplicativo. Modelos válidos são

executável
executável normal (padrão), usa código de inicialização crt0.o.

xmdstub
para uso com depuração intrusiva de software baseado em Xilinx Microprocessor Debugger (XMD)
agente chamado xmdstub. Isso usa o arquivo de inicialização crt1.o e define o endereço inicial de
o programa deve ser 0x800.

inicialização
para aplicativos que são carregados usando um bootloader. Este modelo usa arquivo de inicialização
crt2.o que não contém um manipulador de vetor de redefinição do processador. Isso é adequado
para transferir o controle de um processador redefinido para o bootloader em vez do
aplicação.

novatos
para aplicativos que não requerem nenhum dos vetores MicroBlaze. Esta opção
pode ser útil para aplicativos executados em um aplicativo de monitoramento. Este modelo
utiliza crt3.o como um arquivo de inicialização.

Opção -xl-modo-modelo de aplicativo é um alias obsoleto para -mxl-modo-modelo de aplicativo.

MIPS Opções

-EB Gere código big-endian.

-A Gere o código little-endian. Este é o padrão para mips * el - * - * configurações.

-march =arco
Gerar código que será executado em arco, que pode ser o nome de um ISA MIPS genérico ou
o nome de um processador específico. Os nomes ISA são: mips1, mips2, mips3, mips4,
mips32, mips32r2, mips64 e mips64r2. Os nomes dos processadores são: 4kc, 4km, 4kp, 4ksc,
4kec, 4 km, 4 minutos, 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 e xlr. O valor especial de-abi seleciona o mais compatível
arquitetura para a ABI selecionada (ou seja, mips1 para ABIs de 32 bits e mips3 para 64 bits
ABI).

Conjuntos de ferramentas nativos do Linux / GNU e IRIX também suportam o valor nativo, que seleciona o
melhor opção de arquitetura para o processador host. -march = nativo não tem efeito se GCC
não reconhece o processador.

Em nomes de processador, um final 000 pode ser abreviado como k (por exemplo, -march = r2k).
Os prefixos são opcionais e vr pode ser escrito r.

Nomes do formulário nf2_1 referem-se a processadores com FPUs cronometrados na metade da taxa do
núcleo, nomes do formulário nf1_1 referem-se a processadores com FPUs sincronizados na mesma taxa
como o núcleo e os nomes do formulário nf3_2 referem-se a processadores com FPUs com clock de uma proporção
de 3: 2 em relação ao núcleo. Por razões de compatibilidade, nf é aceito como um
sinônimo de nf2_1 enquanto nx e bfx são aceitos como sinônimos para nf1_1.

O GCC define duas macros com base no valor desta opção. O primeiro é _MIPS_ARCH,
que dá o nome da arquitetura de destino, como uma string. O segundo tem a forma
_MIPS_ARCH_Foo, Onde Foo é o valor capitalizado de _MIPS_ARCH. Por exemplo, a
-march = r2000 estabelecerá _MIPS_ARCH para "r2000" e definir a macro _MIPS_ARCH_R2000.

Observe que o _MIPS_ARCH macro usa os nomes de processador fornecidos acima. Em outras palavras,
terá o prefixo completo e não abreviará 000 as k. No caso de a partir de-
abi, a macro nomeia a arquitetura resolvida (ou "mips1" or "mips3") Ele nomeia
a arquitetura padrão quando não -marchar opção é fornecida.

-mtune =arco
Otimizar para arco. Entre outras coisas, esta opção controla a forma como as instruções são
programado e o custo percebido das operações aritméticas. A lista de arco valores
é o mesmo que para -marchar.

Quando esta opção não é usada, o GCC irá otimizar para o processador especificado por -marchar.
Usando -marchar e -mtune juntos, é possível gerar código que será executado em
uma família de processadores, mas otimize o código para um membro específico desse
família.

-mtune define as macros _MIPS_TUNE e _MIPS_TUNE_Foo, que funcionam da mesma maneira que
da -marchar aqueles descritos acima.

-mips1
Equivalente a -march = mips1.

-mips2
Equivalente a -march = mips2.

-mips3
Equivalente a -march = mips3.

-mips4
Equivalente a -march = mips4.

-mips32
Equivalente a -march = mips32.

-mips32r2
Equivalente a -march = mips32r2.

-mips64
Equivalente a -march = mips64.

-mips64r2
Equivalente a -march = mips64r2.

-mips16
-mno-mips16
Gere (não gere) código MIPS16. Se o GCC tiver como alvo um MIPS32 ou MIPS64
arquitetura, fará uso do MIPS16e ASE.

A geração de código MIPS16 também pode ser controlada por função por meio de
Atributos "mips16" e "nomips16".

-mflip-mips16
Gere código MIPS16 em funções alternadas. Esta opção é fornecida para regressão
teste de geração de código MIPS16 / não MIPS16 misto e não se destina a
use na compilação do código do usuário.

-minterlink-mips16
-mno-interlink-mips16
Exigir (não exigir) que o código não MIPS16 seja compatível com o link do código MIPS16.

Por exemplo, o código não MIPS16 não pode saltar diretamente para o código MIPS16; deve usar um
chamada ou um salto indireto. -minterlink-mips16 portanto, desativa os saltos diretos, a menos que
O GCC sabe que o alvo do salto não é MIPS16.

-mabi = 32
-mabi = o64
-mabi = n32
-mabi = 64
-mabi = eabi
Gere o código para o ABI fornecido.

Observe que o EABI tem uma variante de 32 bits e uma de 64 bits. GCC normalmente gera 64 bits
código ao selecionar uma arquitetura de 64 bits, mas você pode usar -mgp32 para obter código de 32 bits
ao invés.

Para obter informações sobre o O64 ABI, consultehttp://gcc.gnu.org/projects/mipso64-abi.html>.

O GCC suporta uma variante do o32 ABI em que os registros de ponto flutuante são 64, em vez
de 32 bits de largura. Você pode selecionar esta combinação com -mabi = 32 -mfp64. Este ABI
depende do mthc1 e mfhc1 instruções e, portanto, só é compatível com
Processadores MIPS32R2.

As atribuições de registro para argumentos e valores de retorno permanecem as mesmas, mas cada
o valor escalar é passado em um único registro de 64 bits em vez de um par de 32 bits
registra. Por exemplo, valores escalares de ponto flutuante são retornados em $ f0 apenas, não um
$ f0/$ f1 par. O conjunto de registros de chamadas salvas também permanece o mesmo, mas todos os 64 bits
são salvos.

-mabicalls
-mno-abicals
Gere (não gere) código adequado para objetos dinâmicos do estilo SVR4.
-mabicalls é o padrão para sistemas baseados em SVR4.

-mshared
-mno-compartilhado
Gere (não gere) código que é totalmente independente da posição e que pode
portanto, ser vinculado a bibliotecas compartilhadas. Esta opção afeta apenas -mabicalls.

Todos -mabicalls o código é tradicionalmente independente da posição, independentemente das opções
como -fPIC e -fpic. No entanto, como uma extensão, a cadeia de ferramentas GNU permite executáveis
para usar acessos absolutos para símbolos de ligação local. Ele também pode usar GP mais curto
sequências de inicialização e gerar chamadas diretas para funções definidas localmente. Esse
modo é selecionado por -mno-compartilhado.

-mno-compartilhado depende do binutils 2.16 ou superior e gera objetos que só podem ser
vinculado pelo vinculador GNU. No entanto, a opção não afeta o ABI da final
executável; afeta apenas a ABI de objetos relocáveis. Usando -mno-compartilhado precisarão
geralmente tornam os executáveis ​​menores e mais rápidos.

-mshared é o padrão.

-mplt
-mno-plt
Suponha (não suponha) que os vinculadores estáticos e dinâmicos suportam PLTs e copiam
deslocalizações. Esta opção afeta apenas -mno-compartilhado -mabicalls. Para o n64 ABI, este
opção não tem efeito sem -msym32.

Você pode fazer -mplt o padrão configurando o GCC com --com-mips-plt. O padrão
is -mno-plt de outra forma.

-mxgot
-mno-xgot
Eleve (não eleve) as restrições usuais no tamanho da tabela de deslocamento global.

O GCC normalmente usa uma única instrução para carregar valores do GOT. Enquanto isso é
relativamente eficiente, ele só funcionará se o GOT for menor que cerca de 64k.
Qualquer coisa maior fará com que o vinculador relate um erro como:

relocação truncada para caber: R_MIPS_GOT16 foobar

Se isso acontecer, você deve recompilar seu código com -mxgot. Deve então funcionar com
GOTs muito grandes, embora também sejam menos eficientes, uma vez que levará três
instruções para buscar o valor de um símbolo global.

Observe que alguns vinculadores podem criar vários GOTs. Se você tiver um linker, você
só deve precisar usar -mxgot quando um único arquivo de objeto acessa mais de 64k's
no valor de entradas GOT. Muito poucos o fazem.

Essas opções não têm efeito, a menos que o GCC esteja gerando um código independente de posição.

-mgp32
Suponha que os registradores de uso geral tenham 32 bits de largura.

-mgp64
Suponha que os registradores de uso geral tenham 64 bits de largura.

-mfp32
Suponha que os registradores de ponto flutuante tenham 32 bits de largura.

-mfp64
Suponha que os registradores de ponto flutuante tenham 64 bits de largura.

-mhard-float
Use as instruções do coprocessador de ponto flutuante.

-msoft-float
Não use as instruções do coprocessador de ponto flutuante. Implementar ponto flutuante
cálculos usando chamadas de biblioteca em vez disso.

-msingle-float
Suponha que o coprocessador de ponto flutuante suporte apenas operações de precisão simples.

-mdouble-float
Suponha que o coprocessador de ponto flutuante suporte operações de precisão dupla. Esse
é o padrão.

-mllsc
-mno-llsc
Use (não use) ll, sc e sincronizar instruções para implementar memória atômica integrada
funções. Quando nenhuma opção for especificada, o GCC usará as instruções se o
a arquitetura de destino os suporta.

-mllsc é útil se o ambiente de execução pode emular as instruções e -mno-llsc
pode ser útil ao compilar para ISAs não padrão. Você pode fazer qualquer uma das opções
padrão configurando o GCC com --com-llsc e --sem-lsc respectivamente.
--com-llsc é o padrão para algumas configurações; veja a documentação de instalação
para obter detalhes.

-mdsp
-mno-dsp
Use (não use) a revisão 1 do MIPS DSP ASE.
Esta opção define a macro do pré-processador __mips_dsp. Também define
__mips_dsp_rev para 1.

-mdspr2
-mno-dspr2
Use (não use) a revisão 2 do MIPS DSP ASE.
Esta opção define as macros do pré-processador __mips_dsp e __mips_dspr2. Também
define __mips_dsp_rev para 2.

-msmartmips
-mno-smartmips
Use (não use) o MIPS SmartMIPS ASE.

-mpareado-único
-mno-pareado-único
Use (não use) instruções de ponto flutuante único emparelhado.
Esta opção requer que o suporte de ponto flutuante de hardware seja habilitado.

-mdmx
-mno-mdmx
Use (não use) as instruções do MIPS Digital Media Extension. Esta opção só pode ser
usado ao gerar código de 64 bits e requer suporte de ponto flutuante de hardware para ser
ativado.

-mips3d
-mno-mips3d
Use (não use) o MIPS-3D ASE. A opção -mips3d implica -mpareado-único.

-mmt
-mno-mt
Use (não use) instruções MT Multithreading.

-mlong64
Força os tipos "longos" a terem 64 bits de largura. Ver -mlong32 para uma explicação do padrão
e a forma como o tamanho do ponteiro é determinado.

-mlong32
Força "long", "int" e os tipos de ponteiro com 32 bits de largura.

O tamanho padrão de "int" s, "long" se ponteiros depende da ABI. Todos
ABIs suportados usam "int" s de 32 bits. O n64 ABI usa "long" s de 64 bits, assim como o de 64 bits
EABI; os outros usam "long" s de 32 bits. Os ponteiros são do mesmo tamanho que s "longos" ou
mesmo tamanho dos registradores inteiros, o que for menor.

-msym32
-mno-sym32
Suponha (não suponha) que todos os símbolos têm valores de 32 bits, independentemente do
ABI. Esta opção é útil em combinação com -mabi = 64 e -mno-abicals porque
permite que o GCC gere referências mais curtas e rápidas para endereços simbólicos.

-G Números
Coloque as definições de dados visíveis externamente em uma pequena seção de dados se esses dados não forem
maior que Números bytes. O GCC pode então acessar os dados com mais eficiência; Vejo -mgpopt for
Detalhes.

O padrão -G opção depende da configuração.

-mlocal-sdata
-mno-local-sdata
Estenda (não estenda) o -G comportamento para dados locais também, como para variáveis ​​estáticas
em C. -mlocal-sdata é o padrão para todas as configurações.

Se o vinculador reclamar que um aplicativo está usando muitos dados pequenos, você pode
quer tentar reconstruir as partes menos críticas de desempenho com -mno-local-sdata. Você
também pode querer construir grandes bibliotecas com -mno-local-sdata, para que as bibliotecas
deixe mais espaço para o programa principal.

-mextern-sdata
-mno-extern-sdata
Suponha (não suponha) que os dados definidos externamente estarão em uma pequena seção de dados se
que os dados estão dentro do -G limite. -mextern-sdata é o padrão para todos
configurações.

Se você compilar um módulo Mod com -mextern-sdata -G Números -mgpopt e Mod referências a
variável var que não é maior que Números bytes, você deve ter certeza de que var está localizado
em uma pequena seção de dados. Se var é definido por outro módulo, você deve compilar
aquele módulo com um alto o suficiente -G definir ou anexar um atributo "seção" a var's
definição. Se var é comum, você deve vincular o aplicativo a um -G
criação.

A maneira mais fácil de satisfazer essas restrições é compilar e vincular cada módulo
com a mesma -G opção. No entanto, você pode querer construir uma biblioteca que suporte
vários pequenos limites de dados diferentes. Você pode fazer isso compilando a biblioteca com
o mais alto suportado -G configuração e, adicionalmente, usando -mno-extern-sdata para parar o
biblioteca de fazer suposições sobre dados definidos externamente.

-mgpopt
-mno-gpopt
Use (não use) acessos relativos a GP para símbolos que são conhecidos por estarem em poucos dados
seção; Vejo -G, -mlocal-sdata e -mextern-sdata. -mgpopt é o padrão para todos
configurações.

-mno-gpopt é útil para casos em que o registro $ gp pode não conter o valor de
"_gp". Por exemplo, se o código faz parte de uma biblioteca que pode ser usada em um boot
monitor, os programas que chamam as rotinas do monitor de inicialização passarão um valor desconhecido em $ gp.
(Em tais situações, o próprio monitor de inicialização normalmente seria compilado com -G0.)

-mno-gpopt implica -mno-local-sdata e -mno-extern-sdata.

-dados-incorporados
-mno-dados incorporados
Alocar variáveis ​​para a seção de dados somente leitura primeiro, se possível, depois, na
pequena seção de dados se possível, caso contrário, em dados. Isso resulta em um código um pouco mais lento
do que o padrão, mas reduz a quantidade de RAM necessária durante a execução e, portanto, pode
ser preferido para alguns sistemas incorporados.

-muninit-const-in-rodata
-mno-uninit-const-in-rodata
Coloque as variáveis ​​"const" não inicializadas na seção de dados somente leitura. Esta opção é
apenas significativo em conjunto com -dados-incorporados.

-mcode-readable =contexto
Especifique se o GCC pode gerar código que lê de seções executáveis. Existem
três configurações possíveis:

-mcode-readable = yes
As instruções podem acessar livremente as seções executáveis. Esta é a configuração padrão.

-mcode-readable = pcrel
As instruções de carregamento relativas ao PC MIPS16 podem acessar seções executáveis, mas outros
as instruções não devem fazê-lo. Esta opção é útil em processadores 4KSc e 4KSd
quando os TLBs de código têm o bit de inibição de leitura definido. Também é útil em processadores
que pode ser configurado para ter uma interface SRAM de instrução / dados dupla e que,
como o M4K, redireciona automaticamente as cargas relativas ao PC para a RAM de instrução.

-mcode-readable = no
As instruções não devem acessar as seções executáveis. Esta opção pode ser útil em
alvos que são configurados para ter uma interface SRAM de instrução / dados dupla, mas
que (ao contrário do M4K) não redireciona automaticamente as cargas relativas ao PC para o
instrução RAM.

-msplit-address
-mno-split-address
Habilite (desabilite) o uso dos operadores de relocação do assembler "% hi ()" e "% lo ()". Esse
opção foi substituída por -mexplícito-relocs mas é retido para trás
compatibilidade.

-mexplícito-relocs
-mno-explícito-relocs
Use (não use) operadores de realocação de assembler ao lidar com endereços simbólicos.
A alternativa, selecionada por -mno-explícito-relocs, é usar macros assembler em vez disso.

-mexplícito-relocs é o padrão se o GCC foi configurado para usar um assembler que
suporta operadores de relocação.

-mcheck-zero-divisão
-mno-check-zero-divisão
Trap (não trapping) na divisão inteira por zero.

O padrão é -mcheck-zero-divisão.

-mdivide-armadilhas
-mdivide-quebras
Os sistemas MIPS verificam a divisão por zero, gerando uma armadilha condicional ou um
quebrar a instrução. O uso de armadilhas resulta em código menor, mas só é compatível com MIPS
II e posterior. Além disso, algumas versões do kernel do Linux têm um bug que evita armadilhas
de gerar o sinal adequado ("SIGFPE"). Usar -mdivide-armadilhas permitir condicional
armadilhas em arquiteturas que os suportam e -mdivide-quebras para forçar o uso de
rompe.

O padrão geralmente é -mdivide-armadilhas, mas isso pode ser sobrescrito no momento da configuração
utilização --with-divide = quebras. As verificações de divisão por zero podem ser completamente desabilitadas usando
-mno-check-zero-divisão.

-mmemcpy
-mno-memcpy
Força (não force) o uso de "memcpy ()" para movimentos de bloco não triviais. O padrão
is -mno-memcpy, que permite que o GCC incorpore a maioria das cópias de tamanho constante.

-muito chamadas
-mno-long-chamadas
Desative (não desative) o uso da instrução "jal". Chamando funções usando "jal"
é mais eficiente, mas requer que o chamador e o receptor tenham os mesmos 256 megabytes
segmento.

Esta opção não tem efeito no código abicalls. O padrão é -mno-long-chamadas.

-mmad
-mno-louco
Habilite (desabilite) o uso das instruções "mad", "madu" e "mul", conforme fornecido pelo
R4650ISA.

-mfuso-louco
-mno-fundido-madd
Habilite (desabilite) o uso das instruções de multiplicação-acumulação de ponto flutuante, quando eles
Estão disponíveis. O padrão é -mfuso-louco.

Quando as instruções de multiplicação-acumulação são usadas, o produto intermediário é calculado
com precisão infinita e não está sujeito ao bit FCSR Flush to Zero. Isso pode ser
indesejável em algumas circunstâncias.

-nocpp
Diga ao montador MIPS para não executar seu pré-processador sobre os arquivos do montador do usuário (com um
.s sufixo) ao montá-los.

-mfix-24k
-mno-fix-24k
Contorne a errata 24K E48 (dados perdidos nas lojas durante o reabastecimento). As soluções alternativas
são implementados pelo montador em vez do GCC.

-mfix-r4000
-mno-fix-r4000
Contorne certas erratas da CPU R4000:

- Um deslocamento de palavra dupla ou variável pode dar um resultado incorreto se executado
imediatamente após iniciar uma divisão inteira.

- Uma palavra dupla ou uma mudança de variável pode dar um resultado incorreto se executado enquanto
uma multiplicação inteira está em andamento.

- Uma divisão inteira pode dar um resultado incorreto se iniciada em um slot de atraso de um
ramo tomado ou um salto.

-mfix-r4400
-mno-fix-r4400
Contorne certas erratas da CPU R4400:

- Um deslocamento de palavra dupla ou variável pode dar um resultado incorreto se executado
imediatamente após iniciar uma divisão inteira.

-mfix-r10000
-mno-fix-r10000
Trabalhe em torno de certas erratas R10000:

- Seqüências "ll" / "sc" não podem se comportar atomicamente em revisões anteriores a 3.0. Eles podem
impasse nas revisões 2.6 e anteriores.

Esta opção só pode ser usada se a arquitetura de destino suportar ramificação provável
instruções. -mfix-r10000 é o padrão quando -march = r10000 é usado; -mno-fix-r10000
é o padrão caso contrário.

-mfix-vr4120
-mno-fix-vr4120
Contornar certas erratas VR4120:

- "dmultu" nem sempre produz o resultado correto.

- "div" e "ddiv" nem sempre produzem o resultado correto se um dos operandos
é negativo.

As soluções alternativas para a errata de divisão dependem de funções especiais em libgcc.a. Em
presente, essas funções são fornecidas apenas pelas configurações "mips64vr * -elf".

Outras erratas VR4120 requerem que um nop seja inserido entre certos pares de
instruções. Essas erratas são tratadas pelo montador, não pelo próprio GCC.

-mfix-vr4130
Contorne a errata "mflo" / "mfhi" VR4130. As soluções alternativas são implementadas pelo
assembler em vez do GCC, embora o GCC evite usar "mflo" e "mfhi" se o
VR4130 "macc", "macchi", "dmacc" e instruções "dmacchi" estão disponíveis em seu lugar.

-mfix-sb1
-mno-fix-sb1
Contorne certas erratas do núcleo da CPU SB-1. (Este sinalizador atualmente funciona em torno do SB-1
revisão 2 errata de ponto flutuante "F1" e "F2".)

-mr10k-cache-shield =contexto
Especifique se o GCC deve inserir barreiras de cache para evitar os efeitos colaterais de
especulação em processadores R10K.

Em comum com muitos processadores, o R10K tenta prever o resultado de uma
ramificar e especulativamente executa as instruções da ramificação "obtida". Mais tarde
aborta essas instruções se o resultado previsto estiver errado. No entanto, no R10K,
mesmo instruções abortadas podem ter efeitos colaterais.

Esse problema afeta apenas os armazenamentos de kernel e, dependendo do sistema, o kernel carrega.
Como exemplo, um armazenamento executado especulativamente pode carregar a memória de destino no cache
e marcar a linha do cache como suja, mesmo se o armazenamento em si for abortado posteriormente. Se um DMA
operação grava na mesma área da memória antes que a linha "suja" seja liberada, o
os dados armazenados em cache sobrescreverão os dados editados por DMA. Consulte o manual do processador R10K para um
descrição, incluindo outros problemas potenciais.

Uma solução alternativa é inserir instruções de barreira de cache antes de cada acesso à memória que
pode ser executado especulativamente e pode ter efeitos colaterais, mesmo se abortado.
-mr10k-cache-shield =contexto controla a implementação desta solução alternativa pelo GCC. Isto
assume que os acessos abortados a qualquer byte nas seguintes regiões não terão
efeitos:

1. a memória ocupada pelo quadro de pilha da função atual;

2. a memória ocupada por um argumento de pilha de entrada;

3. a memória ocupada por um objeto com um endereço de constante de tempo de link.

É responsabilidade do kernel garantir que acessos especulativos a essas regiões
estão realmente seguros.

Se o programa de entrada contiver uma declaração de função, como:

void foo (vazio);

então a implementação de "foo" deve permitir que "j foo" e "jal foo" sejam executados
especulativamente. O GCC respeita esta restrição para funções que ele próprio compila. Isto
espera que funções não GCC (como código assembly escrito à mão) façam o mesmo.

A opção tem três formas:

-mr10k-cache-shield = load-store
Insira uma barreira de cache antes de um carregamento ou armazenamento que pode ser executado especulativamente
e isso pode ter efeitos colaterais, mesmo se abortado.

-mr10k-cache-shield = store
Insira uma barreira de cache antes de um armazenamento que pode ser executado especulativamente e
que pode ter efeitos colaterais, mesmo se abortado.

-mr10k-cache-shield = none
Desative a inserção de barreiras de cache. Esta é a configuração padrão.

-mflush-func =função
-mno-flush-func
Especifica a função a ser chamada para liberar os caches I e D, ou para não chamar nenhum
função. Se chamada, a função deve ter os mesmos argumentos que o comum
"_flush_func ()", ou seja, o endereço da faixa de memória para a qual o cache está sendo
liberado, o tamanho do intervalo de memória e o número 3 (para liberar ambos os caches). o
o padrão depende do destino para o qual o GCC foi configurado, mas geralmente é
_flush_func or __cpu_flush.

custo mbranch =Números
Defina o custo das filiais para aproximadamente Números instruções "simples". Este custo é apenas um
heurística e não é garantido que produza resultados consistentes em todas as versões. Um zero
custo seleciona de forma redundante o padrão, que se baseia no -mtune criação.

-mbranch-provável
-mno-branch-provável
Habilite ou desabilite o uso de instruções do Branch Provável, independentemente do padrão para o
arquitetura selecionada. Por padrão, as instruções do Branch Provável podem ser geradas se
eles são suportados pela arquitetura selecionada. Uma exceção é para o MIPS32 e
Arquiteturas e processadores MIPS64 que implementam essas arquiteturas; para aqueles,
As instruções de ramificação provável não serão geradas por padrão porque o MIPS32 e
As arquiteturas MIPS64 especificamente descontinuam seu uso.

-mfp-exceções
-mno-fp-exceções
Especifica se as exceções FP estão ativadas. Isso afeta a forma como agendamos FP
instruções para alguns processadores. O padrão é que as exceções FP estejam habilitadas.

Por exemplo, no SB-1, se as exceções FP estão desabilitadas, e estamos emitindo 64 bits
código, então podemos usar os dois tubos FP. Caso contrário, só podemos usar um tubo FP.

-mvr4130-alinhar
-mno-vr4130-align
O pipeline VR4130 é superescalar bidirecional, mas só pode emitir duas instruções
juntos se o primeiro estiver alinhado com 8 bytes. Quando esta opção está habilitada, o GCC irá
alinhe pares de instruções que ele pensa que devem ser executadas em paralelo.

Esta opção só tem efeito na otimização para o VR4130. Normalmente cria código
mais rápido, mas à custa de torná-lo maior. Está habilitado por padrão em
nível de otimização -O3.

-msynci
-mno-sinci
Habilite (desabilite) a geração de instruções "synci" nas arquiteturas que as suportam.
As instruções "synci" (se habilitadas) serão geradas quando
"__builtin ___ clear_cache ()" é compilado.

Esta opção é padronizada como "-mno-synci", mas o padrão pode ser sobrescrito configurando
com "--with-synci".

Ao compilar o código para sistemas de processador único, geralmente é seguro usar "synci".
No entanto, em muitos sistemas multi-core (SMP), isso não invalidará a instrução
caches em todos os núcleos e pode levar a um comportamento indefinido.

-mrelax-pic-chamadas
-mno-relax-pic-chamadas
Tente transformar as chamadas PIC que normalmente são enviadas por meio do registro $ 25 em chamadas diretas.
Isso só é possível se o vinculador puder resolver o destino no momento do link e se
o destino está dentro do alcance de uma chamada direta.

-mrelax-pic-chamadas é o padrão se o GCC foi configurado para usar um assembler e um
vinculador que suporta a diretiva de montagem ".reloc" e "-mexplicit-relocs" está em
efeito. Com "-mno-explicit-relocs", essa otimização pode ser realizada pelo
assembler e o linker sozinho, sem ajuda do compilador.

-mmcount-ra-endereço
-mno-mcount-ra-endereço
Emita (não emita) código que permite que "_mcount" modifique o retorno da função de chamada
Morada. Quando ativada, esta opção estende a interface usual "_mcount" com um novo
ra-endereço parâmetro, que tem tipo "intptr_t *" e é passado no registro $ 12.
"_mcount" pode então modificar o endereço de devolução ao fazer o seguinte:

· Retornando o novo endereço no registro $ 31.

· Armazenando o novo endereço em "*ra-address ", Se ra-endereço não é nulo.

O padrão é -mno-mcount-ra-endereço.

MIX Opções

Essas opções são definidas para o MMIX:

-mlibfuncs
-mno-libfuncs
Especifique que as funções intrínsecas da biblioteca estão sendo compiladas, passando todos os valores em
registra, não importa o tamanho.

-mepsilon
-mno-épsilon
Gere instruções de comparação de ponto flutuante que se comparam com o "rE"
registro epsilon.

-mabi = mmixware
-mabi = gnu
Gerar código que passa parâmetros de função e valores de retorno que (no chamado
função) são vistos como registradores $ 0 e superiores, em oposição ao GNU ABI que usa global
registra $ 231 e acima.

-mzero-estender
-mno-zero-estender
Ao ler dados da memória em tamanhos menores que 64 bits, use (não use) zero-
estendendo instruções de carregamento por padrão, ao invés de extensões de sinal.

-mknuthdiv
-mno-knuthdiv
Faça com que o resultado de uma divisão produzindo um resto tenha o mesmo sinal do divisor.
Com o padrão, -mno-knuthdiv, o sinal do resto segue o sinal do
dividendo. Ambos os métodos são aritmeticamente válidos, sendo o último quase exclusivamente
usava.

-mtoplevel-símbolos
-mno-símbolos de nível superior
Anexar (não anexar) a : a todos os símbolos globais, para que o código de montagem possa ser usado
com a diretiva de montagem "PREFIX".

-me
Gere um executável no formato ELF, em vez do padrão mmo formato usado por
da mmix simulador.

-mbranch-prognosticar
-mno-branch-Pred
Use (não use) as instruções de ramificação provável, quando a previsão de ramificação estática
indica um provável ramo.

-mbase-endereços
-mno-base-address
Gere (não gere) código que usa base endereços. Usando um endereço básico
gera automaticamente uma solicitação (tratada pelo montador e pelo vinculador) para um
constante a ser configurada em um registro global. O registro é usado para uma ou mais bases
solicitações de endereço no intervalo de 0 a 255 do valor mantido no registro. o
geralmente leva a um código curto e rápido, mas o número de itens de dados diferentes que
pode ser endereçado é limitado. Isso significa que um programa que usa muitos dados estáticos
pode exigir -mno-base-address.

-m saída única
-mno-single-saída
Force (não force) o código gerado a ter um único ponto de saída em cada função.

MN10300 Opções

Este -m as opções são definidas para arquiteturas Matsushita MN10300:

-mmult-bug
Gere código para evitar bugs nas instruções de multiplicação para os processadores MN10300.
Este é o padrão.

-mno-mult-bug
Não gere código para evitar bugs nas instruções de multiplicação para o MN10300
processadores.

-mam33
Gere código usando recursos específicos do processador AM33.

-mno-am33
Não gere código usando recursos específicos do processador AM33. Isto é o
padrão.

-mam33-2
Gere código usando recursos específicos do processador AM33 / 2.0.

-mam34
Gere código usando recursos específicos do processador AM34.

-mtune =tipo cpu
Use as características de tempo do tipo de CPU indicado ao programar instruções.
Isso não altera o tipo de processador de destino. O tipo de CPU deve ser um dos
mn10300, am33, am33-2 or am34.

-mreturn-ponteiro-on-d0
Ao gerar uma função que retorna um ponteiro, retorne o ponteiro em "a0" e
"d0". Caso contrário, o ponteiro é retornado apenas em a0, e tenta chamar tal
funções sem um protótipo resultariam em erros. Observe que esta opção é ativada por
predefinição; usar -mno-retorno-ponteiro-em-d0 para desativá-lo.

-mno-crt0
Não vincule o arquivo de objeto de inicialização de tempo de execução C.

-mrelax
Indique ao vinculador que ele deve realizar uma passagem de otimização de relaxamento para
encurte ramos, chamadas e endereços de memória absolutos. Esta opção só tem efeito
quando usado na linha de comando para a etapa final do link.

Esta opção torna a depuração simbólica impossível.

-mliw
Permitir que o compilador gere longo Instrução Word instruções se o alvo for o
AM33 ou mais tarde. Este é o padrão. Esta opção define a macro do pré-processador
__LIW__.

-mnoliw
Não permitir que o compilador gere longo Instrução Word instruções. Esta opção
define a macro do pré-processador __NÃO_LIW__.

-msetlb
Permita que o compilador gere o SETLB e Lcc instruções se o alvo for o
AM33 ou mais tarde. Este é o padrão. Esta opção define a macro do pré-processador
__SETLB__.

-mnosetlb
Não permitir que o compilador gere SETLB or Lcc instruções. Esta opção define
a macro do pré-processador __NO_SETLB__.

PDP-11 Opções

Essas opções são definidas para o PDP-11:

-mfpu
Use ponto flutuante de FPP de hardware. Este é o padrão. (Ponto flutuante FIS no
PDP-11/40 não é compatível.)

-msoft-float
Não use ponto flutuante de hardware.

-mac0
Retorna resultados de ponto flutuante em ac0 (fr0 na sintaxe do montador Unix).

-mno-ac0
Retorna resultados de ponto flutuante na memória. Este é o padrão.

-m40
Gere código para um PDP-11/40.

-m45
Gere o código para um PDP-11/45. Este é o padrão.

-m10
Gere código para um PDP-11/10.

-mbcopy-construído
Use padrões "movmemhi" embutidos para copiar a memória. Este é o padrão.

-mbcopiar
Não use padrões "movmemhi" embutidos para copiar a memória.

-hortelã16
-mno-int32
Use "int" de 16 bits. Este é o padrão.

-hortelã32
-mno-int16
Use "int" de 32 bits.

-mfloat64
-mno-float32
Use "float" de 64 bits. Este é o padrão.

-mfloat32
-mno-float64
Use "float" de 32 bits.

-mabshi
Use o padrão "abshi2". Este é o padrão.

-mno-abshi
Não use o padrão "abshi2".

-mbranch-caro
Finja que as filiais são caras. Isso é para experimentar a geração de código
só.

-mbranch-barato
Não finja que os ramos são caros. Este é o padrão.

-munix-asm
Use a sintaxe do assembler Unix. Este é o padrão quando configurado para pdp11 - * - bsd.

-mdec-asm
Use a sintaxe do assembler DEC. Este é o padrão quando configurado para qualquer alvo PDP-11
exceto pdp11 - * - bsd.

picochip Opções

Este -m as opções são definidas para implementações picoChip:

-mae =tipo_ae
Defina o conjunto de instruções, conjunto de registros e parâmetros de agendamento de instruções para a matriz
tipo de elemento tipo_ae. Valores suportados para tipo_ae e guarante que os mesmos estão QUALQUER, MUL e MAC.

-mae = QUALQUER seleciona um tipo de AE ​​completamente genérico. O código gerado com esta opção irá
executado em qualquer um dos outros tipos de AE. O código não será tão eficiente quanto seria se
compilado para um tipo específico de AE ​​e alguns tipos de operação (por exemplo, multiplicação)
não funcionará corretamente em todos os tipos de AE.

-mae = MUL seleciona um tipo MUL AE. Este é o tipo de AE ​​mais útil para código compilado,
e é o padrão.

-mae = MAC seleciona um MAC AE estilo DSP. O código compilado com esta opção pode sofrer de
baixo desempenho de manipulação de byte (char), uma vez que o DSP AE não fornece
suporte de hardware para carregamento / armazenamento de bytes.

-msímbolo-como-endereço
Habilite o compilador para usar diretamente um nome de símbolo como um endereço em um carregamento / armazenamento
instrução, sem primeiro carregá-la em um registrador. Normalmente, o uso deste
opção irá gerar programas maiores, que rodam mais rápido do que quando a opção não é
usado. No entanto, os resultados variam de programa para programa, por isso é deixado como um usuário
opção, em vez de ser permanentemente ativado.

-mno-ineficiente-avisos
Desativa avisos sobre a geração de código ineficiente. Esses avisos podem ser
gerado, por exemplo, ao compilar o código que executa operações de memória em nível de byte
no tipo MAC AE. O MAC AE não tem suporte de hardware para memória em nível de byte
operações, portanto, todos os carregamentos / armazenamentos de bytes devem ser sintetizados a partir do carregamento / armazenamento de palavras
operações. Isso é ineficiente e um aviso será gerado indicando ao
programador que eles devem reescrever o código para evitar operações de byte, ou para direcionar um
Tipo de AE ​​que possui o suporte de hardware necessário. Esta opção ativa o aviso para
ser desligado.

PowerPC Opções

Estes estão listados em

RL78 Opções

-msim
Links em bibliotecas de destino adicionais para oferecer suporte à operação em um simulador.

-mmul = nenhum
-mmul = g13
-mmul = rl78
Especifica o tipo de suporte de multiplicação de hardware a ser usado. O padrão é
"nenhum", que usa funções de multiplicação de software. A opção "g13" é para o
hardware multiplica / divide periféricos apenas nos alvos RL78 / G13. A opção "rl78"
é para a multiplicação de hardware padrão definida no manual do software RL78.

IBM RS / 6000 e PowerPC Opções

Este -m as opções são definidas para o IBM RS / 6000 e PowerPC:

-power
-mno-poder
-mpower2
-mno-poder2
-mpowerpc
-mno-powerpc
-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mpowerpc64
-mno-powerpc64
-mmfcrf
-mno-mfcrf
-mpopcntb
-mno-popcntb
-mpopctd
-mno-popcntd
-mfprnd
-mno-fprnd
-mcmpb
-mno-cmpb
-mmfpgpr
-mno-mfpgpr
-mhard-dfp
-mno-hard-dfp
O GCC suporta duas arquiteturas de conjunto de instruções relacionadas para RS / 6000 e PowerPC.
A PODER conjunto de instruções são as instruções suportadas pelo rios chipset usado
nos sistemas RS / 6000 originais e os PowerPC conjunto de instruções é a arquitetura de
os microprocessadores Freescale MPC5xx, MPC6xx, MPC8xx e IBM 4xx, 6xx e
microprocessadores de acompanhamento.

Nenhuma das arquiteturas é um subconjunto da outra. No entanto, há um grande subconjunto comum
de instruções suportadas por ambos. Um registro MQ está incluído nos processadores
suportando a arquitetura POWER.

Você usa essas opções para especificar quais instruções estão disponíveis no processador que você
estão usando. O valor padrão dessas opções é determinado durante a configuração do GCC.
Especificando o -mcpu =tipo_cpu substitui a especificação dessas opções. Nós
recomendo que você use o -mcpu =tipo_cpu opção em vez das opções listadas acima.

A -power opção permite que o GCC gere instruções que são encontradas apenas no
Arquitetura POWER e para usar o registro MQ. Especificando -mpower2 implica -poder e
também permite que o GCC gere instruções que estão presentes na arquitetura POWER2
mas não a arquitetura POWER original.

A -mpowerpc opção permite que o GCC gere instruções que são encontradas apenas no
Subconjunto de 32 bits da arquitetura PowerPC. Especificando -mpowerpc-gpopt implica
-mpowerpc e também permite que o GCC use as instruções opcionais da arquitetura PowerPC em
o grupo de finalidade geral, incluindo raiz quadrada de ponto flutuante. Especificando
-mpowerpc-gfxopt implica -mpowerpc e também permite que o GCC use o PowerPC opcional
instruções de arquitetura no grupo Gráficos, incluindo seleção de ponto flutuante.

A -mmfcrf opção permite que o GCC gere a movimentação do campo de registro de condição
instrução implementada no processador POWER4 e outros processadores que suportam o
Arquitetura PowerPC V2.01. o -mpopcntb opção permite que o GCC gere o popcount
e instrução de estimativa recíproca FP de precisão dupla implementada no POWER5
processador e outros processadores que suportam a arquitetura PowerPC V2.02. o
-mpopctd opção permite que o GCC gere a instrução popcount implementada no
Processador POWER7 e outros processadores que suportam a arquitetura PowerPC V2.06.
A -mfprnd opção permite que o GCC gere o ciclo de FP para instruções inteiras
implementado no processador POWER5 + e outros processadores que suportam o PowerPC
Arquitetura V2.03. o -mcmpb opção permite que o GCC gere os bytes de comparação
instrução implementada no processador POWER6 e outros processadores que suportam o
Arquitetura PowerPC V2.05. o -mmfpgpr opção permite que o GCC gere o movimento FP
para / de instruções de registro de uso geral implementadas no processador POWER6X e
outros processadores que suportam a arquitetura PowerPC V2.05 estendida. o -mhard-dfp
opção permite que o GCC gere as instruções de ponto flutuante decimal implementadas em
alguns processadores POWER.

A -mpowerpc64 opção permite que o GCC gere as instruções adicionais de 64 bits que
são encontrados na arquitetura PowerPC64 completa e para tratar GPRs como 64-bit, doubleword
quantidades. O padrão do GCC é -mno-powerpc64.

Se você especificar ambos -mno-poder e -mno-powerpc, O GCC usará apenas as instruções em
o subconjunto comum de ambas as arquiteturas mais algumas chamadas especiais de modo comum do AIX, e
não usará o registro MQ. Especificando ambos -power e -mpowerpc permite que o GCC
usar qualquer instrução de qualquer arquitetura e permitir o uso do registro MQ;
especifique isso para o Motorola MPC601.

-mnew-mnemônicos
-mold-mnemônicos
Selecione quais mnemônicos usar no código assembler gerado. Com -mnew-mnemônicos,
O GCC usa os mnemônicos assembler definidos para a arquitetura PowerPC. Com
-mold-mnemônicos ele usa os mnemônicos assembler definidos para a arquitetura POWER.
As instruções definidas em apenas uma arquitetura têm apenas um mnemônico; GCC usa isso
mnemônico, independentemente de qual dessas opções é especificada.

O padrão do GCC é os mnemônicos apropriados para a arquitetura em uso. Especificando
-mcpu =tipo_cpu às vezes substitui o valor dessas opções. A menos que você esteja construindo
um compilador cruzado, você normalmente não deve especificar -mnew-mnemônicos or
-mold-mnemônicos, mas deve aceitar o padrão.

-mcpu =tipo_cpu
Defina o tipo de arquitetura, registre o uso, escolha de mnemônicos e programação de instruções
parâmetros para tipo de máquina tipo_cpu. Valores suportados para tipo_cpu e guarante que os mesmos estão 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, titã, poder, power2, power3, power4, power5,
power5 +, power6, poder6x, power7, comum, poder pc, powerpc64, rios, rios1, rios2, rsc,
e rs64.

-mcpu = comum seleciona um processador completamente genérico. Código gerado sob esta opção
será executado em qualquer processador POWER ou PowerPC. O GCC usará apenas as instruções no
subconjunto comum de ambas as arquiteturas e não usará o registro MQ. GCC assume um
modelo de processador genérico para fins de programação.

-mcpu = poder, -mcpu = power2, -mcpu = powerpc e -mcpu = powerpc64 especificar POWER genérico,
POWER2, ​​PowerPC puro de 32 bits (ou seja, não MPC601) e arquitetura PowerPC de 64 bits
tipos de máquina, com um modelo de processador genérico apropriado assumido para agendamento
finalidades.

As outras opções especificam um processador específico. Código gerado sob essas opções
funcionará melhor naquele processador e pode não funcionar em outros.

A -mcpu opções ativam ou desativam automaticamente as seguintes opções:

-maltivec -mfprnd -mhard-float -mmfcrf -múltiplos -mnew-mnemônicos -mpopcntb
-mpopctd -power -mpower2 -mpowerpc64 -mpowerpc-gpopt -mpowerpc-gfxopt
-msingle-float -mdouble-float -msimple-fpu -mstring -mmulhw -mdlmzb -mmfpgpr -mvsx

As opções específicas definidas para qualquer CPU em particular variam entre as versões do compilador,
dependendo de qual configuração parece produzir o código ideal para essa CPU; não faz
refletem necessariamente as capacidades reais do hardware. Se você deseja definir um
opção individual para um determinado valor, você pode especificá-lo após o -mcpu opção,
como -mcpu = 970 -mno-altivec.

No AIX, o -maltivec e -mpowerpc64 opções não são habilitadas ou desabilitadas pelo -mcpu
opção no momento porque o AIX não tem suporte completo para essas opções. Você pode
ainda ative ou desative-os individualmente se tiver certeza de que funcionará em seu
ambiente.

-mtune =tipo_cpu
Defina os parâmetros de programação de instrução para o tipo de máquina tipo_cpu, mas não defina
o tipo de arquitetura, registro de uso ou escolha de mnemônicos, como -mcpu =tipo_cpu
seria. Os mesmos valores para tipo_cpu são usados para -mtune quanto a -mcpu. Se ambos são
especificado, o código gerado usará a arquitetura, os registros e o conjunto de mnemônicos
by -mcpu, mas os parâmetros de agendamento definidos por -mtune.

-mcmodel = pequeno
Gere código PowerPC64 para o modelo pequeno: O TOC é limitado a 64k.

-mcmodel = medium
Gere o código PowerPC64 para o modelo médio: O TOC e outros dados estáticos podem estar ativos
para um total de 4G de tamanho.

-mcmodel = grande
Gere código PowerPC64 para o modelo grande: O TOC pode ter até 4G de tamanho. De outros
os dados e o código são limitados apenas pelo espaço de endereço de 64 bits.

-maltivec
-mno-altivec
Gera código que usa (não usa) instruções AltiVec, e também permite o uso
de funções integradas que permitem um acesso mais direto ao conjunto de instruções AltiVec.
Você também pode precisar definir -mabi = altivec para ajustar o ABI atual com AltiVec ABI
aprimoramentos.

-mvrsave
-mno-vrsave
Gere instruções VRSAVE ao gerar o código AltiVec.

-mgen-célula-microcódigo
Gerar instruções de microcódigo celular

-mwarn-cell-microcódigo
Aviso quando uma instrução de microcódigo Cell vai ser emitida. Um exemplo de uma célula
a instrução de microcódigo é um deslocamento variável.

-msecure-plt
Gerar código que permite que ld e ld.so construam executáveis ​​e bibliotecas compartilhadas com
seções não-exec .plt e .got. Esta é uma opção de SYSV ABI PowerPC de 32 bits.

-mbss-plt
Gere código que usa uma seção BSS .plt que ld.so preenche e requer .plt e
.got seções que são graváveis ​​e executáveis. Este é um SYSV PowerPC de 32 bits
Opção ABI.

-misel
-mno-isel
Essa opção ativa ou desativa a geração de instruções ISEL.

-misel =sim não
Esta opção foi descontinuada. Usar -misel e -mno-isel ao invés.

-mspe
-mno-spe
Essa opção ativa ou desativa a geração de instruções SPE simd.

-mparado
-mno-pareado
Esta opção ativa ou desativa a geração de instruções simd PAIRED.

-mspe =sim não
Esta opção está obsoleta. Usar -mspe e -mno-spe ao invés.

-mvsx
-mno-vsx
Gerar código que usa (não usa) instruções vetoriais / escalares (VSX) e também
permitem o uso de funções integradas que permitem um acesso mais direto ao VSX
conjunto de instruções.

-mfloat-gprs =sim / solteiro / duplo / não
-mfloat-gprs
Esta opção ativa ou desativa a geração de operações de ponto flutuante no
registradores de uso geral para arquiteturas que o suportam.

O argumento sim or solteiro permite o uso de ponto flutuante de precisão única
operações.

O argumento duplo permite o uso de ponto flutuante de precisão simples e dupla
operações.

O argumento não desativa operações de ponto flutuante nos registradores de uso geral.

Esta opção está disponível apenas no MPC854x.

-m32
-m64
Gerar código para ambientes de 32 bits ou 64 bits de destinos Darwin e SVR4 (incluindo
GNU / Linux). O ambiente de 32 bits define int, long e pointer para 32 bits e
gera código que é executado em qualquer variante do PowerPC. O ambiente de 64 bits define int para
32 bits e longo e ponteiro para 64 bits, e gera código para PowerPC64, como para
-mpowerpc64.

-mfull-toc
-mno-fp-in-toc
-mno-soma-em-toc
-mínimo-toc
Modifica a geração do TOC (Índice), que é criado para cada
arquivo executável. o -mfull-toc opção é selecionada por padrão. Nesse caso, GCC
irá alocar pelo menos uma entrada TOC para cada referência variável não automática única
em seu programa. O GCC também colocará constantes de ponto flutuante no TOC. Contudo,
apenas 16,384 entradas estão disponíveis no TOC.

Se você receber uma mensagem de erro do linker informando que você ultrapassou o limite disponível
Espaço TOC, você pode reduzir a quantidade de espaço TOC usado com o -mno-fp-in-toc e
-mno-soma-em-toc opções. -mno-fp-in-toc evita que o GCC coloque ponto flutuante
constantes no TOC e -mno-soma-em-toc força o GCC a gerar código para calcular o
soma de um endereço e uma constante em tempo de execução, em vez de colocar essa soma no TOC.
Você pode especificar uma ou ambas as opções. Cada um faz com que o GCC produza muito
código ligeiramente mais lento e maior à custa de conservar o espaço TOC.

Se você ainda ficar sem espaço no TOC, mesmo quando especificar essas duas opções,
especificamos -mínimo-toc em vez de. Esta opção faz com que o GCC faça apenas uma entrada TOC para
cada arquivo. Quando você especifica esta opção, o GCC irá produzir um código que é mais lento e
maior, mas que usa muito pouco espaço TOC. Você pode querer usar esta opção
apenas em arquivos que contêm código executado com menos frequência.

-maix64
-maix32
Ative AIX ABI de 64 bits e convenção de chamada: ponteiros de 64 bits, tipo "longo" de 64 bits e
a infraestrutura necessária para suportá-los. Especificando -maix64 implica -mpowerpc64 e
-mpowerpc, enquanto -maix32 desativa o ABI de 64 bits e implica -mno-powerpc64. CCG
o padrão é -maix32.

-mxl-compatibilidade
-mno-xl-compatível
Produzir código que esteja mais de acordo com a semântica do compilador IBM XL ao usar AIX-
ABI compatível. Passe argumentos de ponto flutuante para funções prototipadas além do
registre a área de salvamento (RSA) na pilha além dos FPRs de argumento. Não presuma
aquele duplo mais significativo no valor duplo longo de 128 bits é devidamente arredondado quando
comparando valores e convertendo para o dobro. Use nomes de símbolo XL para duplo longo
rotinas de suporte.

A convenção de chamada AIX foi estendida, mas não documentada inicialmente para lidar com um
caso obscuro K&R C de chamar uma função que leva o endereço de seus argumentos com
menos argumentos do que o declarado. Os compiladores IBM XL acessam argumentos de ponto flutuante que
não cabem no RSA da pilha quando uma sub-rotina é compilada sem
otimização. Porque sempre armazenar argumentos de ponto flutuante na pilha é
ineficiente e raramente necessária, esta opção não é habilitada por padrão e apenas é
necessário ao chamar sub-rotinas compiladas por compiladores IBM XL sem otimização.

-mpe
Suporte IBM RS / 6000 SP Paralelo Meio Ambiente (EDUCAÇAO FISICA). Vincule um aplicativo escrito para usar
mensagem transmitida com código de inicialização especial para permitir que o aplicativo seja executado. o
sistema deve ter PE instalado no local padrão (/usr/lpp/ppe.poe/), ou o
óculos arquivo deve ser substituído com o -specs = opção para especificar o apropriado
localização do diretório. O Ambiente Paralelo não suporta threads, então o -mpe
opção e -pthread opção são incompatíveis.

-maligno-natural
-poder maligno
No AIX, Darwin de 32 bits e PowerPC GNU / Linux de 64 bits, a opção -maligno-natural
substitui o alinhamento definido por ABI de tipos maiores, como duplos de ponto flutuante,
em seu limite natural baseado em tamanho. A opção -poder maligno instrui o GCC a
siga as regras de alinhamento especificadas pela ABI. O padrão do GCC é o alinhamento padrão
definido na ABI.

No Darwin de 64 bits, o alinhamento natural é o padrão, e -poder maligno não é
suportado.

-msoft-float
-mhard-float
Gere código que não usa (usa) o conjunto de registros de ponto flutuante. Programas
emulação de ponto flutuante é fornecida se você usar o -msoft-float opção, e passar o
opção para GCC ao vincular.

-msingle-float
-mdouble-float
Gere código para operações de ponto flutuante de precisão única ou dupla.
-mdouble-float implica -msingle-float.

-msimple-fpu
Não gere instruções sqrt e div para unidade de ponto flutuante de hardware.

-mfpu
Especifique o tipo de unidade de ponto flutuante. Os valores válidos são sp_lite (equivalente a
-msingle-float -msimple-fpu), dp_lite (equivalente a -mdouble-float -msimple-fpu),
sp_completo (equivalente a -msingle-float), e dp_completo (equivalente a -mdouble-float).

-mxilinx-fpu
Realize otimizações para a unidade de ponto flutuante em Xilinx PPC 405/440.

-múltiplos
-mno-múltiplo
Gerar código que usa (não usa) as instruções de carregamento de várias palavras e o
armazenar instruções com várias palavras. Essas instruções são geradas por padrão em
Sistemas POWER, e não gerados em sistemas PowerPC. Não use -múltiplos em pouco
sistemas PowerPC endian, uma vez que essas instruções não funcionam quando o processador está em
modo little-endian. As exceções são PPC740 e PPC750 que permitem estes
instruções no modo little-endian.

-mstring
-mno-string
Gerar código que usa (não usa) as instruções da string de carregamento e o armazenamento
string word instruções para salvar vários registros e fazer pequenos movimentos de bloco. Esses
as instruções são geradas por padrão em sistemas POWER e não geradas em PowerPC
sistemas. Não use -mstring em sistemas PowerPC little-endian, uma vez que aqueles
as instruções não funcionam quando o processador está no modo little-endian. As exceções
são PPC740 e PPC750 que permitem essas instruções no modo little-endian.

-mupdate
-mno-atualização
Gerar código que usa (não usa) as instruções de carregamento ou armazenamento que atualizam o
registro de base para o endereço da localização de memória calculada. Essas instruções
são gerados por padrão. Se você usar -mno-atualização, há uma pequena janela entre o
hora em que o ponteiro da pilha é atualizado e o endereço do quadro anterior é
armazenado, o que significa que o código que percorre o frame da pilha entre interrupções ou sinais pode
obter dados corrompidos.

-mavoid-indexed-endereços
-mno-Avoid-indexed-endereços
Gerar código que tenta evitar (não evitar) o uso de carga ou armazenamento indexado
instruções. Estas instruções podem incorrer em uma penalidade de desempenho em processadores Power6
em certas situações, como ao percorrer grandes matrizes que cruzam um 16M
fronteira. Esta opção é habilitada por padrão ao direcionar Power6 e desabilitada
de outra forma.

-mfuso-louco
-mno-fundido-madd
Gerar código que usa (não usa) o ponto flutuante, se multiplica e se acumula
instruções. Estas instruções são geradas por padrão se o ponto flutuante do hardware
é usado. O dependente da máquina -mfuso-louco opção agora está mapeada para a máquina-
de treinadores em Entrevista Motivacional -ffp-contract = fast opção, e -mno-fundido-madd está mapeado para
-ffp-contract = off.

-mmulhw
-mno-mulhw
Gerar código que usa (não usa) a meia palavra multiplica e multiplica-acumula
instruções sobre os processadores IBM 405, 440, 464 e 476. Essas instruções são
gerado por padrão ao direcionar esses processadores.

-mdlmzb
-mno-dlmzb
Gerar código que usa (não usa) o string-search dlmzb instrução na IBM
405, 440, 464 e 476 processadores. Esta instrução é gerada por padrão quando
visando esses processadores.

-mno-bit-align
-mbit-align
No System V.4 e nos sistemas PowerPC incorporados não forçam estruturas e uniões
que contêm campos de bits a serem alinhados ao tipo de base do campo de bits.

Por exemplo, por padrão, uma estrutura contendo nada além de 8 campos de bits "sem sinal" de
o comprimento 1 está alinhado a um limite de 4 bytes e tem um tamanho de 4 bytes. Usando
-mno-bit-align, a estrutura é alinhada a um limite de 1 byte e tem 1 byte de tamanho.

-mno-strict-align
-mstrict-align
No System V.4 e nos sistemas PowerPC incorporados, não presuma que a memória não alinhada
as referências serão tratadas pelo sistema.

-mrelocável
-mno-relocável
Gerar código que permite (não permite) que um executável estático seja realocado para um
endereço diferente em tempo de execução. Um carregador de sistema PowerPC embutido simples deve
realocar todo o conteúdo de ".got2" e locais de 4 bytes listados em ".fixup"
seção, uma tabela de endereços de 32 bits gerada por esta opção. Para que isso funcione, todos
objetos ligados entre si devem ser compilados com -mrelocável or -mrelocável-lib.
-mrelocável o código alinha a pilha a um limite de 8 bytes.

-mrelocável-lib
-mno-relocável-lib
Como -mrelocável, -mrelocável-lib gera uma seção ".fixup" para permitir estática
executáveis ​​a serem realocados em tempo de execução, mas -mrelocável-lib não usa o
alinhamento de pilha menor de -mrelocável. Objetos compilados com -mrelocável-lib pode
ser vinculado a objetos compilados com qualquer combinação dos -mrelocável opções.

-mno-toc
-mtoc
No System V.4 e nos sistemas PowerPC incorporados, não presuma que o registro 2 contém
um ponteiro para uma área global apontando para os endereços usados ​​no programa.

-um pouco
-mlittle-endian
No System V.4 e nos sistemas PowerPC incorporados, compilar o código para o processador em pouco
modo endian. o -mlittle-endian opção é a mesma que -um pouco.

-grande
-mbi-endian
No System V.4 e nos sistemas PowerPC embutidos, compilar o código para o processador em grandes
modo endian. o -mbi-endian opção é a mesma que -grande.

-mdynamic-no-pic
Nos sistemas Darwin e Mac OS X, compile o código de forma que não seja realocável, mas que
suas referências externas são realocáveis. O código resultante é adequado para
aplicativos, mas não bibliotecas compartilhadas.

-msingle-pic-base
Trate o registro usado para endereçamento PIC como somente leitura, em vez de carregá-lo no
prólogo para cada função. O sistema de tempo de execução é responsável por inicializar este
registrar com um valor apropriado antes do início da execução.

-mprioritize-restricted-insns =prioridade
Esta opção controla a prioridade que é atribuída ao slot de despacho restrito
instruções durante a segunda passagem de agendamento. O argumento prioridade pega o valor
0/1/2 atribuir não / mais alto / segundo mais alto prioridade para envio de slot restrito
instruções.

-msched-costly-dep =tipo_dependência
Esta opção controla quais dependências são consideradas caras pelo destino durante
programação de instruções. O argumento tipo_dependência pega um dos seguintes
valores: não: nenhuma dependência custa caro, todos os: todas as dependências são caras,
true_store_to_load: uma verdadeira dependência da loja para o carregamento custa caro, armazenar_para_carregar: qualquer
a dependência da loja para o carregamento é cara, número: qualquer dependência para a qual latência> =
número é caro.

-minsert-sched-nops =esquema
Esta opção controla qual esquema de inserção nop será usado durante o segundo
passe de agendamento. O argumento esquema assume um dos seguintes valores: não: Não
inserir nops. caminho: Preencher com nops qualquer grupo de despacho que tenha slots de emissão vagos,
de acordo com o agrupamento do planejador. reagrupar_exato: Insira nops para forçar caro
insns dependentes em grupos separados. Insira exatamente quantos nops forem necessários para forçar
um insn para um novo grupo, de acordo com o agrupamento de processadores estimado. número: Inserir
nops para forçar insns dependentes dispendiosos em grupos separados. Inserir número nops para
forçar um insn para um novo grupo.

-mcall-sysv
No System V.4 e nos sistemas PowerPC incorporados, compilar o código usando convenções de chamada que
adere ao rascunho de março de 1995 da Interface Binária do Aplicativo System V, PowerPC
suplemento do processador. Este é o padrão, a menos que você tenha configurado o GCC usando
powerpc - * - eabiaix.

-mcall-sysv-eabi
-mcall-eabi
Especifique ambos -mcall-sysv e -meabi opções.

-mcall-sysv-noeabi
Especifique ambos -mcall-sysv e -mno-eabi opções.

-mcall-aixdesc
No System V.4 e nos sistemas PowerPC integrados, compile o código para o sistema operacional AIX.

-mcall-linux
No System V.4 e nos sistemas PowerPC incorporados, compilar o código para o GNU baseado em Linux
sistema.

-mcall-freebsd
No System V.4 e sistemas embutidos PowerPC compilar o código para o funcionamento do FreeBSD
sistema.

-mcall-netbsd
No System V.4 e nos sistemas PowerPC embutidos, compilar o código para o funcionamento do NetBSD
sistema.

-mcall-openbsd
No System V.4 e sistemas embutidos PowerPC compilar o código para o funcionamento do OpenBSD
sistema.

-maix-struct-retorno
Retorna todas as estruturas na memória (conforme especificado pelo AIX ABI).

-msvr4-struct-return
Retorna estruturas menores que 8 bytes em registros (conforme especificado pelo SVR4 ABI).

-mabi =tipo abi
Estenda a ABI atual com uma extensão específica ou remova essa extensão. Válido
valores são Altivec, sem altivec, spe, sem especificação, ibmlongdouble, ieelongdouble.

-mabi = spe
Estenda a ABI atual com extensões SPE ABI. Isso não altera o ABI padrão,
em vez disso, adiciona as extensões SPE ABI à ABI atual.

-mabi = no-spe
Desative as extensões Booke SPE ABI para a ABI atual.

-mabi = ibmlongdouble
Altere o ABI atual para usar o duplo longo de precisão estendida da IBM. Este é um PowerPC
Opção SYSV ABI de 32 bits.

-mabi = ieeelongdouble
Altere o ABI atual para usar o duplo longo de precisão estendida IEEE. Este é um PowerPC
Opção Linux ABI de 32 bits.

-mprotótipo
-mno-protótipo
No System V.4 e nos sistemas PowerPC incorporados, presumem que todas as chamadas para o argumento variável
as funções são devidamente prototipadas. Caso contrário, o compilador deve inserir uma instrução
antes de cada chamada não prototipada para definir ou limpar o bit 6 do registro do código de condição
(CR) para indicar se os valores de ponto flutuante foram passados ​​no ponto flutuante
registradores caso a função receba argumentos variáveis. Com -mprotótipo, apenas chamadas
para funções de argumento de variável prototipada definirão ou limparão o bit.

-msim
Em sistemas PowerPC embarcados, suponha que o módulo de inicialização seja chamado sim-crt0.o e
que as bibliotecas C padrão são libsim.a e libc.a. Este é o padrão para
powerpc - * - eabisim configurações.

-mmvme
Em sistemas PowerPC embarcados, suponha que o módulo de inicialização seja chamado crt0.o e os votos de
bibliotecas C padrão são libmvme.a e libc.a.

-loucos
Em sistemas PowerPC embarcados, suponha que o módulo de inicialização seja chamado crt0.o e os votos de
bibliotecas C padrão são libads.a e libc.a.

-faca amarela
Em sistemas PowerPC embarcados, suponha que o módulo de inicialização seja chamado crt0.o e os votos de
bibliotecas C padrão são libyk.a e libc.a.

-mvxworks
Nos sistemas System V.4 e PowerPC incorporados, especifique que você está compilando para um
Sistema VxWorks.

-membro
Em sistemas embutidos PowerPC, defina o PPC_EMB bit no cabeçalho dos sinalizadores ELF para indicar
que ebi deslocalizações estendidas são usadas.

-meabi
-mno-eabi
Em System V.4 e sistemas PowerPC embutidos, (não) aderem ao Embedded
Interface Binária de Aplicativos (eabi), que é um conjunto de modificações no Sistema V.4
especificações. Selecionando -meabi significa que a pilha está alinhada a um bloco de 8 bytes
limite, uma função "__eabi" é chamada de "principal" para configurar o ambiente eabi,
e os votos de -msdados opção pode usar "r2" e "r13" para apontar para dois pequenos dados separados
áreas. Selecionando -mno-eabi significa que a pilha está alinhada a um limite de 16 bytes, faça
não chamar uma função de inicialização de "principal", e o -msdados opção só vai usar
"r13" para apontar para uma única área de dados pequena. o -meabi opção está ativada por padrão se você
configurou o GCC usando um dos powerpc * - * - eabi * opções.

-msdata = eabi
Em sistemas System V.4 e PowerPC incorporados, coloque um pequeno "const" inicializado global e
dados estáticos no .sdata2 seção, que é apontada pelo registro "r2". Colocar pequeno
dados globais e estáticos não "const" inicializados no .sdata seção, que é apontada
para pelo registro "r13". Coloque pequenos dados globais e estáticos não inicializados no .sbss
seção, que é adjacente ao .sdata seção. o -msdata = eabi opção
incompatível com o -mrelocável opção. O -msdata = eabi opção também define o
-membro opção.

-msdata = sysv
No System V.4 e em sistemas PowerPC incorporados, coloque pequenos dados globais e estáticos no
.sdata seção, que é apontada pelo registro "r13". Coloque pequeno global não inicializado
e dados estáticos no .sbss seção, que é adjacente ao .sdata seção. o
-msdata = sysv opção é incompatível com o -mrelocável opção.

-msdata = padrão
-msdados
Em System V.4 e sistemas PowerPC incorporados, se -meabi é usado, compilar o mesmo código
as -msdata = eabi, caso contrário, compile o código da mesma forma que -msdata = sysv.

-msdata = data
Em System V.4 e sistemas PowerPC incorporados, coloque pequenos dados globais no .sdata
seção. Coloque pequenos dados globais não inicializados no .sbss seção. Não use
registre "r13" para endereçar pequenos dados no entanto. Este é o comportamento padrão, a menos que
de outros -msdados opções são usadas.

-msdata = nenhum
-mno-sdata
Em sistemas PowerPC embarcados, coloque todos os dados globais e estáticos inicializados no .dados
seção, e todos os dados não inicializados na .bss seção.

-mblock-move-inline-limit =Números
Inline todas as movimentações de bloco (como chamadas para "memcpy" ou cópias de estrutura) menos que ou
igual a Números bytes. O valor mínimo para Números é de 32 bytes em destinos de 32 bits e 64
bytes em destinos de 64 bits. O valor padrão é específico do destino.

-G Números
Em sistemas PowerPC embarcados, coloque itens globais e estáticos menores ou iguais a Números
bytes em pequenos dados ou seções bss em vez dos dados normais ou seção bss.
Por padrão, o Números é 8. O -G Números switch também é passado para o vinculador. Todos os módulos
deve ser compilado com o mesmo -G Números valor.

-mregnomes
-mno-regnomes
No System V.4 e nos sistemas PowerPC incorporados, (não) emitem nomes de registro no
saída de linguagem assembly usando formas simbólicas.

-mlongcall
-mno-longcall
Por padrão, suponha que todas as chamadas estão distantes para que uma chamada mais longa e mais cara
a sequência é necessária. Isso é necessário para chamadas com mais de 32 megabytes
(33,554,432 bytes) do local atual. Uma curta chamada será gerada se o
o compilador sabe que a chamada não pode estar tão longe. Esta configuração pode ser substituída por
o atributo de função "shortcall" ou por "#pragma longa chamada(0) ".

Alguns linkers são capazes de detectar chamadas fora do intervalo e gerar código de adesão em
o voo. Nesses sistemas, chamadas longas são desnecessárias e geram código mais lento. Como
desta redação, o vinculador AIX pode fazer isso, assim como o vinculador GNU para PowerPC / 64. Isto
está planejado para adicionar esse recurso ao vinculador GNU para sistemas PowerPC de 32 bits também.

Em sistemas Darwin / PPC, "#pragma longcall" gerará "jbsr callee, L42", mais um
"ilha de ramificação" (código de cola). Os dois endereços de destino representam o receptor e o
"ilha ramo". O vinculador Darwin / PPC preferirá o primeiro endereço e gerará um
"bl callee" se a instrução PPC "bl" alcançará o receptor diretamente; caso contrário, o
o vinculador irá gerar "bl L42" para chamar a "ilha de ramificação". A "ilha filial" é
anexado ao corpo da função de chamada; ele calcula o endereço completo de 32 bits de
o receptor e pula para ele.

Em sistemas Mach-O (Darwin), esta opção direciona a emissão do compilador para a cola para
cada chamada direta, e o vinculador Darwin decide se deve usá-la ou descartá-la.

No futuro, podemos fazer com que o GCC ignore todas as especificações longcall quando o vinculador
é conhecido por gerar cola.

-mtls-marcadores
-mno-tls-marcadores
Marque (não marque) chamadas para "__tls_get_addr" com uma realocação especificando a função
argumento. A realocação permite que o ld associe a chamada de função com o argumento
instruções de configuração para otimização TLS, que por sua vez permite ao gcc agendar melhor
a sequência.

-pthread
Adiciona suporte para multithreading com o threads biblioteca. Esta opção define sinalizadores para
o pré-processador e o vinculador.

-mreceita
-mno-receita
Esta opção permitirá que o GCC use a estimativa recíproca e a raiz quadrada recíproca
estimar instruções com etapas adicionais de Newton-Raphson para aumentar a precisão
em vez de dividir ou dividir a raiz quadrada e dividir para argumentos de ponto flutuante. Vocês
deve usar o -rápida matemática opção ao usar -mreceita (ou pelo menos
-funsafe-math-otimizations, -finite-matemática-only, -frecíproca-matemática e
-fno-trapping-matemática) Observe que, embora a taxa de transferência da sequência seja geralmente
maior do que o rendimento da instrução não recíproca, a precisão do
a sequência pode ser diminuída em até 2 ulp (ou seja, o inverso de 1.0 é igual a 0.99999994)
para raízes quadradas recíprocas.

-mrecip =optar
Esta opção permite controlar quais instruções de estimativa recíproca podem ser usadas. optar
é uma lista de opções separada por vírgulas, que pode ser precedida por um "!" para inverter o
opção: "all": habilita todas as instruções de estimativa, "default": habilita o default
instruções, equivalente a -mreceita, "nenhum": desativa todas as instruções de estimativa,
equivalente a -mno-receita; "div": ativa as instruções de aproximação recíproca para
precisão simples e dupla; "divf": ativa o recíproco de precisão simples
instruções de aproximação; "divd": ativa o recíproco de dupla precisão
instruções de aproximação; "rsqrt": permite a aproximação da raiz quadrada recíproca
instruções para precisão simples e dupla; "rsqrtf": habilite o único
instruções de aproximação de raiz quadrada recíproca de precisão; "rsqrtd": habilite o
instruções de aproximação de raiz quadrada recíproca de precisão dupla;

Então, por exemplo, -mrecip = all,! rsqrtd permitiria toda a estimativa recíproca
instruções, exceto para as instruções "FRSQRTE", "XSRSQRTEDP" e "XVRSQRTEDP"
que tratam dos cálculos de raiz quadrada recíproca de precisão dupla.

-mrecip-precisão
-mno-recip-precisão
Suponha (não suponha) que as instruções de estimativa recíproca fornecem
estimativas de precisão do que é exigido pela PowerPC ABI. Selecionando -mcpu = power6 or
-mcpu = power7 seleciona automaticamente -mrecip-precisão. O quadrado de dupla precisão
instruções de estimativa de raiz não são geradas por padrão em máquinas de baixa precisão,
uma vez que não fornecem uma estimativa que converge após três etapas.

-mveclibabi =tipo
Especifica o tipo de ABI a ser usado para vetorizar intrínsecos usando uma biblioteca externa.
O único tipo suportado atualmente é "massa", que especifica o uso de
Bibliotecas Mathematical Acceleration Subsystem (MASS) para vetorizar intrínsecos usando
bibliotecas externas. O GCC atualmente emitirá chamadas para "acosd2", "acosf4", "acoshd2",
"acoshf4", "asind2", "asinf4", "asinhd2", "asinhf4", "atan2d2", "atan2f4", "atand2",
"atanf4", "atanhd2", "atanhf4", "cbrtd2", "cbrtf4", "cosd2", "cosf4", "coshd2",
"coshf4", "erfcd2", "erfcf4", "erfd2", "erff4", "exp2d2", "exp2f4", "expd2", "expf4",
"expm1d2", "expm1f4", "hypotd2", "hypotf4", "lgammad2", "lgammaf4", "log10d2",
"log10f4", "log1pd2", "log1pf4", "log2d2", "log2f4", "logd2", "logf4", "powd2",
"powf4", "sind2", "sinf4", "sinhd2", "sinhf4", "sqrtd2", "sqrtf4", "tand2", "tanf4",
"tanhd2" e "tanhf4" ao gerar o código para power7. Ambos -ftree-vetorize e
-funsafe-math-otimizations tem que ser habilitado. As bibliotecas MASS terão que ser
especificado no momento do link.

-mfriz
-mno-friz
Gere (não gere) a instrução "friz" quando o -funsafe-math-otimizations
opção é usada para otimizar o arredondamento de valores de ponto flutuante para inteiros de 64 bits e
de volta ao ponto flutuante. A instrução "friz" não retorna o mesmo valor se o
o número de ponto flutuante é muito grande para caber em um inteiro.

-mpointers-para-funções aninhadas
-mno-ponteiros-para-funções aninhadas
Gere (não gere) código para carregar o registro da cadeia estática (r11) quando
chamar por meio de um ponteiro em sistemas AIX e Linux de 64 bits onde um ponteiro de função
aponta para um descritor de 3 palavras que fornece o endereço da função, valor TOC a ser carregado em
cadastre-se r2, e o valor da cadeia estática a ser carregado no registro r11. O
-mpointers-para-funções aninhadas está ativado por padrão. Você não será capaz de ligar
ponteiros para funções aninhadas ou ponteiros para funções compiladas em outras linguagens que
use a corrente estática se você usar o -mno-ponteiros-para-funções aninhadas.

-msave-toc-indireto
-mno-save-toc-indireto
Gere (não gere) código para salvar o valor TOC no local reservado da pilha
no prólogo da função se a função chamar por meio de um ponteiro no AIX e 64 bits
Sistemas Linux. Se o valor TOC não for salvo no prólogo, ele será salvo um pouco antes
a chamada por meio do ponteiro. o -mno-save-toc-indireto opção é o padrão.

RX Opções

Essas opções de linha de comando são definidas para destinos RX:

-m64bit-duplos
-m32bit-duplos
Faça com que o tipo de dados "duplo" seja de 64 bits (-m64bit-duplos) ou 32 bits (-m32bit-duplos)
no tamanho. O padrão é -m32bit-duplos. Note Hardware de ponto flutuante RX só funciona
em valores de 32 bits, razão pela qual o padrão é -m32bit-duplos.

-fpu
-nofpu
Possibilita (-fpu) ou desativa (-nofpu) o uso de hardware de ponto flutuante RX. o
o padrão está habilitado para o RX600 série e desativado para o RX200 série.

As instruções de ponto flutuante serão geradas apenas para valores de ponto flutuante de 32 bits
entretanto, se o -m64bit-duplos opção está em uso, então o hardware FPU não será
usado para duplas.

Note Se o -fpu opção é habilitada então -funsafe-math-otimizations também está habilitado
automaticamente. Isso ocorre porque as instruções do RX FPU não são seguras.

-mcpu =nome
Seleciona o tipo de CPU RX a ser direcionado. Atualmente três tipos são suportados, o
genérico RX600 e RX200 hardware da série e o específico RX610 CPU. O padrão é
RX600.

A única diferença entre RX600 e RX610 é que a RX610 não suporta o
Instrução "MVTIPL".

A RX200 série não tem uma unidade de ponto flutuante de hardware e assim -nofpu está ativado
por padrão quando este tipo é selecionado.

-mbi-endian-data
-mlittle-endian-dados
Armazene os dados (mas não o código) no formato big-endian. O padrão é
-mlittle-endian-dados, ou seja, para armazenar dados no formato little-endian.

-msmall-data-limit =N
Especifica o tamanho máximo em bytes de variáveis ​​globais e estáticas que podem ser colocadas
na pequena área de dados. Usar a pequena área de dados pode levar a menores e mais rápidos
código, mas o tamanho da área é limitado e cabe ao programador garantir que
a área não transborda. Além disso, quando a pequena área de dados é usada, um dos RX's
registradores (geralmente "r13") são reservados para uso apontando para esta área, então não é
mais disponível para uso pelo compilador. Isso pode resultar em mais lento e / ou maior
código se as variáveis ​​que antes poderiam ter sido mantidas no registro reservado agora
empurrado para a pilha.

Observe, variáveis ​​comuns (variáveis ​​que não foram inicializadas) e constantes são
não colocados na pequena área de dados, pois são atribuídos a outras seções no
executável de saída.

O valor padrão é zero, o que desativa este recurso. Observe que este recurso não é
habilitado por padrão com níveis de otimização mais altos (-O2 etc) por causa do
efeitos potencialmente prejudiciais da reserva de um registro. Depende do programador
para experimentar e descobrir se esse recurso é benéfico para o programa. Ver
a descrição do -mpid opção para uma descrição de como o registro real para
segure o ponteiro pequeno da área de dados é escolhido.

-msim
-mno-sim
Use o tempo de execução do simulador. O padrão é usar o tempo de execução específico da placa libgloss.

-mas100-sintaxe
-mno-as100-sintaxe
Ao gerar a saída do assembler, use uma sintaxe que seja compatível com AS100 da Renesas
montador. Esta sintaxe também pode ser tratada pelo assembler GAS, mas tem alguns
restrições, portanto, gerá-lo não é a opção padrão.

-mmax-constant-size =N
Especifica o tamanho máximo, em bytes, de uma constante que pode ser usada como operando em
uma instrução RX. Embora o conjunto de instruções RX permita constantes de até 4
bytes de comprimento a serem usados ​​nas instruções, um valor mais longo equivale a um maior
instrução. Assim, em algumas circunstâncias, pode ser benéfico restringir o tamanho de
constantes que são usadas nas instruções. Constantes que são muito grandes são, em vez disso,
colocado em um pool constante e referenciado por via indireta de registro.

O valor que N pode estar entre 0 e 4. Um valor de 0 (o padrão) ou 4 significa que
constantes de qualquer tamanho são permitidas.

-mrelax
Habilite o relaxamento do vinculador. O relaxamento do ligante é um processo pelo qual o ligador irá
tentativa de reduzir o tamanho de um programa, encontrando versões mais curtas de vários
instruções. Desativado por padrão.

-mint-register =N
Especifique o número de registros a serem reservados para funções de manipulador de interrupção rápida. o
valor N pode estar entre 0 e 4. Um valor de 1 significa que o registro "r13" será
reservado para o uso exclusivo de manipuladores de interrupção rápida. Um valor de 2 reservas
"r13" e "r12". Um valor de 3 reservas "r13", "r12" e "r11" e um valor de 4
reserva de "r13" a "r10". Um valor de 0, o padrão, não reserva nenhum
registra.

-msave-acc-in-interrupções
Especifica que as funções do manipulador de interrupção devem preservar o registro do acumulador.
Isso só é necessário se o código normal pode usar o registro do acumulador, por exemplo
porque realiza multiplicações de 64 bits. O padrão é ignorar o acumulador
pois isso torna os manipuladores de interrupção mais rápidos.

-mpid
-mno-pid
Permite a geração de dados independentes de posição. Quando ativado, qualquer acesso a
dados constantes serão feitos por meio de um deslocamento de um endereço de base mantido em um registro. Esse
permite que a localização de dados constantes seja determinada em tempo de execução sem exigir
o executável a ser realocado, o que é um benefício para aplicativos incorporados com
restrições de memória. Os dados que podem ser modificados não são afetados por esta opção.

Observe que o uso deste recurso reserva um registro, geralmente "r13", para os dados constantes
endereço de base. Isso pode resultar em código mais lento e / ou maior, especialmente em códigos complicados
funções.

O registro real escolhido para manter o endereço de base de dados constante depende se
da -msmall-data-limit e / ou o -registro de hortelã opções de linha de comando estão habilitadas.
Começando com o registro "r13" e prosseguindo para baixo, os registros são alocados primeiro
para satisfazer os requisitos de -registro de hortelã, Em seguida -mpid e finalmente
-msmall-data-limit. Assim, é possível que o pequeno registro de área de dados seja "r8"
se ambos -mint-register = 4 e -mpid são especificados na linha de comando.

Por padrão, esse recurso não está habilitado. O padrão pode ser restaurado por meio do -mno-pid
opção de linha de comando.

Nota: A opção de linha de comando genérica do GCC -fixado-reg tem um significado especial para o RX
porta quando usado com o atributo de função "interrupt". Este atributo indica um
função destinada a processar interrupções rápidas. O GCC irá garantir que use apenas o
registra "r10", "r11", "r12" e / ou "r13" e somente desde que o uso normal do
registros correspondentes foram restringidos por meio do -fixado-reg or -registro de hortelã
opções de linha de comando.

S / 390 e Série z Opções

Estes são o -m opções definidas para a arquitetura S / 390 e zSeries.

-mhard-float
-msoft-float
Use (não use) as instruções e registros de ponto flutuante do hardware para
operações pontuais. Quando -msoft-float é especificado, funções em libgcc.a será usado
para realizar operações de ponto flutuante. Quando -mhard-float é especificado, o compilador
gera instruções de ponto flutuante IEEE. Este é o padrão.

-mhard-dfp
-mno-hard-dfp
Use (não use) as instruções de vírgula flutuante decimal do hardware para decimais
operações de ponto flutuante. Quando -mno-hard-dfp é especificado, funções em libgcc.a
será usado para realizar operações de ponto flutuante decimal. Quando -mhard-dfp is
especificado, o compilador gera instruções de hardware de ponto flutuante decimal. Esse
é o padrão para -march = z9-ec ou superior.

-mlong-duplo-64
-mlong-duplo-128
Essas opções controlam o tamanho do tipo "duplo longo". Um tamanho de 64 bits torna o
tipo "long double" equivalente ao tipo "double". Este é o padrão.

-mbackchain
-mno-backchain
Armazene (não armazene) o endereço do frame do chamador como um ponteiro backchain no
frame de pilha do callee. Um backchain pode ser necessário para permitir a depuração usando ferramentas que
não compreendo as informações do quadro de chamada DWARF-2. Quando -mno -pack-stack é em
efeito, o ponteiro do backchain é armazenado na parte inferior do frame da pilha; quando
-empacked-stack está em vigor, o backchain é colocado na palavra superior do
Área de salvamento do registro de 96/160 bytes.

Em geral, o código compilado com -mbackchain é compatível com chamadas com código compilado com
-mmo-backchain; no entanto, o uso do backchain para fins de depuração geralmente requer
que todo binário é construído com -mbackchain. Observe que a combinação de
-mbackchain, -empacked-stack e -mhard-float não é suportado. A fim de construir um
uso do kernel linux -msoft-float.

O padrão é não manter o backchain.

-empacked-stack
-mno -pack-stack
Use (não use) o layout de pilha compactada. Quando -mno -pack-stack é especificado, o
o compilador usa todos os campos da área de salvamento do registro de bytes 96/160 apenas para seus
finalidade padrão; campos não usados ​​ainda ocupam espaço de pilha. Quando -empacked-stack is
especificado, os slots de registro de salvamento são compactados densamente na parte superior do registro de salvamento
área; o espaço não utilizado é reutilizado para outros fins, permitindo um uso mais eficiente de
o espaço de pilha disponível. Porém, quando -mbackchain também está em vigor, o primeiro
palavra da área de salvamento é sempre usada para armazenar o backchain e o endereço de retorno
o registro é sempre salvo duas palavras abaixo do backchain.

Contanto que o backchain do frame da pilha não seja usado, o código gerado com -empacked-stack
é compatível com chamadas com código gerado com -mno -pack-stack. Observe que alguns não-FSF
lançamentos de código gerado GCC 2.95 para S / 390 ou zSeries que usa o frame de pilha
backchain em tempo de execução, não apenas para fins de depuração. Esse código não é chamado
compatível com o código compilado com -empacked-stack. Além disso, observe que a combinação de
-mbackchain, -empacked-stack e -mhard-float não é suportado. A fim de construir um
uso do kernel linux -msoft-float.

O padrão é não usar o layout de pilha compactada.

-msmall-exec
-mno-pequeno-executivo
Gere (ou não gere) código usando a instrução "bras" para fazer a sub-rotina
chamadas. Isso só funciona de forma confiável se o tamanho total do executável não exceder 64k.
O padrão é usar a instrução "basr", que não tem este
limitação.

-m64
-m31
Quando -m31 é especificado, gera código compatível com GNU / Linux para S / 390 ABI. Quando
-m64 for especificado, gera código compatível com GNU / Linux para zSeries ABI. Esse
permite que o GCC, em particular, gere instruções de 64 bits. Para o s390 alvos, o
padrão é -m31, Enquanto que o s390x alvos padrão para -m64.

-mzarch
-mesa
Quando -mzarch for especificado, gere o código usando as instruções disponíveis em
z / Arquitetura. Quando -mesa é especificado, gere o código usando as instruções
disponível em ESA / 390. Observe que -mesa não é possível com -m64. Ao gerar
código compatível com GNU / Linux para S / 390 ABI, o padrão é -mesa. Ao gerar
código compatível com GNU / Linux para zSeries ABI, o padrão é -mzarch.

-mmvcle
-mno-mvcle
Gere (ou não gere) código usando a instrução "mvcle" para realizar o bloco
movimentos. Quando -mno-mvcle for especificado, use um loop "mvc". Este é o padrão
a menos que esteja otimizando para o tamanho.

-mdebug
-mno-depurar
Imprima (ou não imprima) informações adicionais de depuração durante a compilação. O padrão é
para não imprimir informações de depuração.

-march =tipo cpu
Gerar código que será executado em tipo cpu, que é o nome de um sistema que representa um
determinado tipo de processador. Valores possíveis para tipo cpu e guarante que os mesmos estão g5, g6, z900, z990, z9-109,
z9-ec e z10. Ao gerar código usando as instruções disponíveis em
z / Arquitetura, o padrão é -march = z900. Caso contrário, o padrão é -march = g5.

-mtune =tipo cpu
Sintonizar para tipo cpu tudo aplicável sobre o código gerado, exceto para o ABI
e o conjunto de instruções disponíveis. A lista de tipo cpu valores são os mesmos que para
-marchar. O padrão é o valor usado para -marchar.

-mtpf-traço
-mno-tpf-trace
Gerar código que adiciona (não adiciona) em ramificações específicas do SO TPF para rastrear rotinas
no sistema operacional. Esta opção está desativada por padrão, mesmo ao compilar para o
SO TPF.

-mfuso-louco
-mno-fundido-madd
Gerar código que usa (não usa) o ponto flutuante, se multiplica e se acumula
instruções. Estas instruções são geradas por padrão se o ponto flutuante do hardware
é usado.

-mwarn-framesize =tamanho da moldura
Emite um aviso se a função atual exceder o tamanho de quadro fornecido. Porque isso é
uma verificação em tempo de compilação não precisa ser um problema real quando o programa é executado. Isto
destina-se a identificar funções que provavelmente causam um estouro de pilha. Isto é
útil para ser usado em um ambiente com tamanho de pilha limitado, por exemplo, o kernel do Linux.

-mwarn-dynamicstack
Emita um aviso se a função chamar alloca ou usar matrizes de tamanho dinâmico. Isto é
geralmente uma má ideia com um tamanho de pilha limitado.

-mstack-guard =guarda-pilha
-mstack-size =Tamanho da pilha
Se essas opções forem fornecidas, o back end do s390 emite instruções adicionais no
prólogo de função que desencadeia uma armadilha se o tamanho da pilha for guarda-pilha bytes acima
da Tamanho da pilha (lembre-se de que a pilha em s390 cresce para baixo). Se o guarda-pilha
opção é omitida a menor potência de 2 maior que o tamanho do quadro do compilado
função é escolhida. Essas opções devem ser usadas para ajudar na pilha de depuração
problemas de transbordamento. O código adicionalmente emitido causa apenas uma pequena sobrecarga e
portanto, também pode ser usado em sistemas de produção sem maior desempenho
degradação. Os valores dados devem ser potências exatas de 2 e Tamanho da pilha tem que ser
Melhor que guarda-pilha sem exceder 64k. Para ser eficiente, o extra
o código pressupõe que a pilha começa em um endereço alinhado ao valor
dado por Tamanho da pilha. O guarda-pilha opção só pode ser usada em conjunto com
Tamanho da pilha.

Pontuação Opções

Essas opções são definidas para implementações de Pontuação:

-meb
Compile o código para o modo big-endian. Este é o padrão.

-mel
Compile o código para o modo little-endian.

-mnhwloop
Desative gerar instrução bcnz.

-muls
Habilite a geração de carga desalinhada e a instrução de armazenamento.

-mmac
Habilite o uso de instruções de multiplicação-acumulação. Desativado por padrão.

-mscore5
Especifique o SCORE5 como a arquitetura de destino.

-mscore5u
Especifique o SCORE5U da arquitetura de destino.

-mscore7
Especifique o SCORE7 como a arquitetura de destino. Este é o padrão.

-mscore7d
Especifique o SCORE7D como a arquitetura de destino.

SH Opções

Este -m opções são definidas para as implementações SH:

-m1 Gere código para o SH1.

-m2 Gere código para o SH2.

-m2e
Gere código para o SH2e.

-m2a-nofpu
Gere código para o SH2a sem FPU, ou para um SH2a-FPU de tal forma que o
unidade de ponto flutuante não é usada.

-m2a-single-somente
Gere código para o SH2a-FPU, de forma que nenhum ponto flutuante de dupla precisão
operações são usadas.

-m2a-único
Gere código para o SH2a-FPU assumindo que a unidade de ponto flutuante está em precisão simples
modo por padrão.

-m2a
Gere o código para o SH2a-FPU assumindo que a unidade de ponto flutuante está em precisão dupla
modo por padrão.

-m3 Gere código para o SH3.

-m3e
Gere código para o SH3e.

-m4-nofpu
Gere código para o SH4 sem uma unidade de ponto flutuante.

-m4-single-somente
Gere código para o SH4 com uma unidade de ponto flutuante que oferece suporte apenas
aritmética de precisão.

-m4-único
Gere o código para o SH4 assumindo que a unidade de ponto flutuante está no modo de precisão simples
por padrão.

-m4 Gere código para o SH4.

-m4a-nofpu
Gere código para o SH4al-dsp, ou para um SH4a de forma que o ponto flutuante
unidade não é usada.

-m4a-single-somente
Gere código para o SH4a, de forma que nenhum ponto flutuante de dupla precisão
operações são usadas.

-m4a-único
Gere o código para o SH4a assumindo que a unidade de ponto flutuante está em precisão simples
modo por padrão.

-m4a
Gere código para o SH4a.

-m4al
Igual a -m4a-nofpu, exceto que passa implicitamente -dsp para o montador. GCC
não gera nenhuma instrução DSP no momento.

-mb Compile o código para o processador no modo big-endian.

-ml Compile o código para o processador no modo little-endian.

-mdalign
Alinha duplas em limites de 64 bits. Observe que isso muda as convenções de chamada,
e, portanto, algumas funções da biblioteca C padrão não funcionarão a menos que você recompile
primeiro com -mdalign.

-mrelax
Encurte algumas referências de endereço no momento do link, quando possível; usa a opção de vinculador
-relaxar.

-mbigtable
Use offsets de 32 bits nas tabelas "switch". O padrão é usar deslocamentos de 16 bits.

-mbitops
Habilite o uso de instruções de manipulação de bits em SH2A.

-mfmovd
Habilite o uso da instrução "fmovd". Verificar -mdalign para restrições de alinhamento.

-mhitachi
Cumpra as convenções de chamada definidas pela Renesas.

-mrenesas
Cumpra as convenções de chamada definidas pela Renesas.

-mno-renesas
Cumprir com as convenções de chamada definidas para GCC antes das convenções da Renesas
estavam disponíveis. Esta opção é o padrão para todos os destinos do conjunto de ferramentas SH.

-mnomacsave
Marque o registro "MAC" como superado por chamada, mesmo que -mhitachi é dada.

-meee
-mno-ieee
Controlar a conformidade IEEE de comparações de ponto flutuante, o que afeta o manuseio
de casos em que o resultado de uma comparação não está ordenado. Por padrão -meee is
habilitado implicitamente. Se -finite-matemática-apenas está ativado -mno-ieee está implicitamente definido,
o que resulta em comparações mais iguais e menos iguais de ponto flutuante mais rápidas. o
As configurações implícitas podem ser substituídas especificando-se -meee or -mno-ieee.

-minline-ic_invalidate
Código embutido para invalidar as entradas do cache de instrução após configurar a função aninhada
trampolins. Esta opção não tem efeito se -musermode estiver em vigor e o selecionado
a opção de geração de código (por exemplo, -m4) não permite o uso da instrução icbi. Se
a opção de geração de código selecionada não permite o uso da instrução icbi,
e -musermode não estiver em vigor, o código embutido irá manipular a instrução
array de endereços de cache diretamente com uma gravação associativa. Isso não requer apenas
modo privilegiado, mas também falhará se a linha do cache tiver sido mapeada por meio do TLB
e deixou de ser mapeado.

-dimensionar
Descarregue o tamanho e a localização da instrução no código de montagem.

-mpadstruct
Esta opção está obsoleta. Ele preenche estruturas em múltiplos de 4 bytes, que é
incompatível com o SH ABI.

-msoft-atômico
Gerar sequências atômicas de software gUSA compatível com GNU / Linux para o atômico integrado
funções. As sequências atômicas geradas requerem suporte da interrupção /
código de tratamento de exceção do sistema e são adequados apenas para sistemas de núcleo único.
Eles não funcionarão corretamente em sistemas multi-core. Esta opção é habilitada por
padrão quando o destino é "sh - * - linux *". Para obter detalhes sobre o atômico integrado
funções ver __atômico Integrados.

-mespaço
Otimize para espaço em vez de velocidade. Implicado por -Os.

-mprefergot
Ao gerar código independente de posição, emita chamadas de função usando o deslocamento global
Tabela em vez da Tabela de ligação de procedimentos.

-musermode
Não gere código de modo privilegiado apenas; implica -mno-inline-ic_invalidate se o
o código embutido não funcionaria no modo de usuário. Este é o padrão quando o alvo é
"sh - * - linux *".

-multcost =número
Defina o custo a ser assumido para uma multiplicação de insn.

-mdiv =estratégia
Defina a estratégia de divisão a ser usada para operações de divisão de inteiros. Para SHmedia
estratégia pode ser um dos seguintes:

fp Executa a operação em ponto flutuante. Isso tem uma latência muito alta, mas precisa
apenas algumas instruções, por isso pode ser uma boa escolha se o seu código tiver
ILP facilmente explorável para permitir que o compilador agende o ponto flutuante
instruções juntamente com outras instruções. A divisão por zero causa um
exceção de ponto flutuante.

inv Usa operações inteiras para calcular o inverso do divisor e, em seguida,
multiplica o dividendo com o inverso. Esta estratégia permite CSE e içamento
do cálculo inverso. A divisão por zero calcula um resultado não especificado,
mas não armadilha.

inv: minlat
Uma variante de inv onde, se nenhum CSE ou oportunidades de içamento foram encontrados, ou se
toda a operação foi içada para o mesmo local, as últimas etapas do
cálculos inversos são entrelaçados com a multiplicação final para reduzir o total
latência, ao custo de usar mais algumas instruções e, assim, oferecer menos
oportunidades de agendamento com outro código.

chamada
Chama uma função de biblioteca que geralmente implementa o inv: minlat estratégia. Esse
fornece alta densidade de código para compilações "m5- * media-nofpu".

call2
Usa um ponto de entrada diferente da mesma função de biblioteca, onde assume que um
o ponteiro para uma tabela de pesquisa já foi configurado, o que expõe a carga do ponteiro
para CSE e otimizações de içamento de código.

inv: call
inv: call2
inv: fp
Use o inv algoritmo para geração de código inicial, mas se o código permanecer
não otimizado, reverta para o chamada, call2ou fp estratégias, respectivamente. Observe que
o efeito colateral da divisão por zero que pode prender a cabeça é realizado por um
instrução, então é possível que todas as instruções inteiras sejam içadas,
mas o marcador do efeito colateral permanece onde está. Uma recombinação para
operações de ponto flutuante ou uma chamada não são possíveis nesse caso.

inv20u
inv20l
Variantes do inv: minlat estratégia. No caso em que o cálculo inverso é
não separados da multiplicação, eles aceleram a divisão onde o dividendo se encaixa
em 20 bits (sinal de mais quando aplicável), inserindo um teste para pular uma série de
operações neste caso; este teste retarda o caso de dividendos maiores.
inv20u assume que o caso de um dividendo tão pequeno seja improvável, e inv20l
assume que seja provável.

Para destinos diferentes de SHmedia estratégia pode ser um dos seguintes:

chamada-div1
Chama uma função de biblioteca que usa a instrução de divisão de etapa única "div1" para
realizar a operação. A divisão por zero calcula um resultado não especificado e
não armadilha. Este é o padrão, exceto para SH4, SH2A e SHcompact.

chamar-fp
Chama uma função de biblioteca que realiza a operação em flutuação de dupla precisão
apontar. A divisão por zero causa uma exceção de ponto flutuante. Este é o padrão
para SHcompact com FPU. Especificando isso para alvos que não têm um duplo
A FPU de precisão será padronizada como "call-div1".

mesa de chamadas
Chama uma função de biblioteca que usa uma tabela de pesquisa para pequenos divisores e o
Instrução "div1" com distinção de maiúsculas e minúsculas para divisores maiores. Divisão por zero
calcula um resultado não especificado e não intercepta. Este é o padrão para SH4.
Especificar isso para alvos que não têm instruções de mudança dinâmica irá
padrão para "call-div1".

Quando uma estratégia de divisão não for especificada, a estratégia padrão será selecionada
com base na meta atual. Para SH2A, a estratégia padrão é usar os "divs" e
instruções "divu" em vez de chamadas de função de biblioteca.

-maccumulate-args de saída
Reserve espaço uma vez para os argumentos de saída no prólogo da função, em vez de ao redor
cada chamada. Geralmente benéfico para desempenho e tamanho. Também necessário para desenrolar
para evitar alterar o quadro de pilha em torno do código condicional.

-mdivsi3_libfunc =nome
Defina o nome da função de biblioteca usada para divisão assinada de 32 bits para nome. Este
afetam apenas o nome usado nas estratégias de divisão call e inv: call, e o
o compilador ainda irá esperar os mesmos conjuntos de registros de entrada / saída / substituídos como se
esta opção não estava presente.

-mfixed-range =intervalo de registro
Gere o código tratando o intervalo de registro fornecido como registros fixos. Um registro fixo
é aquele que o alocador de registro não pode usar. Istoéútil ao compilar o kernel
código. Um intervalo de registro é especificado como dois registros separados por um traço. Múltiplo
os intervalos de registro podem ser especificados separados por uma vírgula.

-madjust-desenrolar
Acelerar o desenrolamento para evitar a sobrecarga dos registros de destino. Esta opção tem apenas um
efeito se a base de código gcc suportar o gancho de destino TARGET_ADJUST_UNROLL_MAX.

-mindexed-address
Habilite o uso do modo de endereçamento indexado para SHmedia32 / SHcompact. Este é apenas
seguro se o hardware e / ou sistema operacional implementar semântica wrap-around de 32 bits para o indexado
modo de endereçamento. A arquitetura permite a implementação de processadores com 64 bits
MMU, que o sistema operacional poderia usar para obter endereçamento de 32 bits, mas como nenhum hardware atual
implementação suporta esta ou qualquer outra maneira de tornar o modo de endereçamento indexado seguro
para usar na ABI de 32 bits, o padrão é -mno-indexed-address.

-mgettrcost =número
Defina o custo assumido para a instrução gettr como número. O padrão é 2 se
- sintoma corrigido está em vigor, 100 caso contrário.

- sintoma corrigido
Suponha que as instruções pt * não sejam interceptadas. Isso geralmente irá gerar melhor programação
código, mas não é seguro no hardware atual. A definição de arquitetura atual diz
que ptabs e ptrel prendem quando o alvo anded com 3 é 3. Isso tem o
efeito não intencional de tornar inseguro agendar ptabs / ptrel antes de um branch, ou
içá-lo para fora de um laço. Por exemplo, __do_global_ctors, uma parte da libgcc que executa
construtores na inicialização do programa, chama funções em uma lista que é delimitada por -1.
Com a opção -mpt-fixed, os ptabs serão concluídos antes do teste com -1. Este
significa que todos os construtores serão executados um pouco mais rápido, mas quando o loop chegar a
no final da lista, o programa falha porque ptabs carrega -1 em um alvo
registro. Uma vez que esta opção não é segura para qualquer hardware que implemente o atual
especificação de arquitetura, o padrão é -mno-pt-fixed. A menos que o usuário especifique um
custo específico com -mgettrcost, -mno-pt-fixed também implica -mgettrcost = 100; esta
impede a alocação de registradores usando registradores de destino para armazenar inteiros comuns.

-símbolos-minválidos
Suponha que os símbolos podem ser inválidos. Símbolos de funções comuns gerados pelo compilador
sempre será válido para carregar com movi / shori / ptabs ou movi / shori / ptrel, mas com
truques de assembler e / ou linker, é possível gerar símbolos que farão
ptabs / ptrel para interceptar. Esta opção só é significativa quando -mno-pt-fixo é em
efeito. Em seguida, evitará cse cross-basic-block, içamento e a maior parte do agendamento de
símbolo carrega. O padrão é -mno-símbolos inválidos.

-mbranch-cost =Números
Assumir Números para ser o custo de uma instrução de ramificação. Números mais altos farão o
o compilador tenta gerar mais código sem ramificação, se possível. Se não for especificado, o
o valor é selecionado dependendo do tipo de processador para o qual está sendo compilado.

-mcbranchdi
Habilite o padrão de instrução "cbranchdi4".

-mcmpeqdi
Emita o padrão de instrução "cmpeqdi_t" mesmo quando -mcbranchdi está em vigor.

-mfuso-louco
Permitir o uso da instrução "fmac" (ponto flutuante multiplica-acumula) se o
o tipo de processador é compatível. Ativar esta opção pode gerar código que produz
resultados numéricos de ponto flutuante diferentes em comparação com a aritmética IEEE 754 estrita.

-pretend-cmove
Prefira ramificações condicionais de deslocamento zero para instrução de movimento condicional
padrões. Isso pode resultar em um código mais rápido no processador SH4.

Solaris 2 Opções

Este -m opções são suportadas no Solaris 2:

-mimpure-texto
-mimpure-texto, usado além de -compartilhado, diz ao compilador para não passar -z texto para
o vinculador ao vincular um objeto compartilhado. Usando esta opção, você pode vincular a posição-
código dependente em um objeto compartilhado.

-mimpure-texto suprime as "realocações permanecem contra alocáveis, mas não graváveis
seções "mensagem de erro do vinculador. No entanto, as realocações necessárias irão acionar
na gravação, e o objeto compartilhado não é realmente compartilhado entre os processos. Ao invés de
utilização -mimpure-texto, você deve compilar todo o código-fonte com -fpic or -fPIC.

Essas opções são suportadas além das acima no Solaris 2:

-pthreads
Adicione suporte para multithreading usando a biblioteca de threads POSIX. Esta opção define
sinalizadores para o pré-processador e vinculador. Esta opção não afeta o tópico
segurança do código-objeto produzido pelo compilador ou das bibliotecas fornecidas com ele.

-pthread
Este é um sinônimo para -pthreads.

SPARC Opções

Este -m opções são suportadas no SPARC:

-mno-app-regs
-map-regs
Especificar -map-regs para gerar saída usando os registros globais 2 a 4, que
o SPARC SVR4 ABI reserva para aplicações. Como o registro global 1, cada global
o registro 2 a 4 é então tratado como um registro alocável que é superado por
chamadas de função. Este é o padrão.

Para ser totalmente compatível com SVR4 ABI ao custo de alguma perda de desempenho, especifique
-mno-app-regs. Você deve compilar bibliotecas e software de sistema com esta opção.

-mflat
-mno-plano
Com -mflat, o compilador não gera instruções para salvar / restaurar e usa um
modelo de janela "plana" ou de registro único. Este modelo é compatível com o regular
modelo de janela de registro. Os registros locais e os registros de entrada (0--5) ainda estão
tratados como registros de "chamada salva" e serão salvos na pilha conforme necessário.

Com -mno-plano (o padrão), o compilador gera instruções para salvar / restaurar (exceto
para funções de folha). Este é o modo de operação normal.

-mfpu
-mhard-float
Gere saída contendo instruções de ponto flutuante. Este é o padrão.

-mno-fpu
-msoft-float
Gerar saída contendo chamadas de biblioteca para ponto flutuante. Atenção: o requisito
as bibliotecas não estão disponíveis para todos os destinos SPARC. Normalmente as instalações do
o compilador C usual da máquina é usado, mas isso não pode ser feito diretamente em
compilação. Você deve tomar suas próprias providências para fornecer uma biblioteca adequada
funções para compilação cruzada. Os alvos incorporados sparc - * - aout e sparclite - * - *
fornecem suporte de ponto flutuante de software.

-msoft-float altera a convenção de chamada no arquivo de saída; portanto, é apenas
útil se você compilar todos os de um programa com esta opção. Em particular, você precisa
compilar libgcc.a, a biblioteca que vem com o GCC, com -msoft-float em ordem para isso
trabalhar.

-mhard-quad-float
Gerar saída contendo instruções de ponto flutuante de palavra quádrupla (longa dupla).

-msoft-quad-float
Gerar saída contendo chamadas de biblioteca para ponto flutuante de palavra quádrupla (longa dupla)
instruções. As funções chamadas são aquelas especificadas na ABI SPARC. Isto é o
padrão.

No momento em que este documento foi escrito, não havia implementações SPARC com suporte de hardware para
as instruções de ponto flutuante de palavra quádrupla. Todos eles invocam um manipulador de armadilhas para um dos
essas instruções e, em seguida, o manipulador de trap emula o efeito da instrução.
Por causa da sobrecarga do manipulador de trap, isso é muito mais lento do que chamar a biblioteca ABI
rotinas. Assim, o -msoft-quad-float opção é o padrão.

-mno-duplas não alinhadas
-munaligned-duplos
Suponha que os duplos tenham alinhamento de 8 bytes. Este é o padrão.

Com -munaligned-duplos, O GCC assume que os duplos têm alinhamento de 8 bytes apenas se eles
estão contidos em outro tipo, ou se eles têm um endereço absoluto. Caso contrário isto
assume que eles têm alinhamento de 4 bytes. Especificar esta opção evita alguns raros
problemas de compatibilidade com código gerado por outros compiladores. Não é o padrão
porque resulta em perda de desempenho, especialmente para código de ponto flutuante.

-mno-mais rápido-structs
-maior-structs
Com -maior-structs, o compilador assume que as estruturas devem ter 8 bytes
alinhamento. Isso permite o uso de pares de instruções "ldd" e "std" para cópias
na atribuição de estrutura, no lugar de duas vezes mais pares "ld" e "st". No entanto, o
o uso deste alinhamento alterado viola diretamente a ABI SPARC. Assim, é pretendido
apenas para uso em alvos onde o desenvolvedor reconhece que seu código resultante
não estará diretamente de acordo com as regras da ABI.

-mcpu =tipo_cpu
Defina o conjunto de instruções, conjunto de registros e parâmetros de agendamento de instruções para
tipo de máquina tipo_cpu. Valores suportados para tipo_cpu e guarante que os mesmos estão v7, cipreste, v8, superespaço,
hipersparco, leon, esparclito, f930, f934, sparclite86x, espartilho, tsc701, v9,
ultraespaço, ultrasparc3, Niágara, Niágara2, Niágara3 e Niágara4.

Conjuntos de ferramentas nativos Solaris e GNU / Linux também suportam o valor nativo, que seleciona
a melhor opção de arquitetura para o processador host. -mcpu = nativo não tem efeito se
O GCC não reconhece o processador.

Parâmetros de programação de instrução padrão são usados ​​para valores que selecionam um
arquitetura e não uma implementação. Estes são v7, v8, esparclito, espartilho, v9.

Aqui está uma lista de cada arquitetura com suporte e suas implementações com suporte.

cipreste v7

v8 supersparc, hipersparc, leon

esparclito
f930, f934, sparclite86x

espartilho
tsc701

v9 ultrasparc, ultrasparc3, ​​niagara, niagara2, niagara3, niagara4

Por padrão (a menos que configurado de outra forma), o GCC gera código para a variante V7 do
Arquitetura SPARC. Com -mcpu = cipreste, o compilador adicionalmente o otimiza para
o chip Cypress CY7C602, usado na série SPARCStation / SPARCServer 3xx. Isto é
também apropriado para o antigo SPARCStation 1, 2, IPX etc.

Com -mcpu = v8, O GCC gera código para a variante V8 da arquitetura SPARC. o
a única diferença do código V7 é que o compilador emite o número inteiro multiply e
instruções de divisão de inteiros que existem em SPARC-V8, mas não em SPARC-V7. Com
-mcpu = supersparc, o compilador adicionalmente o otimiza para o chip SuperSPARC, como
usado nas séries SPARCStation 10, 1000 e 2000.

Com -mcpu = sparclite, GCC gera código para a variante SPARClite do SPARC
arquitetura. Isso adiciona a multiplicação de inteiros, a etapa de divisão de inteiros e a varredura ("ffs")
instruções que existem no SPARClite, mas não no SPARC-V7. Com -mcpu = f930,
compilador adicionalmente otimiza-o para o chip Fujitsu MB86930, que é o original
SPARClite, sem FPU. Com -mcpu = f934, o compilador adicionalmente o otimiza para
o chip Fujitsu MB86934, que é o SPARClite mais recente com FPU.

Com -mcpu = sparclet, GCC gera código para a variante SPARClet do SPARC
arquitetura. Isso adiciona o inteiro multiplica, multiplica / acumula, divide inteiro
step and scan ("ffs") instruções que existem no SPARClet, mas não no SPARC-V7. Com
-mcpu = tsc701, o compilador adicionalmente o otimiza para o chip TEMIC SPARClet.

Com -mcpu = v9, O GCC gera código para a variante V9 da arquitetura SPARC. Esse
adiciona inteiros de 64 bits e instruções de movimento de ponto flutuante, 3 adicionais de ponto flutuante
registradores de código de condição e instruções de movimentação condicional. Com -mcpu = ultrasparc,
o compilador também o otimiza para os chips Sun UltraSPARC I / II / IIi. Com
-mcpu = ultrasparc3, o compilador adicionalmente o otimiza para o Sun UltraSPARC
Chips III / III + / IIIi / IIIi + / IV / IV +. Com -mcpu = niagara, o compilador adicionalmente
otimiza-o para os chips Sun UltraSPARC T1. Com -mcpu = niagara2, o compilador
além disso, o otimiza para os chips Sun UltraSPARC T2. Com -mcpu = niagara3,
o compilador também o otimiza para os chips Sun UltraSPARC T3. Com -mcpu = niagara4,
o compilador o otimiza adicionalmente para os chips Sun UltraSPARC T4.

-mtune =tipo_cpu
Defina os parâmetros de programação de instrução para o tipo de máquina tipo_cpu, mas não defina
o conjunto de instruções ou conjunto de registros que a opção -mcpu =tipo_cpu seria.

Os mesmos valores para -mcpu =tipo_cpu pode ser usado para -mtune =tipo_cpu, mas o único
os valores úteis são aqueles que selecionam uma determinada implementação de CPU. Esses são
cipreste, superespaço, hipersparco, leon, f930, f934, sparclite86x, tsc701, ultraespaço,
ultrasparc3, Niágara, Niágara2, Niágara3 e Niágara4. Com Solaris nativo e
Conjuntos de ferramentas GNU / Linux, nativo também pode ser usado.

-mv8plus
-mno-v8plus
Com -mv8plus, O GCC gera o código para o SPARC-V8 + ABI. A diferença do V8
ABI é que os registradores globais e externos são considerados de 64 bits de largura. Isso está habilitado
por padrão no Solaris no modo de 32 bits para todos os processadores SPARC-V9.

-mvis
-mno-vis
Com -mvis, O GCC gera código que tira proveito do UltraSPARC Visual
Extensões do conjunto de instruções. O padrão é -mno-vis.

-mvis2
-mno-vis2
Com -mvis2, GCC gera código que tira proveito da versão 2.0 do UltraSPARC
Extensões do conjunto de instruções visuais. O padrão é -mvis2 ao direcionar uma cpu que
suporta tais instruções, como UltraSPARC-III e posterior. Configuração -mvis2 tb
conjuntos -mvis.

-mvis3
-mno-vis3
Com -mvis3, GCC gera código que tira proveito da versão 3.0 do UltraSPARC
Extensões do conjunto de instruções visuais. O padrão é -mvis3 ao direcionar uma cpu que
suporta essas instruções, como niagara-3 e posterior. Configuração -mvis3 também define
-mvis2 e -mvis.

-mpopc
-mno-popc
Com -mpopc, GCC gera código que tira proveito da população UltraSPARC
instrução de contagem. O padrão é -mpopc ao direcionar uma cpu que suporta tal
instruções, como Niagara-2 e posterior.

-mfmaf
-mno-fmaf
Com -mfmaf, GCC gera código que tira vantagem do UltraSPARC Fused Multiply-
Adicione extensões de ponto flutuante. O padrão é -mfmaf ao direcionar uma cpu que
suporta essas instruções, como Niagara-3 e posterior.

-mfix-at697f
Ative a solução alternativa documentada para a única errata do processador Atmel AT697F
(que corresponde à errata nº 13 do processador AT697E).

Este -m opções são suportadas além das acima em processadores SPARC-V9 em 64 bits
ambientes:

-m32
-m64
Gere código para um ambiente de 32 ou 64 bits. O ambiente de 32 bits define int,
longo e ponteiro para 32 bits. O ambiente de 64 bits define int para 32 bits e long e
ponteiro para 64 bits.

-mcmodel =qual
Defina o modelo de código para um dos

Medlow
O modelo de código Médio / Baixo: endereços de 64 bits, os programas devem ser vinculados no 32 baixo
pedaços de memória. Os programas podem ser vinculados estática ou dinamicamente.

médico
O modelo de código Médio / Médio: endereços de 64 bits, os programas devem ser vinculados no baixo
44 bits de memória, os segmentos de texto e dados devem ter menos de 2 GB de tamanho e
o segmento de dados deve estar localizado a 2 GB do segmento de texto.

Medany
O modelo de código Medium / Anywhere: endereços de 64 bits, os programas podem ser vinculados em qualquer lugar
na memória, os segmentos de texto e dados devem ter menos de 2 GB de tamanho e os dados
segmento deve estar localizado a 2 GB do segmento de texto.

embmedany
O modelo de código Medium / Anywhere para sistemas embarcados: endereços de 64 bits, o texto
e os segmentos de dados devem ter menos de 2 GB de tamanho, ambos começando em qualquer lugar na memória
(determinado no momento do link). O registro global% g4 aponta para a base dos dados
segmento. Os programas são vinculados estaticamente e o PIC não é compatível.

-mmemory-model =modelo mem
Defina o modelo de memória em vigor no processador para um dos

omissão
O modelo de memória padrão para o processador e sistema operacional.

rmo Ordem de memória relaxada

pso Pedido parcial da loja

tso Pedido total da loja

sc Consistência Sequencial

Esses modelos de memória são formalmente definidos no Apêndice D da arquitetura Sparc V9
manual, conforme definido no campo "PSTATE.MM" do processador.

-mstack-bias
-mno-stack-viés
Com -mstack-bias, O GCC assume que o ponteiro da pilha e o ponteiro do quadro, se presente,
são deslocados por -2047 que deve ser adicionado de volta ao fazer referências de quadro de pilha. Esse
é o padrão no modo de 64 bits. Caso contrário, suponha que esse deslocamento não esteja presente.

SPU Opções

Este -m opções são suportadas no SPU:

-mwarn-reloc
-merr-reloc
O carregador para SPU não lida com realocações dinâmicas. Por padrão, o GCC dará um
erro ao gerar código que requer uma realocação dinâmica. -mno-erro-reloc
desabilita o erro, -mwarn-reloc irá gerar um aviso em vez disso.

-msafe-dma
-munsafe-dma
As instruções que iniciam ou testam a conclusão do DMA não devem ser solicitadas novamente com
com relação às cargas e armazenamentos da memória que está sendo acessada. Usuários tipicamente
resolver este problema usando a palavra-chave volátil, mas isso pode levar a um código ineficiente
em lugares onde a memória não muda. Em vez de marcar a memória como
volátil, tratamos as instruções DMA como potencialmente afetando toda a memória. Com
-munsafe-dma os usuários devem usar a palavra-chave volatile para proteger os acessos à memória.

-dicas de ramificação
Por padrão, o GCC irá gerar uma instrução de sugestão de ramificação para evitar paralisações de pipeline para
sempre tirou ou provavelmente tirou galhos. Uma dica não será gerada perto de 8
instruções fora de seu ramo. Há poucos motivos para desativá-los, exceto por
para fins de depuração ou para tornar um objeto um pouco menor.

-msmall-mem
-mlarge-mem
Por padrão, o GCC gera código assumindo que os endereços nunca são maiores que 18 bits.
Com -mlarge-mem o código gerado assume um endereço completo de 32 bits.

-mstdmain
Por padrão, o GCC se vincula ao código de inicialização que assume a função principal no estilo SPU
interface (que possui uma lista de parâmetros não convencionais). Com -mstdmain, O GCC irá vincular
seu programa em relação ao código de inicialização que assume uma interface do estilo C99 para "principal",
incluindo uma cópia local das strings "argv".

-mfixed-range =intervalo de registro
Gere o código tratando o intervalo de registro fornecido como registros fixos. Um registro fixo
é aquele que o alocador de registro não pode usar. Istoéútil ao compilar o kernel
código. Um intervalo de registro é especificado como dois registros separados por um traço. Múltiplo
os intervalos de registro podem ser especificados separados por uma vírgula.

-mea32
-mea64
Compile o código presumindo que os ponteiros para o espaço de endereço PPU acessados ​​por meio de "__ea"
o qualificador de espaço de endereço nomeado tem 32 ou 64 bits de largura. O padrão é 32 bits.
Como esta é uma opção de alteração de ABI, todo código-objeto em um executável deve ser compilado
com a mesma configuração.

-maddress-espacial-conversão
-mno-address-space-conversion
Permitir / proibir o tratamento do espaço de endereço "__ea" como superconjunto do endereço genérico
espaço. Isso permite casts de tipo explícito entre "__ea" e ponteiro genérico, bem como
conversões implícitas de ponteiros genéricos para ponteiros "__ea". O padrão é permitir
conversões de ponteiro de espaço de endereço.

-mcache-size =tamanho da memória cache
Esta opção controla a versão do libgcc que o compilador vincula a um executável
e seleciona um cache gerenciado por software para acessar variáveis ​​no endereço "__ea"
espaço com um tamanho de cache específico. Opções possíveis para tamanho da memória cache e guarante que os mesmos estão 8, 16, 32, 64
e 128. O tamanho padrão do cache é 64 KB.

-atualizações-matomic
-mno-atômicas-atualizações
Esta opção controla a versão do libgcc que o compilador vincula a um executável
e seleciona se as atualizações atômicas para o cache gerenciado por software de variáveis ​​do lado PPU
são usados. Se você usar atualizações atômicas, mude para uma variável PPU do código SPU usando
o qualificador de espaço de endereço denominado "__ea" não interferirá nas alterações em outro PPU
variáveis ​​que residem na mesma linha de cache do código PPU. Se você não usa atômico
atualizações, tal interferência pode ocorrer; no entanto, escrever de volta linhas de cache será mais
eficiente. O comportamento padrão é usar atualizações atômicas.

-mdual-nops
-mdual-nops =n
Por padrão, o GCC irá inserir nops para aumentar o problema duplo quando espera que aumente
desempenho. n pode ser um valor de 0 a 10. Um menor n irá inserir menos nops. 10
é o padrão, 0 é o mesmo que -mno-dual-nops. Desativado com -Os.

-mhint-max-nops =n
Número máximo de nops a serem inseridos para uma dica de ramificação. Uma sugestão de ramificação deve ser de pelo menos 8
instruções fora do ramo que está efetuando. GCC irá inserir até n nops para
imponha isso, caso contrário, ele não gerará a dica de ramificação.

-mhint-max-distance =n
A codificação da instrução de sugestão de ramificação limita a sugestão para estar dentro de 256
instruções do ramo que está efetuando. Por padrão, o GCC certifica-se de que está dentro
125.

-msafe-dicas
Contorne um bug de hardware que faz com que o SPU pare indefinidamente. Por padrão, GCC
irá inserir a instrução "hbrp" para se certificar de que este bloqueio não aconteça.

Opções for System V

Essas opções adicionais estão disponíveis no System V Release 4 para compatibilidade com outros
compiladores nesses sistemas:

-G Crie um objeto compartilhado. É recomendado que -simbólico or -compartilhado ser usado em seu lugar.

-Qy Identifique as versões de cada ferramenta utilizada pelo compilador, em um assembler ".ident"
diretiva na saída.

-Qn Evite adicionar diretivas ".ident" ao arquivo de saída (este é o padrão).

-Sim,dirs
Pesquise os diretórios dirs, e nenhum outro, para bibliotecas especificadas com -l.

-Sim,dir
Procure no diretório dir para encontrar o pré-processador M4. O montador usa este
opção.

TELHA-Gx Opções

Este -m opções são suportadas no TILE-Gx:

-mcpu =nome
Seleciona o tipo de CPU a ser almejado. Atualmente, o único tipo suportado é tilex.

-m32
-m64
Gere código para um ambiente de 32 ou 64 bits. O ambiente de 32 bits define int,
longo e o ponteiro para 32 bits. O ambiente de 64 bits define int para 32 bits e long e
ponteiro para 64 bits.

TILEPro Opções

Este -m opções são suportadas no TILEPro:

-mcpu =nome
Seleciona o tipo de CPU a ser almejado. Atualmente, o único tipo suportado é telhapro.

-m32
Gere código para um ambiente de 32 bits, que define int, long e pointer para 32 bits.
Este é o único comportamento com suporte, portanto, o sinalizador é essencialmente ignorado.

V850 Opções

Este -m as opções são definidas para implementações V850:

-muito chamadas
-mno-long-chamadas
Trate todas as chamadas como estando longe (perto). Se as chamadas forem presumidas como distantes, o
o compilador sempre carregará o endereço das funções em um registro e chamará
através do ponteiro.

-mno-ep
-mep
Não otimize (otimize) blocos básicos que usam o mesmo indicador de índice 4 ou mais
vezes para copiar o ponteiro para o registrador "ep" e usar o "sld" e o "sst" mais curtos
instruções. o -mep opção está ativada por padrão se você otimizar.

-mno-prolog-função
-mprolog-função
Não use (use) funções externas para salvar e restaurar registros no prólogo
e epílogo de uma função. As funções externas são mais lentas, mas usam menos código
espaço se mais de uma função salvar o mesmo número de registros. o
-mprolog-função opção está ativada por padrão se você otimizar.

-mespaço
Tente tornar o código o menor possível. No momento, isso apenas liga o -mep
e -mprolog-função opções.

-mtda =n
Coloque variáveis ​​estáticas ou globais cujo tamanho seja n bytes ou menos na pequena área de dados
para o qual o registro "ep" aponta. A pequena área de dados pode conter até 256 bytes no total
(128 bytes para referências de bytes).

-msda =n
Coloque variáveis ​​estáticas ou globais cujo tamanho seja n bytes ou menos na pequena área de dados
para o qual o registro "gp" aponta. A pequena área de dados pode conter até 64 kilobytes.

-mzda =n
Coloque variáveis ​​estáticas ou globais cujo tamanho seja n bytes ou menos nos primeiros 32
kilobytes de memória.

-mv850
Especifique que o processador de destino é o V850.

-big-switch
Gere código adequado para grandes tabelas de comutação. Use esta opção apenas se o
assembler / linker reclama sobre ramificações fora do intervalo dentro de uma mesa de switch.

-map-regs
Esta opção fará com que r2 e r5 sejam usados ​​no código gerado pelo compilador.
Esta configuração é o padrão.

-mno-app-regs
Esta opção fará com que r2 e r5 sejam tratados como registradores fixos.

-mv850e2v3
Especifique que o processador de destino é o V850E2V3. As constantes do pré-processador
__v850e2v3__ será definido se esta opção for usada.

-mv850e2
Especifique que o processador de destino é o V850E2. As constantes do pré-processador
__v850e2__ será definido se esta opção for usada.

-mv850e1
Especifique que o processador de destino é o V850E1. As constantes do pré-processador
__v850e1__ e __v850e__ será definido se esta opção for usada.

-mv850es
Especifique que o processador de destino é o V850ES. Este é um alias para o -mv850e1
opção.

-mv850e
Especifique que o processador de destino é o V850E. A constante do pré-processador __v850e__
será definido se esta opção for usada.

Se nenhum -mv850 nem -mv850e nem -mv850e1 nem -mv850e2 nem -mv850e2v3 são definidos
em seguida, um processador de destino padrão será escolhido e o relevante __v850 * __ pré-processador
constante será definida.

As constantes do pré-processador __v850 e __v851__ são sempre definidos, independentemente de qual
a variante do processador é o alvo.

-mdisable-call
Esta opção irá suprimir a geração da instrução CALLT para o v850e, v850e1,
Tipos v850e2 e v850e2v3 da arquitetura v850. O padrão é
-mno-disable-call que permite que a instrução CALLT seja usada.

VAX Opções

Este -m as opções são definidas para o VAX:

-munix
Não envie certas instruções de salto ("aobleq" e assim por diante) que o montador Unix
pois o VAX não pode lidar com longas distâncias.

-mgnu
Faça a saída dessas instruções de salto, supondo que você montará com o
montador GNU.

-mg Código de saída para números de ponto flutuante de formato G em vez de formato D.

VxWorks Opções

As opções nesta seção são definidas para todos os destinos VxWorks. Opções específicas para o
o hardware de destino é listado com as outras opções para aquele destino.

-mrtp
O GCC pode gerar código para kernels VxWorks e processos em tempo real (RTPs). Esse
opção muda do primeiro para o último. Ele também define a macro do pré-processador
"__RTP__".

-não estático
Vincule um executável RTP a bibliotecas compartilhadas em vez de bibliotecas estáticas. o
opções -estático e -compartilhado também pode ser usado para RTPs; -estático é o padrão.

-Bestático
-Bdinâmico
Essas opções são passadas para o vinculador. Eles são definidos para compatibilidade com
Diab.

-Xbind-preguiçoso
Habilite a vinculação lenta de chamadas de função. Esta opção é equivalente a -Wl, -z, agora e é
definido para compatibilidade com Diab.

-Xbind-agora
Desative a vinculação lenta de chamadas de função. Esta opção é o padrão e é definida para
compatibilidade com Diab.

x86-64 Opções

Estes estão listados em

Xstormy16 Opções

Essas opções são definidas para Xstormy16:

-msim
Escolha os arquivos de inicialização e o script do vinculador adequados para o simulador.

Xtensa Opções

Estas opções são suportadas para destinos Xtensa:

-mconst16
-mno-const16
Habilite ou desabilite o uso das instruções "CONST16" para carregar valores constantes. o
A instrução "CONST16" atualmente não é uma opção padrão da Tensilica. Quando
habilitado, as instruções "CONST16" são sempre usadas no lugar do "L32R" padrão
instruções. O uso de "CONST16" é habilitado por padrão apenas se o "L32R"
instrução não está disponível.

-mfuso-louco
-mno-fundido-madd
Ative ou desative o uso das instruções fundidas de multiplicação / adição e multiplicação / subtração nas
opção de ponto flutuante. Isso não tem efeito se a opção de ponto flutuante também não for
ativado. Desativar as instruções fundidas de multiplicação / adição e multiplicação / subtração força o
compilador para usar instruções separadas para as operações de multiplicação e adição / subtração.
Isso pode ser desejável em alguns casos onde resultados estritos em conformidade com IEEE 754 são
necessário: as instruções fundidas, multiplicar, adicionar / subtrair não arredondam o intermediário
resultado, produzindo resultados com mais bits de precisão do que o especificado pelo
Padrão IEEE. Desativar as instruções de adição / subtração de multiplicação fundida também garante que
a saída do programa não é sensível à capacidade do compilador de combinar multiplicação e
adicionar / subtrair operações.

-mserializar-volátil
-mno-serialize-volátil
Quando esta opção é habilitada, o GCC insere instruções "MEMW" antes da memória "volátil"
referências para garantir a consistência sequencial. O padrão é -mserializar-volátil.
Use -mno-serialize-volátil para omitir as instruções "MEMW".

-mforce-no-pic
Para destinos, como GNU / Linux, onde todo o código Xtensa em modo de usuário deve ser posicionado-
código independente (PIC), esta opção desativa o PIC para compilar o código do kernel.

-mtext-section-literais
-mno-text-section-liters
Controle o tratamento de pools literais. O padrão é -mno-text-section-liters,
que coloca literais em uma seção separada no arquivo de saída. Isso permite que o
pool literal a ser colocado em uma RAM / ROM de dados, e também permite que o linker combine
pools literais de arquivos de objetos separados para remover literais redundantes e melhorar o código
Tamanho. Com -mtext-section-literais, os literais são intercalados na seção de texto
a fim de mantê-los o mais próximo possível de suas referências. Isso pode ser necessário
para grandes arquivos de montagem.

-mtarget-alinhar
-mno-target-align
Quando esta opção está habilitada, o GCC instrui o montador a alinhar automaticamente
instruções para reduzir as penalidades de ramificação às custas de alguma densidade de código. o
assembler tenta alargar as instruções de densidade para alinhar alvos de ramificação e o
instruções seguindo as instruções da chamada. Se não houver seguro precedente suficiente
instruções de densidade para alinhar um alvo, nenhum alargamento será executado. O padrão é
-mtarget-alinhar. Essas opções não afetam o tratamento de alinhamento automático
instruções como "LOOP", que o montador sempre alinhará, seja alargando
instruções de densidade ou inserindo instruções autônomas.

-mlongcalls
-mno-longcalls
Quando esta opção está habilitada, o GCC instrui o montador a traduzir as chamadas diretas para
chamadas indiretas, a menos que possa determinar que o alvo de uma chamada direta está no
intervalo permitido pela instrução de chamada. Esta tradução normalmente ocorre para chamadas para
funções em outros arquivos de origem. Especificamente, o montador traduz um direto
Instrução "CALL" em um "L32R" seguida por uma instrução "CALLX". O padrão é
-mno-longcalls. Esta opção deve ser usada em programas onde o alvo da chamada pode
potencialmente fora do alcance. Esta opção é implementada no assembler, não no
compilador, então o código assembly gerado pelo GCC ainda mostrará a chamada direta
instruções --- veja o código do objeto desmontado para ver as instruções reais.
Observe que o montador usará uma chamada indireta para cada chamada de arquivo cruzado, não apenas
aqueles que realmente estarão fora de alcance.

Série z Opções

Estes estão listados em

Opções for Code Generation Convenções
Essas opções independentes de máquina controlam as convenções de interface usadas no código
geração.

A maioria deles tem formas positivas e negativas; a forma negativa de -foo seria
-fno-foo. Na tabela abaixo, apenas um dos formulários está listado --- aquele que não é o
predefinição. Você pode descobrir a outra forma removendo no- ou adicionando.

-fbounds-verificar
Para front ends que o suportam, gere código adicional para verificar se os índices costumavam
as matrizes de acesso estão dentro do intervalo declarado. Atualmente, isso só é suportado pelo
Front ends Java e Fortran, em que esta opção é padronizada como true e false
respectivamente.

-ftrapv
Esta opção gera armadilhas para estouro assinado na adição, subtração,
operações de multiplicação.

-fwrapv
Esta opção instrui o compilador a assumir que estouro aritmético assinado de
adição, subtração e multiplicação envolvem o uso de complemento de dois
representação. Este sinalizador ativa algumas otimizações e desativa outras. Esse
opção é habilitada por padrão para o front end Java, conforme exigido pela linguagem Java
especificação.

-fexceções
Ative o tratamento de exceções. Gera código extra necessário para propagar exceções. Para
alguns alvos, isso implica que o GCC irá gerar informações de desenrolamento de quadros para todos
funções, que podem produzir sobrecarga de tamanho de dados significativa, embora não
afetar a execução. Se você não especificar esta opção, o GCC irá habilitá-la por padrão
para linguagens como C ++, que normalmente requerem tratamento de exceção, e desabilite-o para
linguagens como C, que normalmente não exigem isso. No entanto, pode ser necessário habilitar
esta opção ao compilar o código C que precisa interoperar adequadamente com exceção
manipuladores escritos em C ++. Você também pode desabilitar esta opção se estiver
compilar programas C ++ mais antigos que não usam tratamento de exceção.

-fnon-call-exceções
Gere código que permite instruções de trap para lançar exceções. Observe que este
requer suporte de tempo de execução específico da plataforma que não existe em todos os lugares. Além disso,
só permite prendendo instruções para lançar exceções, ou seja, referências de memória ou
instruções de ponto flutuante. Ele não permite que exceções sejam lançadas de
manipuladores de sinal, como "SIGALRM".

-funwind-mesas
Semelhante a -fexceções, exceto que irá apenas gerar quaisquer dados estáticos necessários, mas
não afetará o código gerado de nenhuma outra forma. Você normalmente não habilitará
esta opção; em vez disso, um processador de linguagem que precisa desse tratamento o habilitaria em
seu nome.

-fasynchronous -wind-tables
Gere a tabela de desenrolamento no formato anão2, se compatível com a máquina de destino. A mesa é
exato em cada limite de instrução, por isso pode ser usado para o desenrolar da pilha de
eventos assíncronos (como depurador ou coletor de lixo).

-fpcc-struct-return
Retorna valores "curtos" de "estrutura" e "união" na memória como os mais longos, em vez de em
registra. Essa convenção é menos eficiente, mas tem a vantagem de permitir
intercalabilidade entre arquivos compilados pelo GCC e arquivos compilados com outros compiladores,
particularmente o Compilador C portátil (pcc).

A convenção precisa para retornar estruturas na memória depende do destino
macros de configuração.

Estruturas curtas e uniões são aquelas cujo tamanho e alinhamento correspondem aos de alguns
tipo inteiro.

Atenção: código compilado com o -fpcc-struct-return switch não é binário compatível
com código compilado com o -freg-struct-return trocar. Use-o para estar em conformidade com uma
interface binária do aplicativo padrão.

-freg-struct-return
Retorne os valores "struct" e "union" nos registradores quando possível. Isso é mais eficiente
para estruturas pequenas do que -fpcc-struct-return.

Se você não especificar nenhum -fpcc-struct-return nem -freg-struct-return, O padrão do GCC é
qualquer convenção é padrão para o alvo. Se não houver convenção padrão,
O padrão do GCC é -fpcc-struct-return, exceto em alvos onde GCC é o principal
compilador. Nesses casos, podemos escolher o padrão e escolhemos o mais eficiente
registrar a alternativa de retorno.

Atenção: código compilado com o -freg-struct-return switch não é binário compatível
com código compilado com o -fpcc-struct-return trocar. Use-o para estar em conformidade com uma
interface binária do aplicativo padrão.

-fshort-enums
Aloque para um tipo "enum" apenas os bytes necessários para o intervalo declarado de
valores possíveis. Especificamente, o tipo "enum" será equivalente ao menor
tipo inteiro que tem espaço suficiente.

Atenção: da -fshort-enums switch faz com que o GCC gere um código que não é binário
compatível com o código gerado sem esse switch. Use-o para estar em conformidade com uma
interface binária do aplicativo padrão.

-fcurto-duplo
Use o mesmo tamanho para "double" e "float".

Atenção: da -fcurto-duplo switch faz com que o GCC gere um código que não é binário
compatível com o código gerado sem esse switch. Use-o para estar em conformidade com uma
interface binária do aplicativo padrão.

-fshort-wchar
Substitua o tipo subjacente para wchar_t ser baixo não assinado int ao invés de
padrão para o destino. Esta opção é útil para construir programas para rodar sob
VINHO.

Atenção: da -fshort-wchar switch faz com que o GCC gere um código que não é binário
compatível com o código gerado sem esse switch. Use-o para estar em conformidade com uma
interface binária do aplicativo padrão.

-fno-comum
No código C, controla a colocação de variáveis ​​globais não inicializadas. Compiladores Unix C
têm tradicionalmente permitido múltiplas definições de tais variáveis ​​em diferentes
unidades de compilação, colocando as variáveis ​​em um bloco comum. Este é o comportamento
especificado por -fcomume é o padrão para GCC na maioria dos destinos. Por outro lado,
este comportamento não é exigido pelo ISO C, e em alguns alvos pode ter uma velocidade ou código
penalidade de tamanho em referências variáveis. o -fno-comum opção especifica que o
o compilador deve colocar variáveis ​​globais não inicializadas na seção de dados do objeto
arquivo, em vez de gerá-los como blocos comuns. Isso tem o efeito de que se o
mesma variável é declarada (sem "extern") em duas compilações diferentes, você
obterá um erro de definição múltipla ao vinculá-los. Neste caso, você deve compilar
com -fcomum em vez de. Compilando com -fno-comum é útil em alvos para os quais
fornece melhor desempenho, ou se você deseja verificar se o programa funcionará em
outros sistemas que sempre tratam as declarações de variáveis ​​não inicializadas desta forma.

-fno-ident
Ignore o #ident Directiva.

-finhibit-size-Directive
Não produza uma diretiva assembler ".size" ou qualquer outra coisa que possa causar problemas
se a função é dividida no meio, e as duas metades são colocadas em locais distantes
separados na memória. Esta opção é usada ao compilar crtstuff.c; você não deveria precisar
para usá-lo para qualquer outra coisa.

-fverbose-asm
Coloque informações de comentários extras no código de montagem gerado para torná-lo mais
legível. Esta opção é geralmente útil apenas para aqueles que realmente precisam ler o
código de montagem gerado (talvez durante a depuração do próprio compilador).

-fno-verbose-asm, o padrão, faz com que as informações extras sejam omitidas e sejam
útil ao comparar dois arquivos assembler.

-frecord-gcc-switches
Esta opção faz com que a linha de comando usada para invocar o compilador seja
gravado no arquivo-objeto que está sendo criado. Esta mudança só é implementada
em alguns alvos e o formato exato da gravação é o alvo e o formato de arquivo binário
dependente, mas geralmente assume a forma de uma seção contendo texto ASCII. Esse
interruptor está relacionado ao -fverbose-asm switch, mas esse switch apenas grava
informações no arquivo de saída do assembler como comentários, para que nunca cheguem ao objeto
Arquivo. Veja também -grecord-gcc-switches para outra maneira de armazenar opções do compilador em
o arquivo objeto.

-fpic
Gerar código independente de posição (PIC) adequado para uso em uma biblioteca compartilhada, se
suportado para a máquina de destino. Esse código acessa todos os endereços constantes por meio de um
tabela de deslocamento global (GOT). O carregador dinâmico resolve as entradas GOT quando o
o programa é iniciado (o carregador dinâmico não faz parte do GCC; faz parte do funcionamento
sistema). Se o tamanho do GOT para o executável vinculado exceder um máximo específico da máquina
tamanho, você recebe uma mensagem de erro do vinculador indicando que -fpic não funciona; no
nesse caso, recompile com -fPIC em vez de. (Esses máximos são 8k no SPARC e 32k
no m68k e RS / 6000. O 386 não tem esse limite.)

O código independente de posição requer suporte especial e, portanto, funciona apenas em
certas máquinas. Para o 386, o GCC suporta PIC para System V, mas não para o Sun
386i. O código gerado para o IBM RS / 6000 é sempre independente da posição.

Quando este sinalizador é definido, as macros "__pic__" e "__PIC__" são definidas como 1.

-fPIC
Se compatível com a máquina alvo, emite código independente de posição, adequado para
vinculação dinâmica e evitando qualquer limite no tamanho da tabela de deslocamento global. Esse
opção faz a diferença no m68k, PowerPC e SPARC.

O código independente de posição requer suporte especial e, portanto, funciona apenas em
certas máquinas.

Quando este sinalizador é definido, as macros "__pic__" e "__PIC__" são definidas como 2.

-fpie
-fPIE
Essas opções são semelhantes a -fpic e -fPIC, mas gerou código independente de posição
só pode ser vinculado a executáveis. Normalmente, essas opções são usadas quando -torta GCC
opção será usada durante a vinculação.

-fpie e -fPIE ambos definem as macros "__pie__" e "__PIE__". As macros têm o
valor 1 para -fpie E 2 para -fPIE.

-fno-jump-tables
Não use tabelas de salto para instruções switch, mesmo onde seria mais eficiente
do que outras estratégias de geração de código. Esta opção é usada em conjunto com
-fpic or -fPIC para construir o código que faz parte de um vinculador dinâmico e não pode
referencie o endereço de uma tabela de salto. Em alguns alvos, as tabelas de salto não requerem um
GOT e esta opção não é necessária.

-fixado-reg
Trate o registro nomeado reg como um registro fixo; código gerado nunca deve se referir a
(exceto talvez como um ponteiro de pilha, ponteiro de quadro ou em alguma outra função fixa).

reg deve ser o nome de um registro. Os nomes de registro aceitos são específicos da máquina
e são definidos na macro "REGISTER_NAMES" no arquivo de macro de descrição da máquina.

Este sinalizador não tem uma forma negativa, porque especifica uma escolha de três vias.

-fcall-usado-reg
Trate o registro nomeado reg como um registro alocável que é superado pela função
chamadas. Pode ser alocado para temporários ou variáveis ​​que não vivem em um
ligar. As funções compiladas desta forma não irão salvar e restaurar o registro reg.

É um erro usar este sinalizador com o ponteiro do quadro ou o ponteiro da pilha. Uso deste
sinalizar para outros registradores que fixaram funções abrangentes na execução da máquina
modelo produzirá resultados desastrosos.

Este sinalizador não tem uma forma negativa, porque especifica uma escolha de três vias.

-fcall-salvo-reg
Trate o registro nomeado reg como um registro alocável salvo por funções. Pode ser
alocado mesmo para temporários ou variáveis ​​que vivem através de uma chamada. Funções
compilado desta forma irá salvar e restaurar o registro reg se eles usam.

É um erro usar este sinalizador com o ponteiro do quadro ou o ponteiro da pilha. Uso deste
sinalizar para outros registradores que fixaram funções abrangentes na execução da máquina
modelo produzirá resultados desastrosos.

Um tipo diferente de desastre resultará do uso desta bandeira para um registro em
quais valores de função podem ser retornados.

Este sinalizador não tem uma forma negativa, porque especifica uma escolha de três vias.

-fpack-struct [=n]
Sem um valor especificado, empacote todos os membros da estrutura sem orifícios. Quando um
valor é especificado (que deve ser uma pequena potência de dois), membros da estrutura do pacote
de acordo com este valor, representando o alinhamento máximo (ou seja, objetos com
requisitos de alinhamento padrão maiores do que isso serão produzidos potencialmente desalinhados
no próximo local de ajuste.

Atenção: da -fpack-estrutura switch faz com que o GCC gere um código que não é binário
compatível com o código gerado sem esse switch. Além disso, torna o código
subótimo. Use-o para se adequar a uma interface binária de aplicativo não padrão.

-funções de instrumentos
Gere chamadas de instrumentação para entrada e saída de funções. Logo após a função
entrada e antes de sair da função, as seguintes funções de perfil serão chamadas
com o endereço da função atual e seu site de chamada. (Em algumas plataformas,
"__builtin_return_address" não funciona além da função atual, então o site de chamada
as informações podem não estar disponíveis para as funções de criação de perfil de outra forma.)

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

O primeiro argumento é o endereço do início da função atual, que pode ser
olhou exatamente na tabela de símbolos.

Essa instrumentação também é feita para funções expandidas em linha em outras funções.
As chamadas de criação de perfil indicarão onde, conceitualmente, a função inline é inserida
e saiu. Isso significa que versões endereçáveis ​​de tais funções devem estar disponíveis.
Se todos os seus usos de uma função forem expandidos embutidos, isso pode significar um adicional
expansão do tamanho do código. Se você usar externo em linha em seu código C, um endereçável
versão de tais funções deve ser fornecida. (Este é normalmente o caso de qualquer maneira, mas
se você tiver sorte e o otimizador sempre expandir as funções embutidas, você pode ter
escapou sem fornecer cópias estáticas.)

Uma função pode receber o atributo "no_instrument_function", caso em que este
a instrumentação não será feita. Isso pode ser usado, por exemplo, para o perfil
funções listadas acima, rotinas de interrupção de alta prioridade e quaisquer funções das quais
as funções de criação de perfil não podem ser chamadas com segurança (talvez manipuladores de sinal, se o
as rotinas de criação de perfil geram saída ou alocam memória).

-finstrument-functions-exclude-file-list =lima,lima, ...
Defina a lista de funções que são excluídas da instrumentação (ver a descrição
de "funções -finstrument"). Se o arquivo que contém uma definição de função corresponder
com um de lima, então essa função não é instrumentada. A partida acabou em
substrings: se o lima parâmetro é uma substring do nome do arquivo, é considerado
ser uma partida.

Por exemplo:

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

irá excluir qualquer função embutida definida em arquivos cujos nomes de caminho contenham "/ bits / stl"
ou "incluir / sys".

Se, por algum motivo, você quiser incluir a letra ',' em um dos sym, escrever ','. Para
exemplo, "-finstrument-functions-exclude-file-list = ',, tmp'" (observe a aspa simples
em torno da opção).

-finstrument-functions-exclude-function-list =sym,sym, ...
Isso é semelhante a "-finstrument-functions-exclude-file-list", mas esta opção define
a lista de nomes de funções a serem excluídos da instrumentação. O nome da função para
ser correspondido é seu nome visível ao usuário, como "vetor blah (vetor const &) ",
não o nome interno mutilado (por exemplo, "_Z4blahRSt6vectorIiSaIiEE"). A partida acabou
em substrings: se o sym parâmetro é uma substring do nome da função, é
considerado uma correspondência. Para identificadores estendidos C99 e C ++, o nome da função
deve ser fornecido em UTF-8, não usando nomes de caracteres universais.

-fstack-verificar
Gere código para verificar se você não vai além do limite da pilha. Vocês
deve especificar este sinalizador se você estiver executando em um ambiente com vários threads,
mas raramente é necessário especificá-lo em um ambiente de thread único, pois a pilha
o estouro é detectado automaticamente em quase todos os sistemas se houver apenas uma pilha.

Observe que essa opção não faz com que a verificação seja feita; o funcionamento
sistema ou o tempo de execução da linguagem deve fazer isso. A mudança faz com que a geração de código para
certifique-se de que eles vejam a pilha sendo estendida.

Além disso, você pode especificar um parâmetro de string: "no" significa sem verificação, "genérico"
significa forçar o uso da verificação do estilo antigo, "específico" significa usar a melhor verificação
método e é equivalente a nua -fstack-verificar.

A verificação de estilo antigo é um mecanismo genérico que não requer suporte de destino específico em
o compilador, mas vem com as seguintes desvantagens:

1. Estratégia de alocação modificada para objetos grandes: eles sempre serão alocados
dinamicamente se seu tamanho exceder um limite fixo.

2. Limite fixo no tamanho do quadro estático de funções: quando é encimado por um
função específica, a verificação de pilha não é confiável e um aviso é emitido pelo
compilador

3. Ineficiência: por causa da estratégia de alocação modificada e do genérico
implementação, o desempenho do código é prejudicado.

Observe que a verificação de pilha no estilo antigo também é o método substituto para "específico" se não
suporte de destino foi adicionado no compilador.

-fstack-limit-register =reg
-fstack-limit-symbol =sym
-fno-limite de pilha
Gere código para garantir que a pilha não cresça além de um certo valor, também
o valor de um registro ou o endereço de um símbolo. Se a pilha crescesse além
o valor, um sinal é gerado. Para a maioria dos alvos, o sinal é gerado antes do
pilha ultrapassa o limite, então é possível pegar o sinal sem tomar
precauções especiais.

Por exemplo, se a pilha começa no endereço absoluto 0x80000000 e cresce para baixo,
você pode usar as bandeiras -fstack-limit-symbol = __ stack_limit e
-Wl, - defsym, __ stack_limit = 0x7ffe0000 para impor um limite de pilha de 128 KB. Observe que
isso pode funcionar apenas com o vinculador GNU.

-fsplit-stack
Gere código para dividir automaticamente a pilha antes que ela transborde. O resultado
programa tem uma pilha descontígua que só pode estourar se o programa for incapaz de
alocar mais memória. Isso é mais útil ao executar programas encadeados, pois
não é mais necessário calcular um bom tamanho de pilha a ser usado para cada segmento. Isto é
atualmente implementado apenas para os back-ends i386 e x86_64 executando GNU / Linux.

Quando o código é compilado com -fsplit-stack chama o código compilado sem -fsplit-stack, Há
pode não haver muito espaço de pilha disponível para a execução do último código. Se compilar tudo
código, incluindo código de biblioteca, com -fsplit-stack não é uma opção, então o vinculador pode
consertar essas chamadas para que o código compilado sem -fsplit-stack sempre tem um grande
pilha. O suporte para isso é implementado no linker ouro na versão GNU binutils
2.21 e mais tarde.

-fluindo-sublinhado
Esta opção e sua contraparte, -fno-leader-underscore, mudar à força a maneira C
os símbolos são representados no arquivo de objeto. Um uso é para ajudar a conectar com o legado
código de montagem.

Atenção: da -fluindo-sublinhado switch faz com que o GCC gere um código que não é
binário compatível com o código gerado sem essa opção. Use-o para se conformar a um
interface binária de aplicativo não padrão. Nem todos os alvos fornecem suporte completo
para este switch.

-ftls-model =modelo
Altere o modelo de armazenamento local de encadeamento a ser usado. o modelo argumento deve ser um de
"global-dynamic", "local-dynamic", "initial-exec" ou "local-exec".

O padrão sem -fpic é "initial-exec"; com -fpic o padrão é
"global-dinâmico".

-fvisibility =padrão | interno | oculto | protegido
Defina a visibilidade do símbolo de imagem ELF padrão para a opção especificada --- todos os símbolos
ser marcado com isso, a menos que seja substituído no código. Usar este recurso pode muito
melhorar substancialmente os tempos de vinculação e carregamento de bibliotecas de objetos compartilhados, produzir mais
código otimizado, fornece exportação de API quase perfeita e evita conflitos de símbolos. Isto é
discordaram recomendado que você use isso em quaisquer objetos compartilhados que você distribuir.

Apesar da nomenclatura, "padrão" sempre significa público; ou seja, disponível para ser vinculado
contra de fora do objeto compartilhado. "protegido" e "interno" são bastante inúteis
no uso do mundo real, então a única outra opção comumente usada será "oculta". o
padrão se -fvisibilidade não especificado é "padrão", ou seja, tornar todos os símbolos
público --- isso causa o mesmo comportamento das versões anteriores do GCC.

Uma boa explicação dos benefícios oferecidos, garantindo que os símbolos ELF tenham os
a visibilidade é dada por "How To Write Shared Libraries" de Ulrich Drepper (que pode ser
Encontrado emhttp://people.redhat.com/~drepper/>) --- no entanto, uma solução superior feita
possível com esta opção de marcar coisas ocultas quando o padrão é público é fazer
o oculto padrão e marcar coisas públicas. Esta é a norma com DLLs no Windows e
com -fvisibility = oculto e "__attribute__ ((visibilidade (" padrão ")))" em vez de
"__declspec (dllexport)" você obtém semântica quase idêntica com sintaxe idêntica.
Esta é uma grande vantagem para aqueles que trabalham com projetos de plataforma cruzada.

Para aqueles que adicionam suporte de visibilidade ao código existente, você pode encontrar #pragma GCC
visibilidade de uso. Isso funciona quando você inclui as declarações que deseja definir
visibilidade para com (por exemplo) #pragma GCC visibilidade push (oculto) e #pragma GCC
visibilidade estouro. Tenha em mente que a visibilidade do símbolo deve ser vista as parte of da
API interface contract e, portanto, todo código novo deve sempre especificar a visibilidade quando
não é o padrão; ou seja, as declarações apenas para uso no DSO local devem sempre
ser marcado explicitamente como oculto para evitar sobrecargas de indireção PLT --- tornando isso
abundantemente claro também ajuda na legibilidade e autodocumentação do código. Observe que
devido aos requisitos de especificação ISO C ++, operador novo e exclusão de operador devem
sempre ter visibilidade padrão.

Esteja ciente de que os cabeçalhos de fora do seu projeto, em particular os cabeçalhos do sistema e
cabeçalhos de qualquer outra biblioteca que você usa, pode não esperar ser compilado com
visibilidade diferente do padrão. Você pode precisar dizer explicitamente #pragma GCC
visibilidade push (padrão) antes de incluir qualquer um desses cabeçalhos.

externo declarações não são afetadas por -fvisibilidade, então muito código pode ser
recompilado com -fvisibility = oculto sem modificações. No entanto, isso significa que
chama para externo funções sem visibilidade explícita usarão o PLT, então é mais
eficaz de usar __atributo ((visibilidade)) e / ou #pragma GCC visibilidade para dizer o
compilador que externo as declarações devem ser tratadas como ocultas.

Observe que -fvisibilidade afeta as entidades de ligação vagas do C ++. Isso significa que, para
instância, uma classe de exceção que será lançada entre os DSOs deve ser explicitamente
marcado com visibilidade padrão para que o tipo_info nós serão unificados entre os
DSOs.

Uma visão geral dessas técnicas, seus benefícios e como usá-las está em
<http://gcc.gnu.org/wiki/Visibility>.

-fstrict-voláteis-bitfields
Esta opção deve ser usada se o acesso a campos de bits voláteis (ou outra estrutura
campos, embora o compilador geralmente aceite esses tipos de qualquer maneira) deve usar um único
acesso da largura do tipo do campo, alinhado a um alinhamento natural se possível.
Por exemplo, alvos com registros periféricos mapeados em memória podem exigir todos esses
os acessos devem ter 16 bits de largura; com este sinalizador, o usuário pode declarar todos os bits periféricos
campos como "curto sem sinal" (assumindo que o curto é de 16 bits nesses alvos) para forçar o GCC
para usar acessos de 16 bits em vez de, talvez, um acesso de 32 bits mais eficiente.

Se esta opção estiver desabilitada, o compilador usará a instrução mais eficiente. No
o exemplo anterior, que pode ser uma instrução de carregamento de 32 bits, embora isso vá
bytes de acesso que não contêm nenhuma parte do campo de bits, ou mapeado na memória
registros não relacionados ao que está sendo atualizado.

Se o alvo exigir alinhamento estrito, e honrar o tipo de campo exigiria
violando este alinhamento, um aviso é emitido. Se o campo tiver o atributo "empacotado",
o acesso é feito sem respeitar o tipo de campo. Se o campo não tiver
atributo "empacotado", o acesso é feito respeitando o tipo de campo. Em ambos os casos, GCC
assume que o usuário sabe algo sobre o hardware de destino que não conhece.

O valor padrão desta opção é determinado pela interface binária do aplicativo para
o processador de destino.

MEIO AMBIENTE

Esta seção descreve várias variáveis ​​de ambiente que afetam como o GCC opera. Algum
deles funcionam especificando diretórios ou prefixos para usar ao pesquisar por vários tipos
de arquivos. Alguns são usados ​​para especificar outros aspectos do ambiente de compilação.

Observe que você também pode especificar lugares para pesquisar usando opções como -B, -I e -L.
Eles têm precedência sobre os lugares especificados usando variáveis ​​de ambiente, que por sua vez
têm precedência sobre aqueles especificados pela configuração do GCC.

GRANDE
LC_CTYPE
LC_MESSAGES
LC_ALL
Essas variáveis ​​de ambiente controlam a maneira como o GCC usa as informações de localização
o que permite que o GCC trabalhe com diferentes convenções nacionais. GCC inspeciona o local
Categorias LC_CTYPE e LC_MESSAGES se tiver sido configurado para isso. Estas localidades
categorias podem ser definidas para qualquer valor suportado por sua instalação. Um valor típico é
en_GB.UTF-8 para inglês no Reino Unido codificado em UTF-8.

A LC_CTYPE a variável de ambiente especifica a classificação de caracteres. GCC usa para
determinar os limites dos caracteres em uma string; isso é necessário para alguns multibyte
codificações que contêm aspas e caracteres de escape que, de outra forma, seriam interpretados
como um final de string ou escape.

A LC_MESSAGES variável de ambiente especifica a linguagem a ser usada no diagnóstico
mensagens.

Se o LC_ALL variável de ambiente é definida, substitui o valor de LC_CTYPE e
LC_MESSAGES; por outro lado, LC_CTYPE e LC_MESSAGES padrão para o valor de GRANDE
variável de ambiente. Se nenhuma dessas variáveis ​​for definida, o padrão do GCC é o tradicional
Comportamento do inglês C.

TMPDIR
If TMPDIR é definido, ele especifica o diretório a ser usado para arquivos temporários. GCC usa
arquivos temporários para manter a saída de um estágio de compilação que deve ser usado como
entrada para o próximo estágio: por exemplo, a saída do pré-processador, que é o
entrada para o compilador adequado.

GCC_COMPARE_DEBUG
Configuração GCC_COMPARE_DEBUG é quase equivalente a passar -fcompare-depurar ao
driver do compilador. Veja a documentação desta opção para mais detalhes.

GCC_EXEC_PREFIX
If GCC_EXEC_PREFIX é definido, ele especifica um prefixo para usar nos nomes dos
subprogramas executados pelo compilador. Nenhuma barra é adicionada quando este prefixo é combinado
com o nome de um subprograma, mas você pode especificar um prefixo que termina com uma barra se
você deseja.

If GCC_EXEC_PREFIX não estiver definido, o GCC tentará descobrir um prefixo apropriado para
use com base no nome do caminho com o qual foi invocado.

Se o GCC não conseguir encontrar o subprograma usando o prefixo especificado, ele tenta procurar no
locais usuais para o subprograma.

O valor padrão de GCC_EXEC_PREFIX is prefixo / lib / gcc / onde prefixo é o prefixo para
o compilador instalado. Em muitos casos prefixo é o valor de "prefix" quando você executou o
configurar script.

Outros prefixos especificados com -B têm precedência sobre este prefixo.

Este prefixo também é usado para encontrar arquivos como crt0.o que são usados ​​para vinculação.

Além disso, o prefixo é usado de forma incomum para encontrar os diretórios para pesquisar
para arquivos de cabeçalho. Para cada um dos diretórios padrão cujo nome normalmente começa
com / usr / local / lib / gcc (mais precisamente, com o valor de GCC_INCLUDE_DIR), GCC tenta
substituindo aquele começo com o prefixo especificado para produzir um diretório alternativo
nome. Assim, com -Bfoo /, O GCC irá pesquisar foo / bar onde normalmente procuraria
/ usr / local / lib / bar. Esses diretórios alternativos são pesquisados ​​primeiro; o padrão
os diretórios vêm em seguida. Se um diretório padrão começa com o configurado prefixo então
o valor de prefixo é substituído por GCC_EXEC_PREFIX ao procurar arquivos de cabeçalho.

COMPILER_PATH
O valor de COMPILER_PATH é uma lista de diretórios separados por dois pontos, bem como PATH.
O GCC tenta os diretórios assim especificados ao pesquisar por subprogramas, se não puder
encontre os subprogramas usando GCC_EXEC_PREFIX.

LIBRARY_PATH
O valor de LIBRARY_PATH é uma lista de diretórios separados por dois pontos, bem como PATH.
Quando configurado como um compilador nativo, o GCC tenta os diretórios assim especificados quando
procurando por arquivos de linker especiais, se não puder localizá-los usando GCC_EXEC_PREFIX.
A vinculação usando o GCC também usa esses diretórios ao pesquisar bibliotecas comuns
para o -l opção (mas os diretórios especificados com -L vem primeiro).

GRANDE
Esta variável é usada para passar informações de localidade para o compilador. Uma maneira pela qual
esta informação é usada para determinar o conjunto de caracteres a ser usado quando o personagem
literais, literais de string e comentários são analisados ​​em C e C ++. Quando o compilador é
configurado para permitir caracteres multibyte, os seguintes valores para GRANDE e guarante que os mesmos estão
reconhecido:

C-JIS
Reconhecer personagens JIS.

C-SJIS
Reconhecer personagens SJIS.

C-EUCJP
Reconhecer caracteres EUCJP.

If GRANDE não está definido, ou se tiver algum outro valor, o compilador usará
mblen e mbtowc conforme definido pelo local padrão para reconhecer e traduzir multibyte
caracteres.

Algumas variáveis ​​de ambiente adicionais afetam o comportamento do pré-processador.

CPATH
C_INCLUDE_PATH
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
O valor de cada variável é uma lista de diretórios separados por um caractere especial, muito
como PATH, no qual procurar arquivos de cabeçalho. O personagem especial,
"PATH_SEPARATOR" é dependente do destino e determinado no momento da construção do GCC. Para Microsoft
Alvos baseados no Windows é um ponto e vírgula, e para quase todos os outros alvos é um
cólon.

CPATH especifica uma lista de diretórios a serem pesquisados ​​como se especificados com -I, mas
depois de quaisquer caminhos dados com -I opções na linha de comando. Esta variável de ambiente
é usado independentemente de qual idioma está sendo pré-processado.

As variáveis ​​de ambiente restantes se aplicam apenas ao pré-processamento do
idioma indicado. Cada um especifica uma lista de diretórios a serem pesquisados ​​como se
especificado com -isistema, mas depois de quaisquer caminhos fornecidos com -isistema opções no
linha de comando.

Em todas essas variáveis, um elemento vazio instrui o compilador a pesquisar seu atual
diretório de trabalho. Elementos vazios podem aparecer no início ou no final de um caminho. Para
instância, se o valor de CPATH é ": / especial / incluir", que tem o mesmo efeito que
-EU. -Eu / especial / inclui.

DEPENDENCES_OUTPUT
Se esta variável for definida, seu valor especifica como as dependências de saída para Make com base
nos arquivos de cabeçalho não pertencentes ao sistema processados ​​pelo compilador. Arquivos de cabeçalho do sistema são
ignorado na saída de dependência.

O valor de DEPENDENCES_OUTPUT pode ser apenas um nome de arquivo, caso em que as regras Make
são gravados nesse arquivo, adivinhando o nome de destino a partir do nome do arquivo de origem. Ou o
o valor pode ter a forma lima alvo, caso em que as regras são gravadas em arquivo lima
utilização alvo como o nome do alvo.

Em outras palavras, esta variável de ambiente é equivalente a combinar as opções -MILÍMETROS
e -MF, com um opcional -MT mudar também.

SUNPRO_DEPENDENCIES
Esta variável é a mesma que DEPENDENCES_OUTPUT (veja acima), exceto aquele sistema
arquivos de cabeçalho não são ignorados, o que implica -M em vez de -MILÍMETROS. No entanto, o
a dependência do arquivo de entrada principal é omitida.

Use arm-linux-gnueabi-gcc-4.7 online usando serviços onworks.net