Opções de linha de comando GCC incomuns, mas úteis

Ferramentas de software geralmente oferecem múltiplas funcionalidades, mas - como a maioria de vocês concordará - nem todas as suas funcionalidades são usadas por todos. De maneira geral, não há nada de errado nisso, já que cada usuário tem sua própria necessidade e utiliza as ferramentas dentro dessa esfera apenas. No entanto, é sempre bom continuar explorando as ferramentas que você usa, pois você nunca sabe quando uma de suas funcionalidades pode ser útil, economizando um pouco do seu precioso tempo no processo.

Um exemplo disso: compiladores. Um bom compilador de linguagem de programação sempre oferece uma infinidade de opções, mas os usuários geralmente conhecem e usam apenas um conjunto limitado. Especificamente, se você é um desenvolvedor da linguagem C e usa o Linux como sua plataforma de desenvolvimento, é altamente provável que você esteja usando o compilador gcc, que oferece uma lista interminável de opções de linha de comando.

Você sabia que, se quiser, pode pedir ao gcc para salvar a saída em cada estágio do processo de compilação? Você conhece a opção -Wall que você usa para gerar avisos, mas que não cobre alguns avisos específicos? Existem muitas opções de linha de comando do gcc que não são comumente usadas, mas podem ser extremamente úteis em certos cenários, por exemplo, durante a depuração do código.

Assim, neste artigo, abordaremos algumas dessas opções, oferecendo todos os detalhes necessários e explicando-as através de exemplos fáceis de entender sempre que necessário.

Mas antes de prosseguirmos, por favor, tenha em mente que todos os exemplos, comandos e instruções mencionados neste tutorial foram testados no Ubuntu 16.04 LTS, e a versão do gcc que usamos é 5.4.0.

Veja a saída intermediária durante cada estágio de compilação

Você sabia que existem, de forma ampla, um total de quatro estágios pelos quais seu código C passa quando você o compila usando o compilador gcc? Estes são pré-processamento, compilação, montagem e linkagem. Após cada estágio, o gcc produz um arquivo de saída temporário que é passado para o próximo estágio. Agora, todos esses são arquivos temporários que são produzidos, e, portanto, não conseguimos vê-los - tudo o que vemos é que emitimos o comando de compilação e ele produz o binário/executável que podemos executar.

Mas suponha que, enquanto depura, haja a necessidade de ver como o código ficou após, digamos, o estágio de pré-processamento. Então, o que você faria? Bem, a boa notícia é que o compilador gcc oferece uma opção de linha de comando que você pode usar em seu comando de compilação padrão e você obterá esses arquivos intermediários que são deletados pelo compilador de outra forma. A opção da qual estamos falando é -save-temps.

Aqui está o que a página do manual do gcc diz sobre esta opção:

           Armazena os "arquivos intermediários" temporários normalmente de forma permanente; coloca-os  
           no diretório atual e os nomeia com base no arquivo de origem. Assim, compilar foo.c com -c -save-temps produz arquivos  
           foo.i e foo.s, bem como foo.o. Isso cria um arquivo de saída pré-processado foo.i, mesmo que o compilador agora normalmente use um  
           pré-processador integrado.

           Quando usado em combinação com a opção de linha de comando -x,  
           -save-temps é sensato o suficiente para evitar sobrescrever um arquivo de origem de entrada com a mesma extensão que um arquivo intermediário. O  
           arquivo intermediário correspondente pode ser obtido renomeando o  
           arquivo de origem antes de usar -save-temps.

A seguir está um comando de exemplo que lhe dará uma ideia de como você pode usar esta opção:

gcc -Wall -save-temps** test.c -o test-exec

E é assim que eu verifiquei que todos os arquivos intermediários foram de fato produzidos após o comando mencionado acima ser executado:

Assim, como você pode ver na captura de tela acima, os arquivos test.i, test.s e test.o foram produzidos pela opção -save-temps. Esses arquivos correspondem aos estágios de pré-processamento, compilação e linkagem, respectivamente.

Prepare seu código para depuração e perfilagem

Existem ferramentas dedicadas que permitem que você depure e perfil seu código fonte. Por exemplo, o gdb é usado para fins de depuração, enquanto o gprof é uma ferramenta popular para fins de perfilagem. Mas você sabia que existem opções específicas de linha de comando que o gcc oferece para tornar seu código pronto para depuração e também para perfilagem?

Vamos começar com a depuração. Para poder usar o gdb para depuração de código, você terá que compilar seu código usando a opção de linha de comando -g fornecida pelo compilador gcc. Esta opção basicamente permite que o gcc produza informações de depuração que são necessárias para que o gdb consiga depurar seu programa com sucesso.

Caso você planeje usar esta opção, é aconselhável que você passe pelos detalhes que a página do manual do gcc oferece sobre esta opção - alguns deles podem se provar vitais em alguns casos. Por exemplo, a seguir está um trecho retirado da página do manual:

           O GCC permite que você use -g com -O. Os atalhos tomados pelo código otimizado  
           podem ocasionalmente produzir resultados surpreendentes: algumas variáveis  
           que você declarou podem não existir; o fluxo de controle pode brevemente se mover  
           para onde você não esperava; algumas instruções podem não ser executadas  
           porque computam resultados constantes ou seus valores já estão  
           disponíveis; algumas instruções podem ser executadas em lugares diferentes porque  
           foram movidas para fora de loops.

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

Não apenas o gdb, compilar seu código usando a opção -g também abre a possibilidade de usar a ferramenta memcheck do Valgrind em todo seu potencial. Para aqueles que não estão cientes, o memcheck é usado por programadores para verificar vazamentos de memória (se houver) em seu código. Você pode aprender mais sobre esta ferramenta aqui.

Seguindo em frente, para poder usar o gprof para perfilagem de código, você deve compilar seu código usando a opção de linha de comando -pg. Isso permite que o gcc gere código extra para escrever informações de perfilagem, que são necessárias para o gprof para análise de código. “Você deve usar esta opção ao compilar os arquivos de origem dos quais deseja dados, e também deve usá-la ao vincular”, diz a página do manual do gcc. Para aprender mais sobre como realizar a perfilagem de código usando o gprof, acesse este tutorial dedicado em nosso site.

Nota: O uso das opções -g e -pg é semelhante à forma como a opção -save-temps foi usada na seção anterior.

Conclusão

A menos que você seja um profissional do gcc, tenho certeza de que você aprendeu algo novo com este artigo. Experimente essas opções e veja como elas funcionam. Enquanto isso, aguarde a próxima parte desta série de tutoriais onde discutiremos mais opções de linha de comando do gcc interessantes e úteis.