Pl DEBUTS.DOC/fr
--------------------------
CHAPITRE nr° 3:
* PREMIERS PROGRAMMES *
--------------------------
*** INTRODUCTION AVEC UN EXEMPLE ***
------------------------------------
- Soit le programme (#1) en ASSembleur 68000 suivant:
-------------------
; programme #1 en Assembleur 68000
TEXT ;d‚but zone Text
A EQU 18 ;A=18
B EQU 2 ;B=2
move.w A,destination ;pose mot A en destination
move.b B,autre ;pose bit B en autre
move.w autre,d0 ;pose ce qu'il y a en autre ds
;le registre d0
add.l A,d0 ;ajoute A à d0
lea A,a0 ;met l'adresse de A ds le
;registre a0
move.w (a0)+,sauve_A ;incr‚mente a0 et sauve a0
add.l sauve_A,d1 ;ajoute sauve_A à d1
add.l d0,d1 ;ajoute d0 à d1
move.l d1,resultat ;pose d1 en resultat
move.w DAT,d0 ;met dat ds d0
add.l DAT,resultat ;ajoute dat à r‚sultat
clr.l resultat ;efface r‚sultat
DATA ;d‚but zone Data
DAT DC.W 6 ;data 6 en DAT
BSS ;d‚but zone Bss
sauve_A DS.L 1 ;r‚serve un M-L en sauve_A
resultat DS.L 1 ;r‚serve un M-L en resultat
destination DS.L 1 ;idem en destination
autre DS.B 1 ;r‚serve un OCTET en autre
END ;fin du listing
--------------------
1) EXPLICATIONS:
-------------
- Ne cherchez pas de sens particulier à ce listing, il n'a pour but que
d'introduire les diff‚rentes notions de la programmation en ASS...
- Comme vous pouvez le constater, un programme en ASS. est structur‚.
Cette structure se divise en 3 colonnes.
.1° colonne: Les LABELS ou noms d'ETIQUETTES:
-----------
Ils ont pour but de fixer une adresse de la m‚moire,ainsi on
peut appeller une ADRESSE en nommant le LABEL quand une ins-
truction le n‚ssecite. (Comme un num‚ro de ligne en BASIC)
La v‚ritable adresse attribu‚e au Label est donn‚e après le
'linkage',ces adresses servent de points de rep‚res dans
le prg , et ne pointent pas sur des adresses d‚finissables.
(Sauf si le programme est relog‚ en un endroit pr‚cis de la
m‚moire, mais cela n'a pas de r‚el int‚rèt)
.2° colonne: Les INSTRUCTIONS et leurs OPERANDES:
-----------
Les instructions indiquent à l'ordi la marche à suivre, ces
instructions peuvent ètres suivies d'op‚randes si leur syn-
taxe le demande ( comme pour MOVE x,y )
En ASS 68000, on d‚monbre 56 instructions de Base.
.3° colonne: Les REMARQUES:
-----------
Tout le texte situ‚ après les Op‚randes n'est plus reconnu en
tant qu'instruction, et il peut donc servir à d‚crire le lis-
ting en y mettant des renseignements utiles...
Avec certains ‚diteurs (PROFIMAT), il faut mettre une virgule
avant les commentaires, sinon cela entraine une erreur lors
de l'assemblage.
Les lignes blanches (ou vides) ou celles qui commencent par *
(pour METACOMCO ) ou ';' (pour PROFIMAT)sont aussi assimill‚es
à des REMARQUES.
NB: .Pour qu'un LABEL soit reconnu comme tel, il doit ètre ‚cris sur
--- la premi‚re colonne, les autres colonnes doivent ètres s‚par‚es
d'au moins un espace (' ').
.Pas plus d'une instruction par ligne.
2) COMMENTAIRE DETAILLE DU LISTING:
--------------------------------
-ligne 1 : '; Programme #1 en Assembleur 68000 '
---------
.Comme vous pouvez le constater, il sagit d'une 'remarque', ici
,il s'agit du nom du programme...
-ligne 2 : ' '
---------
.Une ligne blanche... c.à.d. rien du tout (eh oui !)
-ligne 3 : ' TEXT'
---------
.Il y a une instruction (colonne 2).
.Il s'agit en fait d'une DIRECTIVE D'ASSEMBLAGE.
.Les DIRECTIVES sont des fonctions propres à l'ASSEMBLEUR utilis‚,
ceci peut expliquer pourquoi leur syntaxe peut varier avec l'‚di-
teur utilis‚.
Pour la plupart des directives,la syntaxe est identique. (je vous
nommerais les exceptions mais la notice de votre assembleur devrait
contenir les noms et la description des directives qu'il utilise.)
.Les DIRECTIVES se placent sur la 2° colonne du listing, tout comme
les intructions ou les MACROS-INSTRUCTIONS.
.La directive 'TEXT' a pour effet de forcer l'initialisation du P.C.
,le Compteur Programme. ( à 0 ou à sa valeur lors de sa dernière
initialisation si il existe plusieurs sections 'text' )
----------------
- Mais qu'est ce que le 'P.C.' ? :
------------
- C'est le compteur programme ou Programm Counter
C'est un REGISTRE de 32 Bits qui contient l'adresse ( paire ) du MOT
dans lequel se trouve le CODE (en BIN) de la prochaine instruction à
ex‚cuter.
En pratique, seul les 24 Bits de poids faibles sont utilis‚s dans ce
registre particulier.
Le P.C. est donc incr‚ment‚ apr‚s chaque instruction d'un nombre pair
d'octets (suivant la taille de l'instruction) .
Les instructions de saut (jmp...) ou de branchement (bsr..), ont pour
but de modifier le P.C. et provoquent ainsi un saut à l'adresse que
pointe le P.C.
donc: PC | code de l'instruction en BIN
-----
???????????????
PC ---------->
???????????????
PC ---------->
???????????????
PC ---------->
etc...
repr‚sentation du PC:
---------------------
32 23 0
********[][][][][][][][][][][][][][][][][][][][][][][][]
------------------
.La directive 'TEXT' a donc pour but d'intialiser le P.C.:
Elle pr‚cède les instructions qui forment le listing,d'o—
le nom 'text'.
-ligne 4: ' A EQU 18 '
-------- (je ne compte plus les lignes blanches)
.On trouve, un LABEL: A, une DIRECTIVE : EQU et son OPERANDE: 18
.la directive EQU a pour but d'assigner une valeur à l'‚tiquette
à laquelle elle se rapporte.(un nombre entier)
Dans notre listing: on associe la valeur 18 à l'adresse 'A'
-ligne 5: ' B EQU 2 '
--------
.On associe 2 à l'adresse 'B'
-ligne 6: ' move.w A,destination '
--------
.On y trouve une INSTRUCTION (move) et deux o‚randes (la source
et la destination)
.L'instruction 'move' d‚place une op‚rande source j'usqu'à une
op‚rande destination.
.L'instruction 'move' est suivie du suffixe '.w' : ceci indique
que l'instruction agit sur un MOT (ou Word)
.Il existe 3 suffixes pouvant ètres rajout‚s à certaines instru
-ctions (nous verrons en d‚tail lesquelles)
- .L :l'instruction porte sur un L-M ( Long )
- .W :elle porte sur un MOT ( Word )
- .B :elle porte sur un OCTET (ou Byte en Anglais)
NB: Si une instruction admet un de ces suffixe et qu'on ne le met pas :
-- par exemple si on ‚crit 'MOVE #1,d0', le suffixe .W sera pris par
d‚faut,c.à.d. que si vous ‚crivez 'MOVE #3,d2' cela revient à ‚crire
'MOVE.W #3,d2' )
----------------------
Que sont Les MODES D'ADRESSAGE ?:
-------------------------
Voilà le point le plus fondamental de la programmation en ASS.
- L'Ass permet de d‚placer aisement des donn‚es en m‚moire (par exemple
avec l'instruction 'move') ou de 'pointer' sur des instructions ou des
donn‚es rep‚r‚es en m‚moire.
Une des richesses de l'Ass. compar‚ aux autres langages est que l'Ass.
utilise plusieurs MODES D'ADRESSAGES :14 en 68000.
C.à.d. qu'en Ass, il est possible de d‚placer (directement ou indirec-
tement) des donn‚es en m‚moire ou d'agir sur des donn‚es localis‚es en
m‚moire, de 14 mamières diff‚rentes !
- Les ‚l‚ments qui interviennent dans les diff‚rents modes d'adressages
sont: Les REGISTRES,le PC (et aussi le SR , un registre tr‚s sp‚cial,
que nous ‚tudierons en d‚tail)
les REGISTRES:
--------------
. On distingue les REGISTRES DE DONNEES:
---------------------
Ils sont 8 et sont d‚sign‚s par leurs adresses:d0,d1,d2,d3,d4,d5,d6,d7
,ils ont une taille de 32 Bits et SERVENT AU STOCKAGE DE DONNEES num‚-
riques. ------------------------------
ainsi, si on ‚crit: MOVE.L #1,d0
ADD.L #1,d0
On pose 1 dans le registre d0 de 32 Bits (les 32 Bits du registre sont
affect‚s par l'instruction 'move.l' à cause du suffixe '.L' ), puis on
ajoute (add.l) 1 à ce registre (les 32 Bits du registre sont à nouveau
affect‚s), donc d0 contiendra '2' et sera repr‚sent‚ ainsi en m‚moire:
00000000000000000000000000000010 ,(%10=2)
et les REGISTRES D'ADRESSES:
---------------------
Ils sont 9 ,8 sont à la disposition du programmeur: ils sont d‚sign‚s
par leurs adresses:a0,a1,a2,a3,a4,a5,a6,a7 et SERVENT AU STOCKAGE DES
ADRESSES. -----------------------
--------
ainsi, si on ‚crit: MOVE.L NOM,a0
Le registre a0 est charg‚ avec la valeur de l'adresse de 'NOM' (les 32
bits du registre a0 sont affect‚s à cause du suffixe '.L')
ATTENTION: On ne peut transf‚rer que des MOTS ou des L-M dans un
---------- REGISTRE D'ADRESSE (pas d'OCTET,c'est très important!)
NB le registre a7 est particulier, il est utilis‚ comme pointeur de PILE
-- SYSTEME ( ou SP de 'Stack Pointer' ) qui est une zone particulière de
la m‚moire utilis‚e par certaines instructions de saut qui y stockent
l'adresse de retour à l'instruction appelant le sous programme (en r‚-
alit‚ c'est le PC qui est sauv‚ puis recharg‚ ,donc remis à sa valeur
initiale à la fin du sous programme ce qui provoque un retour à l'ins-
truction suivant l'instruction de saut, nous ‚tudierons cela en pro-
fondeur plus tard)
il y a le PC, qui EST aussi UN REGISTRE:
-----
.Nous avons vu qu'il est compos‚ de 32 bits dont 24 sont utilis‚s et qu'
il pointe sur l'adresse paire de la prochaine instruction † executer.
et le SR (le Registre d'‚tat ou 'Status Register'):
--
C'est un registre de 16 Bits qui se divise en 2 octets distincts:
- Un octet utilisateur (de poids faible)
- Un octet superviseur (de poids fort)
Voici sa structure:
superviseur | utilisateur
--------------------------+------------------------
SR: [T][ ][S][ ][ ][i2][i1][i0][ ][ ][ ][X][N][Z][V][C]
---
Bits n° 15 8 7 0
- L'octet superviseur:n'est utilisable en ‚criture qu'en MODE SUPER-
VISEUR par mise à 1 du bit 'S'. ( Il existe une fonction du Gemdos
qui le fait si on l'appelle )
Ce n'est qu'en mode superviseur qu'on peut avoir accès à la PILE
SYSTEME et à certaines instructions dites privil‚gi‚es.
La mise à 1 du bit 'T' permet ou microprocesseur de fonctionner en
mode TRACE (ex‚cution pas à pas du prg à chaque instruction, nous
en reparlerons dans le chapitre sur les DEBUGGERS)
Les bits i2,i1,i0 constituent le masque d'interruption.
(j'y reviendrais en d‚tail...)
- L'octet utilisateur:est utilisable dans les 2 MODES (utilisateur et
superviseur)
Cet OCTET est aussi appell‚ REGISTRE DES CODES CONDITIONS ou CCR de
'Condition Codes Register' ---
- Il est modifi‚ par la plupart des instructions du 68000.
* Le bit 'N' (n°3) est à 1 si le r‚sultat d'une op‚ration
arithm‚tique est N‚gatif ,sinon il est mis à 0.
* Le bit 'Z' (n°2) est mis à 1 si le r‚sultat d'une op‚ration
est nul (Z‚ro) , sinon il est mis à 0.
* Le bit 'V' (n°1) est mis à 1 si le r‚sultat d'une op‚ration
ne peut pas ètre repr‚sent‚ dans la taille de l'op‚rande d‚-
finie (d‚bordement) sinon il est mis à 0.
* Le bit 'C' (n°0) est mis à 1 si une op‚ration provoque une
retenue au dela du bit de plus fort poids de l'op‚rande r‚
sultat (division par exemple), sinon il est mis à 0.
* Le bit 'X' (n°4) est le bit d'eXtension, son utilisation se
limite à certaines instructions que nous ‚tudierons.
.Maintenant que vous vous ètes familliaris‚ avec les diff‚rents Registres
du 68000, je vais d‚finir les diff‚rents MODES D'ADRESSAGE.
Les modes d'adressage permettent de modifier les valeurs du PC, du SP,
du SR et la pile système.
je prendrais les intructions MOVE (permet de d‚placer l'op‚rande source
jusqu'à l'op‚rande destination) et ADD (ajoute l'op‚rande source à son
op‚rande destination) pour illustrer les diff‚rents types de modes d'ad-
ressage.
*** LES MODES D'ADRESSAGE DU 68000 ***
------------------------------
1) l'adressage IMMEDIAT (sh‚matis‚ #...)
--------------------
A) NUMERIQUE: (L'op‚rande source est une donn‚e)
----------
Il s'‚crit:
-----------
+-------------------------------------+
| Instruction #donn‚e,destination |
+-------------------------------------+
Et se lit:
----------
On pose la donn‚e source dans ( à ) l'op‚rande destination
Exemples:
--------- MOVE #12,d1
( c.à.d. MOVE.W #12,d1)
On pose le nombre 12 ,cod‚ sur un MOT dans le MOT de poids faible du
registre d1:
0000000000001100 ( Mot=%12 )
|
\|/
................0000000000000000( Registre d1, seul le MOT de
poids faible est affect‚ car
Bits n° 31 15 0 on a ‚crit:'move.W' )
et on obtient:
--------------
................0000000000001100 ( %12 Dans le MOT de poids
faible de d1 )
Bits n° 31 15 0
Exp 2: ADD.L #3,d1
------
On ajoute 3, cod‚ sur un L-M au contenu de d1 et les 32 bits de d1
participent à l'op‚ration:
00000000000000000000000000000011 ( L-M=%3 )
|
\|/
00000000000000000000000000000000 ( Registre d1 )
Bits n° 31 0
et on obtient:
--------------
00000000000000000000000000000011 ( Registre d1=%3)
Bits n° 31 0
B) SYMBOLIQUE: (L'op‚rande source est un LABEL)
----------
Il s'‚crit:
----------- +--------------------------------------+
| Instruction #Label,destination |
+--------------------------------------+
Et se lit:
----------
On pose l'adresse du Label dans ( à ) l'op‚rande destination.
Exemple:
--------
MOVE.L #etiquette,a0
On pose le L-M (paire) contenant l'adresse de 'etiquette' dans le
registre d'adresse a0, les 32 bits du registre sont affect‚s.
si on a l'adresse de 'etiquette' =00000000000000001101101011010000
cela donnerait:
00000000000000001101101011010000 ( adresse de 'etiquette')
|
\|/
00000000000000000000000000000000 ( Registre a0 )
Bits n° 31 0
et on obtiendrait:
---------------
00000000000000001101101011010000 ( adresse de 'etiquette'
dans le registre a0 )
Bits n° 31 0
2) L'adressage INDIRECT SIMPLE: (sh‚matis‚: (an) )
----------------------------
Il s'‚crit:
-----------
+-------------------------------------+
| Instruction (an),destination |
+-------------------------------------+
OU
--
+-------------------------------------+
| Instruction source,(an) |
+-------------------------------------+
Et se lit:
----------
On d‚place la donn‚e point‚e par le registre d'adresse an dans
( à ) l'op‚rande destination.
OU
--
On d‚place la donn‚e source jusqu'à l'adresse point‚e par an
Exemple:
--------
MOVE.B (a2),d2
On pose le BIT situ‚ à l'adresse point‚e par le registre d'adresse a2
dans le BIT de poids faible du registre de donn‚e d2.
Ainsi, si a2 pointe sur une adresse qui contient l'octet 01101001
On obtient:
........................01101001 (registre d2)
Bits n° 31 7 0
NB: notez que la taille d'op‚ration .B est autoris‚e pour ce mode
d'adressage, alors qu'elle est interdite pour d‚placer une ad-
resse dans un registre.
3) L'adressage INDIRECT AVEC POSTINCREMENTATION: (sh‚matis‚ (an)+ )
---------------------------------------------
Il s'‚crit:
-----------
+-----------------------------------+
| Instruction (an)+,destination |
+-----------------------------------+
OU
--
+-----------------------------------+
| Instruction source,(an)+ |
+-----------------------------------+
Et se lit:
----------
On prend la donn‚e point‚e par le registre d'adresse 'an', puis on
incr‚mente (augmente) la valeur de 'an' en fonction du SUFFIXE de
l'instruction ( de 1 pour .B, 2 pour .W, 4 pour .L ) et on d‚place
la donn‚e ainsi point‚e jusqu'à l'op‚rande destination.
OU
--
On d‚place l'op‚rande source jusqu'à l'adresse point‚e par le regis-
tre an, puis on incr‚mente la valeur de 'an' en fonction du SUFFIXE
de l'instruction ( de 1 pour .B, 2 pour .W, 3 pour .L )
C'est à dire: Si vous ‚crivez ' MOVE.B #%10101011,(A2)+ '
-------------
Vous posez le BIT '10101011' à l'adresse que pointe le registre a2
, puis le registre d'adresse a2 est INCREMENTE d'1 unit‚ ( .B ).
Si a2 pointe par exemple sur l'adresse $FFA0:
on a: 10101011
|
\|/
|--------|--------| $FF9F
$FFA0 |--------|--------| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- |--------|--------|
registre a2: 00000000000000001111111110100000 (=$ffa0)
------------
et on obtient:
|--------|--------| $FF9F
$FFA0 |10101011|--------| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- |--------|--------|
registre a2: 00000000000000001111111110100001 (=$ffa1)
------------
.L'octet 10101011 est plac‚ en $FFA0
.L'adresse de a2 est Incr‚ment‚ de 8 Bits (un Octet) car le
suffixe de l'instruction est ' .B ', comme la m‚moire est
adressable à l'octet, a2 est augment‚ d'une unit‚.
Et si on ‚crivait maintenant: MOVE.B #%11101010,(a2)
Que se passerait-il ?
R‚ponse: MOVE.B #%11101010,(a2) c'est poser l'octet 11101010 à
-------- l'adresse point‚e par le registre a2:
Comme a2 vaut $FFA1 maintenant, on obtiendrait:
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- |--------|--------|
registre a2: 00000000000000001111111110100001 (=$ffa1)
------------
Et si j'‚cris maintenant : MOVE #%00000001,(a2) ?
Il y aurait une ERREUR !, a2 pointe sur $FFA1, c'est une adresse
impaire, donc impropre pour y placer un MOT (MOVE sans suffixe =
MOVE.W)
Et si j'‚crivais : MOVE.B (a2)+,(a2) ?
Je prends l'octet que pointe a2, j'augmente a2 d'une unit‚ (.B) c.à.d.
que a2 pointe sur $FFA2 et je place cet octet à l'adresse que pointe
a2, c.à.d. en $FFA2 puisque a2 vient d'ètre incr‚ment‚.
cela donne:
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- |--------|--------|
registre a2: 00000000000000001111111110100001 (=$ffa1)
------------
après MOVE.B (a2)+,(a2)
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|--------| $FFA3
-------- |--------|--------|
registre a2: 00000000000000001111111110100001 (=$ffa1)
------------
Si maintenant je change la valeur de a2, et que a2 vaut $FFA0 et si
j'‚cris: MOVE (a2)+,(a2)+
On prend le MOT en $FFA0, on incr‚mente a2 ,a2 vaut donc $FFA2 ( car
MOVE = MOVE.W et un MOT=2 Octets, comme la m‚moire est adressable au
niveau de L'octet: a2=a2+2 Oct ) et on le met à l'adresse point‚e par
le registre a2 (c.à.d. $FFA2) puis on incr‚mente à nouveau le registre
d'adresse a2 de 2 (Oct.) donc a2 vaudra finalement $FFA4.
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|--------| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110100000 (=$ffa0)
------------
MOVE (a2)+,(a2)+
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |10101011|11101010| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110100100 (=$ffa4)
------------
4) L'adressage INDIRECT AVEC PREDECREMENTATION: (sh‚matis‚ -(an) )
--------------------------------------------
Il s'‚crit:
----------- +------------------------------------+
| Instruction -(an),destination |
+------------------------------------+
OU
--
+------------------------------------+
| Instruction source,-(an)|
+------------------------------------+
Et se lit:
----------
On d‚cr‚mente (diminue) la valeur du registre d'adresse an en fonction
du suffixe de l'instruction (de 1,2 ou 4) , on prend la donn‚e point‚e
par cette nouvelle valeur de 'an' et on la pose dans ( à ) l'op‚rande
destination.
OU
--
On prend l'op‚rande source, on d‚cr‚mente la valeur du registre 'an' en
fonction du suffixe de l'instruction (de 1,2 ou 4) puis on la pose dans
dans ( à ) l'adresse point‚e par cette nouvelle valeur de 'an'.
NB: Important, notez que pour ce mode d'adressage la d‚cr‚mentation de
--- 'an' se fait avant (signe '-' avant '(an)' , c'est de là que vient
le nom de PREd‚cr‚mentation).
Pour le mode d'adressage (an)+ ,le signe '+' se situe après '(an)',
ceci explique le nom de POSTincr‚ment‚.
Ce mode d'adressage ressemble fort au mode d'adressage postincr‚ment‚
(an)+ ,sauf qu'ici le registre d'adresse 'an' voit sa valeur diminuer
en fonction du suffixe de l'instructon.
exemple: Soit la portion de m‚moire suivante:
--------
Si le registre a2 pointe sur $FFA4:
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|00000001| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110100100 (=$ffa4)
------------
et si j'‚cris: MOVE.L -(a2),-(a2)
On d‚cr‚mente a2 de 4 (oct.) car on a move.L , a2 pointe donc sur
$FFA0, on prend le L-M situ‚ en $FFA0, on d‚cr‚mente à nouveau a2
de 4 , a2 pointe donc sur $FF9C et on d‚place le L-M en $FF9C
on a donc:
|--------|--------| $FF9B
$FF9C |10101011|11101010| $FF9D
$FF9E |11101010|00000001| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|00000001| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110011100 (=$ff9c)
------------
Si maintenant je fais pointer a2 sur $FFA0 et que j'‚cris:
MOVE.B #23,-(a2)
Je prend l'octet 23 (=%00010111) , je d‚cr‚mente a2 de 1 (.B), a2
vaudra donc $FF9F et je pose l'octet 00010111 à cette nouvelle ad-
resse.
Donc:
|--------|--------| $FF9F
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|00000001| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110100000 (=$ffa0)
------------
MOVE.B #23,-(a2)
donne:
|--------|00010111| $FF9F (23 en $FF9F)
$FFA0 |10101011|11101010| $FFA1
m‚moire: $FFA2 |11101010|00000001| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 0000000000000000111111111011111 (=$ffa0)
------------
5) L'adressage INDIRECT AVEC DEPLACEMENT: (sh‚matis‚ d(an) )
--------------------------------------
Il s'‚crit:
----------- +------------------------------------+
| Instruction d(an),destination |
+------------------------------------+
Et se lit:
----------
On ajoute au contenu du registre d'adresse 'an', la valeur (sign‚e)
du d‚placement 'd', la donn‚e point‚e par cette nouvelle valeur du
registre 'an' est pos‚e dans ( à ) l'op‚rande destination.
Donc d(an)= d+(an)
'd' est un nombre entier sign‚ (+ si le MSB est nul,- si il est actif)
et contenu dans un MOT: ( -32768 <= d < 32768 ).
Exemple: Si le registre d'adresse a3 pointe sur $FFA0
--------
|--------|--------| $FF9F
$FFA0 |--------|--------| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- $FFA4 |--------|--------|
registre a3: 00000000000000001111111110100000 (=$ffa0)
------------
et que j'‚cris: MOVE.W #458,2(a3)
On pose 458=%0000000111001010 à l'adresse $FFA0+2=$FFA2
on obtient:
|--------|--------| $FF9F
$FFA0 |--------|--------| $FFA1
m‚moire: $FFA2 |00000001|11001010| $FFA3
-------- $FFA4 |--------|--------|
registre a3: 00000000000000001111111110100000 (=$ffa0)
------------
Le registre a3 est inchang‚ !
6) L'adressage INDIRECT AVEC INDEX ET DEPLACEMENT: (sh‚matis‚ d(an,rn) )
-----------------------------------------------
Il s'‚crit:
----------- +---------------------------------------+
| Instruction d(an,rn),destination |
+---------------------------------------+
Et se lit:
----------
On ajoute au registre 'an', la valeur sign‚e du d‚placement 'd' contenu
sur un MOT et la valeur du registre 'rn' (d'adresse ou de donn‚e), puis
on d‚place la donn‚e ainsi point‚e dans ( à ) l'op‚rande destination.
donc d(an,rn)= d+(an)+(an) ou =d+(an)+(dn)
Si le registre rn prend le suffixe .w, son mot de poids faible parti-
cipe à l'op‚ration, si il prend le suffixe .l, il y participe en ent-
ier. (taille .w par d‚faut)
Exemple: Si le registre d'adresse a2 pointe sur $FFA0 et si le registre de
-------- donn‚e d5 vaut 122.
Si j'‚cris MOVE.B #2,5(a2,d5)
On pose l'octet 2=%00000010 en 5+$FFA0+122=$1001F
00000010
|
\|/
|--------|--------| $FF9F
$FFA0 |--------|--------| $FFA1
m‚moire: $FFA2 |--------|--------| $FFA3
-------- $FFA4 |--------|--------|
registre a2: 00000000000000001111111110100000 (=$ffa0)
------------
registre d5: 00000000000000000000000001111010 (=122)
------------
on obtient:
|--------|--------| $1001D
$1001E |--------|00000010| $1001F
m‚moire: $10020 |--------|--------| $10021
-------- $10022 |--------|--------| $10023
registre a2: 00000000000000001111111110100000 (=$ffa0)
------------
registre d5: 00000000000000000000000001111010 (=122)
------------
Les registres a2 et d5 sont inchang‚s !
NB: ATTENTION,certains Assembleurs (Metacomco) n'admettent pas la syntaxe
--- (an,rn) si d=0, il faut ‚crire 0(an,rn) quand d=0 !
-----------------
PIECHOCKI Laurent
8, impasse Bellevue
57980 TENTELING suite dans [[pl_COURS.DOC]]
---------
Back to ASM_Tutorial