Assembleur I8086

Assembleur i8086
Philippe Preux IUT Informatique du Littoral Ann ee universitaire 95 96
Avertissement
Ce document d ecrit le langage dassemblage etudi e et utilis e dans le cadre des TP darchitecture. Il est avant tout ` a consid erer comme un manuel de r ef erence. Il ne sagit pas den eectuer une lecture s equentielle du d ebut ` a la n. Les chapitres 1, 2 et 4 pr esentent les principes de base. Les chapitres 3 et 5 sont ` a utiliser en cas de besoin. Le chapitre 6 pr esente des etudes de cas montrant comment ecrire un programme en assembleur, depuis la sp ecication du probl` eme, jusqu` a son ex ecution. Une r` egle dor (valable pour la programmation en assembleur mais aussi dans nimporte quel langage et m eme en toute g en eralit e en informatique) : Lordinateur ne se trompe jamais : il ne fait que ce quon lui demande de faire. Aussi, la programmation en assembleur etant quelque peu subtile, il sagit de r e echir avant de commencer ` taper un programme, de continuer ` a a r e echir pendant quon le tape, ` a poursuivre leort pendant quon lassemble et que lon corrige les erreurs de syntaxe, et de ne pas se laisser aller quand enn, on en arrive ` a son ex ecution qui donnera rarement le r esultat attendu du premier coup avant une bonne p eriode dentra nement. Pendant tout ce temps, rappelez-vous la r` egle dor et gardez votre calme. Ca ne sert ` a rien de s enerver : lordinateur a tout son temps et cest lui qui (( d ecide )) si votre programme marche ou pas ! On se reportera au document intitul e (( M ethodologie de programmation en assembleur )) o` u est d ecortiqu ee la mani` ere de concevoir et d ecrire des programmes en assembleur. An de simplier lexpos e qui suit, nous nous en sommes tenus ` a la programmation dans le mod` ele m emoire dit SMALL (ou TINY). Pour la programmation dans des mod` eles m emoires plus etendus, on se r ef erera au manuel de lassembleur.
Chapitre 1
Introduction
Dans ce premier chapitre, nous introduisons rapidement les notions de processeur, m emoire, adresse et registre et d ecrivons le codage des valeurs num eriques.
1.1
Un processeur, en deux mots
Sans entrer dans les d etails qui seront vus en cours, nous pr esentons le minimum ` a savoir sur ce quest un processeur. Un processeur constitue le cur de tout ordinateur : il ex ecute les instructions qui composent les programmes que nous lui demandons dex ecuter. Les instructions sont stock ees en m emoire (en dehors du processeur). Ces instructions (dont lensemble compose le langage dassemblage, ou assembleur) sont tr` es simples mais nen permettent pas moins, en les combinant, de r ealiser nimporte quelle op eration programmable. Pour ex ecuter un programme, le processeur lit les instructions en m emoire, une par une. Il connait ` a tout instant ladresse (lendroit dans la m emoire) ` a laquelle se trouve la prochaine instruction ` a ex ecuter car il m emorise cette adresse dans son compteur ordinal. Les instructions agissent sur des donn ees qui sont situ ees soit en m emoire, soit dans des registres du processeur. Un registre est un el ement de m emorisation interne au processeur et contenant une valeur. Les registres sont en nombre tr` es limit e, 14 en loccurence pour le 8086. Pour acc eder une donn ee en m emoire, il faut sp ecier son adresse. Pour acc eder une donn ee dans un registre, il faut sp ecier son nom (chaque registre poss` ede un nom qui est une cha ne de caract` eres). Le 8086 est un processeur 16 bits, cest-` a-dire quil traite des donn ees cod ees sur 16 bits. Pour terminer, on donne quelques d enitions : un bit est une valeur binaire qui, par convention, peut prendre la valeur 0 ou 1 ; un octet est une donn ee cod ee sur 8 bits ; un mot est une donn ee cod ee sur 16 bits ; un Koctet est un ensemble de 1024 octets.
1.2
La m emoire
La m emoire est une s equence doctets, tous num erot es de mani` ere unique par un entier compris entre 0 et N 1. On dit alors que la capacit e de la m emoire est de N octets. On a toujours N qui est une puissance de 2 (N = 2m ). On appelle adresse eective (AE) dun octet en m emoire le num ero qui lui est associ e (cf. g 1.1).
4 Adresses eectives 0 1 2
CHAPITRE 1. INTRODUCTION
N 1 = 2m 1
Fig. 1.1 Une m emoire de N octets.
Pour le 8086, et donc pour nous programmeurs du 8086, un octet est d esign e par un couple ( num ero de segment, d eplacement dans le segment ) qui constituent une adresse segment ee (AS). Un segment est un ensemble de 64 Koctets cons ecutifs. Le d eplacement (ou oset) sp ecie un octet particulier dans un segment (cf. g. 1.2). Segment et d eplacement sont cod es sur 16 bits et peuvent donc prendre une valeur comprise entre 0 et 65535. On a une relation entre adresses eectives et couple (segment, d eplacement) sous la forme de l equation : adresse eective = 16 segment + d eplacement Une cons equence de la relation enonc ee plus haut entre adresse eective et adresse segment ee est quun octet dadresse eective donn ee peut etre acc ed e de plusieurs mani` eres. Plus pr ecis ement, ` a chaque AE correspond 212 = 4096 AS di erentes (cf. g. 1.3). Lors de son ex ecution, un programme utilise plusieurs segments m emoire (cf. g. 1.4) : un segment contient les instructions du programme (le segment de code) ; un segment contient les donn ees du programme (le segment de donn ees) ; un segment contient la pile du programme (le segment de pile). Ce segment tr` es important sera d ecrit au chapitre 4. Ces trois segments peuvent se situer nimporte o` u en m emoire et m eme se recouvrir partiellement ou totalement. Leur attribution en m emoire est g en eralement r ealis ee automatiquement par le syst` eme dexploitation sans que le programmeur ait a ` sen soucier. En respectant un certain protocole (suivi dans ce manuel), on est certain de r ef erencer le bon segment sans se poser de questions trop compliqu ees.
1.3
Les registres du 8086
Le 8086 poss` ede 14 registres de 16 bits (cf. g. 1.5). Ce sont : ax registre dusage g en eral contenant des donn ees. Les 8 bits de poids faible se nomment al et les 8 bits de poids fort se nomment ah.
1.3. LES REGISTRES DU 8086
Adresses eectives 0 1 2
s0 1
octet ` a loset d du segment N = s/16
65535
2m 1
Fig. 1.2 Adressage segment e. En traits gras, on a repr esent e le segment commen cant a ` ladresse eective s . s doit etre un multiple de 16 pour etre le 1er octet dun segment. s dont le num ero est donc N = 16
bx registre dusage g en eral contenant des donn ees. Comme ax, bx se d ecompose en bl et bh. cx registre dusage g en eral contenant des donn ees. Comme ax, cx se d ecompose en cl et ch. dx registre dusage g en eral contenant des donn ees. Comme ax, dx se d ecompose en dl et dh. si registre dusage g en eral contenant g en eralement le d eplacement dans un segment dune donn ee. di registre dusage g en eral contenant g en eralement le d eplacement dans un segment dune donn ee. bp registre utilis e pour adresser des donn ees dans la pile (cf. section 4.4). sp registre pointeur de pile. Ce registre sera d ecrit plus loin (cf. section 4.2.4). ip registre pointeur dinstruction (compteur ordinal ). Ce registre indique la prochaine instruction ` a ex ecuter. ags registre dindicateurs de l etat du processeur. Certains bits de ce registre portent des noms. Ce sont tous des indicateurs binaires : O le bit doverow est positionn e par la plupart des instructions arithm etiques pour indiquer sil y a eut un d ebordement de capacit e lors du calcul (un nombre trop grand ou trop petit) D bit de direction. Il sera d ecrit plus loin (cf. section 3.3.6) S le bit de signe est positionn e par la plupart des instructions arithm etiques pour indiquer le signe du r esultat (positif ou n egatif cf. section 1.4.2) Z le bit de z ero est positionn e par la plupart des instructions arithm etiques pour indiquer que le r esultat du calcul est 0
CHAPITRE 1. INTRODUCTION C le bit de carry (retenue) est positionn e par la plupart des instructions arithm etiques pour indiquer si le calcul a engendr e une retenue qui devra etre report ee sur les calculs suivants (cf. section 3) A le bit dit auxiliary carry (retenue auxiliaire) est positionn e par la plupart des instructions arithm etiques pour indiquer une retenue entre bits de poids faible et bits de poids forts dun octet, dun mot ou dun double mot (cf. section 3) P le bit de parit e est positionn e par la plupart des instructions arithm etiques. Il indique si les 8 bits de poids faible du r esultat comportent un nombre pair de 1. Le 8086 comporte egalement des registres 16 bits pour contenir des num eros de segment :
cs code segment segment contenant le programme en cours dex ecution ds data segment segment contenant les donn ees es registre segment auxiliaire pour adresser des donn ees ss stack segment segment contenant la pile Les valeurs des registres cs, ds et ss sont automatiquement initialis ees par le syst` eme dexploitation au lancement du programme. D` es lors, ces segments sont implicites, cest-` a-dire que si lon d esire acc eder ` a une donn ee en m emoire, il sut de sp ecier son oset sans avoir ` a se soucier du segment.
1.4
Le codage des nombres
Les instructions du 8086 manipulent des valeurs num eriques enti` eres cod ees sur 1 ou 2 octets. Nous d ecrivons ici le codage des nombres entiers. Nous distinguons quatre types de codage : non sign e pour des nombres entiers forc ement positifs ; sign e pour des nombres entiers positifs ou n egatifs. d ecimal compact e, ou d ecimal cod e binaire d ecimal non compact e Cest au programmeur de d ecider du codage quil utilise et ` a ecrire son programme en cons equence. Lordinateur ne sait pas quel est le codage utilis e. Il ex ecute simplement des instructions. Nous d ecrivons ces codages et quelques notions qui leur sont li ees. Nous supposerons dans ce qui suit que les donn ees sont cod ees sur un octet (8 bits). Tout ce qui est dit peut- etre adapt e imm ediatement pour des donn ees qui seraient cod ees sur un mot, un double mot ou un nombre quelconque de bits.
1.4.1
Repr esentation non sign ee des nombres entiers
Avec l bits, il est possible de coder 2l valeurs di erentes. Si l = 8, on peut donc coder 256 valeurs di erentes. On peut etablir le codage suivant, sur 8 bits : Valeur 0 1 2 3 ... 84 ... 254 255 Codage 00000000 00000001 00000010 00000011 ... 01010100 ... 11111110 11111111
Ce codage permet de repr esenter tout nombre entier entre 0 et 255 (0 et 2l 1) avec 8 bits (l bits). Du fait que lon ne repr esente que des nombres positifs, ce codage est quali e de non sign e.
1.4. LE CODAGE DES NOMBRES
1.4.2
Repr esentation sign ee des nombres entiers
Si lon veut pouvoir repr esenter des nombres positifs et n egatifs, lid ee naturelle consiste, plut ot qu` a coder des nombres compris entre 0 et 255, ` a repr esenter des nombres entre -128 et +127, ce qui repr esente toujours 256 valeurs di erentes ` a coder avec 8 bits.
Valeur -128 -127 ... -45 ... -1 0 1 2 ... 84 ... 126 127
Codage 10000000 10000001 ... 11010011 ... 11111111 00000000 00000001 00000010 ... 01010100 ... 01111110 01111111
Ce codage se nomme codage par compl ement a ` deux. Lobtention du codage par compl ement ` a deux dun nombre est indiqu e plus bas. On constate, ceci est tr` es important pour que le processeur traite indi eremment des nombres en codage sign e ou non, que le fait de faire une op eration (par exemple ajouter 1 ` a une valeur) fonctionne quel que soit le codage utilis e. Faire la somme au niveau du codage binaire ou au niveau des nombres repr esent es donne le m eme r esultat. Prenons 25 + 36 61 un exemple : 00011001 00100100 00111101
Dans le codage sign e, on constate que le bit de poids fort vaut 1 pour tous les nombres n egatifs, 0 pour tous les nombres positifs. Ce bit indique donc le signe du nombre cod e. Aussi, ce bit se nomme le bit de signe. Il faut bien prendre garde que si le bit de signe vaut 0, la valeur repr esent ee est la m eme en codage sign e ou non sign e. Par contre, si le bit de signe vaut 1, la valeur cod ee est sup erieure ` a 127 en codage non sign e, inf erieure ` a 0 en codage sign e.
1.4.3
Codage d ecimal
En codage d ecimal 1 , un chire d ecimal (compris donc entre 0 et 9) est cod e sur 4 bits. 4 bits codant en principe 16 valeurs di erentes, seules 10 de ces 16 combinaisons sont eectivement utilis ees en codage d ecimal, les autres nayant alors pas de sens. Le codage est le suivant :
1. on parle aussi de binaire cod e d ecimal
8 Valeur 0 1 2 3 4 5 6 7 8 9 Codage 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
On distingue deux types de repr esentation, compact ee ou non. Un chire n ecessitant 4 bits pour son codage, on peut repr esenter deux chires par octet. Ce codage porte le nom de codage d ecimal compact e. On peut egalement ne mettre quun seul chire par octet, les 4 bits de poids fort de loctet etant inutilis es. On qualie ce codage de d ecimal non compact e. On reverra plus loin ces codages (cf. 3.3.6). Le codage d ecimal est tr` es utile pour passer de la repr esentation cod ee dun nombre dans sa repr esentation en cha ne de caract` eres ASCII. Par exemple, 19 se code : d ecimal compact e 00011001 d ecimal non compact e 00000001 00001001 Deux octets sont n ecessaires dans la repr esentation non compact ee.
1.4.4
Compl ement ` a deux dun nombre
Nous indiquons ici comment obtenir le compl ement ` a deux dun nombre. Cette m ethode donne la repr esentation binaire sign ee dun nombre n egatif. Lalgorithme est simple. Soit ` a calculer la repr esentation du nombre n (o` u n est un nombre positif). On eectue les op erations suivantes : ecrire n sous forme binaire en compl ementer tous les bits (0 1, 1 0) ajouter la valeur 1 ` a ce nombre binaire. Nous pr esentons cet algorithme sur un exemple. Soit ` a calculer le compl ement ` a deux de -23 : la repr esentation binaire sur 8 bits de 23 est 00010111 par compl ement des bits, on obtient : 11101000 en ajoutant 1, on obtient : 11101001 Le compl ement ` a deux de 00010111 est donc 11101001. La repr esentation binaire sign ee de -23 est donc 11101001.
1.4.5
Extension du signe
Etendre le signe dune donn ee consiste, lors du transfert de la valeur dun octet dans un mot ` a recopier le bit de signe de loctet sur tous les bits de loctet de poids fort du mot. Par exemple, lextension du signe de 10011110 en mot donne 1111111110011110.
1.5. NOTATION
1.5
Notation
Dans ce document, nous utiliserons la notation suivante : 10 indique la valeur num erique 10 AX indique la valeur contenue dans le registre AX (10) indique la valeur qui se trouve ` a loset 10 dans le segment de donn ees (SI) indique la valeur qui se trouve ` a loset dont la valeur se trouve dans le registre SI (DS:SI) indique la valeur qui se trouve ` a loset contenu dans le registre SI et le segment dans le registre DS
10
0 / 1 / / / a + 16 16 / / / / a + 32 32 / / d / / / a
\ \ \ \ \ \ \ \ \ \ \ \ \
/ / segment s = /
a 16
/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
\ \ segment s + 1 \
/ \ / \ segment s + 2 / \
Fig. 1.3 Les segments : on a repr esent e quelques segments pour montrer leur chevauchement et le fait quun octet-m emoire poss` ede plusieurs adresses segment ees. Par exemple, loctet dadresse eective peut etre adress e de multiples fa cons, selon que lon consid` ere quil se trouve dans le segment s, s + 1, s + 2, ... Dans chacun de ces cas, ladresse segment ee de loctet est ( s, d ), ( s + 1, d 16 ), ( s + 2, d 32 ), ... Notons que chaque octet-m emoire appartient a ` 212 = 4096 segments di erents.
1.5. NOTATION
11
(cs)
(ip) instruction suivante ` a ex ecuter
(ds)
(ss) 0 : fond de la pile 1 2
(sp) dernier octet utilis e dans la pile
Fig. 1.4 Structure de la m emoire. On a repr esent e en traits gras les segments de code, de donn ees et de pile qui sont cr e es lors du d eclenchement de lex ecution dun programme (de haut en bas en r ealit e, ils peuvent bien entendu etre situ es nimporte o` u en m emoire). Chaque segment est r ef erenc e par un registre de segment. Les di erents segments peuvent se recouvrir partiellement ou compl etement.
12
ax bx cx dx si di sp bp ip cs ds es ss flags
ah bh ch dh
al bl cl dl
oset du sommet de pile oset de la prochaine instruction ` a ex ecuter num ero du segment dinstructions num ero du segment de donn ees num ero du segment de pile
Fig. 1.5 Les registres du 8086 et leur utilisation. Chaque registre contient 16 bits.
13
Chapitre 2
Anatomie dun programme en assembleur

Un programme en assembleur a une forme bien particuli` ere. Chaque ligne dun source assembleur comporte une instruction. Chaque ligne est compos ee de champs. De gauche ` a droite, on a : le champ etiquette, qui peut etre vide le champ mn emonique (le nom de linstruction) le champ op erande (les arguments de linstruction), qui peut etre vide le champ commentaire, qui peut etre vide Une etiquette est un identicateur compos e de lettres, chires et de caract` eres $, %, _ et ? Quelques exemples d etiquettes valides : boucle, fin_de_tant_que, ... Un mn emonique est, g en eralement, compos e uniquement de lettres. Quelques mn emoniques que nous retrouverons souvent : MOV, CMP, LOOP, ... On pourra indi eremment ecrire les mn emoniques avec des lettres minuscules ou majuscules. Les op erandes dune instruction indiquent les donn ees ` a traiter, soit sous la forme de valeurs constantes, soit en sp eciant ladresse m emoire (lemplacement en m emoire) o` u se trouve la donn ee, soit le nom dun registre contenant la donn ee ou contenant ladresse m emoire de la donn ee. Un commentaire commence par un caract` ere ; et se termine en n de ligne. Bien que la syntaxe soit assez souple, nous respecterons toujours les r` egles suivantes : une instruction par ligne le mn emonique de linstruction commence ` a la colonne 10 une d enition d etiquette commence en colonne 1 les op erandes des instructions commencent en colonne 20 les commentaires en n de ligne commencent en colonne 35 les blocs de commentaires sont align es sur les mn emoniques et commencent donc en colonne 10 (cesta-dire, le ; de d ` ebut de commentaire se trouve en colonne 10)
14
CHAPITRE 2. ANATOMIE DUN PROGRAMME EN ASSEMBLEUR
2.1
Exemple
; ; ; ; ; Forme g en erale dun fichier source en assembleur 8086 Nom du fichier : modele.asm Date decriture : 15 Nov. 1993 Objet : indiquer ici a ` quoi sert le programme, comment on lutilise, ... small 200h ; d efinit le mod` ele m emoire ; taille de la pile ; d efinition des donn ees du programme ....
.MODEL .STACK .DATA DB .... .... .... .CODE .... .... .... .... mov int .... .... END
donnee1
; les instructions composant le programme
ah,4ch 21h
; ; terminaison du programme
; fin du source
Un programme en assembleur commencera donc, par convention, par un bloc de commentaire indiquant lauteur du programme, la date de r ealisation du programme ainsi que son utilit e et utilisation. On trouve ensuite quelques lignes sp eciant des informations qui seront d etaill ees plus tard. On trouve ensuite une zone de d enition des donn ees qui d ebute par la pseudo-instruction 1 .DATA. On trouve ensuite les instructions du programme, lesquelles d ebutent par une pseudo-instruction .CODE. Parmi ces instructions, on trouvera g en eralement la s equence indiqu ee qui termine lex ecution du programme. Enn, la derni` ere ligne du programme est la pseudo-instruction END qui indique la n du source. On notera que la plupart des instructions ont leur premier op erande qui indique une donn ee et lendroit o` u il faut ranger le r esultat (donn ee et r esultat sont stock es au m eme endroit), le deuxi` eme qui indique une donn ee. Par exemple, dans le squelette de programme ci-dessus, dans linstruction mov ah, 4ch, ah est la destination de linstruction, 4ch la donn ee source.
2.1.1
Sp ecier une donn ee en m emoire (une variable)
Il y a 16 mani` eres de sp ecier le d eplacement dans un segment m emoire : etiquette [bx] [si] [di] bx+ etiquette
1. une pseudo-instruction, ou directive dassemblage, est une commande en langage dassemblage qui nest pas une instruction du processeur. Elle est seulement utilis ee pour donner des informations a ` lassembleur.
2.1. EXEMPLE bx+si+ etiquette bx+di+ etiquette [bx+si] [bx+di] [bp+si] [bp+di] bp+ etiquette bp+si+ etiquette bp+di+ etiquette si+ etiquette di+ etiquette
15
etiquette indique l etiquette dune donn ee d enie dans la section .data du programme (cf. plus bas). o` u d eplacement est une constante cod ee sur 16 bits. Notons au passage que lon peut r ecup erer la valeur des adresses de d ebut de segment de donn ees et de code en utilisant les symboles @data et @code respectivement. Il faut noter que toutes les r ef erences ` a des op erandes en m emoire sont implicitement situ ees dans le segment dont le num ero est contenu dans le registre DS. Lorsque cela nest pas le cas, cela sera mentionn e explicitement.
2.1.2
Les constantes
Les constantes num eriques On peut sp ecier les constantes num eriques dans les bases 2, 8, 10 et 16. Une constante num erique commence toujours par un chire. A priori, une constante est not ee en base 10. Pour lexprimer en base 2, une constante ne doit comporter que des chires 0 et 1 et etre termin ee par la lettre b. Pour lexprimer en base 8, une constante ne doit comporter que des chires 0, 1, 2, 3, 4, 5, 6 ou 7 et se terminer par la lettre o. Pour lexprimer en base 16, une constante ne doit comporter que des chires de 0 ` a 9 ou des lettres de a ` af pour les valeur hexad ecimales correspondant aux nombres d ecimaux 10, 11, 12, 13, 14 et 15 et se terminer par la lettre h. Par exemple : 100110b est une constante binaire dont la valeur d ecimale est 38 37o est une constante octale dont la valeur d ecimale est 31 4ch est une constante hexad ecimale dont la valeur d ecimale est 76 Puisquune constante num erique doit toujours commencer par un chire, une constante hexad ecimale dont le premier caract` ere est une lettre sera pr ec ed ee dun 0. Ainsi, la valeur c3 sera not ee 0c3h dans un source assembleur. Les constantes cha nes de caract` eres Une cha ne de caract` eres est une suite de caract` eres entre . Si on veut mettre un caract` ere dans une constante, il sut de la doubler. Exemples : hello world larbre
16 D eclaration dune constante
La directive EQU associe une valeur ` a un symbole qui pourra etre ensuite utilis e dans le programme ` a la place de la constante quelle d enit. nom EQU constante Par exemple, la commande : TROIS EQU 3
d enit une constante qui sappelle TROIS. dont la valeur est 3. Une fois cette d eclaration eectu ee, toute occurence de lidenticateur TROIS sera remplac ee par la valeur indiqu ee.
2.1.3
Les d eclarations de variables
Lespace m emoire est utilis e pour stocker des constantes (cha nes de caract` eres, valeurs num eriques, ...) ou des variables. Avant demployer une variable, il faut pr ealablement la d eclarer (comme dans tout langage). D eclarer une variable (et ceci est vrai aussi dans les langages de haut niveau comme Pascal, mais cest un peu cach e) revient toujours ` a r eserver un emplacement en m emoire pour y stocker la valeur de cette variable. La directive DB [nom] DB constante [, constante] R eserve et initialise un octet. nom est un symbole permettant dacc eder ` a cet octet 2 . Par exemple, les 4 lignes suivantes : OCTET DEUX_OCTETS LETTRE CHAINE TABLEAU DB DB DB DB DB 36 43, 26 e hello world !, 13, 10, $ 10 dup (0)
d enissent 5 symboles comme suit : NB_OCTET r ef erence une donn ee cod ee sur un octet dont la valeur sera initialis ee ` a 36 DEUX_OCTETS r ef erence une donn ee cod ee sur un octet dont la valeur sera initialis ee ` a 43, loctet suivant etant initialis e avec 26. On peut consid erer que DEUX_OCTETS r ef erence un tableau de 2 octets ; LETTRE r ef erence une donn ee dont la valeur sera initialis ee avec le code ASCII du caract` ere e ; CHAINE r ef erence une cha ne de caract` eres compos ee des caract` eres h, e, l, l, o, , w, o, r, l, d, , !, des caract` eres de code 13 (retour en d ebut de ligne) et 10 (aller ` a la ligne suivante) et enn du caract` ere $ 3 . TABLEAU r ef erence un tableau de 10 octets dont la valeur initiale des el ements est 0 On constate donc que la valeur initiale dun symbole peut etre exprim ee de di erentes mani` eres : une valeur plusieurs valeurs s epar ees par des virgules
2. la notation [xxx] indique que xxx est facultatif 3. les caract` eres de code 13 et 10 plac es en n de cha ne entra nent le passage a ` la ligne apr` es lachage du message ; le caract` ere $ indique la n de la cha ne de caract` eres. En g en eral, toute cha ne de caract` eres devant etre ach ee a ` l ecran se terminera par un caract` ere $.
2.2. LASSEMBLAGE le code dun caract` ere une cha ne de caract` eres, chacun des caract` eres initialisant un octet
17
On pourra g en eralement utiliser lune de ces formes dans toute instruction, du moment que cela a un sens. On verra egalement dautres mani` eres de sp ecier des valeurs par la suite. Celles-ci sont tout aussi valides pour nimporte quelle instruction, du moment quelles ont un sens. La directive DW [nom] DW constante [, constante] R eserve et initialise un mot (16 bits). nom est un symbole permettant dacc eder ` a ce mot. Ainsi, les lignes suivantes d enissent : MOT MOT2 TMOT DW DW DW 1559 ((45 * 23) / 9 + 23) 20 DUP (0)
le symbole MOT qui r ef erence une une donn ee cod ee sur un mot et qui sera initialis ee avec la valeur 1559 ; le symbole MOT2 qui r ef erence une donn ee cod ee sur un mot et qui est initialis ee avec la valeur 138 ; le symbole TMOT qui r ef erence un tableau de 20 mots initialis es avec la valeur 0 On voit donc sur cet exemple quune valeur constante peut etre sp eci ee avec une expression num erique, du moment que celle-ci est calculable lors de lassemblage. Sans entrer dans les d etails ici, on peut indiquer que la valeur dune expression est calculable ` a lassemblage si elle ne comporte que des valeurs num eriques ou des constantes d enies par des pseudo-instructions EQU ou une adresse. A ce propos, il est tr` es important de bien noter la di erence entre un symbole d eni par une directive EQU et un symbole d eni par une directive DB ou DW. Si nous consid erons les exemples pr ec edents : TROIS est une constante dont la valeur est 3 ; OCTET, MOT, DEUX_OCTETS, ... sont des constantes dont la valeur est ladresse ` a laquelle seront stock ees les valeurs 36, 1559, 43, 26, ... Par analogie avec un programme Pascal, nous pouvons dire que TROIS est une constante, alors que les autres symboles (OCTET, MOT, ...) sont des variables qui seront initialis ees avec les valeurs indiqu ees. Au cours de lex ecution du programme, la valeur se trouvant ` a ladresse OCTET pourra etre modi ee. Notons que les octets composant un mot sont stock es de la mani` ere suivante : le poids faible est mis dans le premier octet, le poids fort dans le deuxi` eme octet. Ainsi, si on d eclare : M DW 1234h
la valeur 34h est mise ` a ladresse M et la valeur 12h ` a ladresse M+1.
2.2
Lassemblage
Une fois un programme source assembleur saisi sous editeur de textes dans un chier dont lextension est ASM, il faut le transformer en un programme ex ecutable. Pour un langage de haut niveau comme Pascal, cette phase se nomme la compilation. Pour un programme ecrit en assembleur, cette transformation se nomme assemblage. Pour cela, on utilise la commande TASM2 avec, en argument, le nom du chier ` a assembler. Des erreurs de syntaxe seront eventuellement d etect ees quil faudra corriger avant de continuer. Une fois que lassemblage a eu lieu sans d etection derreur, on obtient un chier de m eme nom que le chier source et avec une extension OBJ. Il faut alors r ealiser une edition de liens. Pour cela, on utilise la commande TLINK2
18
avec, en argument, le nom du chier, sans extension. A lissue de ce processus, on obtient un chier portant le m eme nom que le chier source et dextension EXE. Ce chier est ex ecutable. Il est bon de noter que dans le programme ex ecutable, les instructions ont et e cod ees. Ainsi, chaque instruction est cod ee par un octet ou une succession doctets cons ecutifs en m emoire (segment de code). Dans le codage dune instruction, on trouve le code-op eration qui indique le mn emonique (1 ou 2 octets) suivi du ou des op erandes (valeur imm ediate, registre, adresse).
Code op eration
Codes op erandes
Fig. 2.1 Le codage dune instruction
19
Chapitre 3
Les instructions du 8086

Dans ce chapitre, nous pr esentons une par une les instructions du 8086.
Mod` ele de description dune instruction

Pour toutes les instructions poss edant plusieurs modes dadressage des op erandes, on trouvera un tableau pr esentant ces modes de la forme suivante ; xxx ... ... operande1, operande2, ... commentaire
Dans la colonne de gauche, on trouve le mn emonique de linstruction. Dans la colonne suivante, on trouve le mode dadressage des op erandes. La colonne de droite absente dans certaines tables, donnent quelques informations compl ementaires. Les modes dadressage sont indiqu es de la mani` ere suivante : AL, AH, ... un registre particulier registre un registre 8 ou 16 bits parmi AL, AH, AX, BL, BH, BX, CL, CH, CX, DL, DH, DX, SI ou DI. variable une etiquette de donn ee d enie dans la section .data du programme registre/variable un registre ou une etiquette de donn ee constante une constante etiquette une etiquette correspondant ` a une instruction, donc d enie dans la section.code du programme La plupart des instructions modient les indicateurs du registre FLAGS. Un tableau indique leet de linstruction couramment d ecrite sur ces indicateurs. Il a la forme suivante ; O D I T S Z A P C
La premi` ere ligne indique le nom des bits int eressants de FLAGS. La deuxi` eme ligne (vide ici) indique leet de linstruction sur un bit en particulier. On note : * le bit est modi e en fonction du r esultat de lex ecution de linstruction ? le bit a une valeur ind enie apr` es lex ecution de linstruction 1 le bit est mis ` a1 0 le bit est mis ` a0 Une case vide indique que lindicateur nest pas modi e par linstruction.
20
CHAPITRE 3. LES INSTRUCTIONS DU 8086
3.1
3.1.1
Les instructions arithm etiques et logiques

Les instructions arithm etiques
Comme dans de nombreux processeurs, le 8086 poss` ede des instructions +, , et qui traitent des donn ees enti` eres cod ees sur un octet ou un mot. Pour faire des op erations sur des donn ees plus complexes (des nombres ottants par exemple), on devra les programmer. ADD addition sans retenue
ADD ADD ADD O *
registre/variable, registre registre, registre/variable registre/variable, constante D I T S * Z * A * P * C *
Linstruction ADD eectue laddition du contenu du registre source au registre destination, sans report de retenue, soit ; destination source + destination La retenue est positionn ee en fonction du r esultat de lop eration. Par exemple, si les instructions suivantes sont ex ecut ees ; mov add ax, a9h ax, 72h
alors le registre AX contient la valeur 1bh, le bit C est positionn e` a la valeur 1, la retenue auxiliaire A est mise ` a 0. Si nous consid erons les deux instructions suivantes ; mov add ax, 09h ax, 3ah
alors le registre AX contient la valeur 43h, le bit C est mis ` a 0, la retenue auxiliaire A est mise ` a 1. SUB soustraction sans retenue
SUB SUB SUB O *
Linstruction SUB eectue la soustraction du contenu du registre source au registre destination, sans report de retenue, soit ; destination destination - source
3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES La retenue est positionn ee en fonction du r esultat de lop eration. Par exemple, si les instructions suivantes sont ex ecut ees ; mov sub ax, 39h ax, 18h
21
le registre AX contient ensuite la valeur 21h. Les bits Z, S et C du registre FLAGS sont mis ` a 0 car le r esultat nest pas nul, son signe est positif et aucune retenue nest g en er ee. Si nous consid erons les deux instructions suivantes ; mov sub ax, 26h ax, 59h
le registre AX contient ensuite la valeur cdh. Le bit Z est mis ` a z ero. Les bits C, A et S sont mis ` a 1. IMUL MUL
Les multiplications en assembleur
IMUL O * D I
registre/variable T S ? Z ? A ? P ? C *
Les deux instructions IMUL et MUL eectuent des multiplications. Linstruction IMUL eectue la multiplication dop erandes sign es. Linstruction MUL eectue la multiplication dop erandes non sign es. Les indicateurs de retenue (C) et de d ebordement (O) sont mis ` a un si le r esultat ne peut pas etre stock ee dans lop erande destination. Une addition ou une soustraction de donn ees cod ees sur n bits donne un r esultat sur au plus n + 1 bits. Le bit suppl ementaire est la retenue et est stock e dans le bit C de flags. Par contre, une multiplication de deux donn ees de n bits donne un r esultat sur 2n bits. Dans leur premi` ere forme qui prend une donn ee 8 bits en op erande (donc le r esultat est sur 16 bits), les instructions mul et imul eectuent le produit de la valeur contenue dans le registre al avec la valeur de lop erande fourni. Le r esultat est plac e dans le registre ax. Dans leur deuxi` eme forme qui prend une donn ee 16 bits en op erande (donc le r esultat est sur 32 bits), les instructions mul et imul eectuent le produit de la valeur contenue dans le registre ax avec la valeur de lop erande fourni. Le r esultat est plac e dans la paire de registres dx et ax. dx contient le poids fort du r esultat, ax le poids faible. Exemple de multiplication sur 8 bits : soient les instructions suivantes : mov mov imul al, 4 ah, 25 ah
` lissue de lex A ecution de ces 3 instructions, le registre AH contient la valeur 100, produit de 4 par 25. Pour bien comprendre la di erence entre les instructions imul et mul, regardons les exemples suivants : mov bx, 435 mov ax, 2372 imul bx
22
` lissue de lex A ecution de ces 3 instructions, ax contient la valeur be8c et dx la valeur f, soit la valeur hexad ecimale fbe8c, cest-` a-dire 1031820, le produit de 435 par 2372. Les deux donn ees etant positives, le r esultat est le m eme que lon utilise linstruction imul ou linstruction mul. Consid erons maintenant la s equence dinstructions : mov bx, -435 mov ax, 2372 imul bx ` A lissue de leur ex ecution, ax contient la valeur 4174 et dx contient la valeur fff0, soit la valeur -1031820. Si lon remplace imul par mul, le r esultat na pas de sens. IDIV DIV Les divisions en assembleur IDIV O ? D I registre/variable T S ? Z ? A ? P ? C ?
Les deux instructions DIV et IDIV r ealisent les op erations de division et de calcul de reste. DIV leectue sur des donn ees non sign ees, IDIV sur des donn ees sign ees. Dans tous les cas, le dividende est implicite. Le diviseur est fourni en op erande. Le r esultat se compose du quotient et du reste de la division. Le reste est toujours inf erieur au diviseur. On a le choix entre : la division dune donn ee 16 bits stock ee dans AX par une donn ee 8 bits qui fournit un quotient dans AL et un reste dans AH sur 8 bits. la division dune donn ee 32 bits stock ee dans la paire de registres DX (poids fort) et AX (poids faible) par une donn ee 16 bits qui fournit un quotient dans AX et un reste dans DX sur 16 bits. Soient les quelques lignes dassembleur suivantes : mov mov div ax, 37 dx, 5 dl
Apr` es leur ex ecution, le registre AX contient la valeur 7, quotient de 37 par 5 et le registre DX contient le reste de la division, 2. Pour les deux instructions, si le diviseur de la division est nul, un message Division par zero sera ach e automatiquement. Dans le cas dune division sign ee IDIV, le reste a le m eme signe que le dividende et sa valeur absolue est toujours inf erieure au diviseur. Pour bien comprendre le fonctionnement de ces deux instructions, prenons lexemple suivant : mov bx, 435 mov ax, 2372 div bx ` lissue de lex A ecution de cette s equence dinstructions, le registre ax contiendra la valeur 5 qui est le quotient de 2372 par 435, et le registre dx vaudra 197 qui est le reste de la division. Si on remplace div par idiv, le r esultat est inchang e puisque le diviseur et le dividende sont tous deux positifs. Si lon consid` ere maintenant la s equence : mov bx, -435 mov ax, 2372 idiv bx on aura ensuite ax qui contient la valeur -5 (soir fffb en hexad ecimal) et dx la valeur 197. Si lon remplace idiv par div, le r esultat na pas de sens.
3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES
23
3.1.2
Incr ementation, d ecr ementation
Nous voyons ici deux types dinstructions tr` es fr equemment utilis ees et qui sont en fait des cas particuliers des instructions daddition et de soustraction, lincr ementation et la d ecr ementation. Incr ementer signie (( ajouter 1 )), alors que d ecr ementer signie (( retirer 1 )). Notons cependant que lon utilise souvent les termes incr ementer et d ecr ementer m eme si les quantit es ajout ees ou retir ees sont di erentes de 1, en g en eral lorsque la variable modi ee est un compteur. DEC d ecr ementation DEC O * D I registre/variable T S * Z * A * P * C
DEC soustrait 1 au contenu de lop erande, sans modier lindicateur de retenue. Soient les instructions assembleur suivantes ; mov dec al, 01h al
AL contient ensuite la valeur 00. Le bit Z est mis ` a 1, les bits O, P, A et S mis ` a 0. INC incr ementation INC O * D I registre/variable T S * Z * A * P * C
INC ajoute 1 au contenu de lop erande, sans modier lindicateur de retenue. Soient les instructions assembleur suivantes ; mov inc al, 3fh al
AL contient ensuite la valeur 40h. Le bit Z est mis ` a 0 (le r esultat de lincr ementation nest pas nul), lindicateur de retenue auxiliaire bit A est mis ` a 1 (passage de retenue entre les bits 3 et 4 lors de lincr ementation), les bits bit O et bit S mis ` a 0 (pas de d ebordement de capacit e, le signe du r esultat est positif).
3.1.3
NEG
Oppos e dun nombre
N egation par compl ement ` a2 NEG O * D I registre/variable T S * Z * A * P * C *
NEG transforme la valeur dun registre ou dun op erande m emoire en son compl ement ` a deux. Ainsi, apr` es ex ecution des instructions ; mov neg ax, 35 ax
le registre AX contient la valeur -35.
24
3.1.4
Les instructions bool eennes et logiques
Ces instructions disponibles sur tous les processeurs travaillent sur les donn ees au niveau des bits (et non sur des valeurs num eriques comme les instructions vues jusqu` a pr esent). AND et-logique
AND AND AND O 0
registre/variable, registre regisre, registre/variable registre/variable, constante D I T S * Z * A ? P * C 0
AND r ealise un et-logique bit ` a bit entre lop erande source et lop erande destination. Le r esultat est rang e dans lop erande destination. Consid erons les deux lignes suivantes : mov and al, 36h al, 5ch
Le registre AL contient ensuite la valeur 14h obtenue de la mani` ere suivante ; 36h 5ch 14h 0011 0101 0001 0110 1100 0100
Les bits S et Z sont mis ` a z ero et le bit P ` a 1. OR ou-logique
OR OR OR O 0
registre/variable, registre regisre, registre/variable registre/variable, constante D I T S * Z * A ? P * C 0
OR r ealise un ou-logique bit ` a bit entre lop erande source et lop erande destination. Le r esultat est rang e dans lop erande destination. Consid erons les deux lignes suivantes : mov or al, 36h al, 5ch
Le registre AL contient ensuite la valeur 7eh obtenue de la mani` ere suivante ; 36h 5ch 7eh 0011 0101 0111 0110 1100 1110
Les bits S et Z sont mis ` a z ero et le bit P ` a 1. XOR ou-exclusif
3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES XOR XOR XOR O 0 registre/variable, registre regisre, registre/variable registre/variable, constante D I T S * Z * A ? P * C 0
25
XOR r ealise un ou-exclusif bit ` a bit entre lop erande source et lop erande destination. Le r esultat est rang e dans lop erande destination. Consid erons les deux lignes suivantes : mov and al, 36h al, 5ch
Le registre AL contient ensuite la valeur 6ah obtenue de la mani` ere suivante ; 36h 5ch 6ah 0011 0101 0110 0110 1100 1010
Les bits S et Z sont mis ` a z ero et le bit P ` a 1. NOT N egation logique
NOT O D I
registre/variable T S Z A P C
NOT transforme la valeur dun registre ou dun op erande m emoire en son compl ement logique bit ` a bit. Consid erons les deux lignes suivantes : mov not al, 36h al
Le registre AL contient ensuite la valeur c9h obtenue de la mani` ere suivante ; 36h c9h 0011 1100 0110 1001
Les bits S et P sont mis ` a 1, le bit Z ` a 0.
3.1.5
Les instructions de d ecalage et rotation
Nous d ecrivons ici des op erations classiques des langages dassemblage qui se nomment d ecalages et rotations. On les rencontre couramment car leur utilisation simplie grandement certains traitements. RCL ROL RCR ROR
Les rotations en assembleur
26
Op erande 6 6 6 6 6 6 6 a.SAR
retenue -
Op erande Op erande retenue 6 6 6 6 6 6 6 d.ROL
retenue 6
6 6 6 6 6 6 6 b.SHR Op erande retenue Op erande 0 6 6 6 6 6 6 6 c.SHL ( equivalent ` a SAL) Fig. 3.1 D ecalages et rotations en assembleur 6 6 6 6 6 6 6 e.RCL retenue 6
Les rotations sont des op erations logiques binaires fr equemment utilis ees. Elles consid` erent un op erande (octet ou mot) comme un tore dont elles d ecalent les bits. Lors du d ecalage, un bit d eborde dun c ot e, ` a gauche ou ` a droite, selon le sens de la rotation. Selon le cas, quelques d etails di` erent ; RCL le bit de poids fort est mis dans lindicateur de retenue C, la valeur de cet indicateur etant pr ealablement mise dans le bit de poids faible (cf. gure 3.1.e) ROL le bit de poids fort est mis dans lindicateur de retenue C et dans le bit de poids faible de lop erande. Lancienne valeur de lindicateur de retenue nest pas utilis ee (cf. gure 3.1.d) Les op erandes des instructions RCL, RCR, ROL et ROR. etant les m emes, nous nen pr esentons quune, linstruction RCL. RCL RCL O * D registre/variable, 1 registre/variable, CL I T S Z A P C *
RCL eectue une rotation ` a gauche de lop erande destination indiqu e, 1 ou CL fois, en prenant en compte le contenu de lindicateur de retenue. Le bit de poids fort de lop erande destination est mis dans la retenue. Le contenu de la retenue est mis dans le bit de poids faible de lop erande destination. RCR eectue une rotation ` a droite de lop erande destination indiqu e, 1 ou CL fois, en prenant en compte le contenu de lindicateur de retenue. Le bit de poids faible de lop erande destination est mis dans la retenue. Le contenu de la retenue est mis dans le bit de poids fort de lop erande destination.
3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES
27
ROL eectue une rotation ` a gauche de lop erande destination indiqu e, 1 ou CL fois, sans prendre en compte le contenu de lindicateur de retenue. Le bit de poids fort est mis dans lindicateur de retenue lors de la rotation ainsi que dans le bit de poids faible de lop erande. ROR eectue une rotation ` a droite de lop erande destination indiqu e, 1 ou CL fois, sans prendre en compte le contenu de lindicateur de retenue. Le bit de poids faible est mis dans lindicateur de retenue lors de la rotation ainsi que dans le bit de poids fort de lop erande. Consid erons les deux lignes suivantes : mov mov xxx al, 16h cl, 3 al, cl
o` u xxx est une instruction de rotation. Selon le choix de cette instruction, nous obtenons les r esultats suivants ; xxx al C SAL SHL SAR SHR rcl b0h 0 rcr 85h 1 rol b0h 0 ror 85h 1
Les d ecalages en assembleur Une op eration de d ecalage consiste simplement ` a d ecaler tous les bits dune donn ee. Contrairement aux rotations qui consid` erent une donn ee (un octet ou un mot) comme un tore, un d ecalage consid` ere la donn ee comme une le ; ainsi, le bit qui (( d eborde )) de la retenue est perdu. Les op erandes des instructions SAL, SAR, SHL et SHR etant les m emes, nous ne pr esentons quune seule instruction, SAL. SAL SAL O * D registre/variable, 1 registre/variable, CL I T S * Z * A ? P * C *
SAL et SHL sont des synonymes et peuvent etre utilis ees lune pour lautre indi eremment. SAL eectue un d ecalage vers la gauche, sauvegardant le bit de poids fort dans lindicateur de retenue et mettant un 0 dans le bit de poids faible (cf. gure 3.1.c). SHR eectue un d ecalage vers la droite. Le bit de poids faible est mis dans la retenue. Un 0 est mis dans le bit de poids fort de la donn ee (cf. gure 3.1.b). SAR eectue un d ecalage vers la droite, sauvegardant le bit de poids faible dans lindicateur de retenue. Par ailleurs (et cest l` a toute la di erence avec linstruction pr ec edente), le bit de poids fort est conserv e (cf. gure 3.1.a). Le bit de poids fort de la donn ee initiale est donc dupliqu e. Consid erons les deux lignes suivantes : mov mov sal al, 16h cl, 3 al, cl
28
Le registre AL contient ensuite la valeur b0h. En eet, 16h s ecrit 00010110 en binaire. Si on d ecale cette valeur de trois positions vers la gauche, on obtient 10110000, soit b0h Le bit C est mis ` a 0. Consid erons les deux lignes suivantes : mov mov sar al, 36h cl, 3 al, cl
Le registre AL contient ensuite la valeur 05h. Le bit C est mis ` a 1. La di erence entre les instructions SAR et SAL napparait que si le bit de poids fort de la donn ee vaut 1. Le tableau suivant donne, pour deux valeurs de la donn ee (mise dans le registre AL), leet des di erents d ecalages. al sar al, 1 shr al, 1 f0 f8 78 70 38 38
Il faut noter que pour un nombre, un d ecalage dune position vers la gauche correspond ` a une multiplication de ce nombre par 2 et quun d ecalage dune position vers la droite correspond ` a une division enti` ere par 2. En g en eralisant, un d ecalage de l positions vers la gauche correspond ` a une multiplication par 2l et un d ecalage de l positions vers la droite correspond ` a une division par 2l . Il faut bien noter, et cest ce qui justie lexistence des deux instructions sar et shr et leur subtile di erence, que sar eectue une division sur un nombre en repr esentation sign ee tandis que shr eectue une division sur un nombre en repr esentation non sign ee. Bien entendu, les op erations de d ecalage etant connues comme des op erations logiques binaires et non des op erations arithm etiques, on prendra garde ` a linterpr etation des indicateurs de d ebordement ou de retenue que lon fera ` a lissue dune instruction de d ecalage.
3.1.6
MOV
Les instructions de transfert
transfert dune valeur Ces instructions r ealisent des transferts de donn ees entre 2 adresses m emoire, 2 registres, ou entre un registre et la m emoire. Ceci correspond donc ` a laectation des langages de haut niveau A:= B. MOV MOV MOV MOV MOV O registre/variable, registre registre, registre/variable registre, registre de segment registre de segment, registre registre/variable, constante D I T S Z A P C
registre de segment indique lun des registres cs, ds, es ou ss. Linstruction MOV eectue le transfert dune donn ee vers un registre ou une adresse m emoire. Transfert de la valeur dun registre de segment vers un autre registre de segment Aucun mode dadressage de la commande MOV ne permet de transf erer la valeur dun registre de segment dans un autre registre de segment. Nous disposons uniquement de la possibilit e de transf erer la valeur dun registre de segment vers un registre de donn ees et de la possibilit e de transf erer la valeur dun registre de donn ees vers un registre de segment. Aussi, pour atteindre notre but, nous devrons eectuer le transfert en deux etapes, en utilisant un registre de donn ees interm ediaire : transf erer la valeur du registre de segment source dans un registre de donn ees sur 16 bits
3.2. LES TESTS EN ASSEMBLEUR transf erer la valeur de ce registre de donn ees dans le registre de segment destination
29
Par exemple, supposons que nous voulions transf erer le contenu du registre DS dans le registre ES. Nous pouvons l ecrire sous la forme suivante : mov mov ax, ds es, ax
Remarquons quau cours de cette op eration, la valeur du registre AX a et e perdue lors de lex ecution de la premi` ere instruction. Ceci peut poser un probl` eme qui pourra etre r esolu en utilisant les techniques pr esent ees ` a la section 4.3.2.
LEA
Chargement de loset dune donn ee
LEA O
registre/variable, e tiquette D I T S Z A P C
Ctte instruction charge loset de la donn ee r ef erenc ee dans le deuxi` eme op erande qui est, en g en eral, une donn ee d eclar ee dans le segment de donn ees. Echange de valeurs
XCHG
XCHG XCHG O
registre/variable, registre registre, registre/variable D I T S Z A P C
Linstruction XCHG echange le contenu de deux emplacements m emoire ou registres. Supposons que le registre AX contienne la valeur 20 et le registre DX la valeur 10, lex ecution de linstruction : xchg ax, dx
entra nera : AX contient la valeur 10 et DX la valeur 20.
3.2
Les tests en assembleur
En assembleur, il nexiste pas de tests comme dans les langages de haut niveau tel Pascal. Cependant, il est bien entendu possible de r ealiser des tests. On utilise pour cela les bits du registre FLAGS comme condition de test et une instruction de branchement conditionnelle (saut si certains bits du registre FLAGS valent 0 ou 1) pour d eclencher la partie alors ou la partie sinon du test.
30
3.2.1
Principe g en eral
Les bits du registre FLAGS sont positionn es par les instructions que nous avons d ej` a vues (instructions arithm etiques, logiques, ...). Ils sont egalement positionn es par des instructions sp ecialement con cues pour r ealiser des tests et qui nont dautres eets que de positionner les bits de FLAGS en fonction de certaines conditions sur leurs op erandes. Ces instructions sont CMP et TEST. Une fois les indicateurs positionn es, une instruction dite de saut conditionnel teste un bit ou une combinaison de bits de FLAGS et, en fonction du r esultat : eectue une rupture de s equence (un saut ) vers un endroit pr ecis dans le code o` u lex ecution se poursuit normalement. continue en s equence si le test ne donne pas un r esultat positif. Nous pr esentons linstruction CMP, les instructions de sauts conditionnels et inconditionnels puis pr esentons sur des exemples le codage des tests.
3.2.2
CMP
Les instructions de comparaison
comparaison Cest linstruction la plus utilis ee pour positionner les indicateurs avant deectuer une instruction de saut conditionnel. CMP CMP CMP O * registre/variable, registre registre, registre/variable registre/variable, constante D I T S * Z * A * P * C *
CMP permet de comparer deux valeurs. Pour cela CMP soustrait le second op erande du premier, sans cependant modier lop erande destination, mais en positionnant les indicateurs en fonction du r esultat. Ainsi, si le r esultat de la soustraction est nul, donc lindicateur Z a et e positionn e` a 1, cela signie que les deux valeurs compar ees sont egales. En utilisant des raisonnements du m eme genre, on peut savoir si les deux valeurs sont di erentes, ordonn ees strictement ou non. ` lissue de lex A ecution des deux instructions suivantes : mov cmp al, 23 al, 34
le registre AL nest pas modi e par lex ecution de linstruction CMP et contient toujours la valeur aect ee auparavant 23. Lindicateur de retenue C est positionn e ` a 1, ce qui indique que le deuxi` eme op erande de linstruction CMP est sup erieur ` a la valeur du premier op erande. Lindicateur de z ero Z valant 0, cela indique que les deux donn ees sont di erentes (sinon, la soustraction dun nombre ` a lui-m eme donne 0, donc le bit Z est positionn e` a 1). Le bit de signe S est egalement mis ` a 1 car 29 34 est un nombre n egatif. Jxx Les instructions de saut conditionnel
3.2. LES TESTS EN ASSEMBLEUR
31
Toutes les instructions de saut conditionnel prennent le m eme type dop erande (attention, bien distinguer la valeur z ero 0 du bit O du registre d etat) : JA JAE JB JBE JC JCXZ JE JG JGE JL JLE JNC JNE JNO JNP JNS JO JP JS e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette e tiquette O D saut saut saut saut saut saut saut saut saut saut saut saut saut saut saut saut saut saut saut I si si si si si si si si si si si si si si si si si si si sup erieur (C =0 et Z =0) sup erieur ou egal (C =0) inf erieur (C =1) inf erieur ou egal (C =1 ou Z =1) retenue (C =1) CX vaut 0 egal (Z =1) sup erieur (Z =0 ou S =O) sup erieur ou egal (S =O) inf erieur (S =O) inf erieur ou egal (Z =1 ou S =O) pas de retenue (C =0) non egal (Z =0) pas de d ebordement (O =0) pas de parit e (P =0) pas de signe (S =0) d ebordement (O =1) parit e (P =1) signe (S =1) S Z A P C
Toutes ces instructions fonctionnent selon le sch ema suivant. Quand la condition est vraie, un saut est eectu e` a linstruction situ ee ` a l etiquette sp eci ee en op erande. Notons que les tests dordre (inf erieur, sup erieur, ...) se comprennent de la mani` ere suivante. Supposons que nous comparions deux donn ees par une instruction CMP et que nous ex ecutions ensuite une instruction JG, cest-` a-dire (( saut si plus grand )). Il y aura alors saut si la valeur du deuxi` eme op erande de linstruction CMP est sup erieur ` a la valeur du premier op erande. L etiquette r ef erenc ee dans linstruction de saut conditionnel ne doit pas se trouver trop loin de linstruction de saut. Sinon, une erreur dassemblage est d eclench ee et le message : Relative jump out of range by xxx bytes est ach e. Pour rem edier ` a cette erreur, il faut proc eder de la mani` ere suivante. Supposons que linstruction : je etiquette
provoque lerreur en question. Il faut transformer cette instruction dans la s equence dinstructions : jne nouvelle-etiquette jmp etiquette nouvelle-etiquette: Cest-` a-dire : 1. remplacer linstruction de saut conditionnel par linstruction de saut correspondant ` a la condition oppos ee (ici, saut si le bit Z vaut 1 est remplac e par saut si le bit Z vaut 0). Lop erande de cette nouvelle instruction est une nouvelle etiquette. 2. faire suivre linstruction de saut conditionnel par une instruction de saut inconditionnel jmp (voir 3.2.2) dont lop erande est l etiquette de linstruction de saut conditionnel originale 3. d eclarer ensuite la nouvelle etiquette apr` es linstruction jmp
32 JMP : saut inconditionnel JMP O D I T
e tiquette S Z A P C
Linstruction JMP eectue un saut inconditionnel ` a l etiquette sp eci ee. Contrairement ` a un saut conditionnel, le saut est toujours eectu e, le registre FLAGS nintervenant en rien dans cette op eration.
3.2.3
Exemples de codage de tests en assembleur
G en eralement parlant, un test dans un langage evolu e a la forme suivante : SI (condition vraie) ALORS action-alors SINON action-sinon FIN_SI Si la valeur de lexpression condition est vraie, les instructions composant la partie action-alors sont ex ecut ees. Sinon, les instructions de la partie action-sinon sont ex ecut ees. En assembleur, ce type de construction est r ealis e` a laide du squelette de programme suivant : calcul de la condition Jcc SINONn action-alors ... JMP FSIn SINONn: action-sinon ... FSIn: ... o` u Jcc d enote lune des instructions de saut conditionnel vues plus haut. Nous notons les points suivants : le calcul de la condition positionne les indicateurs du registre FLAGS en fonction de ce positionnement, un saut conditionnel est r ealis e par linstruction Jcc (o` u cc repr esente la condition ` a tester voir les di erentes possibilit es dans la section traitant des instructions de saut conditionnel) vers la partie sinon du test. Si la condition est v eri ee, aucun saut nest r ealis e et le programme poursuit son ex ecution en s equence avec les instructions de la partie action-alors une fois les instructions de la partie alors ex ecut ees, un saut doit etre r ealis e (instruction JMP FSIn) pour atteindre la n de la structure de test an de ne pas egalement ex ecuter la partie sinon une etiquette (SINONn) est d eclar ee indiquant le d ebut de la partie action-sinon o` u le branchement conditionnel doit etre ex ecut e pour d eclencher lex ecution des instructions de la partie sinon du test une fois la partie sinon ex ecut ee, on continue en s equence avec les instructions situ ees apr` es le test (cest-` a-dire, apr` es l etiquette FSIn)
3.3. LES BOUCLES EN ASSEMBLEUR
33
Pour des raisons de clart e, nous utiliserons un format sp ecial pour les etiquettes codant un test. Une etiquette SINON indique le d ebut de la s equence action-sinon et une etiquette FSI indique la n de la structure de test. Ces etiquettes seront num erot ees, les tests etant num erot es dans le programme de 1 ` a n, par convention. An dillustrer le propos, nous donnons un exemple de codage dun test. Nous voulons eectuer la division dun nombre par un autre. La division nest possible que si le diviseur est non nul. Aussi, nous devons tester si lop erande diviseur est nul avant dex ecuter la division. Si le diviseur est nul, nous d esirons que le r esultat du traitement soit -1. Sinon, le r esultat est le quotient des deux nombres. .data db .code ... mov cmp je mov div jmp SINON1: mov FSI1: ... ... val .... ; mettre ici la valeur du diviseur
ax, ... val, 0 SINON1 bl, [val] bl FSI1 ax, -1
; valeur du dividende ; diviseur nul => saut
; diviseur nul => resultat vaut -1
Notons que ce programme nest pas complet. Il vise simplement ` a montrer le codage dun test.
3.3
Les boucles en assembleur
Comme pour les tests, il nexiste pas de structure g en erale en assembleur pour coder une boucle. Cependant, ` a laide des instructions vues pr ec edemment pour r ealiser des tests, on peut coder nimporte quel type de boucle. On verra egalement que des instructions simplient grandement le codage des boucles pour.
3.3.1
Principe g en eral
Le principe de la r ealisation des boucles tant-que ou jusqua est assez particulier. Une boucle est essentiellement compos ee de deux el ements : une condition de sortie qui indique quand la boucle doit etre interrompue, quil faut sortir de la boucle et continuer lex ecution des instructions en s equence un corps de boucle qui sp ecie laction ` a r ealiser pendant que la condition de sortie nest pas v eri ee, a chaque it ` eration de la boucle La condition de sortie va donc etre cod ee dune mani` ere ressemblant aux tests. Un saut conditionnel testera cette condition et entra nera, quand la condition est v eri ee, la sortie de la boucle. Le corps de la boucle devra pour sa part (( boucler )), cest-` a-dire, une fois ex ecut e, entra ner le re-calcul de la condition de sortie et la prise de d ecision quant ` a la poursuite ou non des it erations. Nous indiquons maintenant comment est r ealis e le codage dune boucle tant-que et dune boucle r ep eter.
3.3.2
Boucles tant-que
Le squelette dune boucle tant-que, dans un langage de haut niveau, est le suivant : TANT-QUE (condition) FAIRE action FIN_TQ
34
CHAPITRE 3. LES INSTRUCTIONS DU 8086 Cela va se traduire en assembleur sous la forme suivante :
TQn:
calcul de la condition Jcc FTQn action ... JMP TQn ...
FTQn: o` u Jcc d enote lune des instructions de saut conditionnel vues plus haut. Nous notons les points suivants : une etiquette TQ indique le d ebut de la boucle la boucle commence par une evaluation de la condition de sortie qui positionne les indicateurs du registre FLAGS en fonction de la valeur des indicateurs (donc du r esultat du test de sortie), un saut conditionnel est eectu e en n de boucle (Jcc FTQn), pour quitter la boucle le moment venu on trouve ensuite le corps de la boucle, termin e par une instruction de saut incondtionnel vers le d ebut de la boucle (JMP TQn) qui permettra de r e- evaluer la condition darr et apr` es chaque it eration une etiquette FTQ indiquant la n de la boucle Pour des raisons de clart e, nous utiliserons un format sp ecial pour les etiquettes codant une boucle TANT-QUE. Une etiquette TQ indique le d ebut de la structure de boucle et une etiquette FTQ indique la n de la structure de boucle. Ces etiquettes seront num erot ees, les boucles etant num erot ees dans le programme de 1 ` a n, par convention.
3.3.3
Boucles r ep eter
Le squelette dune boucle REPETER dans un langage de haut niveau est le suivant : REPETER action JUSQUA (condition vraie) Cela se traduit de la mani` ere suivante en assembleur : REPETERn: action ... calcul de la condition Jcc REPETERn Notons les points suivants : une etiquette REPETER rep` ere le d ebut de la boucle on trouve ensuite le corps de la boucle a ` lissue de lex ecution du corps, on trouve l evaluation du test darr et qui positionne les indicateurs du registre FLAGS une instruction de saut conditionnel eectue un branchement pour continuer les it erations si la condition darr et nest pas v eri ee Pour des raisons de clart e, nous utiliserons un format sp ecial pour les etiquettes codant une boucle REPETER. Une etiquette REPETER indique le d ebut de la boucle. Ces etiquettes seront num erot ees, les boucles REPETER etant num erot ees dans le programme de 1 ` a n, par convention.
35
3.3.4
Les boucles pour
Une boucle pour est g en eralement cod ee ` a laide dune instruction de la famille LOOP. Pour les boucles traitant des cha nes de donn ees (caract` eres, mots), voir la section 3.3.6. LOOP boucles contr ol ees par un compteur
LOOP LOOPE LOOPNE
e tiquette e tiquette e tiquette O D
saut court si le compteur est di erent de 0 saut court si compteur di erent de 0 et Z =1 saut court si compteur di erent de 0 et Z =0 I T S Z A P C
LOOP fonctionne avec le registre CX qui joue le r ole de compteur de boucles. LOOP d ecr emente le compteur sans modier aucun des indicateurs. Si le compteur est di erent de 0, un saut ` a l etiquette op erande de linstruction LOOP est r ealis e. Le squelette dune boucle pour s ecrit de la mani` ere suivante : POUR indice := 1 A bs FAIRE action FAIT Cependant, en assembleur, seules existent des boucles ayant un indice variant dune certaine valeur bs ` a 1, en d ecr ementant sa valeur ` a chaque it eration. Aussi, la boucle pr ec edente doit initialement etre transform ee dans une boucle du genre 1 : POUR indice := bs A 1, pas := -1 FAIRE action FAIT Cette boucle se traduit en assembleur de la mani` ere suivante : mov cx, bs POURn: ... action loop POURn En exemple, nous ecrivons un programme qui ache dix fois la cha ne de caract` eres hello world. .data db hello world, 13, 10, $ .code mov ax, @data ; initialisation de la valeur mov ds, ax ; de ds mov cx, 10 ; initialisation du compteur de boucles ; ; corps de boucle ; boucle: mov ah, 9 ; affichage du message lea dx, msg int 21h loop boucle : contr^ ole de la boucle ... msg:
1. on prendra garde en eectuant cette transformation. Voir a ` ce propos le document ( ( m ethodologie de programmation en assembleur ) )
36
Le d ebut initialise le registre DS pour quil contienne le num ero du segment de donn ees et le compteur de boucles. Le corps de la boucle contient alors un appel ` a la routine achant un message ` a l ecran (cf. section 5.1.2). Il est tr` es courant de parcourir un tableau dans une boucle tout en voulant sortir de la boucle lorsquune condition est v eri ee (parce que lon cherche une valeur dans le tableau poss edant une propri et e particuli` ere par exemple). Notons que ce type de construction nexiste pas en Pascal. Des instructions sont disponibles en assembleur pour r ealiser ce genre de boucle, les instructions LOOPE et LOOPNE (les instructions LOOPZ et LOOPNZ etant des synonymes). Comme pour les boucles LOOP, le registre CX joue le r ole de compteur de boucle. Par ailleurs, ` a chaque it eration, une condition (la valeur du bit Z du registre FLAGS) est test ee. Pour linstruction LOOPE, il y a saut ` a l etiquette sp eci ee en op erande tant que le compteur est non nul et que lindicateur Z vaut 1. Pour linstruction LOOPNE, il y a saut ` a l etiquette sp eci ee en op erande tant que le compteur est non nul et que lindicateur Z vaut 0. Exemple Nous pr esentons un exemple de boucle ainsi que les conventions que nous adoptons pour le codage dune boucle pour. Nous recherchons dans un tableau dentiers l el ement dindice le plus faible qui soit multiple de 7.
tableau .data db .code mov mov mov mov mov mov mov div inc cmp loopne 34, 72, 48, 32, 56, 12, 8, 9, 45, 63, 80 ax, ds, cx, dl, bx, @data ax 11 ; nombre d el ements dans la table 7 ; valeur du diviseur 0 ; indice de l el ement consid er e
BOUCLE1: ah, 0 al, BYTE PTR table+bx dl ; division de bx ; mise ` a jour ah, 0 ; ah contient BOUCLE1 ; saut si non
l el ement courant par 7 de lindice le reste de la division multiple et non termin e
` lissue de lex A ecution de ces instructions, le registre BX contient lindice du premier el ement du tableau table ayant une valeur multiple de 7. On notera les points suivants : une etiquette BOUCLE1 indique le d ebut de la boucle ; on trouve ensuite le corps de la boucle ; une instruction (ici CMP) positionne les indicateurs du registre FLAGS pour eventuellement sortir de la boucle avant davoir eectu e toutes les it erations (quand une valeur multiple de 7 a et e trouv ee, on sort imm ediatement) ; linstruction LOOPNE d ecide sil faut boucler en fonction de la position des indicateurs du registre FLAGS et de la valeur du compteur de boucle (le registre CX) qui est automatiquement d ecr ement e. Comme pour les autres structures, on notera que les etiquettes BOUCLE sont num erot ees de 1 ` a n.
3.3.5
Instructions diverses
Nous d ecrivons dans cette section quelques instructions qui se r ev` elent souvent utiles pour le codage des tests ou des boucles. CLC
3.3. LES BOUCLES EN ASSEMBLEUR CLD CMC STC STD
37
Armement des indicateurs Nous d ecrivons ici quelques instructions ne prenant aucun op erande et agissant chacune sur un bit particulier du registre dindicateurs FLAGS. CLC mise ` a z ero de lindicateur de retenue C CLD mise ` a z ero de lindicateur de direction D CMC compl emente lindicateur de retenue C STC mise ` a 1 de lindicateur de retenue C STD mise ` a 1 de lindicateur de direction D
3.3.6
Le traitement des cha nes de donn ees
Nous pr esentons dans cette section des instructions sp ecialement con cues pour le traitement de s equences de donn ees, que ces donn ees soient des caract` eres (des octets) ou des mots. Chacune eectue le traitement dun el ement de cha ne. Il y a cinq types dinstruction : LODS : chargement dun el ement de cha ne depuis la m emoire dans un registre STOS : ecriture dun el ement de cha ne en m emoire MOVS : transfert dun el ement entre deux cha nes CMPS : comparaison entre deux el ements de cha ne SCAS : comparaison entre une valeur et un el ement de cha ne Toutes ces instructions sont con cues pour etre ais ement ins er ees dans une boucle qui traitera lensemble des el ements de la cha ne. Classiquement, lors dune it eration, un el ement dune cha ne est r ef erenc e par son index dans la cha ne. Pour pouvoir it erer linstruction, il faut donc incr ement e cet index apr` es chaque traitement. Pour nous aider, les instructions de traitement de cha nes incr ementent automatiquement lindex. Par ailleurs, ces instructions traitent des cha nes doctets, ou de mots. Aussi, selon le type de donn ees trait ees, 1 ou 2 doit etre ajout e` a la valeur de lindex. Cest eectivement de cette mani` ere quagissent ces instructions. Notons egalement que pour traiter les cha nes de leur n vers leur d ebut plut ot que dans le sens contraire, il sut de soustraire 1 ou 2 ` a la valeur de lindex. Pour cela, lindicateur D du registre FLAGS indique la direction du traitement. Si D vaut 0, le traitement va du d ebut vers la n de la cha ne et la valeur 1 ou 2 est ajout ee ` a lindex. Si D vaut 1, le traitement va dans le sens contraire et la valeur 1 ou 2 est soustraite ` a lindex. Notons que le bit D est positionn e par les instructions STD et CLD. Remarque importante : les indicateurs de FLAGS ne sont pas modi es par les op erations modiant la valeur des index. Dans les instructions de traitement de cha nes de caract` eres, le registre SI pointe implicitement vers la cha ne source, le registre DI vers la cha ne destination. LODS chargement dun el ement de cha ne
LODSB LODSW O D I T S Z A P C
38
LODSB charge le registre AL (respectivement, AX pour linstruction LODSW) avec loctet (respectivement le mot) point e par le registre SI. Une fois le chargement eectu e, il est automatiquement ajout e 1 (respectivement 2) ` a SI si lindicateur D vaut 0, ou retir e 1 (respectivement 2) si lindicateur D vaut 1. MOVS transfert dun el ement entre deux cha nes
MOVSB MOVSW O D I T S Z A P C
MOVSB copie loctet (respectivement le mot pour linstruction MOVSW) point e par SI vers loctet (respectivement le mot) point e par ES:DI. Le segment destination est forc ement ES. Par contre, le segment de la source qui est DS par d efaut peut etre red eni. Une fois la copie r ealis ee, SI et DI sont automatiquement modi es. Si lindicateur de direction vaut 0, 1 (respectivement 2) est ajout e` a SI et DI. Si lindicateur de direction vaut 1, 1 (respectivement 2) est retir e a SI et DI. ` STOS ecriture en m emoire dun el ement dune cha ne
STOSB STOSW O D I T S Z A P C
STOSB ecrit en m emoire loctet (respectivement le mot pour linstruction STOSW) se trouvant dans le registre AL (respectivement dans le registre AX) en m emoire ` a ladresse point ee par le registre DI. Le segment destination est forc ement ES. Une fois la copie r ealis ee, DI est automatiquement modi e. Si lindicateur de direction vaut 0, 1 (respectivement 2) est ajout e` a DI. Si lindicateur de direction vaut 1, 1 (respectivement 2) est retir e` a DI. Nous donnons un premier exemple qui consiste ` a multiplier par 2 tous les el ements dun tableau dentiers .data DW DW .code mov mov mov lea lea mov BOUCLE1: lodsw mov mul stosw loop ... TABLEAU RES
10, 20, 30, 40, 50, 60, 70, 80, 90, 100 10 DUP (0) ax, ds, es, si, di, cx, @data ax ax TABLEAU RES 10
bl, 2 bl BOUCLE1
39
Un deuxi` eme exemple illustre la transformation dune table de donn ees cod ees en d ecimal non compact e en ASCII. Cette op eration est simplement obtenue par ou-logique avec la valeur 30h (le code ASCII des chires 0, 1, ... 9 est 30h, 31h, ... 39h). .data DW DW .code mov mov mov lea lea mov BOUCLE1: lodsw or stosw loop ... TABLEAU RES CMPS 1, 2, 3, 4, 5, 6, 7, 8, 9 9 DUP (0) ax, ds, es, si, di, cx, @data ax ax TABLEAU RES 9
al, 30h BOUCLE1
comparaison de cha nes
CMPSB CMPSW O * D I T S * Z * A * P * C *
CMPSB compare loctet (respectivement le mot pour linstruction CMPSW) point e par SI ` a loctet (respectivement le mot) point e par ES:DI. Le segment destination est forc ement ES. Par contre, le segment de la source qui est DS par d efaut peut etre red eni. Une fois la copie r ealis ee, SI et DI sont automatiquement modi es. Si lindicateur de direction vaut 0, 1 (respectivement 2) est ajout e` a SI et DI. Si lindicateur de direction vaut 1, 1 (respectivement 2) est retir e a SI et DI. ` SCAS comparaison dun el ement de cha ne avec une valeur SCASB SCASW O * D I T S * Z * A * P * C *
SCASB compare la valeur de loctet (respectivement le mot pour linstruction SCASW) contenu dans le registre AL (respectivement AX) ` a loctet (respectivement le mot) point e par ES:DI. La donn ee en m emoire est toujours r ef erenc ee via le registre de segment ES. Une fois la comparaison r ealis ee, DI est automatiquement modi e. Si lindicateur de direction vaut 0, 1 (respectivement 2) est ajout e` a DI. Si lindicateur de direction vaut 1, 1 (respectivement 2) est retir e` a DI. REP REPE REPZ REPNE REPNZ r ep eter une instruction de traitement de cha nes de donn ees
40
Nous d ecrivons ici une instruction qui permet dit erer sur toute une cha ne les op erations el ementaires vues pr ec edemment. Cette instruction pr exe en fait lop eration ` a it erer. Elle donne tout son int er et aux instructions LODS, STOS, MOVS, CMPS, SCAS. REP ne peut pr exer que les instructions LODS, STOS, MOVS. Un compteur (registre CX) indique le nombre dit erations ` a eectuer. Les pr exes REPE et REPNE ne peuvent pr exer que les instructions CMPS et SCAS. Pour les pr exes REPE et REPNE, un compteur (registre CX) indique le nombre maximal dit erations ` a eectuer. Par ailleurs, linstruction el ementaire est r ep et ee tant quune condition ( egalit e ou non- egalit e entre les op erandes de CMPS ou SCAS) nest pas remplie. REP REP REP REP REP REP REPE REPE REPE REPE REPNE REPNE REPNE REPNE MOVSB MOVSW LODSB LODSW STOSB STOSW CMPSB CMPSW SCASB SCASW CMPSB CMPSW SCASB SCASW O D I T S Z * A P C
REP MOVS copie CX el ements de la cha ne point ee par SI vers la cha ne point ee par ES:DI REP LODS charge CX el ements de la cha ne point ee par SI dans AL (ou AX) REP STOS ecrit CX el ements de la cha ne point ee par ES:DI avec la valeur contenue dans AL (ou AX) REPE CMPS compare au plus CX el ements de la cha ne point ee par ES:DI avec ceux de la cha ne point ee par SI. Les it erations sont poursuivies tant que les el ements des deux cha nes sont egaux et tant que le compteur nest pas nul. D` es que lune de ces conditions nest plus v eri ee, linstruction REPE CMPS est termin ee REPE SCAS compare au plus CX el ements de la cha ne point ee par ES:DI avec la valeur du registre AL, ou AX selon le cas. Les it erations sont poursuivies tant que les el ements de la cha ne sont egaux ` a la valeur du registre et tant que le compteur nest pas nul. D` es que lune de ces conditions nest plus v eri ee, linstruction REPE SCAS est termin ee REPNE CMPS compare au plus CX el ements de la cha ne point ee par ES:DI avec ceux de la cha ne point ee par SI. Les it erations sont poursuivies tant que les el ements des deux cha nes sont di erents et tant que le compteur nest pas nul. D` es que lune de ces conditions nest plus v eri ee, linstruction REPNE CMPS est termin ee REPNE SCAS compare au plus CX el ements de la cha ne point ee par ES:DI avec la valeur du registre AL, ou AX, selon le cas. Les it erations sont poursuivies tant que les el ements de la cha ne sont di erents de la valeur du registre et tant que le compteur nest pas nul. D` es que lune de ces conditions nest plus v eri ee, linstruction REPNE SCAS est termin ee Notons que REPZ est un synonyme de REPE ; REPNZ est un synonyme de REPNE. Pour r esumer, ` a chaque it eration, les actions suivantes sont ex ecut ees : 1. tester le compteur (CX). Sil est ` a z ero, sortir de linstruction de r ep etition et d eclencher lex ecution de la suivante. Sinon :
3.3. LES BOUCLES EN ASSEMBLEUR 2. ex ecuter lop eration sur la cha ne 3. d ecr ementer le compteur
41
4. si lop eration est SCAS ou CMPS, tester lindicateur de z ero. Si la condition dit eration nest pas remplie, poursuivre avec linstruction qui suit le REP. Sinon : 5. recommencer Exemple 1 Copie dun tableau de caract` eres dans un autre tableau. CHAINE RES .data db db .code mov mov mov lea lea mov rep movsb ... hello world 11 dup (?) ax, ds, es, di, si, cx, @data ax ax RES TABLE 11 ; cha^ ne source ; cha^ ne cible
; ; ; ;
offset cha^ ne cible offset cha^ ne source longueur de la cha^ ne copie
Exemple 2 Recherche dun caract` ere dans une cha ne de caract` eres en utilisant linstruction SCAS CHAINE .data db hello world .code mov ax, @data mov es, ax mov al, w lea di, CHAINE mov cx, 11 repne scasb ...
` lissue de lex A ecution de cette s equence dinstructions, le registre DI pointe sur le caract` ere qui se trouve apr` es le w dans la cha ne de caract` ere, cest-` a-dire o. Puisque loset de CHAINE vaut 0, di vaut 7 ` a lissue de lex ecution de repne scasb. Exemple 3 ` lissue de cette recherche, le registre AX indiquera Recherche dune cha ne de caract` eres dans une autre. A le r esultat et vaudra 1 si la cha ne est trouv ee, 0 sinon. CH1 CH2 .data db db .code mov mov mov hello world rl ax, @data ds, ax es, ax
42 lea si, CH1 mov ax, 1 mov bx, 10 lea di, CH2 mov cx, 2 repe cmpsb je FTQ1 dec bx jne TQ1 mov ax, 0 ...
TQ1:
; sous-cha^ ne trouv ee
FTQ1:
3.4
Autres instructions
Nous regroupons ici quelques instructions qui peuvent etre utiles.
3.4.1
ADC
Instructions arithm etiques
Addition avec retenue
ADC ADC ADC O *
Linstruction ADC eectue laddition du contenu du registre source au registre destination avec report de retenue, soit ; destination source + destination + retenue La retenue C est positionn ee en fonction du r esultat de lop eration. Pour expliquer le positionnement de la retenue auxiliaire A, supposons que nous additionnions des octets. Le bit A indique si une retenue a lieu entre les quatre bits de poids faible et les quatre bits de poids fort. Ainsi, si on additionne les donn ees hexad ecimales 45 et 3e, il y a une retenue lors de laddition des deux demi-octets de poids faible (5 + e est sup erieur ` a f, donc il y a une retenue). Aussi, le bit de retenue auxiliaire est positionn e` a 1. Nous proposons un exemple daddition sur 32 bits. Nous voulons additionner une donn ee se trouvant dans les registres AX et DX ` a une donn ee se trouvant dans les registres BX et CX et ranger le r esultat dans les registres AX et DX (AX et BX contiennent les poids faibles, DX et CX les poids forts). Le code est alors le suivant ; add adc ax, bx dx, cx
La premi` ere instruction calcule le poids faible du r esultat en additionnant simplement les poids faibles des deux op erandes. La deuxi` eme instruction calcule alors le poids fort du r esultat en additionnant les poids forts des deux op erandes et l eventuelle retenue g en er ee par laddition des poids faibles. Pour tenir compte de cette retenue, on a utilis e linstruction ADC. SBB Soustraction avec retenue
3.4. AUTRES INSTRUCTIONS SBB SBB SBB O * registre/variable, registre registre, registre/variable registre/variable, constante D I T S * Z * A * P * C *
43
Linstruction SBB eectue la soustraction du contenu du registre source au registre destination avec report de retenue, soit : destination destination - source - retenue La retenue est positionn ee en fonction du r esultat de lop eration. Nous proposons un exemple de soustraction sur 32 bits. Nous voulons soustraire une donn ee se trouvant dans les registres BX et CX dune donn ee se trouvant dans les registres AX et DX et ranger le r esultat dans les registres AX et DX (AX et BX contiennent les poids faibles, DX et CX les poids forts). Le code est alors le suivant ; sub sbb ax, bx dx, cx
La premi` ere instruction calcule le poids faible du r esultat en soustrayant simplement les poids faibles des deux op erandes. La deuxi` eme instruction calcule alors le poids fort du r esultat en soustrayant les poids forts des deux op erandes en tenant compte de l eventuelle retenue g en er ee par la soustraction des poids faibles. Pour tenir compte de cette retenue, on a utilis e linstruction SBB. TEST test logique
TEST TEST O 0 D
registre/variable, registre registre/variable, constante I T S * Z * A ? P * C 0
Cette instruction eectue un et-logique entre ses deux op erandes. Cependant, contrairement ` a linstruction AND, elle ne modie pas lop erande destination. Elle se contente de positionner les indicateurs du registre FLAGS. Par exemple, linstruction test peut etre utile pour tester le signe dun nombre (voir la description de linstruction jz dans le paragraphe suivant) : ..... test jz ..... al, 80h negatif ; test du bit de signe
3.4.2
Les instructions dajustement d ecimal
Les instructions d ecrites dans cette section sont utiles pour eectuer des calculs sur des nombres cod es en BCD. Elles r ealisent un ajustement du contenu du registre AL ou AX pour la r ealisation dop erations arithm etiques. Elles ne prennent aucun op erande. Les quatre instructions en question sont les suivantes ; AAA ajustement ASCII de AL apr` es addition ADD
44 AAD ajustement ASCII de AX avant division DIV AAM ajustement ASCII de AX apr` es multiplication MUL AAS ajustement ASCII de AL apr` es soustraction SUB
Ces quatre instructions positionnent les indicateurs du registre FLAGS de la mani` ere suivante : O ? Nous reprenons le r ole de chacune. AAA ajustement apr` es addition Linstruction AAA ne doit etre ex ecut ee quapr` es avoir eectu e une addition ADD. Elle transforme alors le contenu du registre AL en un nombre d ecimal non compact e (cest-` a-dire que le poids faible doit etre compris entre 0 et 9). Si besoin (valeur de AL sup erieure ` a 9), la valeur 1 est ajout ee au contenu de AH. Ainsi, si nous voulons r ealiser laddition de 36 et 45 en repr esentation d ecimale non compact ee, on peut ecrire ; mov add ax, 0306h ax, 0405h D I T S ? Z ? A * P ? C *
qui aectera la valeur 070b au registre AX, ce qui nest pas une valeur correcte en repr esentation d ecimale non compact ee. Si on ex ecute maintenant linstruction AAA, le registre AX contiendra ensuite la valeur 0801. 81 est bien la somme de 36 et 45. AAD ajustement avant division Cette instruction doit etre ex ecut ee avant de r ealiser la division de deux op erandes octets en repr esentation d ecimale non compact ee de mani` ere ` a ce que la division donne le bon r esultat. Pour cela, elle transforme la valeur non compact ee contenue dans AX en une valeur binaire. Ainsi, si nous d esirons diviser 37 par 5, on peut ecrire : mov mov aad div dx,5 ax,0307h dl
Le registre ah re coit la valeur 2, reste de la division. Le registre al re coit la valeur 5, quotient de la division. AAM ajustement apr` es multiplication Cette instruction doit etre ex ecut ee apr` es une multiplication de deux op erandes octets en repr esentation d ecimale non compact ee an dobtenir le r esultat de la multiplication sous forme d ecimale non compact ee egalement. Ainsi, si nous d esirons multiplier 7 par 5, on peut ecrire : mov mov mul aam dx,5 ax,7 dl
3.4. AUTRES INSTRUCTIONS
45
` lissue de lex A ecution de cette s equence dinstructions, ax contient la valeur 0305h. On notera quavant lex ecution de linstruction AAM, ax contient la valeur 23h, soit 35. Notez bien la di erence entre 35 et 0305h. AAS ajustement apr` es soustraction Cette instruction doit etre ex ecut ee apr` es une soustraction SUB de deux op erandes en repr esentation d ecimale non compact ee an dobtenir le r esultat de la soustraction en repr esentation d ecimale non compact ee. Ainsi, si nous d esirons retirer 7 de 6, on peut ecrire : mov mov sub aas al,6 dl,7 al,dl
` lissue de lex A ecution de cette s equence dinstructions, al contient la valeur 9 (et ax contient la valeur FF09h). On notera quavant lex ecution de linstruction AAS, ax contient la valeur 00ffh. Instructions dajustement d ecimal en repr esentation d ecimale compact ee Les deux instructions suivantes permettent deectuer un ajustement pour la r ealisation dadditions ou de soustractions en repr esentation d ecimale compact ee. Aucune instruction nest disponible pour lajustement pour multiplication ou division du fait de la complexit e de la t ache et de la raret e de son utilisation. DAA ajustement d ecimal de AL apr` es addition ADD DAS ajustement d ecimal de AL apr` es soustraction Ces deux instructions positionnent les indicateurs du registre FLAGS de la mani` ere suivante ; O ? D I T S * Z * A * P * C *
Supposons que nous voulions additionner les nombres d ecimaux 35 et 26 en repr esentation d ecimale compact ee. Nous pourrions ecrire ; mov add daa al, 35h al, 26h
Notons que pour indiquer ` a lassembleur que lon veut repr esenter en d ecimal compact e les nombres 35 et 26, il faut les ecrire comme sils etaient des constantes hexad ecimales. Ainsi, consid erant la premi` ere instruction, 5 est mis dans les 4 bits de poids faible de AL, 3 est mis dans les 4 bits de poids fort de AL. ` lissue de lex A ecution de ces trois instructions, AL contient la valeur 61h. 61 est bien le r esultat de la somme de 35 et 26. Pour mieux comprendre le m ecanisme, notons quavant lex ecution de linstruction DAA, le registre AL contient la valeur 5bh. En eet, le processeur ne sait pas (et na pas ` a savoir) que lon a cod e les nombres sous forme d ecimale compact ee ; cest simplement au programmeur de le savoir. Aussi, le 8086 ex ecute simplement dans un premier temps laddition de deux donn ees hexad ecimales 35h et 26h puis ajuste ce r esultat pour obtenir la repr esentation d ecimale compact ee (via linstruction DAA). Prenons un deuxi` eme exemple pour comprendre le fonctionnement du bit de retenue et de d ebordement. Soient les trois lignes ; mov add daa al, 63h al, 82h
46
Laddition d ecimale de 63 et 82 donne 145, donc un nombre qui ne peut etre repr esent e en d ecimal compact e sur un octet puisquil est plus grand que 100. Aussi, comme pour les op erations en binaire, le r esultat contient le poids faible du r esultat, cest-` a-dire 45, et lindicateur de retenue C ainsi que lindicateur de d ebordement sont positionn es ` a 1 par linstruction DAA. Notons que cest lors de linstruction DAA qua lieu le d ebordement de capacit e et quapparait une retenue. En eet, laddition donne le r esultat hexad ecimal e5h qui nest pas trop grand et ne provoque aucun d ebordement et aucune retenue.
3.4.3
LAHF SAHF
Autres
Instructions de transfert entre FLAGS et AH Linstruction LAHF copie dans AH la valeur du registre FLAGS. Linstruction SAHF copie le contenu de AH dans le registre FLAGS. Seuls les cinq bits S, Z, A, P et C sont modi es lors de cette op eration quelle que soit la valeur des 3 bits de poids fort de AH.
47
Chapitre 4
Les sous-programmes
4.1 Principe g en eral
Les sous-programmes jouent, en assembleur, le r ole des proc edures et des fonctions dans les langages de haut niveau. Elles structurent les programmes en donnant un nom ` a un traitement et en r eduisant la taille des programmes qui utilisent plusieurs fois la m eme s equence de code. Dans la suite de ce chapitre, on d ecrit tout dabord le principe de fonctionnement des sous-programmes en assembleur. Nous d ecrivons ensuite les m ecanismes ` a mettre en jeu pour ecrire des sous-programmes param etr es ou renvoyant une valeur.
4.2
Synoptique de lappel dun sous-programme
Appeler un sous-programme consiste ` a eectuer une rupture de s equence, poursuivre lex ecution du programme et reprendre ensuite lex ecution l` a o` u on a pr ealablement rompu la s equence. Cest exactement la m eme notion que dans les langages de haut niveau o` u lappel dune proc edure suspend lex ecution de la s equence dinstructions en cours, ex ecute le corps de la proc edure et reprend ensuite lex ecution de la s equence suspendue auparavant. Notons que lon peut ` a nouveau appeler une proc edure dans une proc edure ou quune proc edure peut sappeler elle-m eme. Dans un langage de haut niveau, on na aucun souci ` a se faire pour que cela fonctionne bien, tout le m ecanisme etant pris en charge par le compilateur qui g en` ere la s equence dinstructions en assembleur pour que tout fonctionne comme pr evu. En assembleur, on doit comprendre le m ecanisme pour pouvoir en tirer le maximum et egalement pouvoir passer des param` etres aux sous-programmes. Dans ce qui suit, nous nommerons appelant le programme ou le sous-programme qui appelle un sousprogramme, et appel e le sous-programme qui est appel e par lappelant. ` la base, deux instructions sont n A ecessaires : une instruction dite dappel de sous-programme qui va rompre la s equence dinstructions en cours dex ecution et donner le contr ole au sous-programme ` a appeler ; une instruction dite de retour de sous-programme qui, plac ee ` a la n du sous-programme, indique au processeur quil faut reprendre lex ecution du programme interrompu, l` a o` u il sest interrompu, cest-` a-dire ex ecuter les instructions qui suivent linstruction dappel du sous-programme.
4.2.1
Lappel dun sous-programme
Un sous-programme est une s equence dinstructions. Pour le rep erer, on peut utiliser ladresse de sa premi` ere instruction. Pour sp ecier dans linstruction dappel de sous-programme le sous-programme ` a appeler, on va donc utiliser son adresse (comme on utilise le nom dune proc edure pour lappeler dans un langage de haut niveau : en assembleur, le nom dune proc edure, cest son adresse).
48
CHAPITRE 4. LES SOUS-PROGRAMMES
4.2.2
Retour ` a lappelant
Un sous-programme peut- etre appel ea ` di erents endroits dans un programme. Aussi, si son adresse est toujours la m eme, ladresse de retour (l` a o` u lex ecution du programme doit reprendre apr` es ex ecution du sous-programme) nest pas toujours la m eme. Aussi, dans linstruction de retour de sous-programme, il est impossible dindiquer o` u il faut continuer lex ecution. Aussi, il est clair que le processeur doit se rappeler de lendroit o` u ` a et e r ealis e lappel pour pouvoir continuer lex ecution du programme ` a cet endroit, une fois le sous-programme ex ecut e. Le registre IP contient ` a tout instant ladresse de linstruction suivante ` a ex ecuter. Lorsque le processeur ex ecute linstruction dappel dun sous-programme, IP contient donc ladresse de linstruction o` u devra reprendre lex ecution de lappelant (cette adresse se nomme adresse de retour). Il sut donc de m emoriser ` a linstant o` u lon ex ecute linstruction dappel de sous-programme la valeur de ce registre. En restaurant la valeur du registre IP ` a lissue de lex ecution du sous-programme, lex ecution du programme reprendra naturellement, l` a o` u il faut, dans lappelant. On pourrait utiliser un registre pour sauvegarder cette valeur du registre IP. Cependant, si le sousprogramme appel e appelle lui-m eme un autre sous-programme, o` u va-t-on sauvegarder la valeur de IP pour pouvoir reprendre son ex ecution, puisque le registre de sauvegarde est d ej` a utilis e. Deux registres de sauvegarde ne ferait pas non plus laaire : rien nemp eche un sous-programme qui appelle un sous-programme dappeler un sous-programme, ... autant de fois que lon veut. Pour r esoudre ce probl` eme, nous utilisons une structure de donn ees fondamentale en informatique, une pile. Pour comprendre les piles en informatique, il sut de comprendre le fonctionnement dune pile dassiettes dans une cuisine. Celle-ci fonctionne de la mani` ere suivante : on place une une assiette au sommet de la pile on prend lassiette qui se trouve en sommet de la pile En informatique, cest la m eme chose pour les donn ees et les piles de donn ees : on place les donn ees au sommet de la pile on r ecup` ere les donn ees au sommet de la pile En informatique, nous pouvons utiliser une pile pour y stocker nimporte quel objet. Lint er et dune pile est quelle constitue une structure o` u lacc` es ` a un objet est uniquement r ealis e sur le dernier objet empil e (comme pour une pile dassiettes, on prend la derni` ere assiette pos ee sur la pile). Revenons, ` a nos sous-programmes. Quand un appel de sous-programme est eectu e, on doit sauvegarder ladresse de retour. Pla cons-la sur une pile. Si ce sous-programme fait lui-m eme appel ` a un autre sous-programme, pla cons egalement ladresse de retour sur la pile (cest-` a-dire, au-dessus de ladresse de retour empil ee pr ec edemment). Quand ce sous-programme termine son ex ecution, consultons le sommet de la pile : elle contient ladresse de retour de sous-programme. D epilons-la et continuons lex ecution du programme ` a cette adresse. Quand ce sous-programme termine egalement son ex ecution, consultons ` a nouveau le sommet de la pile ; elle contient ladresse de retour de ce sous-programme. Si nous la d epilons et que nous reprenons lex ecution du programme ` a cette adresse, nous serons revenus dans le premier programme appelant. Nous pouvons maintenant it erer le processus et avoir des sous-programmes qui appellent des sous-programmes qui appellent des sous-programmes ... Le retour de lappel e au sous-programme appelant se passera alors sans aucune dicult e en utilisant la pile contenant les adresses de retour (nous nommerons cette pile, la pile des adresses de retour).
4.2.3
R esum e
Nous pouvons r esumer succinctement les actions ` a r ealiser lors de lappel et lors du retour dappel dun sous-programme. Supposons que nous ayons une pile de retour. Lappel dun sous-programme est r ealis e simplement en empilant la valeur courante de IP et en stockant dans IP ladresse dappel du sous-programme. Le retour de sous-programme est r ealis e simplement en d epilant le sommet de la pile et en pla cant cette valeur d epil ee dans le registre IP.
` 4.3. APPEL DE SOUS-PROGRAMME SANS PASSAGE DE PARAMETRE
49
4.2.4
La pile dappel de sous-programme
La pile de retour Nous avons indiqu e que lutilisation dune pile de retour permet de r esoudre le probl` eme des appels de sous-programmes. Cependant, nous navons pas encore vu comment on r ealise une pile en assembleur. Cest en fait fort semblable ` a limplantation dune pile dans un langage evolu e. Par ailleurs, certaines instructions et certains registres sont pr evus pour g erer la pile de retour en assembleur. La pile elle-m eme est une zone m emoire (une esp` ece de tableau) o` u le processeur range les donn ees ` a sauvegarder. Le seul probl` eme ` a r esoudre est alors de savoir o` u se trouve son sommet. En eet, si lon voit clairement o` u se trouve le sommet dune pile dassiettes dans une cuisine, il est dicile de dire que lon voit ce sommet pour une pile informatique. Aussi, nous avons besoin dun indicateur qui va nous (( montrer )) ce sommet. Les el ements de la pile etant donc situ es dans une zone m emoire, les el ements etant plac es les uns a la suite des autres, il nous sut davoir un registre qui indique ladresse du sommet de la pile. L ` el ement en-dessous du sommet de la pile se trouve alors dans lemplacement m emoire voisin, ... Ce registre se nomme le pointeur de sommet de pile. Cest le registre SP (SP signie stack pointer, cest ` a dire (( pointeur de pile ))). Quand on empile une donn ee, ce pointeur de pile doit etre mis ` a jour pour indiquer le nouveau sommet de pile (car (( la pile monte ))). Quand on d epile une donn ee, ce pointeur doit egalement etre mis ` a jour (car (( la pile descend ))). Etant donn ee limportance de ces op erations, les instructions dappel et de retour de sous-programme modient automatiquement le pointeur de pile pour que les appels et les retours de sous-programmes fonctionnent correctement. Classiquement, les piles sont implant ees avec leur base au-dessus de leur sommet, cest-` a-dire que ladresse du sommet de pile est inf erieure ` a ladresse de leur base. Aussi, quand une donn ee est empil ee, le pointeur de sommet de pile est d ecr ement e, alors que lorsquune donn ee est d epil ee, le pointeur de sommet de pile est incr ement e. Retour sur les instructions dappel et de retour de sous-programmes Ayant d ecrit limplantation de la pile de retour, nous pouvons maintenant d ecrire compl etement le fonctionnement des instructions dappel et de retour de sous-programmes. Instruction dappel de sous-programme ` lappel dun sous-programme, les op A erations suivantes sont automatiquement r ealis ees : SP est d ecr ement e (SP) adresse de retour (le contenu du registre IP) IP op erande de linstruction dappel de sous-programme Instruction de retour dun sous-programme IP (SP) SP est incr ement e
4.3
4.3.1
Appel de sous-programme sans passage de param` etre

Appels et retours de sous-programmes
Nous nous int eressons ici au cas le plus simple dappel de sous-programme, le cas o` u le sous-programme ne prend pas de param` etre en entr ee. Il sut alors dutiliser une instruction CALL pour appeler le sousprogramme et une instruction RET pour eectuer le retour ` a lappelant. Nous d ecrivons ces deux instructions.
50 CALL : Appel dun sous-programme
Nous d ecrivons ici linstruction dappel dun sous-programme. CALL O D I T e tiquette S Z A P C
Les appels de sous-programme entra nent la sauvegarde dans la pile du contenu du registre IP uniquement. La valeur du registre IP est mise ` a jour avec la valeur de lop erande fournie ` a linstruction CALL pour que lex ecution du programme se poursuive en d ebut de sous-programme. La valeur du registre pointeur de pile SP est bien entendu mise ` a jour apr` es empilement de la valeur de IP. Le contenu du registre CS nest pas modi e. RET : retour dun sous-programme RET O D I T S Z A P C
RET rend le contr ole au sous-programme appelant. Pour cela, le sommet de pile est d epil e dans le registre ip. Ladresse de retour doit donc n ecessairement se trouver en sommet de pile. Squelette dun sous-programme Nous donnons ci-dessous le squelette dun programme en assembleur : nom_sbr proc .... corps du sous-programme .... ret endp
nom_sbr
Nous notons les points suivants : le sous-programme est (( d eclar e )) par la pseudo-instruction proc, son nom etant indiqu e dans le champ etiquette. on trouve ensuite les instructions du sous-programme linstruction RET indique le retour ` a lappelant la pseudo-instruction endp indique la n du sous-programme. On indique le nom du sous-programme dans le champ etiquette
4.3.2
Sauvegarde et restauration de contexte
Un sous-programme est libre de modier le contenu de tous les registres. Cependant, lappelant peut avoir stock e des valeurs dans des registres quil aimerait ne pas voir modi e durant lex ecution dun sousprogramme quil appelle. Pour cela, la solution consiste ` a sauvegarder la valeur des registres en question. An que tout fonctionne bien et an davoir un m ecanisme standard, cette sauvegarde est eectu ee sur la pile. On peut r ealiser ces op erations ` a laide des instructions d ej` a pr esent ees. Ainsi, sauvegarder la valeur du registre AX sur la pile peut se faire de la mani` ere suivante : sub mov sp, 2 [sp], ax
` 4.3. APPEL DE SOUS-PROGRAMME SANS PASSAGE DE PARAMETRE
51
La premi` ere instruction place la valeur du registre AX au sommet de la pile. La deuxi` eme fait pointer le sommet de pile (( au-dessus )) (ou (( au-dessous )), selon le point de vue adopt e). Cependant, ces op erations de sauvegarde/restauration du contenu de registres sont tellement courantes que des instructions sp eciales ont et e ajout ees pour les eectuer. Linstruction PUSH place la valeur sp eci ee en op erande sur la pile. Linstruction POP retire le contenu du sommet de la pile et le place dans lop erande du POP. Il est important de noter que par convention, il est sous la responsabilit e de lappel e de sauvegarder la valeur des registres quil utilise et de restaurer leur valeur ` a la n de lex ecution du sous-programme. Lappelant na pas ` a se soucier de ces sauvegardes. Nous pr esentons maintenant les instructions PUSH et POP. PUSH sauvegarde sur la pile dune valeur
PUSH O D I
registre 16 bits d enote lun des registres ax, bx, cx, dx, si ou di. Linstruction PUSH place au sommet de la pile la valeur de lop erande qui est donc n ecessairement le contenu dun registre. La valeur du pointeur de sommet de pile SP est diminu ee de 2. PUSHF sauvegarde sur la pile de la valeur du registre dindicateurs
PUSHF O D I T S Z A P C
PUSHF empile le registre dindicateurs FLAGS. La valeur du pointeur de sommet de pile SP est ensuite diminu ee de 2. POP d epilement dune valeur
POP O D I
POP d epile une valeur de la pile de retour et place la valeur ainsi d epil ee dans lop erande. La valeur du pointeur de sommet de pile SP est augment ee de 2. POPF d epilement de la valeur du registre dindicateurs
POPF O * D * I * T * S * Z * A * P * C *
POPF d epile la valeur de FLAGS. La valeur du pointeur de sommet de pile est augment ee de 2.
52
4.4
Passage de param` etres et variables locales
Un sous-programme prend souvent des param` etres en entr ee d` es quil est capable de r ealiser des actions un peu complexes. Il est egalement courant quun sous-programme ait besoin de variables locales. Enn, il est egalement courant quun sous-programme ait des param` etres en sortie (r esultat) ou renvoie une valeur (comme une fonction dans un langage de haut niveau). Nous traitons de tous ces m ecanismes dans cette section. Comme toujours, pour autoriser une exibilit e maximale, tous ces m ecanismes vont etre implant es ` a laide de la pile. Les param` etres seront empil es par lappelant juste avant lappel. Lappel e r eservera, si n ecessaire, un espace dans la pile pour y mettre la valeur de ses variables locales. Quant au renvoi dune valeur, il se fera g en eralement par un registre. Nous d ecrivons maintenant dans le d etail chacun de ces m ecanismes.
4.4.1
Passage de param` etres par registre
Le mode de passage de param` etres le plus simple consiste ` a passer la valeur dans un registre : lappelant charge un registre avec la valeur ` a passer ; lappel e r ecup` ere la valeur dans ce m eme registre. Appelant ... mov call ... facto proc ... ... ret facto endp Appel e
ax, 8 facto
; parametre dans ax
Nous donnons un exemple de sous-programme calculant la factorielle dun nombre dont la valeur est pass ee en entr ee dans le registre AX. Appelant ... mov call ... facto proc push mov mov boucle1: mul loop pop ret facto endp Appel e
ax, 8 facto
cx cx, ax ax, 1 ax, cx boucle1 cx
4.4.2
Passage de param` etres dans la pile
Le passage de param` etres par la pile permet de tout faire. Cest de cette mani` ere que tous les langages de haut niveau passent leur param` etres aux proc edures et fonctions. La ma trise de cette technique est indispensable pour bien programmer en assembleur. Pour cela, un peu de rigueur quant ` a la manipulation de la pile de retour est n ecessaire. Le processeur utilise implicitement la pile pour y empiler ladresse de retour des sous-programmes. Il y a donc une contrainte ` a respecter lorsque lon veut utiliser la pile : Le microprocesseur doit imp erativement trouver ladresse de retour dun sous-programme au sommet de la pile lorsquil ex ecute une instruction RET.
` 4.4. PASSAGE DE PARAMETRES ET VARIABLES LOCALES
53
Si on respecte cette convention, on peut faire tout ce que lon veut et cela fonctionnera. Par convention, nous devons d ecider dun protocole commun aux sous-programmes appelants et appel es quant ` a la localisation des donn ees sur la pile. Nous savons que le processeur empile la valeur du registre IP quand il ex ecute une instruction CALL. Le sous-programme appelant est responsable du passage des param` etres, cest-` a-dire de leur empilage. Aussi, nous r ealiserons le passage de param` etres de la mani` ere suivante : lappelant empile (par des instructions PUSH) la valeur des param` etres puis ex ecute lappel du sous-programme (instruction CALL). La pile a alors la forme indiqu ee ` a la gure 4.1.
6 Param` etres dappel Adresses croissantes
Sauvegarde de ip lors du call sp -
Fig. 4.1 Pile apr` es ex ecution de linstruction call.
Pour lappel e, la convention est dutiliser le registre BP pour acc eder ` a la valeur des param` etres. BP doit donc etre initialis e au d ebut de lex ecution de lappel e. Aussi, sa valeur doit etre egalement sauvegard ee. Cette sauvegarde doit etre r ealis ee par lappel e. Pour r esumer, nous donnons le squelette dun appel de sous-programme avec passage de param` etres. Supposons que nous passions trois param` etres, les valeurs des registres AX, BX et CX. Appelant ... push push push call add ... sbr ax bx cx sbr sp, 6 proc push mov ... ... ... ... ... ... pop ret endp Appel e
bp bp, sp ...[bp+4]... ...[bp+6]... ...[bp+8]...
bp
sbr Nous notons les points suivants :
dans lappelant, les valeurs des param` etres sont empil ees avant lappel du sous-programme
54
CHAPITRE 4. LES SOUS-PROGRAMMES dans lappel e (donc, la valeur du compteur ordinal IP ` a et e empil ee sur 2 octets), la valeur du registre BP est empil ee
la valeur du registre BP est initialis ee avec la valeur du sommet de pile contenue dans SP
on peut acc eder maintenant ` a la valeur des param` etres via le registre BP. Ainsi,
[bp+4] acc` ede au dernier param` etre empil e (donc la valeur du registre CX) [bp+6] acc` ede au param` etre empil e avant CX (donc la valeur du registre BX) [bp+8] acc` ede au param` etre empil e avant BX (donc la valeur du registre AX)
en n de sous-programme appel e, on doit restaurer la valeur du registre BP pour que lappelant nait pas de probl` eme. Cest le r ole de linstruction POP
apr` es lex ecution du POP, le sommet de pile contient ladresse de retour ; un RET peut donc etre ex ecut e en toute s ecurit e
de retour dans lappelant, la zone m emoire utilis ee pour stocker des param` etres doit etre lib er ee. Pour cela, on modie simplement la valeur du registre pointeur de sommet de pile SP en lui ajoutant la valeur 6 qui est le nombre doctets occup es sur la pile par les valeurs empil ees (2 pour AX, 2 pour BX et 2 pour CX). On aurait pu egalement lib erer la pile avec des instructions POP. Cependant, lhabitude veut que lon ecrive les programmes comme il a et e indiqu e ici. Pai ailleurs, utiliser des instructions POP modie la valeur des registres, ce qui peut amener des eets ind esirables
Nous donnons un exemple dappel de sous-programme : un sous-programme qui calcule le PGCD de deux nombres pass es en param` etre. Lalgorithme utilis e est le suivant : soit ` a calculer le PGCD de x et y :
Tant-que x = y Faire
Si x > y Alors x x y Sinon Si x < y Alors y y x
Fait
Sortant de la boucle, x (ou y : en sortie de boucle, les deux variables contiennent la m eme valeur) contient la valeur du PGCD.
` 4.4. PASSAGE DE PARAMETRES ET VARIABLES LOCALES
55
Appelant ... mov push mov push call add ... pgcd ax, 453 ax ; empile x ax, 36 ax ; empile y pgcd sp, 4 proc push mov push push mov mov tq1: cmp jg je sub jmp sup: sub jmp ftq1: call pop pop pop ret pgcd endp
Appel e
bp bp, sp ax ; sauvegarde de bx ; ax et bx ax, [bp+4] ; charge y dans ax bx, [bp+6] ; charge x dans bx ax, bx sup ; saut si y>x ftq1 ; sortir si x=y ax, bx tq1 bx, ax tq1 affiche_nombre bx ax bp
On suppose que lon dispose du sous-programme affiche_nombre qui ache le r esultatun nombre ` a l ecran.
4.4.3
Variables locales
Nous abordons maintenant le probl` eme des variables locales. Celui-ci va egalement etre r esolu en utilisant la pile de retour. Les locales sont, par d enition, uniquement connues du sous-programme o` u elles sont d eclar ees. Aussi, la gestion des locales doit-elle etre enti` erement r ealis ee dans lappel e. Pour cela, la solution la plus simple consiste, une fois sauvegard ee la valeur des registres en d ebut de sous-programme, ` a r eserver de la place dans la pile pour y mettre la valeur des locales. Cela donne la conguration de la gure 4.2.
Nous donnons le squelette dun appel de sous-programme avec passage de param` etres et d enition de variables locales. Supposons que nous passions deux param` etres, les valeurs des registres AX, BX, que nous devions sauvegarder la valeur des registres DI et SI et que nous ayons besoin de 10 octets pour stocker des variables locales.
56
Param` etres dappel
Sauvegarde de ip lors du call 6 Sauvegarde de bp Adresses croissantes
Sauvegarde des registres
sp
Variables locales
Fig. 4.2 Pile apr` es r eservation despace pour les variables locales.
Appelant ... push push call add ... sbr ax bx sbr sp, 6 proc push mov push push sub ... ... ... ... ... ... add pop pop pop ret endp
Appel e
bp bp, sp di si sp, 10 ...[bp+4]... ...[bp+6]... ...[bp-6]... sp, 10 si di bp
sbr
Le sous-programme appelant ressemble enorm ement au cas pr esent e plus haut de passage de param` etres
` 4.4. PASSAGE DE PARAMETRES ET VARIABLES LOCALES et nappelle donc aucun commentaire particulier. Pour lappel e, nous notons les points suivants : la sauvegarde (comme auparavant) du registre BP linitialisation du registre BP pour quil pointe au sommet de la pile
57
la sauvegarde de la valeur des registres DI et SI. Notons que BP pointe sur la valeur de la sauvegarde du registre DI la r eservation de 10 octets sur la pile (par linstruction sub sp, 10) qui pourront etre manipul es librement dans le sous-programme et dont le r ole est de contenir la valeur des variables locales lacc` es aux variables locales se fera d` es lors par un adressage du genre [bp-6] ... [bp-15], selon la taille des donn ees. Notons, cest tr` es important, que le programmeur doit d enir lui-m eme lutilisation de ces 10 octets. en n dappel e, on lib` ere la zone de pile utilis ee pour stocker la valeur des variables locales (instruction ADD) on restaure ensuite la valeur dentr ee des registres SI, DI et BP.
4.4.4
Retour dune valeur par un sous-programme : les fonctions en assembleur
Dans un langage de haut niveau, une fonction est une proc edure qui retourne une valeur. En assembleur, une fonction sera un sous-programme qui retournera une valeur. Par convention, la valeur renvoy ee est plac ee dans un registre. Par exemple, le sous-programme suivant calcule la valeur de la factorielle du nombre pass e en param` etre dans la pile et renvoie cette valeur dans le registre AX : Appelant ... mov push call ... facto proc push mov push mov mov boucle1: mul loop pop pop ret facto endp Appel e
ax, 8 ax facto
bp bp, sp cx cx, [bp+4] ax, 1 cx boucle1 cx bp
58
59
Chapitre 5
Les interruptions du DOS

Nous pr esentons ici tr` es succinctement quelques interruptions du BIOS qui nous serons utiles pendant les TPs pour, par exemple, acher un message ` a l ecran ou saisir un caract` ere au clavier. Dune mani` ere g en erale, toutes les op erations dentr ees/sorties sont r ealis ees par interruptions BIOS. Le m ecanisme dinterruptions sera d ecrit en d etail en cours. Sachons simplement ici quune interruption est une esp` ece de sous-programme pr e-existant dans la machine. Lappel se fait via linstruction int 21h. Le registre ah contient un num ero qui r ef erence la fonctionnalit e que lon veut utiliser (9 pour acher une cha ne de caract` eres, 1 pour saisir la frappe dun caract` ere au clavier, ...)
5.1
5.1.1
Achages de caract` eres ` a l ecran

Acher un caract` ere ` a l ecran
mov mov int dl, a ah, 2 21h
ache le caract` ere a ` a l ecran.
5.1.2
msg
Acher un message ` a l ecran

.data db .code mov mov mov lea int mov int end hello world, 13, 10, $ ax, ds, ah, dx, 21h ah, 21h @data ax 9 msg 4ch
ache le message hello world ` a l ecran. La cha ne de caract` eres doit imp erativement se terminer par un caract` ere $. Les caract` eres 13 et 10 sont les codes ASCII des 2 caract` eres constituant un retour-chariot.
60
CHAPITRE 5. LES INTERRUPTIONS DU DOS
5.2
5.2.1
Saisir une frappe au clavier

Saisie avec echo
Saisie dun caract` ere mov int ah, 1 21h
renvoie dans le registre al le code du caract` ere lu au clavier.
Saisie dune cha ne de caract` eres msg .data db .code mov mov mov mov lea mov int 80 dup (?) ax, ds, bx, cx, dx, ah, 21h @data ax 0 80 msg 3fh
saisit une cha ne de caract` eres au clavier dau plus cx caract` eres et la stocke dans la variable msg qui est d eclar ee comme un tableau de 80 octets (soit 80 caract` eres). Le nombre de caract` eres lus est plac e dans le registre ax. Notons que le retour-chariot est stock e sous forme de deux caract` eres successifs : le premier de code 13, le second de code 10.
5.2.2
Saisie sans echo

mov int ah, 8 21h
lit un caract` ere au clavier et le renvoie dans le registre al. Ce caract` ere nest pas ach e` a l ecran.
5.3
Lacc` es aux chiers
Nous pr esentons ici les interruptions ` a utiliser pour eectuer les traitements de base sur les chiers. On se reportera ` a 6.3 pour un exemple complet de traitement de chiers.
5.3.1
Principe
En assembleur, les chiers sont trait es dune mani` ere assez similaire ` a un langage evolu e comme Pascal. Pour pouvoir acc eder aux donn ees dun chier, que ce soit en lecture ou en ecriture, il faut pr ealablement ` louverture, le programme r louvrir. A ecup` ere une poign ee. Ensuite, toutes les op erations sur ce chier seront ` un instant donn eectu ees en sp eciant cette poign ee. A e, plusieurs chiers peuvent avoir et e ouverts par un programme. Chacun a une poign ee di erente laquelle permet au programme de les distinguer.
` AUX FICHIERS 5.3. LACCES
61
5.3.2
Cr eation dun chier

Avant lappel cx contient la valeur 0 ; ds:dx pointent sur le nom de chier. Cest une cha ne de caract` eres termin ee par un caract` ere ASCII de code 0. Apr` es lappel Le bit C du registre flags vaut 1 si une erreur est survenue.
Lappel a le format suivant : mov int ah, 3ch 21h
5.3.3
Ouverture dun chier

Avant lappel al contient le mode dacc` es : 0 pour lecture, 1 pour l ecriture, 2 pour les deux ; ds:dx pointent sur le nom de chier. Cest une cha ne de caract` eres termin ee par un caract` ere ASCII de code 0. Apr` es lappel Le bit C du registre flags vaut 1 si une erreur est survenue. Sinon, le registre ax contient la poign ee sur le chier ouvert.
Lappel a le format suivant : mov int ah, 3dh 21h
5.3.4
Fermeture dun chier

Avant lappel bx contient la poign ee du chier ` a fermer Apr` es lappel Le bit C du registre flags vaut 1 si une erreur est survenue. Sinon, le chier est ferm e. Il ne peut plus etre acc ed e via sa poign ee. Si on veut lacc eder ` a nouveau, il faudra le r e-ouvrir au pr ealable.
Lappel a le format suivant : mov int ah, 3eh 21h
62
5.3.5
Lecture dans un chier

Avant lappel bx contient la poign ee du chier ; cx contient le caract` eres ` a lire ; nombre de Apr` es lappel Le bit C du registre flags vaut 1 si une erreur est survenue. Sinon, le registre ax contient le nombre de caract` eres lus. En principe, cest le nombre de caract` eres qui devait etre lus ` a moins que la n de chier ne soit atteinte.
ds:dx contient ladresse du tampon o` u il faut stocker les caract` eres lus.
On peut utiliser cet appel pour lire une cha ne de caract` eres tap es au clavier. Pour cela, il faut que bx contienne la valeur 0 en entr ee. La lecture seectuera sur au plus cx caract` eres et au plus jusqu` a la frappe dun retour-chariot. Lappel a le format suivant : mov int ah, 3fh 21h
5.3.6
Ecriture dans un chier

Avant lappel bx contient la poign ee du chier ; cx contient le nombre caract` eres ` a ecrire ; de Apr` es lappel Le bit C du registre flags vaut 1 si une erreur est survenue. Sinon, le registre ax contient le nombre de caract` eres ecrits.
ds:dx pointent sur le tampon contenant les caract` eres ` a ecrire. Lappel a alors le format suivant : mov int ah, 40h 21h
5.4
Lire lheure courante
La fonction 2ch de linterruption 21h lit lheure courante, telle quelle est stock ee dans lordinateur (sil nest pas ` a lheure, cela ne donnera pas la bonne heure). mov int ah, 2ch 21h
Au retour de lappel, les registres contiennent les information suivantes : ch heures cl minutes dh secondes dl centi` emes de secondes Voir la section 6.4 pour un exemple dutilisation de cette interruption.
5.5. LIRE LA DATE COURANTE
63
5.5
Lire la date courante
La fonction 2ah de linterruption 21h lit la date courante, telle quelle est stock ee dans lordinateur (comme pour lheure, si la date nest pas bonne, cela ne donnera pas la bonne date). mov int ah, 2ah 21h
Au retour de lappel, les registres contiennent les information suivantes : al jour de la semaine cod e (0 : dimanche, 1 : lundi, ...) cx ann ee dh mois dl jour
64
65
Chapitre 6
Etudes de cas
6.1 Cas 1 : lire une suite de caract` eres au clavier
Probl` eme ` a r esoudre Ecrire un programme qui lit des caract` eres frapp es au clavier et les achent ` a l ecran tant que lutilisateur nappuie pas sur <esc>. Principe Faire une boucle : repeter lire (c) si (c # ESC) alors affiche (c) fin_si jusque c = ESC En accord avec ce qui est dit sur les boucles repeter dans la m ethodologie de programmation en assembleur, on doit tout dabord transformer cette boucle en : repeter: lire (c) si c # ESC alors afficher (c) fin_si si c # ESC alors jmp repeter fin_si Puisque les deux si r epondent ` a la m eme condition, on peut encore ecrire la boucle sous la forme suivante : repeter: lire (c) si c # ESC alors afficher (c) jmp repeter fin_si
66 Ce que nous pouvons traduire en assembleur : Programme .MODEL .DATA .CODE mov mov mov int cmp je mov mov int jmp mov int END SMALL
CHAPITRE 6. ETUDES DE CAS
boucle:
fin:
ax, @data ds, ax ah, 8 21h al, 27 ; 27 est le code ASCII de la touche <Esc> fin dl, al ah, 2 21h boucle ah,4ch 21h
6.2
Cas 2 : acher un nombre en base 2
Probl` eme ` a r esoudre Acher la valeur en binaire dun nombre. Principe Acher lun apr` es lautre les bits du nombre en eectuant une boucle du genre : pour b := 1 a 16 faire si (valeur.bit[b] = 0) alors afficher (0) sinon afficher (1) fait Pour acc eder aux bits du nombre, plusieurs techniques sont envisageables. La plus simple consiste ` a d ecaler vers la gauche les bits du nombre (instruction SHL ou ROL) en pla cant le bit qui d eborde dans le C du registre d etat. En testant ensuite ce bit C (avec une instruction JC ou JNC), on sait sil faut acher un 0 ou un 1. Remarquons quen utilisant une instruction ROL, une fois les 16 d ecalages eectu es, la valeur a et e restaur ee. Programme .MODEL .STACK .DATA dw .CODE mov mov mov mov rol SMALL 100h 52612 ax, ds, bx, cx, bx, @data ax [valeur] 16 1
valeur
boucle:
6.3. CAS 3 : AFFICHER LE CONTENU DUN FICHIER jc mov jmp mov mov int loop mov int END un dl, 0 print dl, 1 ah, 2 21h boucle ah,4ch 21h
67
un: print:
fin:
ache 1100110110000100 qui est bien la repr esentation binaire de 52612.
6.3
Cas 3 : Acher le contenu dun chier
Nous montrons sur un exemple lutilisation des interruptions dacc` es aux chiers. Probl` eme ` a r esoudre Acher le contenu dun chier ` a l ecran. Principe Le principe de lalgorithme est le suivant : ouverture du chier r ep eter lire les caract` eres suivants du chier et les mettre dans une zone m emoire pr evue pour cet usage (un tampon). Notons que cette action lit eectivement caract` eres. En g en eral, = . Si la n de chier est atteinte pendant la lecture, on a lu les < derniers caract` eres du chier. acher caract` eres du tampon ` a l ecran jusqu` a ce que = fermer le chier Programme
.MODEL SMALL .STACK 100H .DATA DB toto, 0 db 100 dup (?), $ db Erreur a louverture, 13, 10, $ db Erreur a la lecture, 13, 10, $ .CODE ; ; initialisations ; mov ax,@data mov ds,ax ; ; ouverture et test dexistence du fichier ; mov ah,3dh ; ouverture du fichier mov al,0 ; acc` es en lecture lea dx, Filename int 21h jc err1 ; le fichier nexiste pas -> erreur ; ; pr eparation de la boucle ;
Filename Buffer err1_msg err2_msg
68
mov bx, ax ; sauvegarde de la poign ee lea dx, Buffer ; boucle: ; ; lecture des 100 caract` eres suivants du fichier ; mov cx, 100 mov ah, 3fh ; lecture du fichier int 21h jc err2 ; ; affichage a lecran des caract` eres lus ; mov cx, ax mov si, ax mov si+Buffer, $ mov ah,9 int 21h cmp cx, 100 je boucle ; ; fin du traitement : mov ah, 3eh ; fermeture du fichier int 21h jmp fin ; ; traitements des erreurs ; err1: ; ; le fichier ne peut etre ouvert ; lea dx, err1_msg jmp affiche_msg err2: ; ; erreur lors de lacc` es au contenu du fichier ; lea dx, err2_msg jmp affiche_msg affiche_msg: mov ah,9 int 21h jmp fin fin: mov ah,4Ch int 21h END
On a suppos e que le chier se nomme toto.
6.4
Cas 4 : acher lheure courante
Probl` eme ` a r esoudre Acher lheure courante ` a l ecran sous une forme lisible. Principe Il sut de lire lheure courante via linterruption BIOS ad hoc et dacher le contenu des registres dune mani` ere compr ehensible pour un etre humain. Programme
; Ce programme affiche lheure courante .MODEL SMALL .STACK 100H .DATA db Il est : $ db h $ db m $ db s, $ .CODE mov ax,@data mov ds,ax ;
ch1 ch2 ch3 ch4
6.4. CAS 4 : AFFICHER LHEURE COURANTE

; lecture de lheure courante ; mov ah,2ch int 21h ; ; maintenant, on a : ; ch: heures ; cl: minutes ; dh: secondes ; dl: 1/100 secondes ; ; ; affiche les heures ; mov ax, offset ch1 call aff_str mov al,ch call aff_nb ; ; affiche les minutes ; mov ax, offset ch2 call aff_str mov al,cl call aff_nb ; ; affiche les secondes ; mov ax, offset ch3 call aff_str mov al,dh call aff_nb ; ; affiche les centi` emes de secondes ; mov ax, offset ch4 call aff_str mov al,dl call aff_nb ; mov ah,4Ch int 21h ; ; PROC ; ; le sous-programme aff_nb affiche la valeur du nombre ; code en hexadecimal se trouvant dans le registre al. ; Ce nombre doit avoir une valeur < 100. ; push dx push ax mov ah, 0 mov dl, 10 div dl ; maintenant, al contient le chiffre des dizaines, ; ah, le chiffre des unites mov dx, ax or dx, 3030h ; les deux chiffres ont ete transformes en code ASCII ; on affiche le chiffre des dizaines mov ah,2 int 21h ; on affiche le chiffre des unites xchg dl, dh mov ah,2 int 21h pop ax pop dx ret ENDP ; ; PROC ; ; le sous-programme aff_str affiche la chaine de caracteres ; dont loffset se trouve dans le registre ax, dans le segment ; courant. ; push dx
69
fin:
aff_nb
aff_nb
aff_str
70
push mov mov int pop pop ret ENDP END ax dx,ax ah,9 21h ax dx
aff_str
71
Annexe A
Introduction ` a lutilisation du debugger

Nous indiquons ici en quelques mots lutilisation du debugger. Un debugger est un outil qui permet dex ecuter instruction par instruction un programme tout en suivant en permanence l evolution du contenu des registres, du segment de donn ees, la pile, ... Cest un outil indispensable pour simplier et acc el erer la mise en point de programmes.
A.1
Lancement et pr esentation du debugger
Lancement du debugger Apr` es avoir obtenu un programme ex ecutable (que nous appellerons ici prg.exe ` a titre dexemple), on lance la commande : td2 prg L ecran seace et ache une interface avec une fen etre dont on peut modier la taille avec la souris. Une barre de menus est disponible en haut de l ecran. L ecran ressemble alors ` a ce qui est pr esent e` a la gure A.1. Notons imm ediatement que lon quitte le debugger en tapant Alt-X. Que peut-on faire avec un debugger ? Sans entrer tout de suite dans les d etails, il est important de comprendre avant tout ce que lon peut attendre dun debugger et le principe g en eral de son utilisation. Sans en attendre de miracles, un debugger aide (grandement) ` a r epondre aux questions suivantes : pourquoi mon programme ne fonctionne-t-il pas? pourquoi mon programme boucle-t-il? o` u se plante mon programme? Pour cela, une fois dans le debugger, on peut placer des points darr et dans le programme an quil sy arr ete 1 . Cest-` a-dire, on indique les instructions o` u lon veut que le programme sarr ete. Une fois arr et e, on pourra consulter ` a loisir le contenu des registres, le contenu de la m emoire ou de la pile. Nous d etaillons maintenant le contenu de la fen etre et pr esentons les fonctionnalit es les plus utiles.
1. il est important de bien noter que si lon ne place pas de points darr et dans le programme, celui-ci va sex ecuter sans sarr eter avant sa terminaison normale (donc, sil boucle, il ne sarr etera pas plus sous le debugger que si on lex ecute sous DOS). Dans ce cas, ex ecuter le programme sous le debugger ou directement sous DOS ne change rien, si ce nest que lon pourra ensuite consulter le contenu des registres.
72
` LUTILISATION DU DEBUGGER ANNEXE A. INTRODUCTION A
adresse
code instruction
6 mn emonique
op erande
ax bx cx dx si di bp sp ds es ss cs ip
0000 0000 0000 0000 0000 0000 0000 0000 .... .... .... .... 0000
c=0 z=0 s=0 o=0 p=0 a=0 i=1 d=0
Segment de code Segment de donn ees es

adresse 8 valeurs hexad ecimales 8 caract` eres ASCII correspondants
Segment de pile
Fig. A.1 La fen etre du d ebugger.
A.1.1
La fen etre de debuggage
Le menu Run Parmi dautres possibilit es, ce menu vous propose : Run lance le programme. Si son ex ecution a d ej` a d ebut ee, le programme poursuit son ex ecution l` a o` u il avait et e arr et e. Sinon, il d emarre ` a son d ebut. Il ne sarr ete que lorsquil arrive ` a son terme ou sur le point darr et (cf. plus loin) suivant, si lon en a plac e; Go to cursor ayant cliqu e sur une instruction, le programme d ebute ou poursuit son ex ecution jusqu` a atteindre cette instruction ; Trace into arr et e sur une instruction call, consid` ere lex ecution de lensemble du sous-programme comme un pas dex ecution ; Step over ex ecute la prochaine instruction et sarr ete ; Until return ex ecute les instructions qui suivent jusque la n du programme ou jusqu` a la prochaine instruction ret ; Animate d eclenche lex ecution instructions par instructions. La vitesse dex ecution est r eglable et est demand ee ` a lutilisateur ; Prg Reset remise ` a z ero de lex ecution du programme. Remet le debugger dans son etat initial, comme si lon navait pas encore lanc e lex ecution du programme.
A.2. QUELQUES OPERATIONS DE BASE Les points darr et
73
Un point darr et est un endroit dans le programme o` u on indique que lon veut que celui-ci arr ete son ex ecution. Il existe deux mani` eres de mettre en place des points darr et : soit implicitement en cliquant sur une instruction du programme et en lan cant ensuite lex ecution du programme par un Go to cursor soit explicitement en cliquant sur une instruction du programme et en choisissant dans le menu Breakpoints loption At dy placer un point darr et. On peut placer plusieurs points darr et dans ` son ex le programme. A ecution (lancement par Run, Go to cursor, ...), le programme sarr etera automatiquement ` a chaque fois quil arrivera sur une instruction o` u on a plac e un point darr et. Linstruction nest pas ex ecut ee avant larr et du programme. Elle lest quand on continue lex ecution du programme.
A.2
A.2.1
Quelques op erations de base

Acher le segment de donn ees
Au lancement de td, le debugger ne conna t pas lemplacement en m emoire du segment de donn ees, le registre ds etant initialis e par le programme, en g en eral ` a lex ecution des premi` eres instructions du programme. Une fois ds initialis e, on peut visualiser le contenu du registre de segment dans une fen etre en choisissant dans le menu View loption Dump.
A.2.2
Acher le contenu dun segment m emoire quelconque
On peut visualiser le contenu de la m emoire ` a partir de nimporte quelle adresse en sp eciant un num ero de segment et un oset. Pour cela, ouvrir un dump m emoire en s electionnant Dump dans le menu View. Ensuite, en cliquant dans la fen etre avec le bouton droit de la souris, un menu apparait. S electionner Goto.... Le debugger demande ladresse ` a partir de laquelle il doit acher le contenu de la m emoire dans la fen etre. On pourra alors taper es:0, ds:0 ou 53DA:14, selon ses besoins.
A.2.3
Modier la valeur dun registre, dun indicateur, dune donn ee en m emoire
On peut facilement modier la valeur dun registre, dun indicateur du registre d etat ou un octet en m emoire en cliquant dessus, en entrant sa nouvelle valeur et en validant.
A.3
Remarques
Il faut noter que certaines instructions napparaissent pas sous le debugger comme vous avez pu les taper dans votre programme source. Ainsi, comme nous lavons vu, les instructions sal et shl sont synonymes. Aussi, quelle que soit celle que vous avez tap e dans le source de votre programme, cest toujours shl qui sera ach ee. Par ailleurs, les instructions de d ecalages du genre shr al,3 o` u le deuxi` eme op erande est une valeur imm ediate sont transform ees en une s equence de 3 instructions shr al,1. Les instructions du genre push 23, cest-` a-dire push dune valeur imm ediate, sont transform ees en une s equence de plusieurs instructions. Par exemple, pour celle-ci, on obtiendra : push push mov pop ax bp word ptr [bp+2], 17 bp
qui empile bien la valeur 23 (cest-` a-dire 17h).
74
` LUTILISATION DU DEBUGGER ANNEXE A. INTRODUCTION A
75
Annexe B
Param` etres de la ligne de commande et environnement

Lorsquon lance un programme, on peut sp ecier des param` etres dans la ligne de commande (des noms de chiers par exemple) quipourront etre pris en compte par le programme durant son ex ecution. Par ailleurs, outre les param` etres de la ligne de commande, le syst` eme dexploitation passe automatiquement au programme les variables denvironnement (cest-` a-dire, les variables positionn ees par la commande MSDOS set). Dans la pr esente annexe, nous indiquons comment ces informations peuvent etre acc ed ees depuis un programme assembleur. Tout programme en cours dex ecution poss` ede une structure de donn ees qui lui est propre est qui porte le doux nom de PSP, acronyme de Program Segment Prex. Ce PSP est toujours compos e de 256 octets. Parmi ceux-ci, on trouve : ` a loset 2ch le num ero du segment o` u est situ e lenvironnement ; ` a partir de loset 81h, la ligne de commande termin ee par un caract` ere de code 0Dh ; ` a loset 80h, le nombre de caract` eres de la ligne de commande (sans compter le 0Dh).
B.1
Lacc` es au PSP
Linterruption 21h renvoie le num ero du segment contenant le PSP si on place la valeur 62h dans le ` son retour, on r registre ah. A ecup` ere le num ero du segment contenant le PSP dans le registre bx. Le PSP occupe les octets doset 0 ` a 255 de ce segment.
B.2
La ligne de commande
Nous indiquons sur des exemples la structure de la ligne de commande telle quelle est stock ee dans le PSP. Si sous MS-DOS, on tape la commande : prg a b c d e on trouvera les informations suivantes dans le PSP : 80: 0A 20 65 20 66 20 67 20 a b c 88: 68 20 69 0D ........... d e Il faut noter que les redirections ne font pas partie des param` etres de la commande et napparaissent pas dans le PSP. Ainsi, si on tape les commandes : prg a b c d e > toto prg a b c d e < titi > toto
76
` ANNEXE B. PARAMETRES DE LA LIGNE DE COMMANDE ET ENVIRONNEMENT prg a b c d e | more on aura toujours le m eme contenu dans le PSP (celui donn e plus haut).
B.3
Lenvironnement
Lenvironnement dun programme est un ensemble de couples < nom de variable, valeur > Le nom dune variable et sa valeur sont des cha nes de caract` eres. Dans le PSP, ils sont s epar es par un signe = pour les distinguer. Chaque couple est termin e par un caract` ere ASCII de code 00. La liste des couples se termine elle-aussi par un caract` ere de code 00. (Donc, les deux derniers caract` eres de la zone m emoire o` u est stock e lenvironnement ont tous deux la valeur 00.) Un exemple de contenu de la zone stockant lenvironnement est donn e ci-dessous : 00: 10: 20: 30: 40: 50: 43 4e 45 3d 3a 00 4f 44 4d 43 5c 4d 2e 50 3a 42 53 43 3d 5c 4f 50 4f 43 44 52 45 4d 3a 4f 4c 43 00 5c 53 41 3d 50 54 3b 4e 43 52 45 43 44 3a 4f 4d 3a 43 5c 4d 50 5c 5c 43 50 00 42 42 4f 54 50 41 49 4d 3d 41 54 4e 4d 00 54 3b 3b 41 54 48 43 00 COMSPEC=C:\COMMA ND.COM PROMPT= T EMP=C:\TEMP PATH =C:\DOS;C:\BAT;C :\BORLANDC\BIN;
An dillustrer notre propos, nous donnons ci-dessous un programme qui ache la premi` ere variable (son nom et sa valeur).
B.3. LENVIRONNEMENT
77
boucle1:
fin:
.MODEL SMALL .STACK 100H .CODE mov ah,62h ; chargement du numero int 21h ; du segment du PSP mov ds,bx ; chargement de ds avec le numero du segment ; contenant lenvironnement mov ax,[ds:2ch] mov ds,ax ; boucle de recherche de la fin de la ; premiere variable denvironnement. Elle ; est reperee par un octet de valeur nulle mov si,0 inc si cmp BYTE PTR [si],0 jne boucle1 ; si contient loffset du caractere nul. ; On met un $ en fin de chaine pour pouvoir ; lafficher avec linterruption classique ; et on appelle linterruption en question mov BYTE PTR [si],$ mov ah,9 int 21h ; on remet un caractere nul la ou on avait mis ; un $. (Cela ne sert a rien ici puisque le ; programme sarrete.) mov BYTE PTR [si],0 ; fin du programme mov ah,4Ch int 21h END
78
` ANNEXE B. PARAMETRES DE LA LIGNE DE COMMANDE ET ENVIRONNEMENT
79
Annexe C
Du bon usage des registres

Mis ` a part quelques registres tr` es sp eciques dont lemploi est impos e par le processeur (par exemple, le registre d etat est forc ement le registre flags, le num ero du segment de code se trouve forc ement dans le registre cs, ...), la plupart des registres peuvent etre utilis es dans diverses circonstances. Il peut etre utile dindiquer ici quelques conventions. ax, bx, cx, dx : registres de donn ees. Ils peuvent g en eralement etre utilis es librement. Seuls ax et cx ont parfois un usage r eserv e (instructions mul, imul, div, idiv et les di erentes versions de loop) ; si, di : oset de donn ees, utilis es par certaines instructions de traitement de cha nes ; sp : pointeur de sommet de pile. Prudence extr eme lors de sa manipulation (cf. appel de sous-programmes 4) ; bp : souvent utilis e pour sauvegarder sp en cas de besoins (cf. appel de sous-programmes 4) ; ip : compteur ordinal. Ne doit pas etre modi e; cs : segment de code. Ne pas le modier ; ds : segment de donn ees : segment dans lequel sont en g en eral r ef erenc ees automatiquement les donn ees ; es : segment de donn ees utilis e sp eciquement par les instructions de traitement de cha nes en liaison avec le registre di; ss : segment de pile. Ne pas le modier a priori ; flags : registre d etat.
80
ANNEXE C. DU BON USAGE DES REGISTRES
81
Annexe D
Le codage ASCII
On donne le code ASCII des caract` eres usuels. Labscisse indique le chire, lordonn ee la dizaine (en hexad ecimal). Aussi, le code ASCII du caract` ere : est 3a. .0 2. 3. 4. 5. 6. 7. 0 @ P p .1 ! 1 A Q a q .2 " 2 B R b r .3 # 3 C S c s .4 $ 4 D T d t .5 % 5 E U e u .6 & 6 F V f v .7 7 G W g w .8 ( 8 H X h x .9 ) 9 I Y i y .a * : J Z j z .b + ; K [ k { .c , < L \ l | .d = M ] m } .e . > N ^ n ~ .f / ? O _ o
82
ANNEXE D. LE CODAGE ASCII
83
Annexe E
Les messages derreur

Nous indiquons ici les messages derreur les plus fr equents qui peuvent survenir lors de lassemblage dun chier. Un message derreur est ach e sous la forme : **Error** nom_de_fichier (num ero_de_ligne) message
Illegal instruction Utilisation dun mn emonique inexistant. Pax exemple move ` a la place de mov. Illegal immediate Utilisation dune constante ` a un endroit interdit. Par exemple : mov 4, ax.
Illegal indexing mode Utilisation dun mode dadressage index e inexistant. Par exemple : mov al, [si+ax]. Les modes existants sont indiqu es ` a la section 2.1.1. Illegal number Erreur dans une constante num erique. Illegal use of constant Utilisation dune constante l` a o` u cela est interdit. Par exemple : mov Invalid operand(s) to instruction Op erande non accept e par linstruction. Labels cant start with numeric characteres Une etiquette doit forc ement commencer par une lettre. Model must be specified first La premi` ere ligne dun source assembleur, en dehors des commentaires, doit etre .model Need address or register Oubli dun op erande. Par exemple : mov ax,. small. ax+4, 5.
Relative Jump out of range by xxx bytes L etiquette en op erande dune instruction de saut conditionnel est trop eloign ee. Voir la section 3.2.2 ` a ce propos. Reserved Word used as a symbol Vous utilisez un mot r eserv e comme etiquette. Changez son nom. Symbol already defined: x
84
ANNEXE E. LES MESSAGES DERREUR Vous d enissez deux fois la m eme etiquette de la m eme mani` ere. Symbol already different kind Vous d enissez deux fois la m eme etiquette de mani` ere di erente. Too few operands to instruction Vous avez oubli e un op erande (ou deux). Par exemple : mov Undefined symbol Utilisation dune etiquette qui na pas et e d enie. Unexpected end of file (no END directive) Votre source ne se termine pas par une directive END. Unknown character Un caract` ere inattendu a et e rencontr e dans une instruction. Value out of range Valeur incorrecte. Par exemple : db 1024 alors quun octet a une valeur forc ement inf erieure ` a 256. ax.
INDEX
85
Index
AAA, 44 AAD, 44 AAM, 44 AAS, 45 ADC, 42 ADD, 20 AND, 24 CALL, 50 CLC, 37 CLD, 37 CMP, 30 CMPS, 39 DAA, 45 DAS, 45 DEC, 23 DIV, 22 IDIV, 22 IMUL, 21 INC, 23 JA, 30 JAE, 30 JB, 30 JBE, 30 JC, 30 JCXZ, 30 JE, 30 JG, 30 JGE, 30 JL, 30 JLE, 30 JMP, 32 JNC, 30 JNE, 30 JNO, 30 JNP, 30 JNS, 30 JO, 30 JP, 30 JS, 30 LAHF, 46 LEA, 29 LODS, 37 LOOP, 35 LOOPE, 35 LOOPNE, 35 LOOPNZ, 35 LOOPZ, 35 MOV, 28 MOVS, 38 MUL, 21 NEG, 23 NOT, 25 OR, 24 POP, 51 POPF, 51 PUSH, 51 PUSHF, 51 RCL, 26 RCR, 26 REP, 40 REPE, 40 REPNE, 40 REPNZ, 40 REPZ, 40 RET, 50 ROL, 27 ROR, 27 SAHF, 46 SAL, 27 SAR, 27 SBB, 43 SCAS, 39 SHL, 27 SHR, 27 STC, 37 STD, 37 STOS, 38 SUB, 20 TEST, 43 XCHG, 29 XOR, 25 DB, 16 DW, 17 EQU, 16 appel e, 47 appelant, 47 d ecalage et multiplication par 2, 28
86 d ecalage et division par 2, 28 pile, 49 pointeur de pile, 49 sous-programmes, 47 Transfert de la valeur dun registre de segment vers un autre registre de segment, 28
INDEX
` TABLE DES MATIERES
87
Table des mati` eres

1 Introduction 1.1 Un processeur, en deux mots . . . . . . . . . . . . . . 1.2 La m emoire . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Les registres du 8086 . . . . . . . . . . . . . . . . . . . 1.4 Le codage des nombres . . . . . . . . . . . . . . . . . . 1.4.1 Repr esentation non sign ee des nombres entiers 1.4.2 Repr esentation sign ee des nombres entiers . . . 1.4.3 Codage d ecimal . . . . . . . . . . . . . . . . . . 1.4.4 Compl ement ` a deux dun nombre . . . . . . . . 1.4.5 Extension du signe . . . . . . . . . . . . . . . . 1.5 Notation . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Anatomie dun programme en assembleur 2.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Sp ecier une donn ee en m emoire (une variable) 2.1.2 Les constantes . . . . . . . . . . . . . . . . . . 2.1.3 Les d eclarations de variables . . . . . . . . . . 2.2 Lassemblage . . . . . . . . . . . . . . . . . . . . . . . 3 Les instructions du 8086 3.1 Les instructions arithm etiques et logiques . . . . . 3.1.1 Les instructions arithm etiques . . . . . . . 3.1.2 Incr ementation, d ecr ementation . . . . . . . 3.1.3 Oppos e dun nombre . . . . . . . . . . . . . 3.1.4 Les instructions bool eennes et logiques . . . 3.1.5 Les instructions de d ecalage et rotation . . 3.1.6 Les instructions de transfert . . . . . . . . . 3.2 Les tests en assembleur . . . . . . . . . . . . . . . 3.2.1 Principe g en eral . . . . . . . . . . . . . . . 3.2.2 Les instructions de comparaison . . . . . . 3.2.3 Exemples de codage de tests en assembleur 3.3 Les boucles en assembleur . . . . . . . . . . . . . . 3.3.1 Principe g en eral . . . . . . . . . . . . . . . 3.3.2 Boucles tant-que . . . . . . . . . . . . . . 3.3.3 Boucles r ep eter . . . . . . . . . . . . . . . 3.3.4 Les boucles pour . . . . . . . . . . . . . . . 3.3.5 Instructions diverses . . . . . . . . . . . . . 3.3.6 Le traitement des cha nes de donn ees . . . . 3.4 Autres instructions . . . . . . . . . . . . . . . . . . 3.4.1 Instructions arithm etiques . . . . . . . . . . 3.4.2 Les instructions dajustement d ecimal . . . 3.4.3 Autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 3 3 4 6 6 7 7 8 8 9 13 14 14 15 16 17 19 20 20 23 23 24 25 28 29 30 30 32 33 33 33 34 35 36 37 42 42 43 46
88 4 Les sous-programmes 4.1 Principe g en eral . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Synoptique de lappel dun sous-programme . . . . . . . . . . . . 4.2.1 Lappel dun sous-programme . . . . . . . . . . . . . . . . 4.2.2 Retour ` a lappelant . . . . . . . . . . . . . . . . . . . . . . 4.2.3 R esum e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.4 La pile dappel de sous-programme . . . . . . . . . . . . . 4.3 Appel de sous-programme sans passage de param` etre . . . . . . . 4.3.1 Appels et retours de sous-programmes . . . . . . . . . . . 4.3.2 Sauvegarde et restauration de contexte . . . . . . . . . . . 4.4 Passage de param` etres et variables locales . . . . . . . . . . . . . 4.4.1 Passage de param` etres par registre . . . . . . . . . . . . . 4.4.2 Passage de param` etres dans la pile . . . . . . . . . . . . . 4.4.3 Variables locales . . . . . . . . . . . . . . . . . . . . . . . 4.4.4 Retour dune valeur par un sous-programme : les fonctions 5 Les interruptions du DOS 5.1 Achages de caract` eres ` a l ecran . . . 5.1.1 Acher un caract` ere ` a l ecran . 5.1.2 Acher un message ` a l ecran . 5.2 Saisir une frappe au clavier . . . . . . 5.2.1 Saisie avec echo . . . . . . . . . 5.2.2 Saisie sans echo . . . . . . . . . 5.3 Lacc` es aux chiers . . . . . . . . . . . 5.3.1 Principe . . . . . . . . . . . . . 5.3.2 Cr eation dun chier . . . . . . 5.3.3 Ouverture dun chier . . . . . 5.3.4 Fermeture dun chier . . . . . 5.3.5 Lecture dans un chier . . . . . 5.3.6 Ecriture dans un chier . . . . 5.4 Lire lheure courante . . . . . . . . . . 5.5 Lire la date courante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
` TABLE DES MATIERES 47 47 47 47 48 48 49 49 49 50 52 52 52 55 57 59 59 59 59 60 60 60 60 60 61 61 61 62 62 62 63 65 65 66 67 68 71 71 72 73 73 73 73 73
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . en assembleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6 Etudes de cas 6.1 Cas 1 : lire une suite de caract` eres au clavier 6.2 Cas 2 : acher un nombre en base 2 . . . . 6.3 Cas 3 : Acher le contenu dun chier . . . 6.4 Cas 4 : acher lheure courante . . . . . . .
A Introduction ` a lutilisation du debugger A.1 Lancement et pr esentation du debugger . . . . . . . . . . . . A.1.1 La fen etre de debuggage . . . . . . . . . . . . . . . . . A.2 Quelques op erations de base . . . . . . . . . . . . . . . . . . . A.2.1 Acher le segment de donn ees . . . . . . . . . . . . . A.2.2 Acher le contenu dun segment m emoire quelconque A.2.3 Modier la valeur dun registre, dun indicateur, dune A.3 Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . B Param` etres de la ligne de commande B.1 Lacc` es au PSP . . . . . . . . . . . . B.2 La ligne de commande . . . . . . . . B.3 Lenvironnement . . . . . . . . . . . C Du bon usage des registres et . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . donn ee en . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . m emoire . . . . . . .
environnement 75 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 79
` TABLE DES MATIERES D Le codage ASCII E Les messages derreur Index
89 81 83 85

Assembleur I8086

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Assembleur I8086

Transféré par

Droits d'auteur :

Formats disponibles

Assembleur i8086

Philippe Preux IUT Informatique du Littoral Ann ee universitaire 95 96

Un processeur, en deux mots

Fig. 1.1 Une m emoire de N octets.

Les registres du 8086

1.3. LES REGISTRES DU 8086

octet ` a loset d du segment N = s/16

Le codage des nombres

Repr esentation non sign ee des nombres entiers

1.4. LE CODAGE DES NOMBRES

Repr esentation sign ee des nombres entiers

Compl ement ` a deux dun nombre

(ip) instruction suivante ` a ex ecuter

(ss) 0 : fond de la pile 1 2

(sp) dernier octet utilis e dans la pile

Anatomie dun programme en assembleur

CHAPITRE 2. ANATOMIE DUN PROGRAMME EN ASSEMBLEUR

; les instructions composant le programme

Sp ecier une donn ee en m emoire (une variable)

16 D eclaration dune constante

CHAPITRE 2. ANATOMIE DUN PROGRAMME EN ASSEMBLEUR

Les d eclarations de variables

la valeur 34h est mise ` a ladresse M et la valeur 12h ` a ladresse M+1.

CHAPITRE 2. ANATOMIE DUN PROGRAMME EN ASSEMBLEUR

Fig. 2.1 Le codage dune instruction

Les instructions du 8086

Mod` ele de description dune instruction

CHAPITRE 3. LES INSTRUCTIONS DU 8086

Les instructions arithm etiques et logiques

ADD ADD ADD O *

registre/variable, registre registre, registre/variable registre/variable, constante D I T S * Z * A * P * C *

SUB SUB SUB O *

registre/variable, registre registre, registre/variable registre/variable, constante D I T S * Z * A * P * C *

Les multiplications en assembleur

CHAPITRE 3. LES INSTRUCTIONS DU 8086

3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES

Incr ementation, d ecr ementation

Oppos e dun nombre

N egation par compl ement ` a2 NEG O * D I registre/variable T S * Z * A * P * C *

le registre AX contient la valeur -35.

CHAPITRE 3. LES INSTRUCTIONS DU 8086

Les instructions bool eennes et logiques

AND AND AND O 0

registre/variable, registre regisre, registre/variable registre/variable, constante D I T S * Z * A ? P * C 0

Les bits S et Z sont mis ` a z ero et le bit P ` a 1. OR ou-logique

registre/variable, registre regisre, registre/variable registre/variable, constante D I T S * Z * A ? P * C 0

Les bits S et Z sont mis ` a z ero et le bit P ` a 1. XOR ou-exclusif

Les bits S et Z sont mis ` a z ero et le bit P ` a 1. NOT N egation logique

Les bits S et P sont mis ` a 1, le bit Z ` a 0.

Les instructions de d ecalage et rotation

Les rotations en assembleur

CHAPITRE 3. LES INSTRUCTIONS DU 8086

Op erande  Op erande retenue 6 6 6 6 6 6 6 d.ROL

3.1. LES INSTRUCTIONS ARITHMETIQUES ET LOGIQUES

CHAPITRE 3. LES INSTRUCTIONS DU 8086

Les instructions de transfert

Chargement de loset dune donn ee

registre/variable, registre registre, registre/variable D I T S Z A P C

entra nera : AX contient la valeur 10 et DX la valeur 20.

Les tests en assembleur

CHAPITRE 3. LES INSTRUCTIONS DU 8086

Les instructions de comparaison

3.2. LES TESTS EN ASSEMBLEUR

Op erande Op erande retenue 6 6 6 6 6 6 6 d.ROL