>Zorro 2: Created page with "

    ******************************************************************    *                                                                *    *             COURS D'ASSEMBL..."

2016-12-22T14:33:56Z

Created page with "<pre> ****************************************************************** * * * COURS D'ASSEMBL..."

New page

<pre>
******************************************************************
* *
* COURS D'ASSEMBLEUR 68000 SUR ATARI ST *
* *
* par Le F‚roce Lapin (from 44E) *
* *
* Cours num‚ro 6 *
* *
******************************************************************

LA PILE Nous avons d‚j… utilis‚ la notion de 'tube' en ce qui
concerne la m‚moire. Nous pouvons y stocker diff‚rentes choses, et
si nous nous rappelons l'adresse, nous pouvons revenir plus tard …
cet endroit pour y r‚cup‚rer ce que nous y avions d‚pos‚.

Essayez avec ce petit programme:

MOVE.L #$12345678,D0
MOVE.L D0,$493E0
MOVE.L #0,D0
MOVE.L $493E0,D0

Assemblez puis passez sous MONST. Avancez en pas … pas. D0 est
d'abord rempli avec $12345678, puis le contenu de D0 est transf‚r‚
… l'adresse $493E0. Notez bien qu'il n'y a pas de # devant $493E0,
afin d'indiquer qu'il s'agit bien d'une adresse. Cette ligne ‚tant
ex‚cut‚e, activez la fenˆtre 3 ([Alternate+3]) et placez le d‚but
de celle-ci sur l'adresse $493E0 ([Alternate+A] puis tapez 493E0)
Vous voyez bien 12345678 … cet endroit dans le 'tube'. Si j'ai
choisit cette adresse c'est parce qu'elle se situe … 300 Kilo du
d‚but de la m‚moire. Elle est donc accessible mˆme sur un 520, et
elle est suffisamment ‚loign‚e pour ne pas se trouver dans GENST
ou MONST. En effet il n'y a qu'un 'tube' m‚moire! Nous sommes donc
en train d'‚crire dans la m‚moire alors qu'une partie de celle-ci
est occup‚e par GENST et MONST! Ecrire … l'int‚rieur des zones oc-
cup‚es par ces programmes est possible, ce qui entraŒnera trŠs
certainement quelques plantages de ceux-ci!

Continuons en pas … pas, nous mettons D0 … 0 puis le contenu de
l'adresse $493E0 (sans #) est remis dans D0.

La pile, c'est une partie de ce tube, mais que nous allons g‚rer
d'une maniŠre un peu diff‚rente. En effet, au lieu de placer les
donn‚es dans le tube et de noter leurs adresses, nous allons cette
fois-ci les empiler et pour les r‚cup‚rer, les d‚piler. L'avantage
c'est le gain de temps (pas la peine de se demander … quelle
adresse on a stock‚ les donn‚es) et un gain de place (si c'est
pour stocker temporairement des donn‚es, inutile de conserver une
portion de 'tube' juste pour ‡a).

Par contre l'inconv‚nient c'est que la gestion doit ˆtre rigou-
reuse. Imaginons que j'empile un premier chiffre puis 10 autres
par dessus. Ensuite je d‚pile, mais erreur de ma part, je ne
d‚pile que 9 chiffres! Quand je d‚pilerai une fois de plus,
croyant retrouver le premier chiffre empil‚, je r‚cup‚rerai en
fait le premier de la s‚rie de 10.

Nous en concluons 2 choses: d'abord que la pile est un moyen sim-
ple pour sauvegarder des donn‚es, mais ensuite que c'est une
source de d‚sagr‚ment potentiel, tel que certains programmeurs h‚-
site … s'en servir. C'est g‚n‚ralement … cause d'un manque de ri-
gueur ce qui, je l'espŠre ne vous arrivera pas.

Une autre remarque: le dernier ‚l‚ment plac‚ sur la pile sera tou-
jours le premier … en sortir. C'est bien le mˆme principe que ce-
lui d'une pile d'assiettes: Regardez chez vous, il y a s–rement
une ‚norme pile d'assiettes, mais par le simple fait que le range-
ment aprŠs le lavage se fait par empilage et que mettre la table
se fait par d‚pilage, vous mangez en fait toujours dans les mˆmes
assiettes... (d'o— l'int‚rˆt de bien faire la vaisselle!)

Cette structure de pile est appel‚e structure LIFO, c'est-…-dire
Last In First Out, en Fran‡ais: 'dernier entr‚ premier sorti'.
Cette structure est diff‚rente d'une autre structure fr‚quemment
rencontr‚e en informatique, celle de la file, appel‚e aussi struc-
ture FIFO (First In First Out), la file ‚tant similaire … une
file d'attente devant un guichet: le premier dans la file sera le
premier parti.

Mais concrŠtement, … quoi sert la pile? Nous allons le voir avec
un exemple. Tapez le programme suivant:

MOVE.L #$12345678,D0
MOVE.L #$BD88,D1
MOVE.L #$BD88,A0
BSR AJOUTE
MOVE.L #0,D0
MOVE.L D2,D0

AJOUTE MOVE.L #$11112222,D2
ADD.L D1,D2
RTS

PremiŠre remarque: ce programme diffŠre des pr‚c‚dents par le fait
que nous utilisons une ‚tiquette, un label qui se nomme AJOUTE.

Ce mot, 'AJOUTE', doit se trouver tout … gauche, contre le bord de
la fenˆtre de l'‚diteur. Ce n'est pas quelque chose … placer DANS
le tube mais bien une marque A COTE du tube.

Autre remarque, les listings en assembleur, contrairement aux lis-
tings dans les autres langages sont assez libres au niveau pr‚sen-
tation. Il est tout a fait possible de passer des lignes, ce qui
est fait ici pour s‚parer les 2 parties. Les sources assembleur
sont bien souvent trŠs longs, et mˆme si cela fait perdre quelques
lignes, espacer les modules permet de s'y retrouver plus faci-
lement.

Assemblons puis d‚buggons. Avan‡ons pas … pas avec Control+Z. Les
3 premiŠres lignes nous sont familiŠres mais pas la quatriŠme.
Celle-ci se lit BRANCH SUB ROUTINE AJOUTE, c'est-…-dire branche-
ment … une subroutine nomm‚e AJOUTE. Pour pr‚ciser vers quelle su-
broutine on d‚sire se diriger, son ‚tiquette est pr‚cis‚e. Ici en
l'occurrence c'est AJOUTE mais le nom importe peu. Il est tout a
fait possible de mettre des noms assez longs et je ne peux que
vous conseiller d'‚viter dans vos listings les noms du genre X Y,
Z ou encore AX1 etc... qui sont quand mˆme moins explicites que
DEBUT_IMAGE, NEW_PALETTE ou bien END_GAME.

Maintenant soyez trŠs attentifs: … la lecture de cette instruction
de nombreuses choses vont se passer. L'ordre demande donc au 68000
de poursuivre la lecture de ses instructions dans un sous
programme dont le d‚but se situe dans le tube, en face de l'‚ti-
quette AJOUTE. Cependant il s'agit bien ici d'un sous-programme.
Ceci suppose qu'une fois termin‚, le 68000 remontera pour ex‚cuter
la ligne qui suit BSR AJOUTE, en l'occurrence MOVE.L #0,D0. Ques-
tion: comment le 68000 saura-t-il o— remonter? En effet le propre
d'une subroutine est de pouvoir ˆtre appel‚e plusieurs fois et de
plusieurs endroits diff‚rents et de pouvoir … chaque fois revenir
… l'endroit mˆme qui l'a appel‚.

Eh bien le 68000 va justement utiliser la pile pour noter ce lieu
de retour. Cette pile a bien sur une adresse, o— se trouve-t-elle
not‚e? En A7. Et oui, ce registre un peu sp‚cial correspond … la
pile.

Mais A7' alors? Et bien c'est aussi une pile, mais r‚serv‚e au
mode Superviseur. Ainsi si nous faisions tourner conjointement 2
programmes, l'un en mode utilisateur et l'autre en superviseur,
chacun aurait sa pile.

Avant d'ex‚cuter la ligne BSR AJOUTE, observons attentivement les
registres d'adresses et les registres de donn‚es.

Nous avons vu que les registres, qu'ils soient de donn‚es ou
d'adresse, peuvent contenir des nombres cod‚s sur 32 bits. Nous
avons vu aussi qu'il existait 2 sortes de nombres pour la machine:
ceux se trouvant … l'int‚rieur du 'tube' et ceux ce trouvant …
l'ext‚rieur, CONTRE ce tube, et indiquant une sorte de distance
par rapport au d‚but de celui-ci.

Ce second type de nombre est appel‚ adresse. Or il est tout … fait
possible de stocker un nombre repr‚sentant une adresse dans un
registre de donn‚es (D0-D7). Imaginons maintenant que nous devions
stocker le score d'un joueur dans le jeu que nous programmons. Ce
score va par exemple ˆtre plac‚ dans la m‚moire (dans le 'tube') …
l'adresse $80792.

Mais que se passera-t-il si nous transf‚rons cette adresse pour
l'utiliser grƒce … A1 par exemple? et bien A1 va prendre la valeur
$80792. C'est bien joli, mais ce qui nous int‚resse, ce n'est pas
‡a! Ce que nous voulons modifier, v‚rifier etc.. c'est ce qu'il y
a DANS le tube … cette adresse.

Et bien notre d‚bugger anticipe un peu cette demande. En effet,
partant du principe que les nombres stock‚s en D0-D7 ou A0-A6 peu-
vent repr‚senter des valeurs d'adresses, il indique … c“t‚ des re-
gistres, ce qu'il y a dans le tube, … l'adresse indiqu‚e dans le
registre.

En ce qui concerne les registres de donn‚es, MONST affiche … leur
droite la valeur de 8 octets se trouvant dans le tube … l'adresse
indiqu‚e dans le registre. Pour les registres d'adresse, ce sont
10 octets qui sont indiqu‚s. Vous remarquez certainement qu'en
face du registre D0 (qui doit contenir $12345678 si vous avez fait
correctement avancer le programme), MONST n'a affich‚ que des
‚toiles. C'est normal car le nombre $12345678 correspond … un em-
placement m‚moire qui se serait accessible qu'avec 305 m‚ga de
m‚moire!!! MONST indique donc qu'il ne peut pas atteindre cette
zone m‚moire en affichant des ‚toiles.

Regardons maintenant D1 et A0. Les nombres situ‚s … leur droite
montrent la mˆme chose, ce qui est normal puisque les 2 registres
D1 et A0 sont remplis avec le mˆme nombre. On dit qu'ils pointent
sur l'adresse $BD88. Allons voir en m‚moire histoire de v‚rifier
l'affichage. Activez la fenˆtre 3 avec Alternate+3. Celle-ci nous
affiche le contenu de la m‚moire, mais nous sommes loin de $BD88!

Demandons donc que cette adresse soit celle du haut de la fenˆtre
3, avec Alternate+A. Tapons cette adresse (BD88). La fenˆtre 3 se
r‚ affiche avec en haut l'adresse $BD88. Dans la colonne de droite
nous voyons le contenu de la m‚moire, dont nous avions d‚j… un
aper‡u avec l'affichage … droite de D1 et de A0. C'est clair?

R‚activons la fenˆtre 1 (alternate+1). Normalement la petite flŠ-
che doit toujours se trouvez en face du BSR AJOUTE. Noter le
chiffre se trouvant dans le registre A7 (donc l'adresse de la
pile) et observer bien les chiffres … droite de ce registre, tout
en faisant Control+Z.

Les chiffres ont chang‚! D'abord le registre A7 ne contient plus
le mˆme nombre. Celui qui s'y trouve actuellement est en effet
plus petit que le pr‚c‚dent. Notons que cette diff‚rence est de 4.
L'adresse de la pile a donc ‚t‚ d‚cr‚ment‚e de 4. De plus des
chiffres ont ‚t‚ plac‚s dans la pile (on les voit … droite du
registre A7). Or, regardez bien le nombre qui est … gauche de
l'instruction MOVE.L #0,D0 de notre programme, c'est-…-dire
l'adresse … laquelle devra revenir le 68000 une fois la subroutine
termin‚e: c'est bien ce nombre qui a ‚t‚ plac‚ dans la pile. Il y
a donc empilage de l'adresse de retour, ce qui explique ‚galement
le changement d'adresse de la pile de 4. En effet une adresse est
cod‚e sur 4 octets !

Note: ‚tant donn‚ que nous parlons de pile, on dit plus souvent
que les donn‚es sont mises sur la pile et moins souvent dans la
pile.

Continuons notre programme avec Control+Z. Nous sommes maintenant
dans la sous-routine. Arrˆtez juste avant RTS. C'est cette ins-
truction qui va nous faire "remonter". Elle se lit RETURN FROM SUB
ROUTINE.

Observons A7 (sa valeur mais aussi le contenu du 'tube' … cette
adresse) et faisons un pas (Control+Z). L'adresse de retour a ‚t‚
d‚pil‚e, A7 a repris son ancienne adresse et nous pointons mainte-
nant sur MOVE.L #0,D0.

Quittez ce programme avec Control+C, effacez le et tapez celui-ci.

MOVE.L #$12345678,D0
MOVE.L #$AAAAAAAA,D1
BSR AJOUTE
MOVE.W D2,D3

AJOUTE MOVE.W #$EEEE,D1
MOVE.W #$1111,D2
ADD.W D1,D2
RTS

Assemblez puis d‚buggez. Avancez pas … pas: D0 prend la valeur
$12345678 D1 la valeur AAAAAAAA, puis nous partons vers la subrou-
tine AJOUTE.

Malheureusement celle-ci utilise D1 et au retour nous constatons
que celui-ci ne contient plus AAAAAAAA. En effet le branchement …
une subroutine ne sauve rien d'autre que l'adresse de retour, et
en assembleur les variables locales et autres bidouilles de langa-
ges ‚volu‚s n'existent pas! C'est donc … nous de sauver les regis-
tres, et c'est ce que nous allons faire maintenant.

Note: le registre A7 contenant l'adresse du sommet de la pile
(cette adresse variant bien s–r avec l'empilage et le d‚pilage),
on peut consid‚rer cette adresse comme un doigt indiquant perp‚-
tuellement le sommet de la pile. Pour cette raison le registre A7
est aussi appel‚ pointeur de pile. Comme toujours nous utiliserons
le vocabulaire anglo-saxon, et nous dirons Stack Pointer, en abr‚-
g‚ SP. Pour cette raison et parce que l'usage en est ainsi, nous
remplacerons d‚sormais A7 par SP (qui ne se lit pas "Šss-p‚" mais
bien STACK POINTER!!!).

Imaginons que nous voulions sauvegarder D0 … l'entr‚e de la su-
broutine:

Il ne faudra pas oublier de le r‚cup‚rer … la
sortie! D‚pla‡ons donc le contenu de D0 vers la pile. Essayons
MOVE.L D0,SP et r‚fl‚chissons: Ceci va mettre le contenu de D0
dans A7, malheureusement ce n'est pas ce que nous voulons faire.
En effet nous d‚sirons mettre le contenu de D0 DANS le tube, …
l'endroit indiqu‚ par A7 (donc SP).

Ceci va se faire avec MOVE.L D0,(SP) ,les parenthŠses indiquant
que la source de l'op‚ration c'est l'int‚rieur du tube.

Effacez le programme actuel et tapez le suivant.

MOVE.L #$12345678,D0
MOVE.L D0,(A0)
MOVE.W D0,(A1)

Assemblez puis comme d'habitude d‚buggez. D0 prend la valeur
$12345678, puis D0 est transf‚r‚ dans sa totalit‚ (… cause du .L
qui indique que l'op‚ration se passe sur un mot long) … l'adresse
qui est not‚e dans A0, ensuite le poids faible de D0 est transf‚r‚
dans le tube … l'adresse not‚e en A1. Pour le v‚rifier, vous
pouvez activer la fenˆtre 3 et demander … placer l'adresse not‚e
dans A0 en haut de cette fenˆtre, et vous constaterez qu'effecti-
vement la valeur de D0 se trouve bien dans le 'tube'.

Nous allons donc utiliser ce type de transfert pour sauvegarder D0

Mais r‚fl‚chissons encore un peu. MOVE.L D0,(SP) va bien placer
le contenu du long mot D0 dans le tube, mais si nous voulons pla-
cer une autre valeur sur la pile, celle-ci va ‚craser notre pre-
miŠre valeur car avec MOVE.L D0,(SP) l'adresse indiqu‚ par SP
(donc A7) ne va pas ˆtre modifi‚e, ce qui devrait ˆtre le cas.

Nous allons donc r‚aliser le transfert diff‚remment (en fait nous
allons encore am‚liorer notre vocabulaire, puisque nous allons
parler maintenant de type ou de mode d'adressage).

Nous allons faire
MOVE.L D0,-(SP)

C'est le mode d'adressage avec pr‚-d‚cr‚mentation. DerriŠre ce vo-
cabulaire pompeux se cache toute une suite d'‚v‚nements. En une
seul instruction, nous diminuons l'adresse du pointeur de pile de
4 (puisque dans notre exemple nous voulions transf‚rer un long mot
donc 4 octets), et nous pla‡ons en m‚moire … cette adresse le long
mot D0.

Pour r‚cup‚rer D0, c'est-…-dire d‚piler, il faudra faire:

MOVE.L D0,(SP)+

Comme nous avions d‚cr‚ment‚ le pointeur de pile pour ensuite d‚-
poser D0 … cette adresse, nous r‚cup‚rons donc D0 sans oublier en-
suite de modifier le pointeur de pile dans l'autre sens, pour
qu'il retrouve son ancienne position. Notons que dans le cas pr‚-
sent, et si nous nous contentons de r‚fl‚chir trŠs sommairement,
il aurait ‚t‚ possible de sauver D0 par MOVE.L D0,(SP) et de le
r‚cup‚rer par MOVE.L (SP),D0. C'est compter sans le fait que la
pile est un r‚servoir commun … beaucoup de choses. Il faut donc de
pr‚f‚rence jouer … chaque fois le jeu d'un empilage correct et r‚-
fl‚chi mais aussi d'un d‚pilage 'collant' parfaitement avec l'em-
pilage pr‚c‚dent.

V‚rifions tout cela avec l'exemple suivant:
MOVE.L #$12345678,D0 valeur dans D0
MOVE.W #$AAAA,D1 valeur dans D1
MOVE.L D0,-(SP) sauve D0.L sur la pile
MOVE.W D1,-(SP) idem D1 mais en word
MOVE.L #0,D0 remet D0 … 0
MOVE.W #0,D1 et D1 aussi
MOVE.W D1,(SP)+ r‚cupŠre D1 (word)
MOVE.L D0,-(SP) puis D0

Assemblez puis faites d‚filer ce programme pas … pas sous MONST.
Notez plusieurs choses: tout d'abord des commentaires ont ‚t‚
ajout‚s au source. Il suffit que ceux-ci soient s‚par‚s des op‚-
randes pour que l'assembleur sache qu'il s'agit de commentaires.
Si vous d‚sirez taper une ligne de commentaires (c'est-…-dire que
sur celle-ci il n'y aura rien d'autre que ce commentaire), vous
devez le faire pr‚c‚der du caractŠre ‚toile ou d'un point virgule.

Seconde chose, nous avions empil‚ D0 puis D1, ensuite nous avons
d‚pil‚ D1 puis D0. Il faut en effet bien faire attention … l'ordre
et aux tailles de ce que nous empilons, afin de pouvoir d‚piler
les mˆmes tailles, dans l'ordre inverse de l'empilage.

Voici un dernier exemple.
MOVE.L #$12345678,D0
BSR AJOUTE saut vers subroutine
MOVE.L D0,D1 transfert

AJOUTE MOVE.L D0,-(SP) sauve d0.l sur la pile
MOVE.W #8,D0
MOVE.W #4,D1
ADD.W D0,D1
MOVE.L (SP)+,D0
RTS

Assemblez puis suivez le d‚roulement sous MONST en ‚tudiant bien
le d‚roulement. Vous voyez bien que le BSR sauve l'adresse de re-
tour sur la pile, puis que D0 et mis par dessus pour ˆtre ensuite
r‚cup‚r‚. Ensuite c'est l'adresse de retour qui est reprise et le
programme remonte.

Maintenant, provoquons une erreur, une toute petite erreur mais
qui sera fatale … notre programme. Au lieu de r‚cup‚rer D0 par un
MOVE.L (SP)+,D0, commettons une faute de frappe et tapons … la
place MOVE.W (SP)+,D0.

Assemblez et suivez pas … pas. Au moment de la sauvegarde de D0,
ce sont bien 4 octets qui vont ˆtre plac‚s sur la pile, modifiant
celle-ci d'autant. Malheureusement la r‚cup‚ration ne va re-mo-
difier cette pile que de 2 octets. Au moment o— l'instruction RTS
va essayer de r‚cup‚rer l'adresse de retour, le pointeur de pile
sera faux de 2 octets par rapport … l'endroit o— se trouve r‚elle-
ment cette adresse de retour, et celui-ci va se faire … une
adresse fausse. En conclusion: prudence et rigueur!!!!!!

Nous venons donc de voir que la pile ‚tait utilis‚e par le 68000
pour certaines instructions, et qu'elle ‚tait bien commode comme
sauvegarde.

Il est aussi possible de l'utiliser pour transmettre des donn‚es,
c'est ce que nous allons voir pour conclure ce chapitre.

ProblŠme: Notre programme principal utilise les registres A0 … A6
et D0 … D6. Il va appeler une subroutine destin‚e … additionner 2
nombres et … retourner le r‚sultat dans D7. Il faudra donc utili-
ser 2 registres par exemple D0 et D1 pour travailler dans notre
routine, et donc les sauvegarder … l'entr‚e de celle-ci.

Voici le d‚but du programme.

MOVE.L #$11111111,D0
MOVE.L #$22222222,D1
MOVE.L #$33333333,D2
MOVE.L #$44444444,D3
MOVE.L #$55555555,D4
MOVE.L #$66666666,D5
MOVE.L #$77777777,D6

Les 7 premiers registres sont remplis avec des valeurs bidons,
juste pour nous permettre de v‚rifier leurs ‚ventuelles modifica-
tions.

Maintenant il faut placer les 2 nombres que nous d‚sirions addi-
tionner, dans un endroit tel qu'ils pourront ˆtre r‚cup‚r‚s par la
routine d'addition. Pla‡ons donc ces 2 nombres sur la pile.

MOVE.L #$12345678,-(SP)
MOVE.L #$00023456,-(SP)
BSR AJOUTE et en route !

R‚digeons maintenant notre subroutine, afin de suivre l'ordre de
travail du 68000.

De quoi aurons nous besoin dans cette routine ?

De D0 et de D1 qui vont recevoir les nombres empil‚s et qui
vont nous servir au calcul. Il va nous falloir ‚galement un regis-
tre d'adresse. En effet, lorsque nous allons d‚piler nous allons
modifier le pointeur de pile, or nous venons d'effectuer un BSR le
68000 a donc empil‚ l'adresse de retour sur la pile, et modifier
celle-ci va compromettre le retour! Nous allons donc copier
l'adresse de la pile dans A0, et utiliser cette copie.

Note: j'ai d‚cid‚ d'utiliser D0, D1 et A0 mais n'importe quel au-
tre registre aurait tout aussi bien convenu.

Commen‡ons donc par sauver nos 3 registres.

Cela pourrait se faire par:

MOVE.L D0,-(SP)
MOVE.L D1,-(SP)
MOVE.L A0,-(SP)

Note: je rappelle que cela se lit move long!

Mais le 68000 possŠde une instruction trŠs utile dans un pareil
cas, qui permet de transf‚rer plusieurs registres d'un coup.

Nous allons donc faire:

MOVEM.L D0-D1/A0,-(SP)

Ce qui se lit: move multiple registers.

Si nous devions transf‚rer de D0 … D5 nous aurions fait :

MOVEM.L D0-D5,-(SP)

et, pour transf‚rer tous les registres d'un seul coup:

MOVEM.L D0-D7/a0-A6,-(SP) Compris?

Sauvons maintenant l'adresse de la pile dans A0. Comme c'est
l'adresse qu'il faut sauver et non pas le contenu, cela se fait
par:
MOVE.L A7,A0 transfert du registre A7 vers A0

Maintenant nous allons r‚cup‚rer les 2 nombres que nous avions em-
pil‚ avant l'instruction BSR.

Imaginons ce qui s'est pass‚. (A ce propos je vous conseille TRES
fortement de vous aider d'un papier et d'un crayon. N'h‚sitez pas
… ‚crire sur ces cours. Ce sont les v“tres et je ne les r‚clamerai
pas!

Faire un petit dessin ou de placer des piŠces sur votre bureau
pour vous aider … comprendre est une excellente chose. Bien sou-
vent les manipulations de m‚moire ont tendance … devenir abstrai-
tes et un petit dessin arrange bien des choses!)

Nous avons d‚cal‚ de 4 octets le STACK POINTER, puis nous y avons
d‚pos‚ $12345678. Mais dans quel sens avons nous d‚cal‚ ce SP ?

Vers le d‚but de la m‚moire, vers l'adresse 0 de notre tube puis-
que nous avons fait -(SP). Le pointeur de pile remonte donc le
long du tube. Nous avons ensuite recommenc‚ la mˆme chose pour y
d‚poser $23456. Ensuite BSR, donc mˆme chose mais r‚alis‚ automa-
tiquement par le 68000 afin d'y d‚poser l'adresse de retour (4 oc-
tets).

Est-ce tout? Non car une fois rendu dans la subroutine nous avons
d‚pos‚ sur la pile les registres D0, D1 et A0. Le transfert ayant
‚t‚ effectu‚ sur le format long mot (MOVEM.L) nous avons transf‚r‚
3 fois 4 octets soit 12 octets (bytes).

Notre copie de A7 qui est en A0 ne pointe donc pas sur nos 2 nom-
bres mais beaucoup plus loin. Le nombre que nous avons plac‚ en
second sur la pile est donc … 16 vers le d‚but du tube (faites le
calcul: 1BSR, + 12 bytes de sauvegarde cela fait bien 16 bytes) et
le nombre plac‚ en premier sur la pile suit son copain et se
trouve donc … 20 bytes d'ici, en vertu toujours du principe de la
pile: le dernier entr‚, c'est le premier sorti.

Nous pouvons donc dire que $23456 est … A0 d‚cal‚ de 16 et que
$12345678 est … A0 d‚cal‚ de 20.

Pour r‚cup‚rer ces 2 nombres plusieurs actions sont possibles:

1) ajouter 16 … l'adresse de A0 puis r‚cup‚rer.

Une addition d'adresse se fait par ADDA (add adress).

Nous faisons donc
ADDA.L #16,A0

A0 pointe donc maintenant sur $23456, r‚cup‚rons donc ce nombre et
profitons du mode d'adressage pour avancer l'adresse indiqu‚e dans
A0 et ainsi tout de suite ˆtre prˆt pour r‚cup‚rer l'autre nombre.
MOVE.L A0)+,D0
L'adresse ayant ‚t‚ augment‚e nous pouvons donc r‚cup‚rer la
suite:
MOVE.L (A0)+,D1

2) Autre m‚thode, utilisant un autre mode d'adressage:

La m‚thode pr‚c‚dente pr‚sente un inconv‚nient: aprŠs le ADDA, A0
est modifi‚ et si nous voulions garder cette adresse, il aurait
fallu le sauvegarder.

Ou bien nous aurions pu ajouter le d‚calage … A0, r‚cup‚rer les
donn‚es et ensuite retirer le d‚calage … A0 pour qu'il retrouve
sont ‚tat de d‚part.

Autre m‚thode donc, indiquer dans l'adressage le d‚calage … appli-
quer. Cela se fait par:

MOVE.L 16(A0),D0
MOVE.L 20(A0),D1

Cela permet de pointer sur le 16Šme octet … partir de l'adresse
donn‚e par A0 et ensuite de pointer sur le 20Šme par rapport … A0.
Dans les 2 cas, A0 n'est pas modifi‚.

Voil… le listing complet de cet exemple.

MOVE.L #$11111111,D0 initialisation de D0
MOVE.L #$22222222,D1 idem
MOVE.L #$33333333,D2 idem
MOVE.L #$44444444,D3 idem
MOVE.L #$55555555,D4 idem
MOVE.L #$66666666,D5 idem
MOVE.L #$77777777,D6 idem
MOVE.L #$12345678,-(SP) passage nombre 1 dans la pile
MOVE.L #$00023456,-(SP) passage nombre 2 dans la pile
BSR AJOUTE et en route !
MOVE.L D7,D0 transfert du r‚sultat pour voir..

* notre subroutine
AJOUTE MOVEM.L D0-D1/A0,-(SP) sauvegarde
MOVE.L A7,A0 copie de SP en A0
MOVE.L 16(A0),D0 r‚cupŠre 23456 et le met en D0
MOVE.L 20(A0),D1 r‚cupŠre 12345678 en D1
ADD.L D0,D1 addition
MOVE.L D1,D7 transfert du r‚sultat
MOVEM.L (SP)+,D0-D1/A0 r‚cup‚ration
RTS et retour

* Note: ce programme n'ayant pas de fin 'normale',
lorsque vous* serez rendu au retour de la subroutine
c'est-…-dire aprŠs la ligne" MOVE.L D7,D0 ", quittez
le avec Control+C, Assemblez et suivez bien TOUT le
d‚roulement.

Bien s–r, il aurait ‚t‚ possible de faire cela tout diff‚remment.
Par exemple nous aurions pu ‚viter de travailler avec A0. En effet
16(A0) et 20(A0) ne modifiant pas A0, il aurait ‚t‚ plus simple de
faire 16(A7) et 20(A7) au lieu de recopier d'abord A7 en A0. De
mˆme il aurait ‚t‚ possible de transf‚rer $23456 directement en D7
et $12345678 en D1 puis de faire ADD.L D1,D7 afin d'‚viter la
sauvegarde de D0 (qui aurait ‚t‚ inutilis‚e), et le transfert D1
vers D7 qui n'aurait alors pas eu lieu d'ˆtre. De mˆme nous au-
rions pu retourner le r‚sultat par la pile au lieu de le faire par
D7.

Beaucoup de variantes possibles n'est ce pas ?

Pour terminer, un petit exercice. Relancer ce petit programme et
analysez PARFAITEMENT TOUT ce qui s'y passe. Quelque chose ne va
pas ! Je vous aide en disant qu'il s'agit bien s–r de la pile.
Cherchez et essayez de trouver comment faire pour arranger ‡a.

La r‚ponse sera au d‚but du prochain cours mais essayez d'imaginer
que c'est votre programme et qu'il ne marche pas et cherchez!!!

Bon, le cours sur la pile se termine ici. Ce fut un peu long mais
je pense, pas trop compliqu‚. Relisez le, car la pile est un truc
d‚licat dont nous allons nous servir TRES abondamment dans le pro-
chain cours. Si vous avez … peu prŠs tout compris jusqu'ici il est
encore temps de rattraper le temps perdu et de tout reprendre au
d‚but, car il faut avoir PARFAITEMENT tout compris et pas … peu
pr‚s!

Afin de vous remonter le moral, je vous signal que vous ˆtes pres-
que … la moiti‚ du cours...
</pre>
Back to [[ASM_Tutorial]]
[[Category: ASSEMBLEUR 68000 sur ATARI ST Part 1 ]]

COURS 6.TXT - Revision history

>Zorro 2: Created page with "
****************************************************************** * * * COURS D'ASSEMBL..."