El Oufir El Mehdi [PDF]

Zitiervorschau

ECOLE NORMALE SUPÉRIEURE DE L'ENSEIGNEMENT TECHNIQUE - MOHAMMEDIA

Compte Rendu

TP - Assembleur i8086 (Sous EMU8086)

Année Universitaire 2015/2016

Par :

Enseignant :

EL OUFIR EL MEHDI

Professeur A.RAIHANI

Sommaire :

 Introduction générale ............................................................................................................................................. 3



Les registres du 8086 .............................................................................................................................. 3



Anatomie d’un programme en assembleur ............................................................................................ 4

 Rapport sur les exercices : ..................................................................................................................................... 5



Programme 01 - La somme de deux nombres ........................................................................................ 5 

Objectif ......................................................................................................................................................... 5



Méthode de résolution .............................................................................................................................. 5



Solution ........................................................................................................................................................ 5



Discussion et amélioration ........................................................................................................................ 5









–

AVEC DIVISION ............................................................................................................................ 6

–

AVEC MASQUAGE ....................................................................................................................... 7

Conclusion.................................................................................................................................................... 8

Programme 02 - La somme de deux vecteurs ........................................................................................ 9 

Objectif ......................................................................................................................................................... 9



Solution ........................................................................................................................................................ 9



Discussion et amélioration ...................................................................................................................... 10



Conclusion.................................................................................................................................................. 12

Programme 03 – Les entries/Sorties – Manipulation des chaine de caractères .................................. 13 

Objectif ....................................................................................................................................................... 13



Solution ...................................................................................................................................................... 13



Conclusion.................................................................................................................................................. 17

Programme 04 – L’heure et la date courante avec les procédures ...................................................... 18 

Objectif ....................................................................................................................................................... 18



Méthode de résolution ............................................................................................................................ 18



Conclusion.................................................................................................................................................. 21

2

Introduction générale : Un langage d'assemblage ou langage assembleur est, en programmation informatique, un langage de bas niveau qui représente le langage machine sous une forme lisible par un humain. Les combinaisons de bits du langage machine sont représentées par des symboles dits « mnémoniques » (du grec mnêmonikos, relatif à la mémoire), c'est-à-dire faciles à retenir. Le programme assembleur convertit ces mnémoniques en langage machine en vue de créer par exemple un fichier objet ou un fichier exécutable. Dans la pratique courante, le même terme assembleur est utilisé à la fois pour désigner le langage d'assemblage et le programme assembleur qui le traduit. On parle ainsi de « programmation en assembleur ».

Les registres du 8086 : Le 8086 est un processeur 16 bits, c’est-à-dire qu’il traite des données codées sur 16 bits. • • • • • • • • •

AX registre d’usage général contenant des données. Les 8 bits de poids faible se nomment AL et les 8 bits de poids fort se nomment AH. BX registre d’usage général contenant des données. Comme ax, bx se d´décompose en BL et BH. CX registre d’usage général contenant des données. Comme AX, CX se décompose en CL et CH. DX registre d’usage général contenant des données. Comme AX, dx se décompose en dl et DH. SI registre d’usage général contenant généralement le d´emplacement dans un segment d’une donnée. DI registre d’usage général contenant généralement le d´emplacement dans un segment d’une donnée. BP registre utilisé pour adresser des données dans la pile. SP registre pointeur de pile. IP registre pointeur d’instruction (compteur ordinal). Ce registre indique la prochaine instruction à exécuter. Flags registre d’indicateurs de l’état du processeur. Certains bits de ce registre portent des noms. Ce sont tous des indicateurs binaires : – – – – – –

O le bit d’overflow est positionné par la plupart des instructions arithmétiques pour indiquer s’il y a eut un débordement de capacité lors du calcul (un nombre trop grand ou trop petit) D bit de direction. S le bit de signe est positionné par la plupart des instructions arithmétiques pour indiquer le signe du résultat (positif ou négatif – cf. section 1.4.2) Z le bit de zéro est positionné par la plupart des instructions arithmétiques pour indiquer que le résultat du calcul est 0 C le bit de carry (retenue) est positionné par la plupart des instructions arithmétiques pour indiquer si le calcul a engendré une retenue qui devra être reportée sur les calculs suivants. A le bit dit auxiliaire carry (retenue auxiliaire) est positionné par la plupart des instructions arithmétiques pour indiquer une retenue entre bits de poids faible et bits de poids forts d’un octet, d’un mot ou d’un double mot.

3

–

• • • •

P le bit de parité est positionné par la plupart des instructions arithmétiques. Il indique si les 8 bits de poids faible du résultat comportent un nombre pair de 1.

CS code segment segment contenant le programme en cours d’exécution. DS data segment segment contenant les données. ES registre segment auxiliaire pour adresser des données. SS stack segment segment contenant la pile.

Les valeurs des registres CS, DS et SS sont automatiquement initialisées par le système d’exploitation au lancement du programme. Dès lors, ces segments sont implicites, c’est-à-dire que si l’on désire accéder à une donnée en m´mémoire, il suffit de spécifier son offset sans avoir à se soucier du segment.

Anatomie d’un programme en assembleur : Un programme en assembleur a une forme bien particulière. Chaque ligne d’une source assembleur comporte une instruction. Chaque ligne est composée de champs. De gauche à droite, on a : – le champ étiquette, qui peut être vide. – le champ mnémonique (le nom de l’instruction). – le champ opérande (les arguments de l’instruction), qui peut être vide. – le champ commentaire, qui peut être vide. Une étiquette est un identificateur composé de lettres, chiffres et de caractères $, %, _ et ? Quelques exemples d’étiquettes valides : boucle, fin_de_tant_que, ... Une mnémonique est, généralement, composé uniquement de lettres. Quelques mnémoniques que nous retrouverons souvent : MOV, CMP, LOOP, ... On pourra indifféremment écrire les mnémoniques avec des lettres minuscules ou majuscules. Les opérandes d’une instruction indiquent les données à traiter, soit sous la forme de valeurs constantes, soit en spécifiant l’adresse mémoire (l’emplacement en mémoire) où se trouve la donnée, soit le nom d’un registre contenant la donnée ou contenant l’adresse mémoire de la donnée. Un commentaire commence par un caractère ; et se termine en fin de ligne.

4

❸ Rapport

sur les exercices :

Programme 01 - La somme de deux nombres : Objectif : Nous avons besoins d’un programme qui nous permettre d’additionner deux nombres (5+3).

Méthode de résolution : On va travailler directement avec le registre de 8 bits noté DL qui est spécialisé dans l’affichage. D’abord, on charge la valeur 5 dans DL par l'instruction MOVE, puis on additionne 3 au contenu de DL par l'instruction ADD.

Solution : 1. CODE SEGMENT 2. Main : 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. CODE ENDS 15. END Main

MOV DL,5 ADD DL,3

; Charger DL avec 5 ; Additionner 3 au contenu de DL

ADD DL,48

; Pour obtenir le code ASCII de la contenu de DL

MOV AH,2 INT 21H

; Charger AH avec 2 (Paramètre de l’affichage) ; Appeler l’interruption 21H

MOV AH,4CH INT 21H

; Retour au DOS

Discussion et amélioration : Cette solution est très limitée, parce qu’il aura un problème si la somme des deux nombres est supérieure à 9. Exemple de 9+3 :

5

Comme vous le voyez on a affiché caractère par caractère avec l’addition de nombre 48 au nombre que l'on souhaite afficher, pour obtenir le code ASCII du caractère correspondant à ce nombre. Mais il y a que les nombre de 1 à 9 dans le table ASCII, pour cela on va faire deux solutions (valable juste pour un nombre ≤ 99) un avec la division et l’autre avec le masquage. Dans ces solutions on va utiliser des directives d'assemblage pour définir des constantes, des variables, etc… au début du programme, exactement dans le data segment. 1. DATA SEGMENT 2. nb1 db 90 3. nb2 db 12 4. tmp db ? 5. diz db ? 6. unit db ? 7. DATA ends

AVEC DIVISION : On va diviser le nombre résultant par 10 par l’instruction DIV. Cette instruction fournit un quotient dans AL et un reste dans AH. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46.

DATA SEGMENT nb1 db 90 nb2 db 12 sum db ? diz db ? unit db ? DATA ends CODE SEGMENT Main:

; Déclaration du « Data segment »

MOV AX,DATA MOV ds,AX

; Définition ; du « Data segment »

XOR AX,AX

; Forcer les bits de AX à 0

MOV AL,nb1 ADD AL,nb2 MOV BL,10 DIV BL MOV diz,al MOV unit,ah MOV ADD MOV INT

DL,diz DL,48 AH,2 21H

MOV ADD MOV INT

DL,unit DL,48 AH,2 21H

MOV AH,4CH INT 21H CODE ENDS END Main

6

AVEC MASQUAGE : Cette méthode a besoin d’un ajustement décimal pour fonctionner. 1 - On va stocker la somme dans un variable temporelle parce qu’on va modifier le contenu. 2 - décaler le nombre résultant 4 fois à la droite par l’instruction SHR pour obtenir les dizaines. 3 – On va remettre le variable temporelle dans AL, Puis on va multiplier AL par 0F (00001111) grâce à l’instruction AND pour obtenir l’unité. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44.

DATA SEGMENT nb1 db 3 nb2 db 9 tmp db ? diz db ? unit db ? DATA ends CODE SEGMENT Main : MOV AX,DATA MOV ds,AX XOR AX,AX MOV AL,nb1 ADD AL,nb2 DAA MOV MOV SHR MOV

; Ajustement décimale du résultat tmp,AL CL,4 AL,CL diz,AL

MOV AL,tmp AND AL,0Fh mov unit,AL MOV ADD MOV INT

DL,diz DL,48 AH,2 21H

MOV ADD MOV INT

DL,unit DL,48 AH,2 21H

; Décalage a droit 4 fois

; Forcer les 4 bits de poids fort à 0

MOV AH,4CH INT 21H CODE ENDS END Main

7

Conclusion : On a résolu le problème de l’affichage par deux méthodes le premier on forcer le AX à 0 et on diviser le contenue tout en l’affichant dans AX, dans la deuxième on utilise l’ajustement décimale du résultat, décalage à droite 4 fois est on force les 4bits de poids fort à 0.

8

Programme 02 - La somme de deux vecteurs : Objectif : Un programme qui fait la somme de deux vecteurs. Méthode de résolution : Il est très courant de parcourir un tableau dans une boucle tout en voulant sortir de la boucle lorsqu'une condition est vérifiée ou si on arrive au dernier élément du tableau. Donc la méthode c’est de parcourir les deux vecteurs au même temps élément par élément : - à chaque itération « i » on charge le vecteur v3[i] par le contenu de v1[i], puis on le additionne par le contenu de v2[i]. - afficher v3[i]. - il doit incrémenter les adresses des tableaux - il doit vérifier qu’on n’a pas encore atteint le dernier élément pour sortir la boucle. Pour prendre les adresses qui pointent sur le premier élément de chaque table on va utiliser 3 registres avec l’utilisation de l’instruction LEA : BX v1 SI v2 DI v3 Et pour afficher les valeurs du tableau résultant on va faire la même chose qu’on a déjà fait dans l’exercice 1 avec la comparaison de l’élément v3[i] par 9 (J’ai utilisé la méthode de masquage dans ce exercice).

Solution : 1. DATA SEGMENT 2. v1 db 1,8,3,9,5,6 3. v2 db 9,8,4,0,1,8 4. v3 db 6 dup(?) 5. tmp db ? 6. diz db ? 7. unit db ? 8. nu db 6 9. DATA ENDS 10. CODE SEGMENT 11. Main: 12. 13. MOV 14. MOV 15. 16. LEA 17. LEA 18. LEA 19. JMP 20. 21. Boucle: MOV 22. MOV 23. INT 24. 25. Debut: MOV 26. ADD 27. MOV 28. 29. DAA

AX,DATA DS,AX BX, v1 SI, v2 DI, v3 Debut

; Copier l’adresse de V1 dans BX

; Saut vers l’étiquette « Debut »

DL,44 AH,2 21H AL,[BX] AL,[SI] [DI],AL

; Charger AL par le contenu de l’@ dans BX

; Ajustement décimale du résultat

9

30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. SiDeuxCh: 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. Continu: 64. 65. 66. 67. 68. 69. 70. 71. 72. CODE ENDS 73. END Main

CMP AL,9 JA SiDeuxCh MOV ADD MOV INT

; Saut vers « SiDeuxCh » si AL > 9

DL,AL DL,48 AH,2 21H

JMP Continu

; Saut vers « Continu »

XOR AH,AH MOV MOV SHR MOV

tmp,AL CL,4 AL,CL diz,AL

MOV AL,tmp AND AL,0Fh MOV unit,AL MOV ADD MOV INT

DL,diz DL,48 AH,2 21H

MOV ADD MOV INT

DL,unit DL,48 AH,2 21H

ADD ADD ADD DEC JNZ

BX ,1 SI ,1 DI ,1 nu Boucle

; Incrémenter BX par 1

; Décrémenter BX nu ; Saut vers « Boucle » si n != 0

MOV AH,4CH INT 21H

Discussion et amélioration : Supposant qu’on a 5 vecteurs, donc il doit utiliser 5 registres pour sauvegarder les adresses de chaque vecteur la chose qu’est impossible dans l’assembleur X86. Pour résoudre ce problème on va manipuler seulement les indices des vecteurs par un seul registre (SI) comme dans la programmation en C.

10

1. DATA SEGMENT 2. v1 db 1,8,3,9,5,6 3. v2 db 9,8,4,0,1,8 4. v3 db 6 dup(?) 5. tmp db ? 6. diz db ? 7. unit db ? 8. nu db 6 9. DATA ENDS 10. CODE SEGMENT 11. Main: 12. 13. MOV AX,DATA 14. MOV DS,AX 15. MOV SI,0 16. JMP Debut 17. 18. Boucle: MOV DL,44 19. MOV AH,2 20. INT 21H 21. 22. Debut: MOV AL,v1[SI] 23. ADD AL,v2[SI] 24. MOV v3[SI],AL 25. 26. DAA 27. CMP AL,9 28. JA SiDeuxCh 29. 30. MOV DL,AL 31. ADD DL,48 32. MOV AH,2 33. INT 21H 34. 35. JMP Continu 36. 37. SiDeuxCh: XOR AH,AH 38. MOV tmp,AL 39. MOV CL,4 40. SHR AL,CL 41. mov diz,AL 42. 43. MOV AL,tmp 44. AND AL,0Fh 45. mov unit,AL 46. 47. MOV DL,diz 48. ADD DL,48 49. MOV AH,2 50. INT 21H 51. 52. MOV DL,unit 53. ADD DL,48 54. MOV AH,2 55. INT 21H 56. 57. Continu: ADD SI ,1 58. DEC nu 59. JNZ Boucle 60.

11

61. 62. 63. 64. CODE ENDS 65. END Main

MOV AH,4CH INT 21H

Conclusion : D’après cette amélioration en déduire que l’utilisation des indices est plus efficace pour la manipulation des tableaux dans le langage assembleur, simple, lisible et facile dans la résolution.

12

Programme 03 – Les entries/Sorties – Manipulation des chaine de caractères: Objectif : L’objectif de cet exercice et de se familiariser avec les instructions de lecture et d’écriture des données en utilisant les interruptions. 1.

Afficher un caractère ;

2. Afficher un caractère saisi au clavier par l'utilisateur ; 3. Afficher une chaîne de caractères ; 4. Afficher une chaîne de caractère saisie au clavier par l'utilisateur ; 5. Lire une chaîne de caractère et l'afficher en sens inverse. 6. Lire un caractère au clavier et tester si son code ASCII est celui d'un chiffre. Si c'est le cas, ranger ce chiffre (et non son code ASCII) dans N1, sinon afficher "N". 7.

Ecrire maintenant un programme (numread.asm) qui lit un nombre décimal au clavier et le sauvegarde dans N1. La lecture s'arrête quand le caractère lu n'est pas un chiffre (plus besoin d'afficher "N").

Solution : 1 - Afficher un caractère. 1. CODE SEGMENT 2. MAIN: 3. MOV DL,'A' 4. MOV AH, 2 5. INT 21H 6. 7. MOV AH, 4CH 8. INT 21H 9. CODE ENDS 10. END MAIN

13

2 - Afficher un caractère saisi au clavier par l'utilisateur. 1. CODE SEGMENT 2. MAIN: 3. MOV AH, 4. INT 21H 5. 6. MOV DL, 7. MOV AH, 8. INT 21H 9. 10. MOV AH, 11. INT 21H 12. CODE ENDS 13. END MAIN

1

; Lecture du caractère ; Via l’interruption 21H

AL 2

; ; Affichage du caractère ; Via l’interruption 21H

4CH

3 - Afficher une chaîne de caractères 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16.

DATA SEGMENT CHAINE DB 'Bonjour','$' DATA ENDS CODE SEGMENT MAIN: MOV AX, DATA MOV DS, AX MOV DX, OFFSET CHAINE MOV AH, 09h INT 21H

; ; Affichage de la chaine ;

MOV AH, 4CH INT 21H CODE ENDS END MAIN

14

4 - Afficher une chaîne de caractère saisie au clavier par l'utilisateur 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25.

DATA SEGMENT mot1 db 20 dup('$') return db 13,10,'$' DATA ENDS CODE SEGMENT MAIN: MOV AX, DATA MOV DS, AX MOV ah,0Ah MOV dx,offset mot1 int 21h

; ; Lecture de la chaine ;

MOV ah,09h MOV dx,offset return int 21h

; ; Saut de ligne et retour chariot ;

MOV ah,09h MOV dx,offset mot1+2 INT 21h

; ; Affichage de la chaine saisie ;

MOV ah,4ch INT 21H code ends END MAIN

5 - Lire une chaîne de caractère et l'afficher en sens inverse. 1. DATA SEGMENT 2. CHAINE DB 100 DUP ('$') 3. return db 13,10,'$' 4. DATA ENDS 5. CODE SEGMENT 6. MAIN: 7. MOV AX, DATA 8. MOV DS, AX 9. 10. MOV DX, OFFSET CHAINE 11. MOV AH, 10 12. INT 21H 13. 14. MOV ah,09h 15. MOV dx,offset return 16. int 21h 17. 18. XOR CX,CX 19. MOV CL,CHAINE[1]

; ; Affichage de retour chariot ;

; La longeur de la chaine dans CL

15

20. boucle: 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. CODE ENDS 31. END MAIN

MOV SI,CX ADD SI,1 MOV DL,CHAINE[SI] MOV AH, 2 INT 21H LOOP boucle

; ; ; Afficher carcatère par caractére ; en commencant par le dernier (Longeur-- + 1) ; ;

MOV AH, 4CH INT 21H

6 - Lire un caractère au clavier et tester si son code ASCII est celui d'un chiffre. Si c'est le cas, ranger ce chiffre (et non son code ASCII) dans N1, sinon afficher "N". 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26.

DATA SEGMENT N1 DB ? DATA ENDS CODE SEGMENT MAIN: MOV AH, 1 INT 21H CMP AL, "0" JB nonchiffre

; Si le contenu de al