1

_____________ __ \/ \/ \ ___________ / \ / \ / \ / \ / / / / \ \ / \ / /__\ / / \ / \ \/ / \ \/ / _____________\ \ \ \/ / \ \ / /\ \ / / \ _____________\ \ /\ / \ \ / \ / / \ \ __ \ \/__\/ / __ \ \ \ / / / \ \ \/ \ /\ \ / /\ / \ / / \ \ / / / / / / \ / \ /___\ / \ /___\ / /________\ / /__\ /__\ /\ /____________\

L'assembleur dbutant ~~~~~~~~~ Cours n2 ~~~~~~~~~

Les Instructions
~~~~~~~~~~~~~~~~ Si vous dsirez ds a prsent charger Asm-one, ce qui est une :excellente initiative, faites comme suit ( .ALLOCATE Chip/Fast/.....>C ( 'C' comme Chip (.WORKSPACE > 50 ( '50' Kb pour stocker la source ... Et on y va

I.1 Instructions : MOVE , ADD , SUB

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :On commence tout de suite par un exemple ------------------------------------Programme 1----------------------; :Start .Move #24,D0 ; Met la valeur 24 dans D0 .Add #10,D0 ; Ajoute 10 D0 .Sub #4,D0 ; Retranche 4 D0 'Move D0,result ; Met la valeur de D0 l'adresse 'Result Clr D0 ; Efface D0 Rts ; Fin du programme :Result .Dc.w $0000 ; Reserve un mot ---------------------------------------------------------------------; ( !! avant les instructions, il faut mettre une tabulation) Pour saisir le programme, appuyez sur 'esc' et vous rentrerez sous l'diteur. Tapez le programme en respectant bien les tabulations avant les instructions. Les ';' indiquent le dbut d'un commentaire. (alors ne les recopiez pas!). Lorsque vous avez termin de taper le programme, appuyez de nouveau sur 'esc' pour sortir de l'diteur. Un vous indique qu'Asm-one attend une commande. Tapez 'a' (puis '<' 'return' bien sr) pour assembler la source. Si le message 'no errors' apparat alors tout va bien pour vous, vous pouvez aller directement .au paragraphe suivant. Sinon, il va falloir debugger...et oui dj Votre programme comporte des erreurs, il vous faut regarder nouveau la source. (vrifiez les tabulations en dbut de ligne, faites attention d'crire D0 et pas DO, vrifiez la syntaxe). Les .commentaires de ce programme expliquent clairement ce qu'il fait : Voici quelques complments

Mansouri Med El-Amine

D0 est un registre interne du processeur. Il en existe huit du mme * type ( D0 D1 D2 D3 D4 D5 D6 D7 ). Cette case n'a pas d'adresse et .lorsque on veut l'utiliser on utilise le nom D0 tout simplement L'instruction 'Move' est ma plus simple des instructions. C'est une * affectation. Le '#' signifie que l'on met une valeur directement dans .la destination. La destination est ici la case D0 Syntaxe : Move #Valeure,Registre .(!)L'instruction 'Add' sert ajouter * Syntaxe : Add #Valeur,Registre .'Il en est de mme pour l'instruction 'Sub Syntaxe : Sub #Valeur,Registre Donc ce stade :instructions Move Add Sub #24,D0 #10,D0 #4,D0 du ; 1 ; 2 ; 3 2, on ajoute 10 D0 (D0=34) 3,on ,1 programme, si on suit les trois premires

on met 24 dans D0 (D0=24)... ...(enlve 4 D0 (D0=30

C'est simple mais on a dj vu trois instructions lmentaires. On : continue Move D0,result'. Voici encore notre instruction Move mais sous une' * : autre forme Syntaxe : Move Registre,Adresse Ici, on oublie le # car il ne s'agit plus d'une valeur directe mais de la valeur contenue dans la case D0. On sait que cette valeur est Donc 30 va tre mis dans la case mmoire qui a pour adresse .30 Result'. 'Result' est ce que l'on appelle un label. Un label est' une tiquette que l'on pose sur une adresse bien prcise. Donc au lieu d'appeler l'adresse $9A096 par exemple, on appellera .'l'adresse 'Result .Clr' signifie 'Clear'. Cela se passe de commentaire' * Syntaxe : Clr Registre Rts' signifie 'ReTurn from Subroutine'. Dans notre cas il montre la' * .fin du programme Syntaxe : Rts .Dc.w' sert assembler des datas directement en mmoire' * ...Syntaxe : Dc.w valeur,valeur,valeur,valeur,valeur..etc Ici 'Dc.w 0' assemble un 0. Donc si on dsassemble la mmoire partir de l'adresse 'Result', on trouvera une case qui avant l'excution est $0000 et aprs excution sera 30 ($001e). On peut visualiser

Mansouri Med El-Amine

3
directement les cases mmoire avec la commande .avant et aprs excution du programme1 'H result'. Essayez

Dc' signifie 'Data Code'. La notation '.w' signifie que les' ?? .'valeurs assembles sont au format 'Word :On distinguera ainsi 3 types de format de donnes 'Byte (Octets) : $00 extension '.b (Valeurs allant de 0 255) 'Word (Mots) : $0000 extension '.w (Valeurs allant de 0 65535) 'Long (Long) : $00000000 extension '.l (!Valeurs allant de 0 bcp) ,Ces extensions s'appliquent sur la majeure partie des instructions : par exemple Move.b Move.w Move.l Add.l Sub.b #$10,d0 #$0666,d0 #$00109700,d0 #$45687987,d2 #$69,d0

(I. Instructions : BSR , BRA , JSR , JMP (Sauts

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ : Tout de suite un petit programme

-----------------------------------Programme 2-----------------------; :Start Bla1 Bsr Efface_Ecran Bla3 Jsr Affiche_Caractere Bra Fin Bla5 Bla5 Fin Rts ----------------; - Sous routines ; ----------------; :Efface_Ecran Bla2 Bla2 Bla2 Rts ----------------; :Affiche_Caractere Bla4 Bla4 Bla4 ; Instructions quelconques ; Saute la sous routine ; Saute a la sous routine

; Fin de la sous routine

Mansouri Med El-Amine

4
Rts --------------------------------------------------------------------; Voici la structure possible d'un programme utilisant des appels de sous routines. Pour comprendre, il faut suivre linairement le droulement du programme depuis le dbut. On commence a 'Start' puis le proc excut les premires instructions 'Bla1' avant de tomber sur 'Bsr Efface_Ecran' Bsr' ou 'Jsr' Cette instruction est gale au 'Gosub' du basic. Le' * programme saute une adresse mmoire pour excuter un morceau de programme mais il garde souvenir de l'endroit d'o il est 'parti. Lorsque dans la sous routine appele, le proc trouve un 'Rts ReTurn From Subroutine) il arrte d'effectuer la sous routine et) revient l'endroit o elle avait t appelle et continue le .programme Syntaxe : Bsr Adresse Syntaxe : Jsr Adresse Bsr' est une instruction code en relatif alors que 'Jsr' est code' en absolu. Du point de vue du programmeur leur fonctionnement est identique. Un 'Bsr' ne pourra pas sauter des sous routines .trop lointaine en mmoire alors qu'un 'Jmp' pourra .Si vous avez bien compris, suivez le .Vous devriez voir les 'Bla' dans l'ordre programme dans l'ordre

.'Bra' C'est un saut sans retour. L'quivalent Basic est 'Goto' * 'Idem pour 'Jmp Syntaxe : Bra Adresse Syntaxe : Jmp Adresse .Donc dans notre exemple les instructions 'Bla5' ne sont pas executes

(I Instructions : DBRA (Utile pour les boucles

~~~~~~~~~~~~~~~~~~~~~ : Essayez le programme suivant -----------------------------------Programme 3----------------------; :Start Clr.l d1 Clr.l d2 Move.w Boucle: Add.w Add.w Dbra #100,d0 #1,d1 #2,d2 d0,Boucle ; Debut de la boucle ; Fin de la boucle

Rts ; Fin du programme --------------------------------------------------------------------; 'Dbra' * Syntaxe : DBra Registre,Adresse Cette instruction utilise un registre (ici D0) qu'elle dcrmente

Mansouri Med El-Amine

5
chaque tour de boucle et tant que ce registre ,n'est pas gal -1, il saute une adresse. On peut remarquer ici en excutant le programme que le rsultat dans d1 est $65 (=101). Donc attention, cette .instruction ralise un tour de boucle supplmentaire Le programme,pour ceux qui auraient l'esprit ailleurs,ralise 101 fois l'opration d1=d1+1 et d2=d2+2. On peut pour bien tre sr de ce qui se passe utiliser le traceur d'Asm-one. Pour cela choisissez la commande 'Debugger' dans le menu 'Assembler'. On peut suivre ainsi sur la droite de l'cran l'volution des registres. Pour excuter une ligne de programme utilisez la flche curseur vers le bas. Ici l'exemple est simple mais pour des algos plus compliqus trs .calculatoires, l'utilisation du 'Debugger' est importante

(I Instructions : AND , OR , EOR , NOT (Operations Logiques

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Le langage machine est intimement li avec la notion de logique. La logique boolenne pour ceux qui n'auraient jamais entendu parler de cette science trange est une faon de rflchir avec des 1 et des ,Donc pour un ordinateur qui ne comprend que les 1 et les 0 .0 .cela semble le meilleur moyen d'effectuer des oprations simples N'oubliez jamais que l'ordinateur compte en binaire. Le dcimal et l'hexadcimal ne sont que des reprsentations, l'intrieur il n'y a que des 0 et des 1 partout. (Ce texte par exemple est constitu de 0 et de 1 uniquement). Voici donc les oprations logiques :lmentaires (NOT : C'est la ngation. Comme on a que deux tats possibles (0 et 1 : le resultat est instinctif ~~~ NOT 0) = 1) NOT 1) = 0) .AND : C'est le 'et' logique ~~~ :Voici sa table de vrit .Premire composante -> | 1 | 0 \ |-------|-| 0 | 0 | 0 .Les 4 cases de ce tableau reprsentent -> |-------|-.le rsultat | 1 | 0 | 1 ----------| .Seconde composante : Ce tableau rsume en fait les 4 possibilits AND AND AND AND 0) 1) 0) 1) = = = = 0 0 0 1 0) 0) 1) 1)

Vous remarquez que la seule faon d'avoir 1 en sortie d'une opration .Et' est d'avoir toutes les entres 1' :EXEMPLE ~~~~~~~~

Mansouri Med El-Amine

6
: Cette opration peut tre faite sur plusieurs bits en mme temps ? = AND 0110011101110000 0010100101010000 Pour effectuer cette opration, il est prfrable de placer les : composantes l'une en dessus de l'autre 0010100101010000 AND 0110011101110000 rsultat-> .0010000101010000 = Il suffit de regarder les colonnes et d'effectuer l'opration And' bit par bit. Lorsque je parlais de reprsentation, ici nous' avons un trs bon exemple. Si vous dsassemblez la mmoire, vous ne verrez jamais les nombres reprsents en binaire comme ci-dessus. En (effet cette reprsentation est trop encombrante. (Voir Cours n1 Vous verriez : $2950 AND $6770 = $2150 .Ce qui est strictement la mme chose mais plus pratique manipuler EXEMPLE ~~~~~~~ La commande assembleur correspondante est AND. (Eh logique non ?) Elle ne peut se faire que sur les registres de donnes (d0 d1 d2 d3 d4 d5 (d6 d7 Syntaxe : AND #Valeur,Dx Syntaxe : AND Dx,Dx ------------------------------------Programme 4----------------------; :Start Move.l #$2950,D0 And.l #$6770,D0 Rts ; Fin du programme ---------------------------------------------------------------------; ou ------------------------------------Programme 5----------------------; :Start Move.l #%0010100101010000,D0 And.l #%0110011101110000,D0 Rts ; Fin du programme ---------------------------------------------------------------------; On trouve aprs excution de ce programme le rsultat dans d0. Pour bien tre sr du rsultat vous pouvez taper comme commande sous .Asm-One : '? $2150'. On retrouve bien ce que nous avions en binaire EXEMPLE ~~~~~~~ ? Mais concrtement, quoi a sert ce truc L'utilisation la plus courante (pour moi en tout cas) est la cration de masques. Par exemple on a le nombre binaire : 11011 et je ne veux pas m'occuper des deux derniers bits, c'est dire que je veux garder que les trois premiers. Donc je vais crer un masque qui filtre uniquement les trois premiers bits. Eh bien le masque peut tre fait .'facilement avec l'instruction 'And Donc si je fais 11011 AND 11100 = 11000

Mansouri Med El-Amine

7
(Valeur) (Masque) (Rsultat)

.J'ai bien les trois premiers bits et j'ais vir les deux derniers ------------------------------------Programme 6----------------------; :Start Move.l #$fedf1234,d0 And.l #$0000ffff,d0 Rts ; Fin du programme ---------------------------------------------------------------------; Dans ce petit exemple, je ne veux garder que les 16 premiers bits .de d0. Donc le Rsultat sera $00001234 .OR : C'est le 'ou' logique ~~ :Voici sa table de vrit | 1 | 0 \ |-------|-| 1 | 0 | 0 |-------|-| 1 | 1 | 1 ----------.Si vous avez bien compris le 'AND', et bien c'est pareil Ici, pour avoir un 1 en sortie, il faut au moins un 1 dans une .des sources .Le 'Or' est utilis pour forcer 1 une srie de bits Syntaxe : Or #Valeure,Dx Syntaxe : Or Dx,Dx ------------------------------------Programme 7----------------------; :Start Move.l #$abcd1234,d0 And.l #$0000ffff,d0 Rts ; Fin du programme --------------------------------------------------------------------; Le Rsultat sera $abcdffff. Les 16 derniers bits ont t forc 1 .EOR : C'est le 'ou exclusif' logique ~~~ :Voici sa table de vrit | 1 | 0 \ |-------|-| 1 | 0 | 0 |-------|-| 0 | 1 | 1 ----------Ici, pour avoir un 1 en sortie, il faut avoir un seul dans les .deux sources Syntaxe : Eor #Valeur,Dx Syntaxe : Eor Dx,Dx .J'utilise cette instruction pour calculer des complments

Mansouri Med El-Amine

8
------------------------------------Programme 8----------------------; Start: ; On veut calculer le complment de 10 63...(C'est 53 bien (!sur Move.w #10,d0

Methode normale ; Move.w Sub.w #63,d1 d0,d1 ; D1 = 54

Avec le Eor ; Eor #63,d0 Voila ; Rts ; Fin du programme ---------------------------------------------------------------------; Cette mthode ne marche qu'avec des complments de multiples de 2 ...Cherchez pourquoi !(1-) ; Meme chose en une instruction

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

(I Instructions : CMP BTST TST Bcc (Comparaisons et tests

Cmp' signifie 'CoMPare'. Donc comme son nom l'indique a sert ' * faire des comparaisons. Cette instruction est utilise avec une .instruction de branchement conditionnel Syntaxe Syntaxe Syntaxe Syntaxe : : : : Cmp Cmp Cmp Cmp Registre,Registrex #Valeur,Registre #Valeur,Adresse Adresse,Registre

... Et tout a bien sur en .l, .w ou mme .b : Voici tout de suite un petit exemple concret -------------------------------------Programme 9---------------------; :Start Move.w #10,d0 ; D0 = 10 Cmp.w #10,d0 .Beq .ok Move.b ok Rts #1,Flag ; Fin du programme. ; Compare 10 et d0 ;Si c'est egal alors on saute .ok

Flag: Dc.b 0 ---------------------------------------------------------------------; Cet exemple est vraiment idiot, j'en conviens mais il faut que a .(! rentre d'une manire ou d'une autre (Hein l'ours, t'es d'accord Donc aprs un 'Compare' on utilise un 'Bcc'. (cc veut dire ('condition' 'Cmp.w #10,d0 'Beq .ok -> 'Compare -> 'Branch if Equal

En basic on aurait -> IF D0=10 THEN GOTO .ok 'On peut utiliser aussi 'BNE' -> 'Branch if Not equal

Mansouri Med El-Amine

Il existe toute une liste de 'Bcc' telle que Bpl, bmi, bge, blt... On peut se limiter l'utilisation de 'Bpl' et 'Bmi' pour le 'suprieur '' et 'l'infrieur ------------------------------------Programme 10---------------------; :Start Move.w #10,d0 ; D0 = 10 Cmp.w #40,d0 Bpl .ok Move.b ok Rts #1,Flag ; Fin du programme. ; Compare 40 et d0 ; Si le rsultat est positif alors saut .ok

Flag: Dc.b 0 --------------------------------------------------------------------; Bon ici il faut faire une petite gymnastique spirituelle. Toutes les instructions 68000 sont comme je dirais 'Instinctive' contrairement Intel par exemple. Donc les instructions instinctives c'est de mettre la source gauche et la destination droite. Donc quand on crit 'Move #10,d0', on met 10 vers D0... Mais, car il y a un mais, 'Cmp' est la seule instruction non instinctive. Si on fait un 'CMP A,B', la machine ralisera l'opration B-A. Le rsultat ne sera pas explicite mais la machine gardera en mmoire si ce rsultat est .positif, ngatif ou gal zero Donc ici... D0=10 Cmp.w #40,d0 ; La machine excut 10-40=-30 .Donc le rsultat est ngatif ; 'Bpl .ok ; 'Branch if plus .On saute si c'est positif ; .Donc ici, on saute pas ; Si on a pas saut, on est ici et aprs on passe par .ok bien sur ; ok ; Si on a saut, on est venu ici sans passer par la case. .dpart et sans toucher 20000 ; .Btst' signifie 'Bit TeSt'. On test si un bit est 0' * : Essayez ce programme, il est marrant ------------------------------------Programme 11---------------------; ... ST: Move.b $dff006,$dff180 ; Eh eh Btst #6,$bfe001 ; Test du 6eme bit de l'octet de l'addresse $bfe001 ; .Bne St ; Si il est egal 0 on saute St Rts ---------------------------------------------------------------------; Pour sortir, on appuie sur le bouton gauche de la souris. Le bit 6 de l'octet contenu l'adresse $bfe001 correspond l'tat du bouton .gauche de la souris '...,Tst'. Cette instruction est quivalente un 'Cmp #0' *

(I Instructions : LSL LSR (Dcalages ~~~~~~~~~~~~~~~~~~~~~~~~ LSR et LSL' signifient 'Logic Shift to Right' et 'Logic Shift to' * .Left' Ce sont justes des dcalages de bits vers la droite ou la gauche .Par exemple. On veut dcaler %11010 vers la droite d'un cran

Mansouri Med El-Amine

10
-----------------------------------Programme 12----------------------; :ST Move.b #%00011010,D0 Lsr #1,D0 ; Dcale d'un cran vers la droite Donc D0=00001101 ; Rts ---------------------------------------------------------------------; Voila c'est simple. On peut dcaler de 1 8 crans. Et selon les gots et les dsirs on peut utiliser d'autres instructions comme : 'ROR ROL er ASL ASR' L'avantage de ce genre d'instructions est que l'on peut faire des divisions et des multiplications. C'est beaucoup beaucoup plus rapide de dcaler des bits que de faire un .algorithme de multiplication Pour multiplier, on dcale vers la gauche. Chaque bit correspond une puissance de 2. Donc pour multiplier par 2, on dcale vers la gauche une fois. Si on veut multiplier par 4, on dcale deux fois.. etc etc .Et pareil pour la division avec le dcalage droite .Donc si on dcale n fois, on multiplie ou on divise par 2 puissance n -----------------------------------Programme 13----------------------; :ST Move.w #7,D0 ; D0 = 7 : Ce qu'il faut pas faire ; Mulu.w #4,D0 ; Multiplication par 4 !!! aie aie

: Ce qu'il faut faire ; Lsl.w #2,d0 ; Dcalage de 2 cran sur la gauche (Multiplication par 4 (2 puissance 2 = ; Rts ---------------------------------------------------------------------;

(I Instructions : MOVEQ ADDQ SUBQ (Instructions rapides

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ MoveQ' est le 'Quick Move'. C'est une instruction optimise pour' * faire des 'Move' de petites valeurs. Enf fait a marche juste avec des entiers entre 0 et 7 !!! (C'est a dire cod sur 3 bits) Cette .instruction ne fonctionne qu'avec des registres de donnes (Syntaxe : Moveq #Valeur,Dx (Avec une valeur comprise entre 0 et 7

.AddQ' ben pareil que 'Moveq' sauf que a marche avec tout' * (Syntaxe: Addq #Valeur,Dx (Avec une valeur comprise entre 0 et 7 (Syntaxe: Addq #Valeur,Ax (Avec une valeur comprise entre 0 et 7 (Syntaxe: Addq #Valeur,Adresse (Avec une valeur comprise entre 0 et 7 .SubQ' ben tout pareil que Miguel. No comment' *

(I Instructions : MULU DIVU ( Multiplication et Divisions

Mansouri Med El-Amine

11
~~~~~~~~~~~~~~~~~~~~~~~~~~ .Pas de commentaire sur ces fonctions, elle sont assez explicites .Mulu' est la multiplication non signe. La plus utilise' * Syntaxe : Mulu.l Syntaxe : Mulu.w Syntaxe : Mulu.l Syntaxe : Mulu.l #Valeur,Registre #Valeur,Registre Registre,Registre Registre,Registre

.'La multiplication signe est obtenue avec 'Muls .Divu' est la division non signe' * : 'La division 'longue Syntaxe : Divu.l Syntaxe : Divu.l #Valeur,Registre Registre,Registre

Elle divise un long (32 bits) par un long et le rsultat est sur un .long : 'La division en 'Word Syntaxe : Divu.w Syntaxe : Divu.w #Valeur,Registre Registre,Registre

Le principe est le mme mais ici le rsultat est diffrent. On trouve sur les 16 bits de poids faible la partie entire et sur les 16 bits .de poids fort le reste de la division .'De mme la division signe sera 'Divs ------------------------------------Programme 14---------------------; :ST Clr.l d1 Clr.l d2 Move.l Mulu.l #10,d0 #40,d0 ; D0 = $0000000A ; D0 = $00000190

Divu.w #13,d0 ; D0 = $000A001E Reste~~~~~----Partie Entire ; Pour rcuprer la partie entire, il suffit de lire le registre d0 en mot ; Move.w d0,d1 ; Transfert des 16 bits de poids faible

Pour rcuprer le reste ($000A), il faut dcaler le registre ; 'fois vers la droite (Sauvage!) ou utiliser la commande 'Swap 16 ; .(!Bien mais faut lire le paragraphe d'aprs) ; Swap Move.w d0 d0,d2 ; Transfert les 16 bits de poids faible

Rts ---------------------------------------------------------------------;

Mansouri Med El-Amine

12
Donc voila la multiplication et la division. Il ne faut pas oublier que ces instructions sont des oprations assez compliques donc elle prennent un peu plus de temps en excution que les autres instructions. Alors si vous pouvez viter d'utiliser des multiplications et des divisions dans vos sources et ben faites le. Et je rappelle que pour faire des multiplications et des divisions par .des multiples de 2 IL FAUT utiliser les dcalages

I Instructions : SWAP EXT EXG

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Swap' signifie 'Swap' eheh. Cette instruction permet d'changer les' * .bits de poids faible et les 16 bits de poids fort d'un registre 16 .Cette instruction ne s'utilise que sur les registres de donnes Syntaxe : Swap Dx -----------------------------------Programme 15----------------------; :Start Move.l #$abcd1234,d0 Swap d0 Rts ; Fin du programme ---------------------------------------------------------------------; On aura dans d0: $1234abcd Cette instruction est utile (si si!) par exemple pour le rsultat d'une division. On a vu que le reste de la division est stock sur les .bits de poids fort. Un 'Swap' permet de le rcuprer directement 16 .'Ext' signifie 'Extend' * Elle permet d'tendre le signe d'un nombre 16 bits (ou 8 bits). On peut ainsi utiliser ce nombre comme un nombre 32 bits (ou 16 bits) car son signe est conserv. Cette instruction ne s'utilise que sur les .registres de donnes ( Syntaxe : Ext.w Dx ( Syntaxe : Ext.l Dx ( extension 8 -> 16 ( extension 16 -> 32

Exemple: le nombre $f000 en 16 bits sign est gal -4096 Si on veut l'utiliser en 32 bits sans tendre son signe on aura $0000f000 qui est gal 61440...aie Donc on tend le signe de $f000 et on obtient $fffff000 qui est lui .bien quivalent -4096 L'opration d'extension de signe consiste simplement recopier le bit de poid fort (c'est le signe!) Sur les 16 bits que l'on ajoute .devant Exg' Signifie 'Exchange'. Cette .contenu de deux registres Syntaxe : Exg Registre,Registre instruction permet d'changer le' *

( 'I Instructions :MOVE (Ax,Dx),Dest

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .'Voici quelques utilisations tendues du 'Move

MOVE (Ax)+,dest ( Autres 'Moves

Mansouri Med El-Amine

13

Lorsqu'on fait 'Move (ax),d0', on met dans D0 le contenu de la case .mmoire dont l'adresse est contenue dans a0 : Voici un exemple -----------------------.... Admettons qu'a partir de $20000 on ait: $14 $18 $21 $52 $36 -----------------------,c'est a dire .... dans la case $20000 il y a $14 ) ,dans la case $20001 il y a $18 ( ...dans la case $20002 il y a $21

------------------------------------Programme 16---------------------; :Start Move.l #$20000,A0 ; Dans a0 on met $20000 ; Mais ici, on remplace cette adresse par une autre ; ...car c'est trs sale d'utiliser des adresses absolues ; Move.l #Datas,A0 ; Voila c'est mieux ----------------------; Move.b (A0),D0 C'est a dire $14 ; Move.w Move.l (A0),D1 (A0),D2 ; D0 reoit le contenu de la case $20000 ; D1 reoit $1418 ; D2 reoit $14182152

-----------------------; Move.b 2(A0),D3 ; D3 reoit $21

-----------------------; Move.w Move.b #2,D4 (A0,D4.w),D5 ; D4 reoit $21 galement

-----------------------; Move.b Move.b Rts (A0)+,D6 (A0)+,D7 ; D6 reoit $14 et on ajoute "1" A0 ; D7 reoit $18 et on ajoute "1" A0

; Fin du programme

Datas: Dc.b $14,$18,$21,$52,$36 ---------------------------------------------------------------------; Move nb(Ax)' c'est la mme instruction .peut se servir d'un index Syntaxe : Move nb(Ax),Dx Syntaxe : Move nb(Ax),Adresse Move (Ax,Dx)' c'est un 'Move' avec un index mais contrairement ' * l'instruction d'avant o l'index tait fixe,ici l'index est le contenu .d'un registre donc on peut le faire varier au cours du programme Syntaxe : Move (Ax,Dx.w),Dx que prcdemment mais on' *

Mansouri Med El-Amine

14
Syntaxe : Move (Ax,Dx.w),Adresse : On peut aussi ajouter une multiplication du registre d'offset Syntaxe : Move (Ax,Dx.w*2),Dx Move (Ax)+' est un 'Move' avec une incrmentation automatique du' * registre Ax. Cette incrmentation est fonction de la taille de .l'lment que l'on dplace Par exemple, si on fait 'Move.b (a0)+,d0', on copie dans d0 un octet donc a0 sera incrmete de "1" pour pointe sur l'octet suivant. Avec un Move.w (a0)+,d0', on dplace un mot (= 2 octets) donc a0 sera' incrmenter de "2". Et logiquement pour un 'Move.l (a0)+,d0' a0 sera .(incrmenter de "4" (1 long= 2 mots= 4 octets Syntaxe : Syntaxe : +(Syntaxe +(Syntaxe Move (Ax)+,Dx Move (Ax)+,Adresse : Move (Ax)+,(Ax : Move Dx,(Ax

On peut utiliser aussi la dcrmentation. 'Move.w -(a0),d0'. Le "-" se .place devant car la dcrmentation est effectue avant le move -------------------------------------Programme 17--------------------; :Start Clr.l D0 Clr.l D1 Move.l #Datas,A0 ; Voila c'est mieux ; A0 pointe sur le dbut de la table + 2 ; D0 reoit $21 ; A0=A0-1 et D1 reoit $18

Add.l #2,A0 C'est a dire $21 ; Move.b Move.b Rts (A0),d0 -(A0),D1

Datas: Dc.b $14,$18,$21,$52,$36 ---------------------------------------------------------------------;

I Instructions : LEA MOVEM

~~~~~~~~~~~~~~~~~~~~~~~~~~ Lea' signifie 'Load Effective Address'. Cette instruction ne' * .(s'utilise qu'avec les registres d'adresses (a0 a1 a2 a3 a4 a5 a6 a7 Syntaxe : Lea Valeur,Ax Cette instruction sert charger une adresse 'pourrait aussi crire 'Move.l #Valuer,Ax dans un registre. On

Movem' est le 'Move multiple'. Il permet de transfrer plusieurs' * registres en une seule instruction. On l'utilise en gnral pour .sauvegarder tous les registres dans la pile .Movem.m D0-D7/A0-A6,-(a7) .Movem.l (a7)+,D0-D7/A0-A6 ; empile les registres ; depile les registres

Mansouri Med El-Amine

15
Voil c'est pas compliqu, remarquez .l'envers. C'est une coutume juste qu'on utilise la pile

I Instructions : Dc Blk ( Assemblage direct de donnes et (rservation de zones mmoires

.Dc' est utilis pour coder directement des donnes en mmoire' * :Voici un exemple -------------------------------------Programme 18--------------------; :Start Rien ; Rts Data1: Even Data2: Dc.w Data3: Dc.w $0000,$0001,$0002,$1545,$7879 Dc.b $14,$18,$21,$52,$36,'q','b',%00000111,12,10

$10+14,45-80,$FFFF>>2 Dc.l $00201451,$01568754,$45687321,$44654654

---------------------------------------------------------------------; .C'est simple... l'adresse 'Data1' on a assembl des octets l'adresse 'Data2' on a assemble des mots. Un mot ne peu pas tre sur une adresse impaire. Par exemple 'Move.w #1,$20001' ne marche .pas Donc pour cette raison, on ajoute une instruction 'Even' qui recale .l'adresse 'Datas2' sur une adresse paire Vous avez dans ce petit programme quelques .qu'accepte Asm-one. le '>>' signifie dcalage exemples de syntaxes

.Blk' est l'instruction qui permet de rserver une zone mmoire' * Par exemple si vous voulez rserver 10 octets pour travailler vous pouvez taper : Dc.b 0,0,0,0,0,0,0,0,0,0 ou Blk.b 10. La deuxime solution tant la bonne bien sr. Vous pouvez remplir ces donnes rserves par un motif... Par exemple 'Blk.b 10000,$ff' rservera octets et ils seront tous initialiss $ff au depart. On peut 10000 .'aussi faire des 'Blk.w' ou des 'Blk.l

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Mansouri Med El-Amine

16

Mansouri Med El-Amine