Pl INSTRUC2.DOC/fr
SUITE DU COURS SUR LES INSTRUCTIONS du fichier [[pl_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 [[pl_INSTRUC3.DOC]]
57980 TENTELING ------------
Back to ASM_Tutorial