Pl INSTRUC2.DOC/fr
SUITE DU COURS SUR LES INSTRUCTIONS du fichier INSTRUC.DOC----------------------------------------------------------
LSL #BBB,dn (.B),[.W],(.L) (Local Shift Left)
--------------
ou
LSL dm,dn (.B),[.W],(.L)
--------------
ou
LSL.W destination (.W)
------------------
Permet de faire un décalage de #BBB ou dm (suivant la syntaxe) BITS
du registre de donnée dn vers la gauche.
Les bits de remplacement sont NULS.
Il faut néanmoins que 1<= #BBB <= 8 pour la 1° forme.
-------------
Pour la 3° forme,les modes d'adressage autorisés pour l'opérande
destination sont:
-----------
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
Mais dans ce cas, l'opération ne peut que porter le décalage sur
1 SEUL BIT.
C.à.d. que par exemple si d0=%10000101110001101111011100000110 (mot)
------
Et que j'écris LSL.W #1,dn
ou MOVE.W #1,d1
LSL.W d1,d0 ,on obtient:
d0=%00001011100011011110111000001100
<-------- <--:0
Tous les Bits du MOT de poids faible du registre de donnée dn (.W)
ont été décalés d'1 bit vers la gauche:
Le bit de plus faible poids rentrant est toujours remplacé par un
bit NUL.
C.à.d. : Qu'on sort #BBB ou dm BITS de dn par la gauche et que les
bits de remplacement qui rentrent à droite de dn sont des bits NULS.
Le contenu de dn est donc changé, le MSB a aussi des chances d'être
changé,c'est pourquoi le SIGNE de dn ne sera pas forcement conservé.
Le CCR sera changé en fonction de la nouvelle valeur de dn.
---
N=1 si le MSB est 1, sinon il est égal à 0
Z=1 si tous les bits de dn sont nuls, sinon il est égal à 0
V est toujours mis à 0
C et X sont mis à la valeur du DERNIER BIT SORTI de dn.
Exemple d'utilisation:
----------------------
MOVE #%1111111101010101,d0
LSL.B #5,d0
On oppère un décalage de 5 bits de l'OCTET de poids faible de d0
(seuls les bits 0 à 7 de d0 sont donc conscernés par lsl.B)
On obtient:
CCR --------<------<:0
X=C=0 <- 1111111110100000 dans d0
5 bits 0 sont rentrés à droite de L'octet de poids faible de d0, le
dernier bit à sortir de d0 etait nul: le bit X=C=0 dans le CCR
LSR #BBB,dn (.B),[.W],(.L) (Local Shift Right)
--------------
ou
LSR dm,dn (.B),[.W],(.L)
--------------
ou
LSR.W destination (.W)
------------------
Permet de faire un décalage de #BBB ou dm (suivant la syntaxe) BITS
du registre de donnée dn vers la droite
Les bits de remplacement sont NULS.
Il faut néanmoins que 1<= #BBB <= 8 pour la 1° forme.
-------------
Pour la 3° forme,les modes d'adressage autorisés pour l'opérande
destination sont:
-----------
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
Mais dans ce cas, l'opération ne peut que porter le décalage sur
1 SEUL BIT.
C.à.d. que par exemple si d0=%10000101110001101111011100000110 (mot)
------
Et que j'écris LSR.W #1,dn
ou MOVE.W #1,d1
LSR.W d1,d0 ,on obtient:
d0=%01000010111000110111101110000011
0:--> ------->
Tous les Bits du MOT de poids faible du registre de donnée dn (.W)
ont été décalés d'1 bit vers la droite:
Le bit de plus fort poids rentrant est toujours remplacé par un
bit NUL.
C.à.d. : Qu'on sort #BBB ou dm BITS de dn par la droite et que les
bits de remplacement qui rentrent à gauche de dn sont des bits NULS.
Le contenu de dn est donc changé, le MSB a aussi des chances d'être
changé,c'est pourquoi le SIGNE de dn ne sera pas forcement conservé.
Le CCR sera changé en fonction de la nouvelle valeur de dn.
---
N=1 si le MSB est 1, sinon il est égal à 0
Z=1 si tous les bits de dn sont nuls, sinon il est égal à 0
V est toujours mis à 0
C et X sont mis à la valeur du DERNIER BIT SORTI de dn.
Exemple d'utilisation:
----------------------
MOVE #%1111111101010101,d0
LSR.B #5,d0
On oppère un décalage de 5 bits de l'OCTET de poids faible de d0
(seuls les bits 0 à 7 de d0 sont donc conscernés par lsr.B)
On obtient:
------0:>------> CCR
d0 :1111111100000010 -> X=C=1
5 bits 0 sont rentrés à gauche de L'octet de poids faible de d0, le
dernier bit à sortir de d0 était égal à 1: le bit X=C=1 dans le CCR
ASL #BBB,dn (.B),[.W],(.L) (Arithmetic Shift Left)
--------------
ou
ASL dm,dn (.B),[.W],(.L)
--------------
ou
ASL.W destination (.W)
------------------
Cette instruction est identique à LSL.
Mais avec ASL, le bit V du CCR est mis à 1 si le MSB de l'opérande
destination est changé. ---
ASR #BBB,dn (.B),[.W],(.L) (Arithmetic Shift Right)
--------------
ou
ASR dm,dn (.B),[.W],(.L)
--------------
ou
ASR.W destination (.W)
------------------
Permet de faire un décalage de #BBB ou dm (suivant la syntaxe) BITS
du registre de donnée dn vers la droite
Les bits de remplacement sont égaux au bit de plus fort poids.
Il faut néanmoins que 1<= #BBB <= 8 pour la 1° forme.
-------------
Pour la 3° forme,les modes d'adressage autorisés pour l'opérande
destination sont:
-----------
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
Mais dans ce cas, l'opération ne peut que porter la ROTATION sur
1 SEUL BIT.
C.à.d. que par exemple si d0=%10000101110001101111011100000110 (mot)
------
MSB=1
Et que j'écris ASR.W #1,dn
ou MOVE.W #1,d1
ASR.W d1,d0 ,on obtient:
d0=%11000010111000110111101110000011
MSB=1:--> ------->
Tous les Bits du MOT de poids faible du registre de donnée dn (.W)
ont été décalés d'1 bit vers la droite:
Le bit de plus faible poids sort par la droite.
Le bit à remplacer est identique au MSB précédant la rotation.
C.à.d. : Qu'on sort #BBB ou dm BITS de dn par la droite et qu'ils
rentre des bits égaux au bit de plus fort poids à gauche,à la place
du bit manquant.
Le contenu de dn est donc changé mais son SIGNE est CONSERVE car le
MSB reste inchangé.
Le CCR sera changé en fonction de la nouvelle valeur de dn.
---
N=1 si le MSB est 1, sinon il est égal à 0
Z=1 si tous les bits de dn sont nuls, sinon il est égal à 0
V est mis à 1 si le MSB de l'opérande destination a été changé.
C et X sont mis à la valeur du DERNIER BIT SORTI de dn.
Exemple d'utilisation:
----------------------
MOVE #%1111111101010101,d0
ASR.W #5,d0
bit nr°15=1
On oppère un décalage de 5 bits du MOT de poids faible de d0
(seuls les bits 0 à 15 de d0 sont donc conscernés par asr.W)
On obtient:
MSB>---------------> CCR
d0 :1111111111111010 -> X=C=1 à la fin
5 bits sont sortis à droite du MOT de poids faible de d0 et on a
placé sucessivement 5 bits égaux à 1 (bit nr°15=1) à la place du
bit de plus fort poids du MOT.
Le signe de d0 reste conservé.
le dernier bit à sortir de d0 était égal à 1:
le bit X=C=1 dans le CCR
ROL #BBB,dn (.B),[.W],(.L) ROtate Left
--------------
ou
ROL dm,dn (.B),[.W],(.L)
--------------
ou
ROL.W destination (.W)
------------------
Permet de faire une ROTATION de #BBB ou dm (suivant la syntaxe) BITS
du registre de donnée dn vers la gauche.
Les bits de remplacement sont égaux ceux qui viennent de sortir.
Il faut néanmoins que 1<= #BBB <= 8 pour la 1° forme.
-------------
Pour la 3° forme,les modes d'adressage autorisés pour l'opérande
destination sont:
-----------
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
Mais dans ce cas, l'opération ne peut que porter la ROTATION sur
1 SEUL BIT.
C.à.d. que par exemple si d0=%10000101110001101111011100000110 (mot)
------
Et que j'écris ROL.W #1,dn
ou MOVE.W #1,d1
ROL.W d1,d0 ,on obtient:
d0=%00001011100011011110111000001101
<----- <:1
Tous les Bits du MOT de poids faible du registre de donnée dn (.W)
ont été décalés d'1 bit vers la gauche:
Le bit de plus fort poids sort par la gauche et revient par la
droite. (rotation)
C.à.d. : Qu'on sort #BBB ou dm BITS de dn par la gauche et qu'ils
rentrent à nouveau à droite, à la place des bits manquants.
Le contenu de dn est donc changé, le MSB risque donc aussi d'être
changé:le signe du registre ne sera donc pas forcement conservé.
Le CCR sera changé en fonction de la nouvelle valeur de dn.
---
N=1 si le MSB est 1, sinon il est égal à 0
Z=1 si tous les bits de dn sont nuls, sinon il est égal à 0
V est mis à 1 si le MSB de l'opérande destination a été changé.
C est mis à la valeur du DERNIER BIT SORTI de dn.
X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE #%1111111101010101,d0
ROL.B #5,d0
On oppère un décalage de 5 bits de l'OCTET de poids faible de d0
(seuls les bits 0 à 7 de d0 sont donc conscernés par rol.B)
On obtient:
-------C<------<:C CCR
d0 :1111111110101010 -> C=0 à la fin
5 bits sont sortis à gauche de l'octet de poids faible de d0 et ont
été remis à la place du bit de plus faible poids de l'octet.
le dernier bit à sortir de d0 était égal à 0:
le bit C=0 dans le CCR
ROR #BBB,dn (.B),[.W],(.L) ROtate Right
--------------
ou
ROR dm,dn (.B),[.W],(.L)
--------------
ou
ROR.W destination (.W)
------------------
Permet de faire une ROTATION de #BBB ou dm (suivant la syntaxe) BITS
du registre de donnée dn vers la droite.
Les bits de remplacement sont égaux ceux qui viennent de sortir.
Il faut néanmoins que 1<= #BBB <= 8 pour la 1° forme.
-------------
Pour la 3° forme,les modes d'adressage autorisés pour l'opérande
destination sont:
-----------
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
Mais dans ce cas, l'opération ne peut que porter la ROTATION sur
1 SEUL BIT.
C.à.d. que par exemple si d0=%10000101110001101111011100000110 (mot)
------
Et que j'écris ROR.W #1,dn
ou MOVE.W #1,d1
ROR.W d1,d0 ,on obtient:
d0=%01000010111000110111101110000011
--> --->
Tous les Bits du MOT de poids faible du registre de donnée dn (.W)
ont été décalés d'1 bit vers la droite:
Le bit de plus faible poids sort par la droite et revient par la
gauche. (rotation)
C.à.d. : Qu'on sort #BBB ou dm BITS de dn par la droite et qu'ils
rentrent à nouveau à gauche, à la place des bits manquants.
Le contenu de dn est donc changé, le MSB risque donc aussi d'ètre
changé:le signe du registre ne sera donc pas forcement conservé.
Le CCR sera changé en fonction de la nouvelle valeur de dn.
---
N=1 si le MSB est 1, sinon il est égal à 0
Z=1 si tous les bits de dn sont nuls, sinon il est égal à 0
V est mis à 1 si le MSB de l'opérande destination a été changé.
C est mis à la valeur du DERNIER BIT SORTI de dn.
X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE #%1111111101010101,d0
ROR.B #5,d0
On oppère un décalage de 5 bits de l'OCTET de poids faible de d0
(seuls les bits 0 à 7 de d0 sont donc conscernés par ror.B)
On obtient:
-------C>------>:C CCR
d0 :1111111110101010 -> C=1 à la fin
5 bits sont sortis à droite de l'octet de poids faible de d0 et ont
été remis à la place du bit de plus fort poids de l'octet.
le dernier bit à sortir de d0 était égal à 1:
le bit C=1 dans le CCR
ROXL #BBB,dn (.B),[.W],(.L) ROtate Left with eXtend
--------------
ou
ROXL dm,dn (.B),[.W],(.L)
--------------
ou
ROXL.W destination (.W)
-------------------
ROXL est identique à ROL à part qu'ici le bit X du CCR est ( tout
comme le bit C) chargé avec le dernier bit qui vient de sortir et
que c'est lui qui est recopié à la place du bit manquant.
ROXR #BBB,dn (.B),[.W],(.L) ROtate Right with eXtend
--------------
ou
ROXR dm,dn (.B),[.W],(.L)
--------------
ou
ROXR.W destination (.W)
-------------------
ROXR est identique à ROR à part qu'ici le bit X du CCR est ( tout
comme le bit C) chargé avec le dernier bit qui vient de sortir et
que c'est lui qui est recopié à la place du bit manquant.
BTST source,dn (.B),[.W],(.L) (TeST a Bit)
----------------
ou
BTST source,destination (.B),[.W],(.L)
------------------------
Permet de tester la valeur (0 ou 1) d'un BIT.
Si le BIT est NUL: le bit Z du CCR est mis à 1
--- - -
Si le BIT est ACTIF: le bit Z du CCR est mis à 0
----- - -
Pour la première forme:
--------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination est un registre de donnée.
-----------
Pour la seconde forme:
-------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination indique la donnée à traiter, elle admet les
modes d'adressage:
dn
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
d(pc)
d(pc,rn)
¶ part le bit Z du CCR, les bits du CCR ne sont pas affectés par
l'instruction. ---
Exemple d'utilisation:
----------------------
MOVE #%0111101101100101,d0
BTST.B #3,d0 ;Test le bit nr°3 de d0
BEQ zero ;Z=1 ?
BNE un ;Z=0 ?
On teste le BIT nr°3 de l'octet de poids faible du mot
%0111101101100101.
Il est égal à 0: Z=1 dans le CCR, on saute en 'zero'
BSET source,dn (.B),[.W],(.L) (test a Bit and SET)
----------------
ou
BSET source,destination (.B),[.W],(.L)
------------------------
Permet de tester la valeur (0 ou 1) d'un BIT.
. Si le BIT est NUL: le bit Z du CCR est mis à 1
--- - -
. Si le BIT est ACTIF: le bit Z du CCR est mis à 0
----- -
. Après le test, le BIT conscerné est mis à 1
--- -------
Pour la première forme:
--------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination est un registre de donnée.
----------- ------------------
Pour la seconde forme:
-------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination indique la donnée à traiter, elle admet les
modes d'adressage:
dn
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
¶ part le bit Z du CCR, les bits du CCR ne sont pas affectés par
l'instruction. ---
Exemple d'utilisation:
---------------------
MOVE #%0111101101100101,d0
BSET.B #3,d0 ;Test le bit nr°3 de d0 et SET à 1
BEQ zero ;Z=1 ?
BNE un ;Z=0 ?
On teste le BIT nr°3 de l'octet de poids faible du mot
%0111101101100101.
Il est égal à 0: Z=1 dans le CCR, on saute en 'zero'.
Le bit nr°3 a été mis à 1:donc d0=%0111101101101101
BCHG source,dn (.B),[.W],(.L) (Bit CHanGe)
----------------
ou
BCHG source,destination (.B),[.W],(.L)
------------------------
Permet de tester la valeur (0 ou 1) d'un BIT.
Si le BIT est NUL: le bit Z du CCR est mis à 1
Si le BIT est ACTIF: le bit Z du CCR est mis à 0
Après le test, le bit conscerné est changé en son opposé:
. 0 si il était égal à 1
. 1 si il était égal à 0
Pour la première forme:
--------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination est un registre de donnée.
----------- ------------------
Pour la seconde forme:
-------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination indique la donnée à traiter, elle admet les
modes d'adressage:
dn
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
¶ part le bit Z du CCR, les bits du CCR ne sont pas affectés par
l'instruction. ---
Exemple d'utilisation:
----------------------
MOVE #%0111101101100101,d0
BTST.B #3,d0 ;Test le bit nr°3 de d0
BEQ zero ;Z=1 ?
BNE un ;Z=0 ?
On teste le BIT nr°3 de l'octet de poids faible du mot
%0111101101100101.
Il est égal à 0: Z=1 dans le CCR, on saute en 'zero'.
Le bit nr°3 a été changé en son opposé:donc d0=%0111101101101101
BCLR source,dn (.B),[.W],(.L) (Bit CLeaR)
----------------
ou
BCLR source,destination (.B),[.W],(.L)
------------------------
Permet de tester la valeur (0 ou 1) d'un BIT.
. Si le BIT est NUL: le bit Z du CCR est mis à 1
--- - -
. Si le BIT est ACTIF: le bit Z du CCR est mis à 0
----- - -
. Après le test, le bit conscerné est mis à 0.
--- -------
Pour la première forme:
--------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination est un registre de donnée.
----------- ------------------
Pour la seconde forme:
-------------
L'opérande source indique le NR° du bit à tester, elle admet les
modes d'adressage: --
dn
#BBB
(avec 0<= NR° <=32, modulo 32)
L'opérande destination indique la donnée à traiter, elle admet
les modes d'adressage:
dn
BBBB
BB
(an)
-(an)
(an)+
d(an)
d(an,rn)
¶ part le bit Z du CCR, les bits du CCR ne sont pas affectés par
l'instruction. ---
Exemple d'utilisation:
---------------------
MOVE #%0111101101100101,d0
BTST.B #3,d0 ;Test le bit nr°3 de d0
BEQ zero ;Z=1 ?
BNE un ;Z=0 ?
On teste le BIT nr°3 de l'octet de poids faible du mot
%0111101101100101.
Il est égal à 0: Z=1 dans le CCR, on saute en 'zero'
Le bit nr°3 de d0 a été mis à 0:d0 reste inchangé
ADDX dm,dn (.B),[.W],(.L) (ADD with eXtend)
--------------
ou
ADDX -(am),-(an) (.B),[.W],(.L)
------------------
ADDX est identique à ADD, sauf qu'ici l'opérande source est augmentée
du bit X du CCR et ajoutée à (dans) l'opérande destination.
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Ceci permet donc de faire des additions avec une précision supérieure
à un L-M: on peut donc additionner deux L-M avec ADDX !
Tous les bits du CCR sont affectés par ADDX.
---
NB: Pour éviter q'une retenue antérieure perturbe une addition avec
-- ADDX, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR avant
l'addition.
ABCD.B dm,dn (.B) (ADD Decimal with eXtend)
----------------
ou
ABCD.B -(am),-(an) (.B)
--------------------
ABCD est identique à ADD, sauf qu'ici l'opérande source est augmentée
du bit X du CCR et ajoutée à (dans) l'opérande destination.
Seule la taille .B est autorisée.
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Les bits du V et N du CCR ne sont pas affectés par ABCD.
---
Le bit C est mis à 1 seulement si il y a une retenue Décimale.
NB: Pour éviter q'une retenue antérieure perturbe une addition avec
-- ABCD, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR avant
l'addition.
SUBX dm,dn (.B),[.W],(.L) (SUBtract with eXtend)
--------------
ou
SUBX -(am),-(an) (.B),[.W],(.L)
------------------
SUBX est identique à SUB, sauf qu'ici l'opérande source est augmentée
du bit X du CCR et retranchée à (dans) l'opérande destination.
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Ceci permet donc de faire des soustractions avec une précision
supérieure à un L-M: on peut donc soustraire deux L-M avec SUBX !
Tous les bits du CCR sont affectés par SUBX.
---
NB: Pour éviter q'une retenue antérieure perturbe une addition avec
-- SUBX, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR avant
la soustraction.
SBCD.B dm,dn (.B) (Subtract Decimal with eXtend)
----------------
ou
SBCD.B -(am),-(an) (.B)
--------------------
SBCD est identique à SUB, sauf qu'ici l'opérande source est augmentée
du bit X du CCR et ajoutée à (dans) l'opérande destination.
Seule la taille .B est autorisée.
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Les bits du V et N du CCR ne sont pas affectés par SBCD.
---
Le bit C est mis à 1 seulement si il y a une retenue Décimale.
NB: Pour éviter q'une retenue antérieure perturbe une soustraction
-- avec SBCD, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR
avant la soustraction.
NEGX source (.B),[.W],(.L) (NEGate with eXtend)
--------------
NEGX est identique à NEG, sauf qu'ici l'opérande source est augmentée
du bit X du CCR avant d'ètre soustraite de 0.
L'opérande source admet les modes d'adressage:
------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Tous les bits du CCR sont affectés par NEGX.
---
NB: Pour éviter q'une retenue antérieure perturbe une negation avec
-- NEGX, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR avant
la négation.
NBCD.B source (.B) (Negate Decimal with eXtend)
----------------
NBCD est identique à NEG, sauf qu'ici l'opérande source est augmentée
du bit X du CCR puis soustraite de 0.
Seule la taille .B est autorisée.
L'opérande source admet les modes d'adressage:
------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Le bit X du CCR est une copie du bit C et est mis à 1 si le résultat
d'une opération provoque une retenue.
Les bits du V et N du CCR ne sont pas affectés par NBCD.
---
Le bit C est mis à 1 seulement si il y a une retenue Décimale.
NB: Pour éviter q'une retenue antérieure perturbe une négation avec
-- NBCD, on peut mettre le bit X du CCR à 0 avec MOVE #0,CCR avant
la négation.
JMP desination (JuMP)
-----------------
JMP permet d'effectuer un saut à l'adresse destination.
L'opérande destination admet les modes d'adressage:
-----------
BBBB
BB
(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le saut se fait en chargeant la valeur actuelle du PC avec la valeur
du PC à l'adresse destination.
Le CCR n'est pas affecté.
---
Exemples d'utilisation:
-----------------------
JMP ici
ou
LEA.L ici,a0
JMP (a0)
ou
JMP 4(pc)
etc...
BRA Label (BRAnch)
------------
BRA permet d'effectuer un saut à l'adresse pointée par le Label
(comme avec JMP)
Le saut se fait en chargeant la valeur actuelle du PC avec la valeur
du PC à l'adresse destination.
Le CCR n'est pas affecté.
---
Exemple d'utilisation:
----------------------
BRA laurent
JSR Destination (Jump Sub Routine)
------------------
Comme JMP, JSR permet d'effectuer un saut à l'adresse pointée par
l'opérande destination.
L'opérande destination admet les modes d'adressage:
-----------
BBBB
BB
(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
De plus, l'adresse de l'instruction qui suit JSR est déposée dans
la pile système (SP):
On distingue 2 types de PILES:
.La pile système et les piles implantées par l'utilisateur.
.La pile système est pointée par le registre A7 ou SP.
.La différence entre ces 2 piles réside dans le fait qu'elles sont
gérées de façon entièrement indépendantes.
.Si on se trouve en MODE SUPERVISEUR, la pile système nous est
disponible.
.Si on se trouve en MODE UTILISATEUR, la pile est nommée la pile
utilisateur.
La PILE système est une partie particulière de la mémoire, elle
est motament utilisée par les instructions de saut pour y déposer
l'adresse de retour à l'instruction.
|--------|--------|
|--------|--------| PILE
|--------|--------| système
|--------|--------|
On peut ranger des données dans cette pile. (c'est comme ça par exp
qu'on passe les paramètres aux fonctions du Bios,Xbios,Gemdos)
Le rangement des données dans la Pile système se fait :
.Soit par prédécrémentation du pointeur de pile SP ( -(sp) )
- Dans ce cas, la lecture des données se fera par mode (sp)+
.Soit par postincrémentation du pointeur de pile SP ( (sp)+ )
- Dans ce cas, la lecture des données se fera par mode -(sp)
NB:Je vous rappelle que le SP (Stack Pointer) doit uniquement pointer
-- des adresses PAIRES !
Les décrémentations ou incrémentations du SP d'1 unité seront donc
interdites.
Exemple d'empilement de données en mode prédécrémenté:
-------
MOVE #5-(sp) ;5=%101
MOVE #3-(sp) ;3=%11
On obtient:
|--------|--------|
SP ----->|00000000|00000011| /|\ On empile les données
|00000000|00000101| | en mode -(SP)
SP avant>|--------|--------|
SP a été décrémenté de 4 unités ( -(sp) 2 fois avec .W )
MOVE (sp)+,d0
MOVE (sp)+,d1
On obtient:
|--------|--------|
SP avant>|00000000|00000011| | On dépile les données
|00000000|00000101| \|/ en mode (SP)+
SP ----->|--------|--------|
SP a été incrémenté de 4 unités ( (sp)+ 2 fois avec .W )
d0 contiendra le MOT 3
d1 contiendra le MOT 5
SP retrouve sa valeur initiale aprés le dépilement des données.
NB: Il sera important de veiller à redonner sa valeur initiale au
-- SP après s'ètre servi de la PILE système car la taille de celle-
ci est limitée.
Mais revennons à JSR: Nous avons vu que l'instruction dépose
l'adresse de la prochaine instruction qui suit JSR dans la pile
système avant d'effectuer un saut à l'adresse destination.
SP est donc décrémenté de 4 unités (car une adresse est contenue
dans un L-M)
La pile système ressemblera donc à cela après un JSR:
|--------|--------|
SP ----->|XXXXXXXX|XXXXXXXX| /|\ L'adresse ( L-M ) de retour
|XXXXXXXX|XXXXXXXX| | après JSR est pointée par
SP avant>|--------|--------| SP qui a été décrémenté de
4 unités ( -(SP) avec .L )
Cette adresse sera dépilée par la suite à la fin du sous programme
par une instruction spécifique et sera chargée dans le PC:
Ceci provoquera le retour à l'instruction suivant JSR.
JSR diffère donc de JMP par le fait que JSR sauve l'adresse de la
prochaine instruction qui la suit dans la pile système, ceci afin
qu'il soit possible de revenir à cette adresse après avoir sauté
à l'adresse destination de JSR.
BSR label (Branch Sub Routine)
-------------
BSR est identique à JSR, sauf que certains assembleurs permettent de
fixer la longueur du déplacement (BRA.S (Mot) ou BRA.L (L-M) )
(Ceci n'a pas de réel intérêt pour nous ...)
RTS (ReTurn from Sub routine)
---
C'est, (comme son nom l'indique) l'instruction qui marque la fin du
sous programme et qui oppère un saut à la prochaine instruction qui
suit l'instruction appellante JSR.
RTS dépile (par mode postincrémenté) l'adresse déposée par JSR et la
charge dans le PC:ceci a pour effet de provoquer un saut à l'adresse
qui suit JSR.
SP retrouve donc sa valeur initiale.
Le CCR n'est pas modifié par RTS.
---
Exemple d'utilisation:
----------------------
MOVE #3,d0 ;mot 3 dans d0
MOVE #8,d1 ;mot 8 dans d1
JSR ajoute ;Appel du sous-programme 'ajoute'
MOVE d0,resu ;met le mot de poids faible de d0 en 'resu'
...... ;on considère qu'ici se trouve une instruction
;qui stoppe le programme pour éviter d'aller
;plus loin...
ajoute ADD d1,d0 ;sous programme 'ajoute'
RTS ;fin du sous programme,retour ^
BSS
resu DS.W 1 ;réserve un mot
END
En 'resu', on trouvera le MOT 8+3=11
RTR (ReTurn & Restore CCR)
---
RTR est identique à RTS sauf que RTR:
.Dépile 1 MOT de la pile système par mode postincrémenté et le place
dans le CCR.
.Dépile 1 L-M de la pile système par mode postincrémanté et le place
dans le PC, tout comme RTS.
Il faudra bien entendu que les 3 premiers MOTS pointés par SP
correspondent aux besoins de RTR.
Exemple d'utilisation:
----------------------
MOVE #3,d0 ;3 dans d0
MOVE d0,d1 ;d0 dans d1
JSR test ;va au sous prg 'test' et pose l'adresse de la
;prochaine instruction dans SP.
MOVE #1,d3
.......... ;fin d'execution du prg pour ne pas aller plus loin
test MOVE sr,-(sp) ;sous-prg 'test':pose le SR (mot) dans la pile
;(la pile contient donc à son sommet le SR (mot)
;puis l'adresse posée par JSR (l-m) )
SUB d0,d1 ;soustrait d0 de d1: d0=d1, le bit Z du CCR est
;mis à 1.(avant SUB il était à 0)
RTR ;on dépile le SR puis l'adresse posée par JSR et
;on revient
Après être revenu du sous-programme, le bit Z du CCR sera donc nul car
RTR a restoré le SR que nous avons déposé avant la soustraction ...
MOVEM registres/registres,destination [.W],(.L)
---------------------------------------
ou
MOVEM source,registres/registres [.W],(.L)
----------------------------------
MOVEM permet la sauvegarde (1° forme) ou la restoration (2° forme) des
registres an et dn.
Seules les tailles .W ou .L sont autorisées.
Pour la 1° forme:
----------------
L'opérande destination admet les modes d'adressage:
-----------
BBBB
BB
(an)
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
On utilise communement le mode d'adressage -(an), dans ce cas, les
registres sont empilés en mémoire par adresses décroissantes, dans
l'odre: a7->a0 , d7->d0
Si l'opérande source est du type: d0-d7/a0-a7 ,tous les registres sont
transférés.
Sinon, on indique le 1° registre DN et le dernier registre DM à
transfèrer (séparés du signe -) puis le 1° registre AN et le dernier
registre AM à transfèrer (séparés du signe -).
De plus:
On sépare les registres DN et AN du signe / dans l'opérande source.
NB:La forme dn-dm/an-am est identique à la forme an-am/dn-dm pour
-- l'opérande source.
(de mème que la forme d0/d1/a0 est identique à la forme d0-d1/a0)
Le registre de donnée an destination est donc décrémenté d'un nombre
égal à la taille x de MOVEM.x (2 si .W,4 si .L) multiplié par le
nombre total de registres à transferer.
Exp: MOVEM.L d3-d5/a0-a2,-(SP)
---
On empile les registres a2,a1 puis d5,d4,d3 dans la pile système.
SP est décrémenté de 6*4=24 unités et pointe sur d3, le dernier
registre empilé.
MOVEM.L a5-a7,-(SP)
On empile les registres a7,a6,a5 dans la pile système.
SP est décrémenté de 3*4=12 unités et pointe sur a5, le dernier
registre empilé
MOVEM.W d3/a0-a1,-(SP)
On empile les mots de poids faible des registres a1,a0,d3 dans la pile
système.
SP est décrémenté de 3*2=6 unités et pointe sur le mot de poids faible
de d3, le dernier mot empilé.
Pour la 2° forme:
-----------------
L'opérande source admet les modes d'adressage:
------
BBBB
BB
(an)
(an)+
d(an)
d(an,rn)
d(pc)
d(pc,rn)
On utilise communement le mode d'adressage (an), dans ce cas, les
registres sont dépilés de la mémoire par adresses croissantes, et
remis dans les registres dans l'odre: d0->d7 , a0->a7
Si l'opérande source est du type: d0-d7/a0-a7 ,tous les registres sont
modifiés.
Sinon, on indique le 1° registre DN et le dernier registre DM à
charger (séparés du signe -) puis le 1° registre AN et le dernier
registre AM à charger (séparés du signe -).
De plus:
On sépare les registres DN et AN du signe / dans l'opérande source.
NB:La forme dn-dm/an-am est identique à la forme an-am/dn-dm pour
-- l'opérande source.
(de mème que la forme d0/d1/a0 est identique à la forme d0-d1/a0)
Le registre de donnée an destination est donc incrémenté d'un nombre
égal à la taille x de MOVEM.x (2 si .W,4 si .L) multiplié par le
nombre total de registres à modifier.
Le registre an destination retrouve donc sa valeur initiale après le
chargement des registres.
ATTENTION, il faudra veiller à ce que les données nécessaires soient
présentes à l'adresse indiquée.
Exp: MOVEM.L (SP)+,d3-d5/a0-a2
---
On dépile les L-M pointés par SP et on les copies dans d3,d4,d5 puis
a0,a1,a2.
Dans la pile système, SP est incrémenté de 6*4=24 unités.
MOVEM.L (SP)+,a5-a7
On dépile les L-M pointés par SP et on les copies dans le registres a5,
a6,a7.
Dans la pile système,SP est incrémenté de 3*4=12 unités.
MOVEM.W (SP)+,d3/a0-a1
On dépile les mots pointés par SP dans les mots de poids faible des
registres d3,a0,a1.
Dans la piles système, SP est incrémenté de 3*2=6 unités.
MOVEM n'influence pas le CCR.
---
Exemple d'utilisation:
----------------------
MOVE #3,d0 ;mot 3 dans d0
MOVE #4,d1 ;mot 4 dans d1
MOVEM.L d0-d1,-(SP) ;on sauvegarde d0 et d1 (voir schéma 1)
ADD d0,d1 ;d1=d0+d1=3+4=7
MOVEM.L (SP)+,d0-d1 ;on restore d0 et d1 (voir schéma 2)
Finalement: on a d0=3 et d1=4 à la fin du prg car les registres d0 et
d1 ont été sauvegardés puis rechargés.
schéma 1:
---------
MOVEM.L d0-d1,-(SP)
On EMPILE les L-M d1=4=%100 puis d0=3=%11 dans la Pile Système:
|--------|--------|
|--------|--------|
|--------|--------| PILE
SP après les 2--->|00000000|00000000| SYSTEME
décrémentations |00000000|00000011|
|00000000|00000000|
|00000000|00000100|
SP avant ----->|--------|--------|
schéma 2:
---------
MOVEM.L (SP)+,d0-d1
On DEPILE les L-M pointés par SP au cours des incrémentations et on
les places dans d0 et d1.
|--------|--------|
|--------|--------|
|--------|--------| PILE
SP avant ----->|00000000|00000000| SYSTEME
|00000000|00000011|
|00000000|00000000|
|00000000|00000100|
SP après les 2 -->|--------|--------|
incrémentations (.L)
MOVEP dn,d(an) [.W],(.L)
----------------
ou
MOVEP d(an),dn [.W],(.L)
---------------
MOVEP permet de sauvegarder (1° forme) ou recharger (2° forme) un
registre de donnée dn (son mot de poids faible pour MOVEP.W ou le
registre en entier pour MOVEP.L) pointé par un mode d'adressage du
type indirect avec déplacement d(an).
MOVEP est une instruction très particulière car le registre de donnée
dn est sauvé (ou chargé) de la manière suivante:
Pour MOVEP.W:
L'octet de poids faible de dn est sauvegardé ou chargé à partir de
l'adresse pointée par d(an) ( ou d(an)+1 si cette adresse était
IMPAIRE )
L'octet de poids fort de dn est sauvegardé ou chargé à partir de
l'adresse pointée par d(an)+2 ( ou d(an)+3 si cette adresse était
IMPAIRE )
Pour MOVEP.L
L'octet de poids faible de dn est sauvegardé ou chargé à partir de
l'adresse pointée par d(an) ( ou d(an)+1 si cette adresse était
IMPAIRE )
L'octet de poids fort du mot de poids faible de dn est sauvegardé ou
chargé à partir de l'adresse pointée par d(an)+2 ( ou d(an)+3 si cette
adresse était IMPAIRE )
L'octet de poids faible du mot de poids fort de dn est sauvegardé ou
chargé à partir de l'adresse pointée par d(an)+4 ( ou d(an)+5 si cette
adresse était IMPAIRE )
L'octet de poids fort de dn est sauvegardé ou chargé à partir de
l'adresse pointée par d(an)+6 (ou d(an)+7 si cette adresse était
IMPAIRE )
EN RESUME:
----------
MOVEP.L dn,d(an): Si d(an) pointe une adresse PAIRE.
----- -----
OCTETS MEMOIRE
------ -------
poids fort
dn: ******** -------> d(an) paire
-- d(an)+1 impaire
******** -------> d(an)+2 paire
d(an)+3 impaire
******** -------> d(an)+4 paire
d(an)+5 impaire
******** -------> d(an)+6 paire
poids faible
MOVEP.L dn,d(an): Si d(an) pointe une adresse IMPAIRE.
----- -------
OCTETS MEMOIRE
------ -------
poids fort
dn: ******** -------> d(an)+1 paire
-- d(an)+2 impaire
******** -------> d(an)+3 paire
d(an)+4 impaire
******** -------> d(an)+5 paire
d(an)+6 impaire
******** -------> d(an)+7 paire
poids faible
MOVEP permet donc TOUJOURS de poser un registre de donnée en mémoire
sur des adresses PAIRES.(Par alternance d'octets 'vides' et d'octets
contenus dans dn qui se situent eux toujours à des adresses paires )
MOVEP n'influence pas le CCR.
---
Exemple d'utilisation:
----------------------
MOVE.L #%00000000000000001111111100000001,d0
LEA aa,a0
MOVEP d0,0(a0)
BSS
aa DS.B 43
'aa' est une adresse paire (BSS initialise la PC) en 0(a0) on trouve donc
l'octet de poids le plus fort de d0 soit %00000000.
'aa'+1 est une adresse impaire.
'aa'+2 est une adresse paire, en 2(a0) on trouve l'octet de poids faible
du mot de poids fort de d0 soit %00000000
'aa'+3 est une adresse impaire
'aa'+4 est une adresse paire, en 4(a0) on trouve l'octet de poids fort
du mot de poids faible de d0 soit %11111111
'aa'+5 est une adresse impaire
'aa'+6 est une adresse paire, en 6(a0) on trouve l'octet de plus faible
poids de d0 soit %00000001
Tous ces octets sont situés à des adresses paires.
PEA source (Push Effective Address)
--------------
PEA pose l'adresse de l'opérande source dans la pile système sous la
forme d'un L-M, SP sera donc décrécmenté de 4 unités.
L'opérande source admet les modes d'adressage:
------
BBBB
BB
(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le CCR n'est pas affecté par PEA.
---
Exemple d'utilisation:
----------------------
PEA eee ;pose l'adresse pointée par le label 'eee' dans la
;pile système.(voir 1°)
MOVE.L (SP)+,a0 ;dépile le L-M pointé par SP et le pose dans a0
;(voir 2°)
JMP (a0) ;saute à l'adresse pointée par a0 (donc en 'eee')
MOVE #4,d0
eee MOVE #3,d1
END
Finalement: d1=3 et d0 est inutilisé.
1°) La pile système ressemblera donc à cela après un PEA:
---
|--------|--------|
SP ----->|XXXXXXXX|XXXXXXXX| /|\ L'adresse ( L-M ) de l'opérande
|XXXXXXXX|XXXXXXXX| | source est empilée dans la pile
SP avant>|--------|--------| système:SP est donc décrémenté
de 4 unités ( -(SP) avec .L )
2°) La pile système ressemblera ensuite à cela après MOVE.L (SP)+,a0
---
|--------|--------|
SP avant>|XXXXXXXX|XXXXXXXX| | L'adresse ( L-M ) de pointée
|XXXXXXXX|XXXXXXXX| \|/ par SP est posée dans a0.
SP ----->|--------|--------| SP qui a été incrémenté de
4 unités ( (SP)+ avec .L )
a0=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX (l'adresse posée par PEA)
------------------
PIECHOCKI Laurent
8,impasse Bellevue Suite dans le fichier INSTRUC3.DOC
57980 TENTELING ------------
Back to ASM_Tutorial