Options de ligne de commande GCC peu courantes mais utiles

Les outils logiciels offrent généralement de multiples fonctionnalités, mais - comme la plupart d’entre vous le conviendront - toutes leurs fonctionnalités ne sont pas utilisées par tout le monde. En général, il n’y a rien de mal à cela, car chaque utilisateur a ses propres besoins et utilise les outils dans cette sphère uniquement. Cependant, il est toujours bon de continuer à explorer les outils que vous utilisez, car vous ne savez jamais quand l’une de leurs fonctionnalités pourrait s’avérer utile, vous faisant gagner un peu de votre temps précieux dans le processus.

Prenons un exemple : les compilateurs. Un bon compilateur de langage de programmation offre toujours une pléthore d’options, mais les utilisateurs connaissent généralement et n’utilisent qu’un ensemble limité. Plus précisément, si vous êtes développeur en langage C et utilisez Linux comme plateforme de développement, il est très probable que vous utilisiez le compilateur gcc, qui offre une liste interminable d’options de ligne de commande.

Savez-vous que si vous le souhaitez, vous pouvez demander à gcc de sauvegarder la sortie à chaque étape du processus de compilation ? Savez-vous que l’option -Wall que vous utilisez pour générer des avertissements ne couvre pas certains avertissements spécifiques ? Il existe de nombreuses options de ligne de commande gcc qui ne sont pas couramment utilisées, mais peuvent être extrêmement utiles dans certains scénarios, par exemple, lors du débogage du code.

Ainsi, dans cet article, nous allons couvrir quelques-unes de ces options, offrant tous les détails nécessaires et les expliquant à travers des exemples faciles à comprendre chaque fois que cela est nécessaire.

Mais avant d’aller plus loin, veuillez garder à l’esprit que tous les exemples, commandes et instructions mentionnés dans ce tutoriel ont été testés sur Ubuntu 16.04 LTS, et la version de gcc que nous avons utilisée est 5.4.0.

Voir la sortie intermédiaire à chaque étape de compilation

Savez-vous qu’il y a, en gros, un total de quatre étapes que votre code C traverse lorsque vous le compilez en utilisant le compilateur gcc ? Ce sont le prétraitement, la compilation, l’assemblage et le lien. Après chaque étape, gcc produit un fichier de sortie temporaire qui est remis à l’étape suivante. Maintenant, ce sont tous des fichiers temporaires qui sont produits, et donc nous ne les voyons pas - tout ce que nous voyons, c’est que nous avons émis la commande de compilation et qu’elle produit le binaire/exécutable que nous pouvons exécuter.

Mais supposons que, lors du débogage, il y ait un besoin de voir à quoi ressemblait le code après, disons, l’étape de prétraitement. Que feriez-vous ? Eh bien, la bonne nouvelle est que le compilateur gcc offre une option de ligne de commande que vous pouvez utiliser dans votre commande de compilation standard et vous obtiendrez ces fichiers intermédiaires qui sont supprimés par le compilateur autrement. L’option dont nous parlons est -save-temps.

Voici ce que dit la page de manuel de gcc à propos de cette option :

           Stocker les "fichiers" intermédiaires "temporaires" habituels de manière permanente ; les placer dans le répertoire courant et les nommer en fonction du fichier source. Ainsi, compiler foo.c avec -c -save-temps produit les fichiers foo.i et foo.s, ainsi que foo.o. Cela crée un fichier de sortie prétraité foo.i même si le compilateur utilise maintenant normalement un préprocesseur intégré.

           Lorsqu'il est utilisé en combinaison avec l'option de ligne de commande -x, -save-temps est assez sensé pour éviter d'écraser un fichier source d'entrée avec la même extension qu'un fichier intermédiaire. Le fichier intermédiaire correspondant peut être obtenu en renommant le fichier source avant d'utiliser -save-temps.

Voici un exemple de commande qui vous donnera une idée de la façon dont vous pouvez utiliser cette option :

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

Et voici comment j’ai vérifié que tous les fichiers intermédiaires avaient effectivement été produits après l’exécution de la commande mentionnée ci-dessus :

Comme vous pouvez le voir dans la capture d’écran ci-dessus, les fichiers test.i, test.s et test.o ont été produits par l’option -save-temps. Ces fichiers correspondent respectivement aux étapes de prétraitement, de compilation et de liaison.

Rendez votre code prêt pour le débogage et le profilage

Il existe des outils dédiés qui vous permettent de déboguer et de profiler votre code source. Par exemple, gdb est utilisé à des fins de débogage, tandis que gprof est un outil populaire pour le profilage. Mais savez-vous qu’il existe des options de ligne de commande spécifiques que gcc propose pour rendre votre code prêt pour le débogage ainsi que pour le profilage ?

Commençons par le débogage. Pour pouvoir utiliser gdb pour le débogage du code, vous devrez compiler votre code en utilisant l’option de ligne de commande -g fournie par le compilateur gcc. Cette option permet essentiellement à gcc de produire des informations de débogage nécessaires à gdb pour déboguer avec succès votre programme.

Dans le cas où vous prévoyez d’utiliser cette option, il est conseillé de consulter les détails que la page de manuel de gcc offre sur cette option - certains d’entre eux peuvent s’avérer vitaux dans certains cas. Par exemple, voici un extrait tiré de la page de manuel :

           GCC vous permet d'utiliser -g avec -O. Les raccourcis pris par le code optimisé peuvent parfois produire des résultats surprenants : certaines variables que vous avez déclarées peuvent ne pas exister du tout ; le flux de contrôle peut brièvement se déplacer là où vous ne vous y attendiez pas ; certaines instructions peuvent ne pas être exécutées car elles calculent des résultats constants ou leurs valeurs sont déjà à portée de main ; certaines instructions peuvent s'exécuter à des endroits différents car elles ont été déplacées hors des boucles.

           Néanmoins, il est possible de déboguer une sortie optimisée. Cela rend raisonnable d'utiliser l'optimiseur pour des programmes qui pourraient avoir des bogues.

Non seulement gdb, compiler votre code en utilisant l’option -g ouvre également la possibilité d’utiliser pleinement l’outil memcheck de Valgrind. Pour ceux qui ne le savent pas, memcheck est utilisé par les programmeurs pour vérifier les fuites de mémoire (s’il y en a) dans leur code. Vous pouvez en savoir plus sur cet outil ici.

En avançant, pour pouvoir utiliser gprof pour le profilage du code, vous devez compiler votre code en utilisant l’option de ligne de commande -pg. Cela permet à gcc de générer du code supplémentaire pour écrire des informations de profilage, qui sont nécessaires à gprof pour l’analyse du code. “Vous devez utiliser cette option lors de la compilation des fichiers source dont vous souhaitez des données, et vous devez également l’utiliser lors du lien,” dit la page de manuel de gcc. Pour en savoir plus sur la façon de réaliser le profilage de code à l’aide de gprof, rendez-vous sur ce tutoriel dédié sur notre site web.

Remarque : L’utilisation des options -g et -pg est similaire à la façon dont l’option -save-temps a été utilisée dans la section précédente.

Conclusion

À moins que vous ne soyez un pro de gcc, je suis sûr que vous avez appris quelque chose de nouveau avec cet article. Essayez ces options et voyez comment elles fonctionnent. En attendant, attendez la prochaine partie de cette série de tutoriels où nous discuterons d’autres options de ligne de commande gcc intéressantes et utiles.