Pl INSTRUC.DOC/fr
-------------------------
CHAPITRE QUATRE
LES INSTRUCTIONS DU 68000
-------------------------
*** LES INSTRUCTIONS DU 68000 ***
---------------------------------
- Voilà un chapitre qui est consacré en entier aux différentes
instructions de l'assembleur 68000.
- Maintenant que vous savez, grƒce aux modes d'adressage,atteindre les
données en mémoire, nous allons nous interesser aux instructions qui
permettent de modifier,déplacer... donc de se servir des données.
- Pour chaque instruction, je vous donnerais:
.La syntaxe pour l'instruction et ses opérandes.
.Ses effets,son but.
.Les modes d'adressages autorisés pour les opérandes.
.L'effet de l'instruction au niveau des registres et notament au
niveau du CCR.
.Et bien sur des exemples d'utilisation...
- De nouvelles notions apparaitront dans les explications conscernant
les instructions, elles seront détaillées,expliquées et commentées.
--------------------
*** LES INSTRUCTIONS DU 68000 ***
---------------------------------
MOVE source,destination :(.B),[.W],(.L)
-----------------------------
Les 3 tailles d'opérations sont autorisées pour cette instruction,
La taille [.W] est prise par défaut.
L'opérande 'source' est copiée (et demeure inchangée) à (dans)
l'opérande 'destination'
Les modes d'adressages autorisés pour l'opérande source sont:
------
dn (registres de données)
an (registres d'adresses)
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Au niveau du CCR: Seuls les Bits N et Z sont affectés
---
Exemple d'utilisation:
----------------------
Move.l #1456701,d0
On pose le L-M égal à 1256701 dans le registre de donnée d0
MOVEQ #D,dn
------------------
L'opérande source est une donnée immédiate,signée,contenue dans un
octet (-128<= D <128)
L'opérande destination est un registre de donnée
On copie la donnée source,signée,contenue dans un octet dans un
registre de donnée après avoir ETENDU LE SIGNE DU REGISTRE:
C.à.d. que la donnée est placée dans l'octet de poids faible du
registre Dn et que le MSB a été étendu (copié) jusqu'au 31° bit du
registre,ceci afin que le registre de donnée soit affecté en entier
par le 'chargement' de la donnée et que le signe de la donnée soit
conservé.
L'opérande source admet donc le mode d'adressage:
------
#BBB ( -128<= BBB <128 )
L'opérande destination admet est un registre de donnée.
----------- ------------------
Seuls les Bits N et Z du CCR sont affectés par cette instruction
---
Exemple:
--------
MOVEQ #%01100101,d0
On pose l'octet 01100101 dans d0:
d0= : 00000000000000000000000001100101
Bit nr 31 .
. .
MSB (0) <---------------MSB (0)
Il y a eu extension du signe de d0 (ici MSB=0 car 01100101>0)
NB:Moveq se distingue de Move par une plus grande rapidité, mais
-- n'oubliez pas les conditions d'utilisation de Moveq !
MOVEA source,an :(.W),(.L)
--------------------
L'instruction Movea complète l'instruction Move car elle accepte un
Registre d'Adresse pour opérande destination.
Sur la plupart des assembleurs,la syntaxe MOVE source,an est
acceptée et automatiquement traduite par MOVEA source,an
Si l'opérande source utilise la taille d'opérantion .W, il y a
extension du signe du registre d'adresse an.
La taille .B n'est pas autorisée pour MOVEA.
Les modes d'adressage autorisés pour l'opérande source sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
L'opérande destination est un registre d'adresse
----------- ------------------
L'instruction MOVEA n'influence pas le CCR.
---
Exemple d'utilisation:
----------------------
MOVEA.L #etiq,a5
Le registre d'adresse a5 est chargé avec l'adresse pointée par le
label 'etiq'
LEA source,an : [.L]
----------------
Cette instruction se lit:'Load Effective Address'
Seule la taille d'opération .L est possible,elle est d'ailleurs prise
par défaut.
Elle permet de poser l'adresse pointée par l'opérande source dans
un registre d'adresse.
L'opérande source admet les modes d'adressage:
------
BBBB
BB
(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
L'opérande destination est un registre d'adresse
----------- ------------------
L'instruction LEA n'influence pas le CCR
---
Exemple d'utilisation:
----------------------
LEA etiq,a2
On pose l'adresse pointée par le label 'etiq' dans le registre
d'adresse a2.
En fait,cela peut aussi se faire avec MOVE.L #etiq,a2 , mais
c'est moins rapide.
CLR destination :(.B),[.W],(.L)
------------------
Cette instruction se lit: 'CLeaR destination'
Et permet de mettre à 0 tous les bits de l'opérande destination.
Elle admet les 3 tailles d'opération.
Les modes d'adressages autorisés pour l'opérande destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Le bit Z du CCR est mis à 1 , les Bits N,V,C à 0.
---
Exemple d'utilisation:
----------------------
CLR.W D0
Les 16 Bits du MOT de poids faible de d0 sont mis à 0.
NEG destination : (.B),[.W],(.L)
---------------------
Permet d'effectuer la NEGation de l'opérande destination.
Les 3 tailles d'opération sont possibles.
L'opérande destination est soustraite de 0, ceci a pour effet de
changer le signe de l'opérande:Les Bits qui étaient activés sont
étteints et les Bits qui étaient etteints sont activés.
L'opérande destination admet les modes d'adressage suivants:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Tous les Bits du CCR sont affectés par la NEGation en fonction du
résultat obtenu. ---
Exemple d'utilisation:
----------------------
MOVE #%1010101010101010,d0
NEG.W d0
On obtient le MOT %0101010101010101 dans d0
EXT dn : [.W],(.L)
------------
Permet d'obtenir une EXTension du signe de l'opérande destination.
La taille .B n'est pas autorisée.
Dans le cas de EXT.W dn:
Le MSB (bit n°7) du registre de donnée est étendu jusqu'au bit n°15
Dans le cas de EXT.L dn:
Le MSB (bit n°15) du registre de donnée est étendu jusqu'au bit n°31
Ceci permet de prolonger le contenu du registre de donnée sur un MOT
ou sur un L-M en préservant le signe de ce registre.
L'opérande destination ne peut ètre qu'un registre de donnée.
----------- ------------------
Les Bits N et Z du CCR sont positionnés suivant le résultat de
l'opérantion. ---
Exemple d'utilisation:
----------------------
MOVE.W #%0001011001010010,d5
EXT.L d5
Le MSB (ici 0) sera copié du bit n°16 au bit n°31, d5 contiendra donc
un L-M :%00000000000000000001011001010010 et non plus un MOT.
EXG rn,rm
-------------
EXG permet d'échanger le contenu de 2 registres dn ou an.
La taille .L est prise par défaut
L'opérande source est un registre de donnée ou d'adresse
------ --------
L'opérande destination est un registre de donnée ou d'adresse
----------- --------
Le CCR n'est pas affecté par EXG
---
Exemple d'utilisation:
----------------------
MOVE.L #$FF,d0
MOVE.L #$A2,d1
EXG d1,d0
D0 contiendra le L-M $A2 et d1 le L-M $FF.
SWAP dn
-----------
Echange les 2 MOTS du L-M contenu dans le registre de donnée dn
L'opérande destination doit être un registre de donnée.
----------- ------------------
Les Bits N et Z du CCR sont affectés en fonction du résultat obtenu.
---
Exemple d'utilisation:
----------------------
MOVE.L #%11111111111111110000000000000000,d3
SWAP d3
D3 contiendra le L-M :%00000000000000001111111111111111
Remarquez que le signe du registre dn n'est pas conservé et qu'il
peut être changé !
ADD dn,destination :(.B),[.W],(.L)
-----------------------
ou
ADD source,dn :(.B),[.W],(.L)
---------------------
Ajoute l'opérande source DANS l'opérande destination ( l'opérande
source est donc inchagée et le résultat se trouve dans l'opérande
destination! )
Les 3 tailles d'opération sont acceptées.
Les modes d'adressage autorisés pour l'opérande source si ADD
s'écrit: ADD.x source,dn sont: ------
----------------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Si l'opérande source est un registre d'adresse, la taille .B n'est
pas autorisée,si la taille est .W,il y a EXTension du signe de an.
Les modes d'adressage autorisés pour l'opérande destination si ADD
s'écrit ADD.x dn,destination sont: -----------
---------------------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Tous le Bits du CCR peuvent réagir à l'opération ADD en fonction
du résultat obtenu.
Exemple d'utilisation:
----------------------
ADD.B d0,d1
L'octet de poids faible du registre de donnée d0 est ajouté a
l'octet de poids faible de d1,le résultat est dans d1:
d0=d0, d1=d1+d0
ADDI #BBB,destination :(.B),[.W],(.L)
-------------------------
ADDI se lit: 'ADD Immediate'
Les 3 tailles d'opération sont autorisées.
La donnée immédiate source est ajouté à l'opérande destination.
--------- ------
Les modes d'adressage qui sont autorisés pour l'opérande
destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Les 5 codes du CCR sont affectés par ADDI
---
Exemple d'utilisation:
----------------------
ADDI.W #12,(a0)
On ajoute le mot 12 au mot pointé par le registre d'adresse a0.
ADDQ #BBB,destination :(.B),[.L],(.L)
-------------------------
La donnée immédiate non signée #BBB est ajoutée DANS l'opérande
destination.
Il faut obligatoirement que 1<= #BBB <=8
L'opérande destination admet les modes d'adressage:
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Si l'opérande destination est un registre d'adresse an,la taille
.B est interdite,si on utilise la taille .W il y aura EXTension
du signe de an sur un L-M.
Les 5 Bits du CCR sont modifiés par ADDQ en fonction du résultat.
---
Exemple d'utilisation:
----------------------
ADDQ.W #3,d0
Ajoute le mot 3 au mot de poids faible de d0.
Remarque:ADDQ est plus rapide que ADDI, ceci explique le nom
-------- de l'instruction:ADD Quick
Attention tout de même à ce que 1<= #BBB <=8
ADDA source,an :(.W),(.L)
--------------------
Cette instructon se lit: 'ADD Adress'
Elle complète ADD car ici l'opérande destination est un registre
d'adresse. ----------- --------
---------
Seuls les tailles .W et .L sont autorisées.
ADDA ajoute l'opérande source au registre d'adresse an.
Les modes d'adressages autorisés pour l'opérande source sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le CCR n'est pas modifié par ADDA
---
Exemple d'utilisation:
----------------------
ADDA.L #2,a0
a0 est incrémenté de 2 unités.
SUB dn,destination :(.B),[.W],(.L)
------------------------
ou
SUB source,dn :(.B),[.W],(.L)
------------------------
Retranche l'opérande source DANS l'opérande destination ( l'opérande
source est donc inchagée et le résultat se trouve dans l'opérande
destination! )
Les 3 tailles d'opération sont acceptées.
Les modes d'adressage autorisés pour l'opérande source si SUB
s'écrit: SUB.x source,dn sont: ------
----------------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Si l'opérande source est un registre d'adresse, la taille .B n'est
pas autorisée,si la taille est .W,il y a EXTension du signe de an.
Les modes d'adressage autorisés pour l'opérande destination si SUB
s'écrit SUB.x dn,destination sont: -----------
---------------------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Tous le Bits du CCR peuvent réagir à l'opération SUB en fonction
du résultat obtenu.
Exemple d'utilisation:
----------------------
SUB.B d0,d1
L'octet de poids faible du registre de donnée d0 est retranché a
l'octet de poids faible de d1,le résultat est dans d1:
d0=d0, d1=d1-d0
SUBI #BBB,destination :(.B),[.W],(.L)
-------------------------
SUBI se lit: 'SUBtract Immediate'
Les 3 tailles d'opération sont autorisées.
La donnée immédiate source est retranchée à l'opérande destination.
--------- ------
Les modes d'adressage qui sont autorisés pour l'opérande
destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Les 5 codes du CCR sont affectés par SUBI
---
Exemple d'utilisation:
----------------------
SUBI.W #12,(a0)
On retranche le mot 12 au mot pointé par le registre d'adresse a0.
SUBQ #BBB,destination :(.B),[.L],(.L)
-------------------------
La donnée immédiate non signée #BBB est retranchée DANS l'opérande
destination.
Il faut obligatoirement que 1<= #BBB <=8
L'opérande destination admet les modes d'adressage:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Si l'opérande destination est un registre d'adresse an,la taille
.B est interdite,si on utilise la taille .W il y aurra EXTension
du signe de an sur un L-M.
Les 5 Bits du CCR sont modifiés par SUBQ en fonction du résultat.
---
Exemple d'utilisation:
----------------------
SUBQ.W #3,d0
Retranche le mot 3 au mot de poids faible de d0.
Remarque:SUBQ est plus rapide que SUBI, ceci explique le nom
-------- de l'instruction:SUBtarct Quick
Attention tout de même à ce que 1<= #BBB <=8
SUBA source,an :(.W),(.L)
--------------------
Cette instructon se lit: 'SUBtract Adress'
Elle complète SUB car ici l'opérande destination est un registre
d'adresse. ----------- --------
---------
Seuls les tailles .W et .L sont autorisées.
SUBA ajoute l'opérande source au registre d'adresse an.
Les modes d'adressages autorisés pour l'opérande source sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le CCR n'est pas modifié par SUBA
---
Exemple d'utilisation:
----------------------
SUBA.L #2,a0
a0 est décrémenté de 2 unités (comme avec .W, -(a0) ).
MULS source,dn
-----------------
Permet une MULtiplication Signée de l'opérande source DANS le
registre de donnée dn.
L'entier relatif 'source' est étendu sur 16 bits et il est multi-
plié par le MOT de poids faible de dn. -------
---
Le résultat est dans dn et c'est un L-M, entier relatif SIGNE.
--- ------
L'opérande source admet les modes d'adressage:
------
dn
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Les bits V et C du CCR sont mis à 0,les bits N,Z sont positionnés
suivant le résultat, X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE.W #3,D0
MULS #-5,D0
D0 contiendra le L-M égal à 3*(-5)=-15
MULU source,dn
-----------------
Permet une MULtiplication non signée (Unsigned) de l'opérande source
DANS le registre de donnée dn.
L'entier relatif 'source' est étendu sur 16 bits et il est multi-
plié par le MOT de poids faible de dn. -------
---
Le résultat est dans dn et c'est un L-M,entier relatif NON SIGNE.
--- ----------
L'opérande source admet les modes d'adressage:
------
dn
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Les bits V et C du CCR sont mis à 0,les bits N,Z sont positionnés
suivant le résultat, X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE.W #4,d2
MULU #3,d2
D2 contiendra le L-M égal à 4*3=12
DIVS source,dn
-----------------
Permet une Division Signée du registre de donnée dn par l'entier
relatif étendu sur 1 mot 'source'.
L'entier relatif 'source' est étendu sur 16 bits et c'est le diviseur
du registre de donnée dn. -------
Le résultat est dans dn et c'est un L-M, entier relatif SIGNE tel que:
--- -----
Le quotient occupe le mot de poids faible de dn.
--------
Le reste (si il y en a) a le signe du dividende et occupe le mot de
-----
poids fort de dn.
L'opérande source admet les modes d'adressage:
------
dn
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le bit C du CCR est mis à 0,les bits N,Z,V sont positionnés suivant
le résultat, le bit X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE.W #4,D2
MOVE.W #12,D0
DIVS D2,D0
MOVE.L D0,RES
BSS
RES DS.W 1
QUO DS.W 1
Le mot pointé par QUO contient 3 et le mot pointé par RES contient
0 car il n'y a pas de reste.
NB:.Pour atteindre facilement les 2 mots (reste/quotient) du registre
-- de donnée destination, on peut par exemple utiliser l'instruction
'SWAP dn' vue précédement.
.Si on pratique une division par 0, ceci entraine une procédure
d'exception et interromps l'execution du programme !
(J'expliquerai plus tard ce que sont les procédures d'exception.)
DIVU source,dn
-----------------
Permet une Division NON SIGNEE du registre de donnée dn par l'entier
relatif étendu sur 1 mot 'source'.
L'entier relatif 'source' est étendu sur 16 bits et c'est le diviseur
du registre de donnée dn. -------
Le résultat est dans dn et c'est un L-M, entier relatif NON SIGNE
tel que: --- ---------
Le quotient occupe le mot de poids faible de dn.
--------
Le reste (si il y en a) occupe le mot de poids fort de dn.
-----
L'opérande source admet les modes d'adressage:
------
dn
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Le bit C du CCR est mis à 0,les bits N,Z,V sont positionnés suivant
le résultat, le bit X n'est pas affecté.
NB:.Il faut bien veiller à ce que les données ('source' et 'dn') sont
-- positives et à ce que l'opérande source soit différente de 0 !
.Les Instructions qui oppèrent sur des donnnées non signées sont
plus rapides que leurs instructions complémentaires qui opèrent
sur des données signées (MULS/MULU, DIVS/DIVU) , c'est là leur
unique intérèt.
Les instructions MULS et DIVS peuvent bien entendu aussi oppèrer
sur des instructions positives.
CLR destination (.B),[.W],(.L)
--------------------
L'instruction CLR permet d'éteindre tous les BITS de l'opérande
destination (CLeaR).
Les 3 tailles d'opérantion sont possibles.
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Le bit Z du CCR est mis à 1, les bits N,V,C à 0 , le bit X n'est pas
affecté. ---
Exemple d'utilisation:
----------------------
MOVE.W #%1111011101110110,d0
CLR.B d0
L'octet de poids faible de d0 est mis à 0, d0 contiendra donc le mot:
%1111011100000000 .
NB: .L'instruction CLR.x est logiquement équivalente à l'instruction
--- 'MOVEQ.x #0,destination' mais est curieusement moins rapide !
AND source,dn (.B),[.W],(.L)
--------------
ou
AND dn,destination (.B),[.W],(.L)
-------------------
Permet d'effectuer un AND (et) logique entre ses deux opérandes.
C.à.d qu'on ajoute les 2 opérandes codées en Binaire en se fixant
une règle selon laquelle:
1+1 donne 1
1+0 donne 0
0+0 donne 0
0+1 donne 0
Et cela pour chacun des bits des 2 opérandes de l'instruction.
Exemple: MOVE.B #%11101011,d0; %11101011
------- MOVE.B #%10101000,d1; %10101000
AND.B d0,d1 ; ||||||||
||||||||
''''''''
on obtient l'octet: %10101000
Pour la première syntaxe possible de AND, les modes d'adressage
possibles pour l'opérande 'source' sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Pour la seconde forme de AND,les modes d'adressage autorisés pour
l'opérande 'destination' sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Seuls les bits N et Z du CCR sont affectés par cette instruction.
---
OR source,dn (.B),[.W],(.L)
--------------
ou
OR dn,destination (.B),[.W],(.L)
-------------------
Permet d'effectuer un OR (ou) logique entre ses deux opérandes.
C.à.d qu'on ajoute les 2 opérandes codées en Binaire en se fixant
une règle selon laquelle:
1+1 donne 1
1+0 donne 1
0+1 donne 1
0+0 donne 0
Et cela pour chacun des bits des 2 opérandes de l'instruction.
Exemple: MOVE.B #%11101011,d0; %11101011
------- MOVE.B #%10101000,d1; %10101000
OR.B d0,d1 ; ||||||||
||||||||
''''''''
on obtient l'octet: %11101011
Pour la première syntaxe possible de OR, les modes d'adressage
possibles pour l'opérande 'source' sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Pour la seconde forme de OR,les modes d'adressage autorisés pour
l'opérande 'destination' sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Seuls les bits N et Z du CCR sont affectés par cette instruction.
---
EOR dn,destination (.B),[.W],(.L)
-------------------
Permet d'effectuer un EOR (ou exclusif) logique entre ses deux
opérandes.
C.à.d qu'on ajoute les 2 opérandes codées en Binaire en se fixant
une règle selon laquelle:
1+1 donne 0
0+0 donne 0
0+1 donne 1
1+0 donne 1
Et cela pour chacun des bits des 2 opérandes de l'instruction.
Exemple: MOVE.B #%11101011,d0; %11101011
------- MOVE.B #%10101000,d1; %10101000
EOR.B d0,d1 ; ||||||||
||||||||
''''''''
on obtient l'octet: %01000011
Les modes d'adressage autorisés pour l'opérande 'destination' sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Seuls les bits N et Z du CCR sont affectés par cette instruction.
---
NOT dn,destination (.B),[.W],(.L)
-------------------
Permet d'effectuer un NOT (négation) logique.
NOT calcule le complément à 1 d'un nombre. (NEG le complément à 2)
Les modes d'adressage possibles pour l'opérande 'source' sont:
------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Seuls les bits N et Z du CCR sont affectés par cette instruction.
---
Les instructions AND,OR,EOR sont complètées par les 3 instructions
logiques immédiates:
ANDI #BBB,destination (.B),[.W],(.L)
------------------------
ORI #BBB,destination (.B),[.W],(.L)
------------------------
EORI #BBB,destination (.B),[.W],(.L)
---------------------------------------
.Ces instructions ont un r“le commun à leurs instructions
complémentaires mais elles admettent une donnée immédiate
comme opérande source. ----------------
------
L'opérandes destination admet les modes d'adressage:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Seuls les bits N et Z du CCR sont affectés par ces 3 instructions.
---
NB: L'opérande destination peut aussi être: 'SR' ou 'CCR'.
-- Mais dans le cas o— l'opérande destination est CCR, l'exectution
de ces instruction nécessitent qu'on soit en MODE SUPERVISEUR !
----------------
Exemple: ANDI.B #%11111011,sr
-------
met à 0 le bit Z du SR sans changer les autres bits du SR.
Je répète: ATTENTION!
Le CCR ne peut ètre atteint qu'en MODE SUPERVISEUR , sinon ceci
provoquerait l'execution d'une procédure d'exception et l'arrêt
du programme.
Avec les modes d'adressage SR ou CCR ,les instructions ANDI,
ORI,EORI sont donc des instructions qui nécessitent que l'on
soit un mode superviseur si l'on modifie le CCR ,c'est l'unique
manière d'atteindre le CCR.
Ce sont donc des INSTRUCTIONS PRIVILEGIEES dans ce cas.
Le SR est par contre aussi disponible en mode utilisateur.
MOVE sr,destination
-----------------------
Sauve le registre d'état SR à l'adresse destination.
Le contenu du CCR n'est pase affecté par l'instruction.
---
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Exemple d'utilisation:
----------------------
MOVE sr,dest
BSS
dest DS.W 1
le mot pointé par 'dest' contiendra le SR.
MOVE source,sr
------------------
Restaure le CCR contenu dans (à) l'opérande source.
Le CCR est chargé avec sa nouvelle valeur, le SR n'est pas affecté.
--- --
Les modes d'adressage autorisés pour l'opérande source sont:
------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Exemple d'utilisation:
----------------------
MOVE sr,dest ;sauve le SR avec Z=0
CLR d0 ;ici le bit Z du CCR est mis à 1 (CLeaR)
MOVE aaa,ccr ;on recharge le CCR de 'aaa': Z=0
BSS
dest DS.B 1 ;SR
aaa DS.B 1 ;CCR
le CCR est chargé avec le mot pointé par 'aaa'.
TST destination (.B),[.W],(.L)
--------------------
TeST compare l'opérande destination à 0 et modifie les bits du
CCR en conséquence.
---
Les 3 tailles d'opération sont possibles.
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Les bits N,Z du CCR sont affectés en fonction du résultat de la
comparaison ,Les bits V et C sont mis à 0 ,X n'est pas affecté.
Exemple d'utilisation:
----------------------
MOVE.W #5,d0 ;d0=5
TST.W d0 ;le bit Z du CCR est mis à 0 car d0=5
SUB #5,d0 ;d0=5-5=0
TST.W d0 ;le bit Z du CCR est mis à 1 car d0=0
CMP source,destination (.B),[.W],(.L)
---------------------------
CoMPare l'opérande destination à l'opérande source en effectuant la
soustraction 'destination' - 'source' et modifie les bits du CCR en
conséquence. ---
Les 3 tailles d'opération sont possibles.
Les modes d'adressage autorisés pour l'opérande source sont:
------
dn
an (taille .B interdite)
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Les bits N,Z,V,C du CCR sont affectés en fonction du résultat de
la comparaison ,Le bit X n'est pas affecté.
Exemple d'utlisation:
---------------------
MOVE.B #2,d0
MOVE.B #98,d1
CMP.B d0,d1
L'instruction CMP sera utilisée avec les instructions du type B**
et DB** que nous étudierons plus loin.
CMPI #BBB,destination (.B),[.W],(.L)
--------------------------
CoMPare l'opérande destination à l'opérande source immédiate en
effectuant la soustraction 'destination' - 'source' et modifie
les bits du CCR en conséquence.
---
Les 3 tailles d'opération sont possibles.
Les modes d'adressage autorisés pour l'opérande destination sont:
-----------
dn
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Les bits N,Z,V,C du CCR sont affectés en fonction du résultat de
la comparaison ,Le bit X n'est pas affecté.
Exemple d'utilisation:
----------------------
CMPI.L #3,d3
Compare le contenu du registre de donnée d3 à 3.
CMPA source,an [.W],(.L)
-------------------
CoMPare le registre d'adresse 'an' à l'opérande source en effectuant
la soustraction 'an' - 'source' et modifie les bits du CCR en con-
séquence. ---
Seules les tailles d'opération .W et .L sont possibles.
Les modes d'adressage autorisés pour l'opérande source sont:
------
dn
an
BBBB
BB
#BBB
(an)
(an)+
-(an)
d(an)
d(an,rn)
d(pc)
d(pc,rn)
Les bits N,Z,V,C du CCR sont affectés en fonction du résultat de
la comparaison ,Le bit X n'est pas affecté.
Exemple d'utilisation:
----------------------
CMPA.L a2,a3
Compare le contenu du registre d'adresse a3 au contenu du regitre
d'adresse a2.
CMPM (an)+,(am)+ (.B),[.W],(.L)
----------------------
CoMPare l'opérande destination à l'opérande source en effectuant
la soustraction 'destination' - 'source' et modifie les bits du
CCR en conséquence.
Les 3 tailles d'opération sont possibles.
Le mode d'adressage autorisé pour l'opérande destination et pour
l'opérande destination est le mode POSTINCREMENTE.
--------------
Les bits N,Z,V,C du CCR sont affectés en fonction du résultat de
la comparaison ,Le bit X n'est pas affecté.
Exemple d'utilisation:
----------------------
LEA TAB,a1 ;pose l'adresse de 'TAB' dans a1
LEA BAT,a2 ;et l'adresse de 'BAT' dans a2
MOVE #5,d3
BBB CMPM.B (a1)+,(a2)+ ;CMPM l'octet pointé par a1 à l'octet pointé
;par a2 et incrémente d'une unité les 2
;registres d'adresses.
DBF d3,BBB ;boucle 6 fois
DATA ;table des données (octets)
TAB DC.B 1,2,3,4,5,6
BAT DC.B 6,5,4,3,2,1
B** label (Branch & Condition Code)
-------------
L'instruction admet différents Codes Condition (**) qui peuvent
changer l'action de B**.
B** oppère un saut à l'adresse pointée par le 'label' si le
code condition demandé est justifié après une CoMParaison ,
sinon le programme continue normalement.
Les ** sont:
B** Si A et B sont SIGNES | Sinon, syntaxe:
---------------------------------------------+----------------
Bgt si A>B (Greater Than) | Bbi (Higher)
Beq si A=B (EQual) | Beq (EQual)
Blt si A<B (Less Than) | Bcs (inférieur)
Bne si A est différent de B (Not Equal) | Bne (Not Equal)
Bge si A >= B (Greater or Equal) | Bcc (sup. ou égal)
Ble si A <= B (Less or Equal) | Bls (inf. ou égal)
L'instruction B** teste en fait les bits du CCR:
Beq test si le bit Z du CCR est à 1 (CPM soustrait les opérandes
pour les tester)
On retrouve aussi les Codes de condition qui ne tiennent que compte
de certains bits du CCR et non pas du résultat d'une comparaison :
Bmi si le bit N du CCR est à 1
(Donc Négatif)
Bpl si le bit N du CCR est nul OU si le bit Z du CCR est à 1
(Donc Positif ou nul)
Bvc si le bit V du CCR est nul
(Donc si il n'y a pas débordement)
Bvs si le bit V du CCR est à 1
(Donc si il y a débordement)
Bcc si le bit C du CCR est à 1
Bcs si le bit C du CCR est nul
Exemple d'utilisation:
----------------------
MOVE.W #4,d3 ;d3=4
MOVE.W dat,d0 ;d0=-20
ADD d3,d0 ;d0=-20+4=-16
CMPI #4,d0 ;Compare -16 à 4
BEQ egal ;Si c'est ègal (Z=1) on saute en 'egal'
BMI negatif ;Si c'est négatif (N=1) on saute en 'negatif'
DATA
dat DC.W -20
Dans notre exemple, le programme sautera en 'negatif', ceci serait
le cas même si il n'y avait pas de 'CMPI #4,d0' car avec Bmi, seul
le bit N du CCR intervient, il n'y a pas besoin de comparaison,
contrairement à Beq.
NB: Le saut au label destination s'effectue par le chargement de
-- la valeur du PC à ce label dans le PC actuel.
DB** dn,label
----------------
Permet d'effectuer une boucle:
Le nombre de passages est contenu dans le registre de donnée dn.
L'adresse a laquelle le saut pour la boucle doit d'effectuer est
un label.
L'instruction admet aussi différents codes condition (**) qui
peuvent opérer un débranchement de la boucle si ils sont
vérifiés.
Les Codes condition possibles sont les mêmes qu'avec l'instruction
B** .
DB** teste d'abord la condition ** ,si celle-ci est vérifiée il y
a débranchement de la boucle et le programme continue à l'instruc-
tion suivante, sinon , le registre dn est décrémenté d'1:
Si dn vaut -1 il y a arrèt de la boucle et le programme continue à
la prochaine instruction.
Si dn est positif ou nul, il s'oppère un saut à l'adresse pointée
par le label.
Le CCR n'est pas modifié par DB**
---
NB:DB** admet aussi les codes condition suivant:
--
.DBf = toujours faux, il n'y a pas de comparaison ou de test
.DBt = toujours vrai, idem
Exemple d'utilisation:
----------------------
LEA dat,a0 ;adresse de 'dat' dans a0
MOVE #7,d1 ;7 dans d1
boo MOVE.W (a0)+,d2 ;pose le MOT pointé par a0 dans le MOT de poids
;faible de d2 en mode postincrémenté
DBMI d1,boo ;teste si N=1 (mi), décrémente d1 et saute en
;'boo' si d1 est positif ou nul.
MOVE.W d2,res ;pose le MOT de poids faible de d2 en 'res'
DATA
dat DC.W 1,5,486,0,-2,0,4,8,100,20,5 ;11 mots
BSS
res DS.W 1 ;réserve 1 mot en 'res'
END
La condition MI (N=1) a été vérifiée au bout de 5 passages en 'boo',
il y a eu débranchement de la boucle avant l'execution des 8 pass-
ages prévus car on a posé le MOT -2 dans d2: Ceci avait pour effet
de mettre le bit N du CCR à 1 et par là mème de sortir de la boucle
car la condition MI a été vérifiée.
A la fin du programme: d2=-2, a0 pointe le mot égal à 0, d1=3
et 'res' pointe sur le mot égal à -2
S** Destination
------------------
L'instruction S** admet elle aussi les différents Codes condition.
Elle teste si la condition ** est vérifiée.
Si elle s'avère vraie, l'OCTET qui se trouve à l'adresse pointée
par l'opérande destination est mis à -1 (soit $FF ou %11111111)
Si elle s'avère fausse, l'OCTET est mis à 0 ($00 ou %00000000)
Il faudra bien entendu réservé cet Octet ! (avec DS.B 1 par exp)
Les modes d'adressage possibles pour l'opérande destination sont:
-----------
dn
an
BBBB
BB
(an)
(an)+
-(an)
d(an)
d(an,rn)
Le CCR n'est pas affecté par S**
---
Exemple d'utilisation:
----------------------
MOVE #3,d0 ;mot 3 dans d0
MOVE #3,d1 ;mot 3 dans d1
CMP.W d0,d1 ;compare les mots de poids faible de d1 et d0
SEQ res ;Si c'est Egal:met L'octet de 'res' à -1 sinon
;met le à 0 (ici d1=d0 on le met donc à -1)
TST.B res ;Compare loctet de 'res' à 0 (0=faux pour S**)
BEQ fin ;si il est égal à 0:va en 'fin'
BNE egal ;sinon (Not Equal) va en 'egal'
BSS
res DS.W 1 ;l'octet pour S**
END
Dans notre exemple: Le programme va sauter en 'egal'.
------------------------
PIECHOCKI Laurent
8,impasse Bellevue Suite dans :INSTRUC2.DOC
57980 TENTELING ------------------------
Back to ASM_Tutorial