Cours guide pour la traduction de structures de haut niveau en assembleur, tutoriel & guide de travaux pratiques en pdf.

Definition du corps des sous-programmes
On analyse maintenant les 4 sous-programmes. On commence par d´efinir leurs param`etres et la valeur qu’ils retournent si ce sont des fonctions. Ensuite, on d´ecrit leur structure, c’est-a`-dire leur algorithme.

Les parametres des sous-programmes
Nous devons tout d’abord bien lister les param`etres des sous-programmes et indiquer comment ils seront pass´es (o`u ils seront stock´es).
1. sous-programme LIRE :
– pas de param`etre en entr´ee
– c’est une fonction et elle retourne le nombre lu
2. sous-programme AFFICHER :
– prend un param`etre en entr´ee, le nombre dont la valeur doit ˆetre affich´ee
3. sous-programme VAL_NUM :
– ce sous-programme prend en entr´ee le code ASCII du caract`ere qui a et´ lu et ce caract`ere est forc´ement un chiffre
– la valeur num´erique correspondant au caract`ere doit ˆetre renvoy´ee
4. sous-programme EST_UN_CHIFFRE :
– ce sous-programme prend en entr´ee le code ASCII du caract`ere a` tester
– le r´esultat est un booleen

Structure des sous-programmes
Pour chaque sous-programme, on ´etudie l’implantation de l’algorithme de plus pr`es.
Sous-programme LIRE
Le sous-programme LIRE se compose essentiellement d’une boucle r´ep´eter. Cette boucle se traduit en assembleur a` l’aide d’une instruction de saut conditionnel (cf. 4.4.2). La boucle a` traduire est :
REPETER
lire_caractere (c)
SI (est_un_chiffre (c) = vrai) ALORS
afficher_caractere (c)
nombre := nombre * 10
nombre := nombre + valeur_numerique (c)
FIN_SI
JUSQU’A (c = <retour-chariot>)
Celle-ci est transform´ee en :
debut_de_boucle:
lire_caractere (c)
SI (est_un_chiffre (c) = vrai) ALORS
afficher_caractere (c)
nombre := nombre * 10
nombre := nombre + valeur_numerique (c)
FIN_SI
SI (c # <retour-chariot>) ALORS
ALLER_EN debut_de_boucle
FIN_SI
Les parties en gras r´esultent de l’implantation de la structure de boucle. La partie en italique forme le corps de la boucle. Nous laissons cette partie de cˆot´e et nous concentrons sur la traduction en assembleur de la structure de la boucle.
Si l’on poursuit la traduction, on obtient la traduction suivante :
debut_de_boucle:
lire_caractere (c)
SI (est_un_chiffre (c) = vrai) ALORS
afficher_caractere (c)
nombre := nombre * 10
nombre := nombre + valeur_numerique (c)
FIN_SI
cmp code_caractere, 13 ; calcul de la condition
jne debut_de_boucle
Une instruction cmp compare le code ASCII du caract`ere saisi a` celui du retour-chariot. En fonction du r´esultat de cette instruction, l’instruction suivante jne d´eclenche une rupture de s´equence en d´ebut de boucle pour effectuer une it´eration ou ne d´eclenche aucune action. Dans ce cas, l’ex´ecution du programme se poursuit en s´equence, avec l’instruction suivante du programme (non repr´esent´ee ici) : on sort de la boucle.
Pour passer a` une premi`ere ´ebauche en assembleur, nous devons encore savoir passer un param`etre a` un sous-programme. Pour cela, on utilise l’instruction push avec, en op´erande, la valeur du param`etre. Par exemple, pour passer la valeur 10 en param`etre, on utilisera l’instruction push 10
Dans notre cas, nous devons passer le code ASCII du caract`ere qui a et´ saisi. Si on suppose que cette valeur se trouve dans la pseudo-variable code caract`ere, on aura donc une instruction :
push code caract`ere
L’appel d’un sous-programme se fait avec l’instruction call avec le nom du sous-programme a appel´ en op´erande.
Pour terminer, lorsqu’un appel de sous-programme est r´ealis´ en passant des param`etres, il faut, imm´e-diatement apr`es l’instruction call mettre une instruction
add sp, xxx
o`u xxx est une valeur num´erique ´egale a` deux fois le nombre de param`etres. Puisqu’il y a ici un seul param`etre, on devra utiliser l’instruction
add sp, 2.
Donc, pour r´esumer, la traduction de l’appel de fonction est_un_chiffre (c) se traduira en assembleur par les trois instructions :
push code_caract`ere
call est_un_chiffre
add sp, 2
La fonction est_un_chiffre renvoie un r´esultat bool´een dont il faut tester la valeur. Comme nous l’avons dit plus haut, une variable bool´eenne est repr´esent´ee par une variable enti`ere. Donc, nous testerons sa valeur `a l’aide de l’instruction cmp vue plus haut et une instruction de saut conditionnel d´eclenchera le traitement en cons´equence.
Dernier point, la saisie d’un caract`ere au clavier : ne cherchons pas plus loin, toutes les op´erations d’entr´ees-sorties disponibles en assembleur sont indiqu´ees `a la section 4.11 de ce document et dans le chapitre 5 du manuel du i8086. Ainsi, nous y trouvons que pour lire un caract`ere au clavier, il faut utiliser les deux instructions :
mov ah, 1
int 21h
L’instruction int d´eclenche l’appel d’une esp`ece de sous-programme pr´ed´efini. La code ASCII du caract`ere saisi est ensuite accessible dans le registre al. Aussi, nous affectons ensuite la valeur du registre al `a la pseudo-variable code caract`ere.

1 Introduction 
2 M´ethodologie 
2.1 M´ethodologie
2.2 Aper¸cu du langage d’assemblage
3 Exemple 
3.1 Programme `a ´ecrire
3.2 Analyse et algorithme
3.3 La r´ealisation du programme assembleur
3.3.1 Structure du programme
3.3.2 D´efinition du corps des sous-programmes
3.3.3 Traduction des expressions
3.3.4 Allocation des pseudo-variables
3.3.5 Derniers ajustements
3.3.6 Programme termin´e
4 Guide pour la traduction de structures de haut niveau en assembleur
4.1 Expression arithmetique et logique
4.1.1 Principe
4.1.2 L’affectation
4.2 S´equence d’instructions
4.3 Les tests
4.3.1 Principe
4.3.2 Conditions simples
4.3.3 La condition est une expression
4.3.4 Conditions compos´ees
4.4 Les boucles
4.4.1 Boucle tant-que
4.4.2 Boucle r´ep´eter
4.4.3 Boucle pour
4.5 Proc´edures et fonctions : principe des sous-programmes
4.5.1 Principe
4.5.2 Appel d’un sous-programme
4.6 Sous-programmes avec param`etres et variables locales
4.6.1 Passage de param`etre en entr´ee du sous-programme
4.6.2 R´eception des param`etres
4.6.3 Variables locales
4.6.4 Valeur de retour
4.7 Traduction des pseudo-variables
4.7.1 Les variables globales du programme
4.7.2 Les variables temporaires
4.7.3 Les instructions de multiplication et de division
4.7.4 Les parametres
4.7.5 Les variables locales
4.7.6 La valeur de retour d’un sous-programme
4.8 Les tableaux en assembleur
4.9 Les constantes
4.10 Programme assembleur minimal
4.11 Quelques fonctions utiles
4.11.1 Afficher un caract`ere
4.11.2 Afficher un nombre positif
4.11.3 Lire un caractere