Notes Hacking

Jason CHAMPAGNE
https://jasonchampagne.fr

1ère Édition
Sommaire
Compilation langage C (séance 3)........................................................................................................3
Traitement par le préprocesseur (preprocessing).............................................................................3
Compilation en langage d'Assembleur (compiling).........................................................................3
Traduction du langage d'Assembleur en binaire (assembling)........................................................3
Édition de liens (linking).................................................................................................................4
BONUS : quelques options à connaître pour GCC..........................................................................4
Compilation langage C (séance 3)
Quatre étapes intermédiaires existent pour obtenir un exécutable depuis un code
source en langage C :

1. Traitement par le préprocesseur (preprocessing)

2. Compilation en langage d'Assembleur (compiling)
3. Traduction du langage d'Assembleur en binaire (assembling)
4. Édition de liens (linking)

Traitement par le préprocesseur (preprocessing)

Le préprocesseur s'occupe de supprimer les commentaires, inclure les fichiers d 'en-tête

dans le code source et traiter les directives :

gcc -E main.c > main.i

Le résultat produit un fichier portant l'extension ".i " contenant l 'ensemble du code qui
sera traduit en langage d'Assembleur (étape suivante).

En ne tapant que la commande gcc -E main.c, on affiche dans le terminal l 'ensemble du

code après le passage du préprocesseur, d'où l'importance de l'enregistrer dans un
fichier. pour pouvoir l'utiliser ensuite !

Compilation en langage d'Assembleur (compiling)

Depuis le code source traité par le préprocesseur, compile en langage d 'Assembleur :

gcc -S main.i

Le résultat produit un fichier portant l'extension ".s" qui sera transformé par la suite en
binaire.

Traduction du langage d'Assembleur en binaire (assembling)

Le code en langage d'Assembleur produit, et ne contenant que des instructions

machine (additions, comparaisons, etc.) est traduit en binaire :
gcc -c main.s

Le résultat produit un fichier portant l'extension ".o " (dit fichier "objet "), souvent
utilisés lors d'une compilation séparée ( notion abordée dans d'autres vidéos sur la
chaîne).

Édition de liens (linking)

Plusieurs fichiers "objet" ont pu être obtenus et il est nécessaire de les fusionner et de
lier l'ensemble des fichiers :

gcc main.o

Le résultat produit notre exécutable final, nommé "a" par défaut (sans extension sur
GNU/Linux et MacOS, avec extension ".exe" sur Windows, etc.)

Pour nommer l'exécutable, il suffit de compléter la commande précédente avec l 'option

-o <nom_exécutable>, comme par exemple :

gcc main.o -o prog

En résumé, toutes ces 4 étapes sont effectuées d 'une traite lorsque vous avez pris
l'habitude de taper la commande :

gcc main.c -o prog

Maintenant, vous savez plus en détail comment fonctionne chacune

d'entre elles, et nous y reviendrons souvent sur la formation Hacking.

BONUS : quelques options à connaître pour GCC

-Wall : active les avertissements

-Wextra : active des avertissements supplémentaires (remplace l'option -W obsolète)
-Werror : tout avertissement qui survient est considéré comme une erreur de compilation
-w : supprime tous les avertissements

-ansi : change le comportement du compilateur suivant la norme ANSI

-pedantic : affiche les avertissements liés à la norme ANSI
-std=n : compile selon un standard (où n = c89, c90, c99 ou encore c11)

-g : génère les informations pour le débogage (avec GDB - voir séance 4)

-On : active les optimisations pour la taille du code généré (où n = 0, 1, 2 ou 3)
-Os : optimise la taille du code
-pipe : utilise des tubes à la place de fichiers intermédiaires

-I <rep> : ajoute un répertoire de fichiers d'entête (parcourus avant ceux du système)

-L <rep> : ajoute des répertoires supplémentaires (en général des fichiers ".a ")