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 CONSERVÉ 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 ot .L 3/ot 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: -- [...] ----->|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 RÉSUMÉ: ---------- MOVEP.L dn,d(an): Si d(an) pointe une adresse PAIRE. ----- ----- OCTETS MÉMOIRE ------ ------- 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 MÉMOIRE ------ ------- 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 #€<F8Ü‹%Ê£ÇgB rÛ€êonc 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 ------------