Pl INSTRUC2.DOC/fr

Languages:

English  • français

       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