Voir la source de Ecriture et debugage d'algorithmes simples en assembleur x86

{{Maintenance uniquement par enseignants}}
{{1A}} {{Informatique}}

[[Catégorie:Assembleur]]
[[Catégorie:Première Année]]
[[Catégorie:Informatique]]
[[Catégorie:Logiciel de Base]]

== Introduction ==

Le but de cette séance machine est d'écrire et mettre au point quelques programmes simples en assembleur.

Note : il est important de bien suffixer vos sources assembleur par un S majuscule (e.g. <tt>mon_prog.S</tt>).

Vous pouvez récupérer les sources fournies pour cette séance dans [[Media:LdB-TP5.zip|cette archive Zip]]. Pour les apprentis, les squelettes se trouvent dans le répertoire {{Url Git ldba|basedir=asm/1-asm-intro}} de votre archive Git.

Attention, on rappelle que les conventions de nommage des fonctions sont légèrement différentes entre Linux et MacOS :
* sous Linux, la fonction <tt>main</tt> du C doit aussi s'appeler <tt>main</tt> en assembleur ;
* sous MacOS, cette fonction doit s'appeller <tt>_main</tt> en assembleur.

Vous pouvez mettre systématiquement les deux noms d'étiquettes si vous voulez que vos programmes fonctionnent sur les deux systèmes.

== Premier programme assembleur : PGCD ==

=== Edition et compilation ===

Ouvrez dans votre éditeur de texte favori le fichier <tt>pgcd.S</tt> récupéré dans l'archive ci-dessus.

Assembler ce programme en utilisant la commande <tt>gcc -o pgcd pgcd.S -g -m32 -gstabs</tt>. Vous pouvez l'exécuter en exécutant <tt>./pgcd</tt> mais vu que le programme ne fait pas d'affichage, ce n'est pas très parlant.

=== Exécution pas à pas avec gdb ===

On va donc utiliser gdb pour tracer l'exécution du programme instruction par instruction :
* charger le programme dans gdb en tapant <tt>gdb ./pgcd</tt> ;
* ajouter un point d'arrêt au début du programme en utilisant la commande « <tt>break main</tt> » (ou pour moins se fatiguer, simplement <tt>b main</tt>) ;
* lancer son exécution en tapant <tt>run</tt> : noter que l'exécution s'arrête sur le point d'arrêt positionné sur <tt>main</tt> : gdb affiche alors la prochaine instruction à exécuter (i.e. elle n'a pas encore été exécutée) ;
* utiliser <tt>step</tt> pour avancer et exécuter l'instruction <tt>movl $15, %ecx</tt> ;
* afficher le contenu du registre <tt>%ecx</tt> en tapant <tt>print $ecx</tt> (attention, pour GDB, les registres s'appellent $eax, $ebx, ... alors que pour l'assembleur ils s'appellent %eax, %ebx, ...). Vérifier qu'il contient bien 15. <br />Note : on peut également faire <code>tui reg general</code> pour afficher la valeur de tous les registres d'une manière semi-graphique, ou bien <code>display $ecx</code> pour afficher la valeur de %ecx à chaque pas. Une dernière solution est d'utiliser la commande <code>info registers</code> (ou <code>i reg</code>), avec éventuellement un argument (<code>i reg eax</code>)
* continuer l'exécution du programme pas à pas avec <tt>step</tt> en affichant les valeurs des registres après l'exécution de chaque instruction qui les modifie (l'utilisation de la commande <tt>display</tt>, qui affiche à chaque pas le contenu d'un registre voulu sans avoir à retaper la commande peut être pratique : <tt>display $ecx</tt>, mais attention à la syntaxe : il faut bien mettre un <tt>$</tt> devant le nom du registre) ;
* vérifier qu'on fait bien deux itérations de la boucle <tt>while</tt> avant d'en sortir (i.e. le branchement conditionnel <tt>je fin_while</tt> n'est pas effectué lors des deux premières itérations) ;
* vérifier aussi qu'on saute bien vers <tt>else</tt> la première fois qu'on exécute l'instruction <tt>jb else</tt> mais pas la deuxième ;
* vérifier enfin que le PGCD (5) est bien dans <tt>%ecx</tt> et <tt>%edx</tt> lorsqu'on arrive à la fin de la boucle (i.e. sur <tt>fin_while</tt>) ;
* ensuite on peut terminer proprement l'exécution du programme en tapant <tt>continue</tt>.

On fourni un [[Media:Gdb-ref.pdf|aide-mémoire pour gdb]] qui contient beaucoup plus d'information que ce qui vous sera nécessaire ce semestre.

== Multiplication simple ==

=== Code en C à traduire ===

On va maintenant implanter l'opération <tt>res := x * y</tt> par additions successives. On donne ci-dessous le code C que l'on va devoir traduire le plus littéralement possible en assembleur :

<pre>
int main(void)
{
    unsigned x, y, res;
    x = 5;
    y = 4;
    res = 0;
    while (y != 0) {
        res = res + x;
        y--;
    }
    return 0;
}
</pre>

=== Version assembleur à produire ===

Ouvrez le fichier <tt>mult.S</tt> et complétez le avec le code effectuant la multiplication. On stockera <tt>x</tt> dans <tt>%ecx</tt>, <tt>y</tt> dans <tt>%edx</tt> et <tt>res</tt> dans <tt>%eax</tt>.

Testez que le programme fonctionne en l'exécutant dans GDB et en suivant l'évolution des valeurs des registres avec la commande <tt>display</tt>.

== Multiplication égyptienne ==

=== Code en C à traduire ===

Refaite le même exercice en implantant cette fois-ci l'algorithme de la multiplication égyptienne :

<pre>
int main(void)
{
    unsigned x, y, res;
    res = 0;
    x = 5;
    y = 4;
    while (y != 0) {
        if (y % 2 == 1) { /* % est l'operateur modulo */
            res = res + x;
        }
        x = x * 2;
        y = y / 2;
    }
    return 0;
}
</pre>

=== Version assembleur à produire ===

Ouvrez le fichier <tt>mult_egypt.S</tt> et complétez le pour implanter l'algorithme ci-dessus.

Pour implanter les opérations modulo, multiplier et diviser par 2, vous aurez sûrement besoin des instructions suivantes :
* <tt>testl A, B</tt> compare A et B en effectuant l'opération <tt>A and B</tt> ;
* <tt>shll $n, A</tt> décale A  de n bits vers la gauche ;
* <tt>shrl $n, A</tt> décale A de n bits vers la droite (c'est un décalage logique, pas arithmétique).

Testez que le programme fonctionne en l'exécutant dans GDB et en suivant l'évolution des valeurs des registres avec la commande <tt>display</tt>.