Sinalizadores úteis do GCC para C

Além da configuração -Walle da configuração -std=XXX, que outros sinalizadores de compilador realmente úteis, mas menos conhecidos, existem para uso em C?

Estou particularmente interessado em avisos adicionais e / ou em transformar avisos em erros em alguns casos para minimizar absolutamente qualquer incompatibilidade acidental de tipo.

Várias -fopções de geração de código são interessantes:

• A -ftrapvfunção fará com que o programa seja interrompido por excesso de número inteiro assinado (formalmente "comportamento indefinido" em C).

• -fverbose-asmé útil se você estiver compilando -Spara examinar a saída do assembly - ele adiciona alguns comentários informativos.

• -finstrument-functions adiciona código para chamar funções de criação de perfil fornecidas pelo usuário em cada ponto de entrada e saída de função.

Aqui estão os meus:

• -Wextra, -Wall: essencial.
• -Wfloat-equal: útil, porque geralmente testar números de ponto flutuante quanto à igualdade é ruim.
• -Wundef: avisa se um identificador não inicializado é avaliado em uma #ifdiretiva.
• -Wshadow: avisa sempre que uma variável local sombreia outra variável local, parâmetro ou variável global ou sempre que uma função interna é sombreada.
• -Wpointer-arith: avisa se alguma coisa depende do tamanho de uma função ou de void.
• -Wcast-align: avisa sempre que um ponteiro é convertido, de modo que o alinhamento necessário do alvo seja aumentado. Por exemplo, avise se a char *é convertido em uma int *máquina em que números inteiros só podem ser acessados ​​em limites de dois ou quatro bytes.
• -Wstrict-prototypes: avisa se uma função é declarada ou definida sem especificar os tipos de argumento.
• -Wstrict-overflow=5: avisa sobre casos em que o compilador otimiza com base na suposição de que o estouro assinado não ocorre. (O valor 5 pode ser muito rigoroso, consulte a página do manual.)
• -Wwrite-strings: dê às constantes da string o const char[comprimento do tipo ]para que a cópia do endereço de uma para um não const char *ponteiro receba um aviso.
• -Waggregate-return: avisa se alguma função que retorna estruturas ou uniões é definida ou chamada.
• -Wcast-qual: avisa sempre que um ponteiro é convertido para remover um qualificador de tipo do tipo de destino ^* .
• -Wswitch-default: avisa sempre que uma switchinstrução não tem um defaultcaso ^* .
• -Wswitch-enum: avisa sempre que uma switchinstrução possui um índice do tipo enumerado e não possui um casepara um ou mais dos códigos nomeados dessa enumeração ^* .
• -Wconversion: avise sobre conversões implícitas que podem alterar um valor ^* .
• -Wunreachable-code: avisa se o compilador detectar que o código nunca será executado ^* .

Os marcados com ^* às vezes dão muitos avisos falsos, então eu os uso conforme a necessidade.

Sempre usar -Oou acima ( -O1, -O2, -Os, etc.). No nível de otimização padrão, o gcc busca a velocidade de compilação e não faz análises suficientes para avisar sobre coisas como variáveis ​​unitizadas.

Considere fazer -Werrorpolítica, pois os avisos que não param a compilação tendem a ser ignorados.

-Wall praticamente ativa os avisos que provavelmente são erros.

Os avisos incluídos -Wextratendem a sinalizar códigos comuns e legítimos. Eles podem ser úteis para revisões de código (embora os programas no estilo fiapo achem muito mais armadilhas são mais flexíveis), mas eu não os ativaria para o desenvolvimento normal.

-Wfloat-equal é uma boa idéia se os desenvolvedores do projeto não estiverem familiarizados com o ponto flutuante e uma má idéia se estiverem.

-Winit-selfé útil; Eu me pergunto por que não está incluído -Wuninitialized.

-Wpointer-arithé útil se você tiver um código principalmente portátil que não funcione -pedantic.

-save-temps

Isso deixa para trás os resultados do pré-processador e da montagem.

A fonte pré-processada é útil para depurar macros.

A montagem é útil para determinar quais otimizações entraram em vigor. Por exemplo, convém verificar se o GCC está otimizando a chamada de cauda em algumas funções recursivas, pois sem ela você pode potencialmente sobrecarregar a pilha.

Estou surpreso que ninguém tenha dito isso ainda - o sinalizador mais útil para mim é -gque coloca as informações de depuração no executável, para que você possa depurá-las e percorrer a fonte (a menos que seja proficiente e esteja lendo a montagem e como o stepicomando) de um programa enquanto estiver em execução.

-fmudflap - adiciona verificações de tempo de execução a todas as operações arriscadas do ponteiro para capturar o UB. Isso efetivamente imuniza seu programa novamente, estouros de buffer e ajuda a capturar todos os tipos de ponteiros pendentes.

• http://gcc.gnu.org/wiki/Mudflap_Pointer_Debugging

Aqui está uma demonstração:

$ cat mf.c 
int main()
{
 int a[10];
 a[10]=1; // <-- o noes, line 4
}

$ gcc -fmudflap mf.c -lmudflap
$ ./a.out 
*******
mudflap violation 1 (check/write): time=1280862302.170759 ptr=0x7fff96eb3d00 size=44
pc=0x7f3a575503c1 location=`mf.c:4:2 (main)'
      /usr/lib/libmudflap.so.0(__mf_check+0x41) [0x7f3a575503c1]
      ./a.out(main+0x90) [0x400a54]
      /lib/libc.so.6(__libc_start_main+0xfd) [0x7f3a571e2c4d]
Nearby object 1: checked region begins 0B into and ends 4B after
mudflap object 0xf9c560: name=`mf.c:3:6 (main) a'
bounds=[0x7fff96eb3d00,0x7fff96eb3d27] size=40 area=stack check=0r/3w liveness=3
alloc time=1280862302.170749 pc=0x7f3a57550cb1
number of nearby objects: 1

Não é realmente relacionado ao C / C ++, mas é útil de qualquer maneira:

@file

Coloque todos os sinalizadores válidos acima (todos que você especificou) em um 'arquivo' e use este sinalizador acima para usar todos os sinalizadores nesse arquivo juntos.

por exemplo:

Arquivo: compilerFlags

-Parede

-std = c99

-Wextra

Em seguida, compile:

gcc yourSourceFile @compilerFlags

-march=native para produzir código otimizado para a plataforma (= chip) na qual você está compilando

Se você precisar conhecer os sinalizadores de pré-processador predefinidos pelo compilador:

echo | gcc -E -dM -

Não é realmente útil para detectar erros, mas a -masm=intelopção raramente mencionada torna o uso-S a inspeção do resultado da montagem seja muito mais agradável.

A sintaxe da montagem da AT&T machuca minha cabeça demais.

Meu makefile normalmente contém

  CFLAGS= -Wall -Wextra -Weffc++ -Os -ggdb
  ...
  g++ $(CFLAGS) -o junk $<
  gcc $(CFLAGS) -o $@ $<
  rm -f junk

As mais importantes dessas opções já foram discutidas antes, por isso vou apontar os dois recursos que ainda não foram apontados:

Mesmo trabalhando em uma base de código que precisa ser C simples para portabilidade para alguma plataforma que ainda não possui um compilador C ++ decente, eu faço uma compilação "extra" com o compilador C ++ (além do compilador C). Isso tem três benefícios:

1. ocasionalmente, o compilador C ++ me fornece mensagens de aviso melhores que o compilador C.
2. O compilador C ++ aceita a opção -Weffc ++, que ocasionalmente me dá algumas dicas úteis, que eu perderia se apenas o compilasse em C.
3. Posso manter o código relativamente fácil de portar para o C ++, evitando algumas condições de contorno em que o código C simples é um código C ++ inválido (como definir uma variável chamada "bool").

Sim, sou uma Pollyanna irremediavelmente otimista que fica pensando que certamente a qualquer mês, agora que uma plataforma será declarada obsoleta ou ganhará um compilador C ++ decente, e finalmente podemos mudar para C ++. Na minha opinião, é inevitável - a única questão é se isso acontece antes ou depois da administração finalmente emitir um pônei para todos. :-)

-Wstrict-prototypes -Wmissing-prototypes

Aqui está uma grande bandeira que não foi mencionada:

-Werror-implicit-function-declaration

Dê um erro sempre que uma função for usada antes de ser declarada.

man gcc

O manual está cheio de sinalizadores interessantes com boas descrições. No entanto, -Wall provavelmente tornará o gcc o mais detalhado possível. Se você deseja dados mais interessantes, consulte o valgrind ou alguma outra ferramenta para verificar se há erros.

Bem, também -Wextradeve ser padrão. -Werrortransforma avisos em erros (o que pode ser muito irritante, especialmente se você compilar sem -Wno-unused-result). -pedanticem combinação com std=c89fornece avisos adicionais se você usar os recursos do C99.

Mas é isso aí. Você não pode ajustar um compilador C em algo mais salvo em tipo do que o próprio C.

-M* família de opções.

Isso permite que você escreva arquivos make que descobrem automaticamente em quais arquivos de cabeçalho seus arquivos de origem c ou c ++ devem depender. O GCC gerará arquivos make com essas informações de dependência e você os incluirá em seu arquivo make principal.

Aqui está um exemplo de um makefile extremamente genérico usando -MD e -MP que irá compilar um diretório cheio de arquivos de código-fonte e cabeçalho c ++ e descobrir todas as dependências automaticamente:

CPPFLAGS += -MD -MP                                         
SRC = $(wildcard *.cpp)                                                       

my_executable: $(SRC:%.cpp=%.o)                                                        
        g++ $(LDFLAGS) -o $@ $^                                               

-include $(SRC:%.cpp=%.d)

Aqui está uma postagem de blog que discute isso em mais profundidade: http://www.microhowto.info/howto/automatically_generate_makefile_dependencies.html

Existe -Werror, que trata todos os avisos como erros e interrompe a compilação. A gccpágina do manual explica cada opção de linha de comando para o seu compilador.

-Wfloat-equal

De: http://mces.blogspot.com/2005/07/char-const-argv.html

Um dos outros novos avisos que eu gosto é o -Wfloat-equal. Isso avisa sempre que você [possui] um número de ponto flutuante em uma condição de igualdade. Isso é brilhante! Se você já programou uma computação gráfica ou (pior :) algoritmo de geometria computacional, sabe que nunca há dois carros alegóricos iguais com a igualdade ...

Encontrei este tópico procurando por um sinalizador para corrigir um problema específico, não o vejo aqui, então vou adicionar um que estava me impressionando na minha postagem :

A -Wformat=2bandeira

-Wformat=> Verificar chamadas para printfe scanf, etc., para se certificar de que os argumentos fornecidos têm tipos apropriados para a cadeia de formato especificado ...

E a parte realmente importante sobre isso (de acordo com o manual do GCC ):

-Wformatestá incluído no -Wall. Para mais controle sobre alguns aspectos do formato de verificação, as opções -Wformat-y2k, -Wno-format-extra-args, -Wno-format-zero-length, -Wformat-nonliteral, -Wformat-security, e -Wformat=2estão disponíveis, mas não estão incluídos no -Wall.`

Então, só porque você tem -Wall, não significa que você tem tudo. ;)

Às vezes eu uso -spara um executável muito menor:

-s
    Remove all symbol table and relocation information from the executable.

Fonte: http://gcc.gnu.org/onlinedocs/gcc/Link-Options.html#Link-Options

Embora essa resposta possa ser um pouco fora do tópico e a pergunta seja um +1 digno de mim, pois

Estou particularmente interessado em avisos adicionais e / ou em transformar avisos em erros em alguns casos para minimizar absolutamente qualquer incompatibilidade acidental de tipo.

A verificação estática por meio de uma ferramenta do tipo fiapo, como o splint, deveria ter sido parte de uma cadeia de ferramentas do compilador.

Estou particularmente interessado em quaisquer avisos adicionais,

Além de -Wall, a opção -Wou -Wextra(-W funciona com versões mais antigas do gcc e com as mais recentes; versões mais recentes suportam o nome alternativo -Wextra, o que significa a mesma coisa, mas é mais descritivo) permite vários avisos adicionais.

Também há ainda mais avisos que não são ativados por nenhum deles, geralmente para coisas que são mais questionáveis. O conjunto de opções disponíveis depende de qual versão do gcc você está usando - consulte man gccou info gccpara obter detalhes, ou consulte a documentação on - line da versão específica do gcc em que está interessado. E -pedanticemite todos os avisos exigidos pelo padrão em particular (que depende em outras opções como -std=xxxou -ansi) e reclama do uso de extensões gcc.

e / ou transformar avisos em erros em alguns casos para minimizar absolutamente qualquer incompatibilidade acidental de tipo.

-Werrortransforma todos os avisos em erros. Eu não acho que o gcc permita que você faça isso seletivamente para avisos específicos, no entanto.

Você provavelmente descobrirá que precisa ser seletivo sobre quais avisos são ativados por projeto (especialmente se você usar -Werror), pois os arquivos de cabeçalho de bibliotecas externas podem disparar alguns deles. ( -pedanticem particular, tende a ser inútil a esse respeito, na minha experiência.)

• -Wmissing-prototypes: Se uma função global for definida sem uma declaração de protótipo anterior.
• -Wformat-security: Avisa sobre o uso de funções de formato que representam possíveis problemas de segurança. No momento, isso avisa sobre chamadas printfe scanffunções em que a cadeia de formato não é literal e não há argumentos de formato

• -Werror=return-type: Aplica erro quando a função não tem retorno no gcc. Está /we4716no Visual Studio.

• -Werror=implicit-function-declaration: Aplica erro quando a função é usada sem definida / não incluída. Está /we4013no Visual Studio.

• -Werror=incompatible-pointer-types: Erro inicial quando o tipo de um ponteiro não corresponde ao tipo de ponteiro esperado. Está /we4133no Visual Studio.

Na verdade, eu gostaria de manter meu código C em várias plataformas e uso o CMake, e coloquei os cflags fornecidos no CMakeLists.txt como:

if (CMAKE_SYSTEM_NAME MATCHES "Windows")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /we4013 /we4133 /we4716")
elseif (CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "Darwin")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=implicit-function-declaration -Werror=incompatible-pointer-types -Werror=return-type")
endif()