Pl INSTRUC2.DOC/fr: Difference between revisions

From Atari Wiki
Jump to navigation Jump to search
m (Added category)
No edit summary
Line 1,557: Line 1,557:
 
</pre>
 
</pre>
 
Back to [[ASM_Tutorial]]
 
Back to [[ASM_Tutorial]]
[[Category:Programming]]
+
[[Category: ASSEMBLEUR 68000 sur ATARI ST Part 1 ]]

Revision as of 15:12, 12 October 2011


       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