Informacje dodatkowe     Opis instrukcji procesora MC68000

 1. ABCD (.b)21. BLT.s,l41. DBGE (.l)61. LEA (.l) 81. ROL.b,w,l101. SPL (.b)
 2. ADD.b,w,l22. BMI.s,l42. DBGT (.l)62. LINK (.w) 82. ROR.b,w,l102. ST (.b)
 3. ADDA.w,l23. BNE.s,l43. DBHI (.l)63. LSL.b,w,l 83. ROXL.b,w,l 103. STOP
 4. ADDI.b,w,l24. BPL.s,l44. DBLE (.l)64. LSR.b,w,l 84. ROXR.b,w,l104. SUB.b,w,l
 5. ADDQ.b,w,l25. BRA.s,l45. DBLS (.l)65. MOVE.b,w,l  85. RTE105. SUBA.w,l
 6. ADDX.b,w,l26. BSET (.b,l) 46. DBLT (.l)66. MOVEA.w,l 86. RTR106. SUBI.b,w,l 
 7. AND.b,w,l27. BSR.s,l47. DBMI (.l)67. MOVEM.w,l 87. RTS107. SUBQ.b,w,l
 8. ANDI.b,w,l28. BTST (.b,l)48. DBNE (.l)68. MOVEP.w,l 88. SBCD (.b)108. SUBX.b,w,l
 9. ASL.b,w,l29. BVC.s,l49. DBPL (.l)69. MOVEQ (.l) 89. SCC (.b)109. SVC (.b)
10. ASR.b,w,l30. BVS.s,l50. DBT (.l)70. MULS (.w) 90. SCS (.b)110. SVS (.b)
11. BCC.s,l31. CHK (.w)51. DBVC (.l)71. MULU (.w) 91. SEQ (.b)111. SWAP (.w)
12. BCHG (.b,l) 32. CLR.b,w,l52. DBVS (.l)72. NBCD (.b) 92. SF (.b)112. TAS (.b)
13. BCLR (.b,l)33. CMP.b,w,l53. DIVS (.w)73. NEG.b,w,l 93. SGE (.b)113. TRAP
14. BCS.s,l34. CMPA.w,l54. DIVU (.w)74. NEGX.b,w,l 94. SGT (.b)114. TRAPV
15. BEQ.s,l35. CMPI.b,w,l55. EOR.b,w,l75. NOP 95. SHI (.b)115. TST.b,w,l
16. BGE.s,l36. CMPM.b,w,l56. EORI.b,w,l 76. NOT.b,w,l 96. SLE (.b)116. UNLK
17. BGT.s,l37. DBCC (.l)57. EXG (.l)77. OR.b,w,l 97. SLS (.b)
18. BHI.s,l38. DBCS (.l)58. EXT.w,l78. ORI.b,w,l 98. SLT (.b)
19. BLE.s,l39. DBEQ (.l)59. JMP79. PEA (.l) 99. SMI (.b)
20. BLS.s,l40. DBF (.l)60. JSR80. RESET100. SNE (.b)117. ILLEGAL
 Rozmiar instrukcji podany w nawiasie jest tylko pomocniczy i nie musi być zapisywany.

Instrukcje skoków bezwarunkowych: BRA.s,l (nr 25) i JMP (nr 59).
Instrukcje rozgałęzień: BSR.s,l (nr 27) i JSR (nr 60).
Instrukcje skoków warunkowych: Bcc (nr 11, 14-24, 29-30) i DBcc (nr 37-52).
Instrukcje RESET (nr 80), RTE (nr 85) i STOP (nr 103) stają się dostępne
tylko wtedy, gdy procesor pracuje w trybie "nadzorcy" (Supervisor mode).

Ponadto wyróżnia się następujące instrukcje:
ANDI to CCR, ANDI to SR, EORI to CCR, EORI to SR, MOVE to CCR,
MOVE to SR, MOVE from SR, MOVE USP, ORI to CCR, ORI to SR.
Instrukcje operujące na rejestrze SR i USP, są dostępne tylko w trybie "nadzorcy". Nie dotyczy
to instrukcji MOVE from SR, która jest dostępna również w trybie "użytkownika" (User mode).

Nie można operować na słowie (.W) lub długim słowie (.L), jeśli argumentem instrukcji jest
nieparzysty adres. Dotyczy to np. takich instrukcji, jak: ADD, ADDQ, CLR, CMP, DIVU,
JMP, MOVE, MULU, NOT, SUB, SUBQ, TST.

Założenie:   e, f, g, h, x = 0-7
v = 1-8
d, n = 0-9, A-F
Re, Rf = rejestr Dx lub Ax

ADD

ADD.b ARG1,ARG -  dodaje wartość najmłodszego bajtu z ARG1, do najmłodszego bajtu
w ARG. Wynik dodawania znajdzie się w najmłodszym bajcie ARG.

beq.s X - skok do X, jeśli wynik =$00.
bne.s X - skok do X, jeśli wynik >$00.
bpl.s X - skok do X, jeśli najstarszy bit w wyniku jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w wyniku jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli wynik =$00; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli wynik >$00; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest zerem;
                 w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest jedynką;
                 w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnnn01 => ADD.b #$15,Dx => Dx: nnnnnn16
Dx: nnnn0001 => ADD.w #$FFF3,Dx => Dx: nnnnFFF4
Dx: 00000001 => ADD.l #$12345678,Dx => Dx: 12345679

ADD Quick

ADDQ.b #v,ARG -  dodaje wartość #v do najmłodszego bajtu w ARG.
Wynik dodawania znajdzie się w najmłodszym bajcie ARG.

Instrukcje warunkowe takie same, jak za instrukcją ADD.

Przykłady:  Dx: nnnnnn01 => ADDQ.b #5,Dx => Dx: nnnnnn06
Dx: nnnn0001 => ADDQ.w #8,Dx => Dx: nnnn0009
Dx: FFFFFFFF => ADDQ.l #3,Dx => Dx: 00000002

test Bit and CHanGe

BCHG ARG1,ARG2 -  sprawdza bit w ARG2, którego numer znajduje się w ARG1. Następnie
bit ten jest zmieniany na przeciwny. Jeśli ARG2 jest rejestrem Dx, to na
każdym jego bicie można wykonać tą operację, podając jako ARG1 wartość
modulo32 ($nnnnnn00-1F/20-3F/40-5F... - bit najmłodszy-najstarszy).
Natomiast, jeśli ARG2 jest komórką pamięci, to operacja może dotyczyć
tylko jej 8-bitów; jako ARG1, należy podać wartość modulo8 ($nnnnnn00-07
/08-0F/10-17... - bit najmłodszy-najstarszy).

beq.s X - skok do X, jeśli sprawdzany bit był zerem.
bne.s X - skok do X, jeśli sprawdzany bit był jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli sprawdzany bit był zerem; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli sprawdzany bit był jedynką; w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnnnn0 => BCHG #$00,Dx => Dx: nnnnnnn1
Dx: nnnn0nnn => BCHG #$0F,Dx => Dx: nnnn8nnn
Dx: Fnnnnnnn => BCHG #$1F,Dx => Dx: 7nnnnnnn

test Bit and CLeaR

BCLR ARG1,ARG2 -  sprawdza bit w ARG2, którego numer znajduje się w ARG1. Następnie
bit ten jest zerowany. Jeśli ARG2 jest rejestrem Dx, to na każdym jego
bicie można wykonać tą operację, podając jako ARG1 wartość modulo32
($nnnnnn00-1F/20-3F/40-5F... - bit najmłodszy-najstarszy).
Natomiast, jeśli ARG2 jest komórką pamięci, to operacja może dotyczyć
tylko jej 8-bitów; jako ARG1, należy podać wartość modulo8 ($nnnnnn00-07
/08-0F/10-17... - bit najmłodszy-najstarszy).

Instrukcje warunkowe takie same, jak za instrukcją BCHG.

Przykłady:  Dx: nnnnnnnF => BCLR #$00,Dx => Dx: nnnnnnnE
Dx: nnnn8nnn => BCLR #$0F,Dx => Dx: nnnn0nnn
Dx: Annnnnnn => BCLR #$1F,Dx => Dx: 2nnnnnnn

BRAnch always

BRA.s,l X - bezwarunkowy skok do etykiety X, znajdującej się w programie głównym.

test Bit and SET

BSET ARG1,ARG2 -  sprawdza bit w ARG2, którego numer znajduje się w ARG1. Następnie
bit ten jest ustawiany. Jeśli ARG2 jest rejestrem Dx, to na każdym jego
bicie można wykonać tą operację, podając jako ARG1 wartość modulo32
($nnnnnn00-1F/20-3F/40-5F... - bit najmłodszy-najstarszy).
Natomiast, jeśli ARG2 jest komórką pamięci, to operacja może dotyczyć
tylko jej 8-bitów; jako ARG1, należy podać wartość modulo8 ($nnnnnn00-07
/08-0F/10-17... - bit najmłodszy-najstarszy).

Instrukcje warunkowe takie same, jak za instrukcją BCHG.

Przykłady:  Dx: nnnnnnn0 => BSET #$00,Dx => Dx: nnnnnnn1
Dx: nnnn0nnn => BSET #$0F,Dx => Dx: nnnn8nnn
Dx: 2nnnnnnn => BSET #$1F,Dx => Dx: Annnnnnn

Branch to SubRoutine

BSR.s,l X -  rozgałęzienie do etykiety X, znajdującej się w programie głównym.
Powrót z rozgałęzienia następuje po wykonaniu instrukcji RTS.

Bit TeST

BTST ARG1,ARG2 -  sprawdza bit w ARG2, którego numer znajduje się w ARG1. Jeśli ARG2
jest rejestrem Dx, to na każdym jego bicie można wykonać tą operację,
podając jako ARG1 wartość modulo32 ($nnnnnn00-1F/20-3F/40-5F...
- bit najmłodszy-najstarszy). Natomiast, jeśli ARG2 jest komórką pamięci,
to operacja może dotyczyć tylko jej 8-bitów; jako ARG1, należy podać war-
tość modulo8 ($nnnnnn00-07/08-0F/10-17... - bit najmłodszy-najstarszy).

beq.s X - skok do X, jeśli sprawdzany bit jest zerem.
bne.s X - skok do X, jeśli sprawdzany bit jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli sprawdzany bit jest zerem; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli sprawdzany bit jest jedynką; w przeciwnym razie Dx=$nnnnnn00.

CLeaR

CLR.b ARG - zeruje najmłodszy bajt w ARG.

Przykłady:  Dx: nnnnnnnn => CLR.b Dx => Dx: nnnnnn00
Dx: nnnnnnnn => CLR.w Dx => Dx: nnnn0000
Dx: nnnnnnnn => CLR.l Dx => Dx: 00000000

CoMPare

CMP.b ARG1,ARG2 -  porównuje wartość najmłodszych bajtów z ARG1 i ARG2. Jest to realizo-
wane następująco: najmłodszy bajt z ARG2 jest przenoszony do najmło-
dszego bajtu wirtualnego rejestru Vx. Następnie wartość najmłodszego
bajtu z ARG1 jest odejmowana od najmłodszego bajtu w rejestrze Vx.
Wynik odejmowania znajdzie się w najmłodszym bajcie rejestru Vx. Na
podstawie tego wyniku, są ustawiane odpowiednie kody warunkowe (CC).
Wartość ARG2 nie zmienia się.

beq.s X - skok do X, jeśli ARG1=ARG2.
bne.s X - skok do X, jeśli ARG1<>ARG2.
bcs.s X lub blt.s X - skok do X, jeśli ARG1>ARG2.
bls.s X lub ble.s X - skok do X, jeśli ARG1>=ARG2.
bhi.s X lub bgt.s X - skok do X, jeśli ARG1<ARG2.
bcc.s X lub bge.s X - skok do X, jeśli ARG1<=ARG2.
bpl.s X - skok do X, jeśli najstarszy bit w wyniku jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w wyniku jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli ARG1=ARG2; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli ARG1<>ARG2; w przeciwnym razie Dx=$nnnnnn00.
SCS Dx lub SLT Dx - Dx=$nnnnnnFF, jeśli ARG1>ARG2; w przeciwnym razie Dx=$nnnnnn00.
SLS Dx lub SLE Dx - Dx=$nnnnnnFF, jeśli ARG1>=ARG2; w przeciwnym razie Dx=$nnnnnn00.
SHI Dx lub SGT Dx - Dx=$nnnnnnFF, jeśli ARG1<ARG2; w przeciwnym razie Dx=$nnnnnn00.
SCC Dx lub SGE Dx - Dx=$nnnnnnFF, jeśli ARG1<=ARG2; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest zerem;
                 w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest jedynką;
                 w przeciwnym razie Dx=$nnnnnn00.

CoMPare Memory to memory

CMPM.b (Ae)+,(Af)+ -  porównuje wartość dwóch komórek pamięci, których adresy
znajdują się w rejestrach Ae i Af. Następnie wartość tych
rejestrów jest zwiększana o 1.

Instrukcje warunkowe takie same, jak za instrukcją CMP,
przyjmując że: ARG1=(Ae)+, ARG2=(Af)+.

DBF - Decrement and Branch until False
(DBRA - Decrement and BRanch Always)

DBF Dx,X -  odejmuje 1 od dwóch najmłodszych bajtów w rejestrze Dx i sprawdza ich wartość.
Jeśli po odejmowaniu Dx<$nnnnFFFF, to skok do etykiety X jest wykonywany.
W przeciwnym razie jest wykonywana instrukcja następna po DBF, a wartość
rejestru Dx=$nnnnFFFF. Za pomocą instrukcji DBF można tworzyć pętle,
wykonywane od 1 (Dx: nnnn0000) do 65536 (Dx: nnnnFFFF) razy.

W poniższym przykładzie, instrukcja ta służy do wykonania pętli 8 razy:

   moveq #$07,Dx    
X: inst1
   inst2
   .....
   DBF   Dx,X		 Zawartość pętli pomiędzy etykietą X,
a instrukcją DBF zostanie wykonana 8 razy.
Po wykonaniu pętli 2 najmłodsze bajty w reje-
strze Dx, będą miały wartość $FFFF.

DBMI - Decrement and Branch until MInus

DBMI Dx,X - działa tak samo, jak instrukcja DBF.

DIVide Unsigned

DIVU ARG1,ARG2 -  dzieli 32-bitową wartość w ARG2 przez wartość 16-bitową z ARG1 (dwa
starsze bajty w ARG1, są ignorowane). Wynik dzielenia znajdzie się
w 2 najmłodszych, a reszta z dzielenia w 2 najstarszych bajtach ARG2
(argumenty i wynik zapisane w systemie Unsigned). Jeśli wynik prze-
kracza wartość 65535 ($FFFF), to dzielenie nie zostanie wykonane,
a zawartość ARG2 nie zmieni się. Jeśli ARG1=$0000, to pojawi się
systemowy komunikat o błędzie (Software Failure).

beq.s X - skok do X, jeśli wynik =$0000.
bne.s X - skok do X, jeśli wynik >$0000.
bpl.s X - skok do X, jeśli najstarszy bit w wyniku jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w wyniku jest jedynką.
bvc.s X - skok do X, jeśli wynik nie jest większy niż 65535 ($FFFF).
bvs.s X - skok do X, jeśli wynik przekracza wartość 65535 ($FFFF).

SEQ Dx - Dx=$nnnnnnFF, jeśli wynik =$0000; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli wynik >$0000; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest zerem;
                w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest jedynką;
                w przeciwnym razie Dx=$nnnnnn00.
SVC Dx - Dx=$nnnnnnFF, jeśli wynik nie jest większy niż
                65535 ($FFFF); w przeciwnym razie Dx=$nnnnnn00.
SVS Dx - Dx=$nnnnnnFF, jeśli wynik przekracza wartość
                65535 ($FFFF); w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: 000003E8 => DIVU #$0064,Dx => Dx: 0000000A
Dx: 000186A0 => DIVU #$0005,Dx => Dx: 00004E20
Dx: 80000000 => DIVU #$9000,Dx => Dx: 2000E38E

EXchanGe registers

EXG Re,Rf -  zamienia zawartością rejestry Re i Rf. Zawartość reje-
stru Re jest przenoszona do rejestru Rf i odwrotnie.

Przykłady:  De: 01234567, Df: 98765432 => EXG De,Df => De: 98765432, Df: 01234567
Dx: 01234567, Ax: 98765432 => EXG Dx,Ax => Dx: 98765432, Ax: 01234567
Ae: 01234567, Af: 98765432 => EXG Ae,Af => Ae: 98765432, Af: 01234567

sign EXTend

EXT.w De -  zeruje 8 starszych bitów w 2 najmłodszych bajtach rejestru De, jeśli najmłodszy
bajt w rejestrze De, ma wartość mniejszą od $80. Zapełnia 8 starszych bitów
w 2 najmłodszych bajtach rejestru De, jeśli najmłodszy bajt w rejestrze De,
ma wartość większą od $7F.

beq.s X - skok do X, jeśli 2 najmłodsze bajty w rejestrze De=$0000 po wykonaniu instrukcji.
bne.s X - skok do X, jeśli 2 najmłodsze bajty w rejestrze De>$0000 po wykonaniu instrukcji.
bpl.s X - skok do X, jeśli najstarszy bit w 2 najmłodszych bajtach
         rejestru De, jest zerem po wykonaniu instrukcji.
bmi.s X - skok do X, jeśli najstarszy bit w 2 najmłodszych bajtach
         rejestru De, jest jedynką po wykonaniu instrukcji.

SEQ Dx - Dx=$nnnnnnFF, jeśli 2 najmłodsze bajty w rejestrze De=$0000
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli 2 najmłodsze bajty w rejestrze De>$0000
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w 2 najmłodszych bajtach rejestru De,
        jest zerem po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w 2 najmłodszych bajtach rejestru De,
        jest jedynką po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.

EXT.l De -  zeruje 2 najstarsze bajty w rejestrze De, jeśli 2 najmłodsze bajty rejestru De,
mają wartość mniejszą od $8000. Zapełnia 2 najstarsze bajty w rejestrze De,
jeśli 2 najmłodsze bajty rejestru De, mają wartość większą od $7FFF.

beq.s X - skok do X, jeśli rejestr De=$00000000 po wykonaniu instrukcji.
bne.s X - skok do X, jeśli rejestr De>$00000000 po wykonaniu instrukcji.
bpl.s X - skok do X, jeśli najstarszy bit w rejestrze De, jest zerem po wykonaniu instrukcji.
bmi.s X - skok do X, jeśli najstarszy bit w rejestrze De, jest jedynką po wykonaniu instrukcji.

SEQ Dx - Dx=$nnnnnnFF, jeśli rejestr De=$00000000 po wykonaniu instrukcji;
        w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli rejestr De>$00000000 po wykonaniu instrukcji;
        w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w rejestrze De, jest zerem
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w rejestrze De, jest jedynką
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnA541 => EXT.w Dx => Dx: nnnn0041
Dx: nnnn86B0 => EXT.w Dx => Dx: nnnnFFB0
Dx: 9AC4614D => EXT.l Dx => Dx: 0000614D
Dx: 253FE050 => EXT.l Dx => Dx: FFFFE050

JuMP

JMP X(pc) - skok do etykiety X, znajdującej się w programie głównym.

JMP (Ax) - skok do komórki pamięci, której adres znajduje się w rejestrze Ax.

Jump to SubRoutine

JSR $nnnn(Ax) -  rozgałęzienie programu do komórki pamięci, o adresie w rejestrze Ax,
przemieszczonym o wartość $nnnn (patrz: Argumenty instrukcji).
Powrót z rozgałęzienia następuje po wykonaniu instrukcji RTS.

Load Effective Address

LEA X(pc),Ax -  umieszcza w rejestrze Ax adres etykiety X,
która znajduje się w programie głównym.

Logical Shift Left

LSL.b #v,De -  przesuwa zawartość najmłodszego bajtu w rejestrze De, o #v-bitów w lewo.
Bity, które nie mieszczą się w nim, są zerowane i umieszczane na najmłodszych
pozycjach.

beq.s X - skok do X, jeśli najmłodszy bajt w rejestrze De=$00 po wykonaniu instrukcji.
bne.s X - skok do X, jeśli najmłodszy bajt w rejestrze De>$00 po wykonaniu instrukcji.
bpl.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie
         rejestru De, jest zerem po wykonaniu instrukcji.
bmi.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie
         rejestru De, jest jedynką po wykonaniu instrukcji.

SEQ Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w rejestrze De=$00
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w rejestrze De>$00
        po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie rejestru De,
        jest zerem po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie rejestru De,
        jest jedynką po wykonaniu instrukcji; w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnnnAB => LSL.b #4,Dx => Dx: nnnnnnB0
Dx: nnnn40E3 => LSL.w #8,Dx => Dx: nnnnE300
Dx: ABCD0123 => LSL.l #5,Dx => Dx: 79A02460

Logical Shift Right

LSR.b #v,De -  przesuwa zawartość najmłodszego bajtu w rejestrze De, o #v-bitów w prawo.
Bity, które nie mieszczą się w nim, są zerowane i umieszczane na najstarszych
pozycjach.

Instrukcje warunkowe takie same, jak za instrukcją LSL.

Przykłady:  Dx: nnnnnnAB => LSR.b #4,Dx => Dx: nnnnnn0A
Dx: nnnn40E3 => LSR.w #8,Dx => Dx: nnnn0040
Dx: ABCD0123 => LSR.l #5,Dx => Dx: 055E6809

MOVE

MOVE.b ARG1,ARG2 -  przenosi najmłodszy bajt z ARG1 do najmłodszego
bajtu w ARG2 (wartość ARG1 nie zmienia się).

beq.s X - skok do X, jeśli najmłodszy bajt w ARG1=$00.
bne.s X - skok do X, jeśli najmłodszy bajt w ARG1>$00.
bpl.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG1 jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG1 jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG1=$00; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG1>$00; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie
                ARG1 jest zerem; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie
                ARG1 jest jedynką; w przeciwnym razie Dx=$nnnnnn00.

Jeśli do rejestru Ax jest przenoszone słowo (.W), to wartość najstarszego
bitu tego słowa jest ustawiana w 16-najstarszych bitach rejestru Ax.

Przykłady:  Dx: nnnnnnnn => MOVE.b #$12,Dx => Dx: nnnnnn12
Dx: nnnnnnnn => MOVE.w #$1234,Dx => Dx: nnnn1234
Ax: nnnnnnnn => MOVE.w #$1234,Ax => Ax: 00001234
Ax: nnnnnnnn => MOVE.w #$8234,Ax => Ax: FFFF8234
Dx: nnnnnnnn => MOVE.l #$12345678,Dx => Dx: 12345678

MOVE Multiple registers

MOVEM.l De-Df,-(Ax) -  przenosi zawartość rejestrów od Df do De (e<f), do komórek
pamięci, których adresy zmniejszają się o 4, wraz z wartością
rejestru Ax.
Na przykład:
MOVEM.l D0-D7,-(Ax) jest równoznaczne z wykonaniem 8 instrukcji, w takiej kolejności:
1. MOVE.l D7,-(Ax); 2. MOVE.l D6,-(Ax); 3. MOVE.l D5,-(Ax); 4. MOVE.l D4,-(Ax);
5. MOVE.l D3,-(Ax); 6. MOVE.l D2,-(Ax); 7. MOVE.l D1,-(Ax); 8. MOVE.l D0,-(Ax).

MOVEM.l De-Df/Ag-Ah,-(Ax) -  przenosi zawartość rejestrów od Ah do Ag (g<h) oraz
od Df do De (e<f), do komórek pamięci, których adresy
zmniejszają się o 4, wraz z wartością rejestru Ax.
Na przykład:
MOVEM.l D0-D7/A0-A3,-(Ax) jest równoznaczne z wykonaniem 12 instrukcji, w takiej kolejności:
1. MOVE.l A3,-(Ax); 2. MOVE.l A2,-(Ax); 3. MOVE.l A1,-(Ax); 4. MOVE.l A0,-(Ax);
5. MOVE.l D7,-(Ax); 6. MOVE.l D6,-(Ax); 7. MOVE.l D5,-(Ax); 8. MOVE.l D4,-(Ax);
9. MOVE.l D3,-(Ax); 10. MOVE.l D2,-(Ax); 11. MOVE.l D1,-(Ax); 12. MOVE.l D0,-(Ax).

MOVE Quick

MOVEQ #$dd,De -  przenosi wartość $dd do rejestru De. Jeśli $dd<$80, to 3 najstarsze bajty
w rejestrze De są zerowane ($000000dd). Jeśli $dd>7F, to 3 najstarsze
bajty w rejestrze De zapełniają się ($FFFFFFdd).

beq.s X - skok do X, jeśli $dd=$00.
bne.s X - skok do X, jeśli $dd>$00.
bpl.s X - skok do X, jeśli najstarszy bit w $dd jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w $dd jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli $dd=$00; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli $dd>$00; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w $dd jest zerem; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w $dd jest jedynką; w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnnnnn => MOVEQ #$0D,Dx => Dx: 0000000D
Dx: nnnnnnnn => MOVEQ #$66,Dx => Dx: 00000066
Dx: nnnnnnnn => MOVEQ #$85,Dx => Dx: FFFFFF85
Dx: nnnnnnnn => MOVEQ #$C4,Dx => Dx: FFFFFFC4

MULtiply Unsigned

MULU ARG1,ARG2 -  mnoży 16-bitową wartość w ARG2 przez wartość 16-bitową z ARG1
(dwa starsze bajty w obydwu argumentach, są ignorowane). Wynik
mnożenia znajdzie się w 32-bitach ARG2 (argumenty i wynik zapisane
w systemie Unsigned).

beq.s X - skok do X, jeśli wynik =$00000000.
bne.s X - skok do X, jeśli wynik >$00000000.
bpl.s X - skok do X, jeśli najstarszy bit w wyniku jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w wyniku jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli wynik =$00000000; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli wynik >$00000000; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest zerem;
        w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w wyniku jest jedynką;
        w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnn003C => MULU #$000D,Dx => Dx: 0000030C
Dx: nnnn1FFF => MULU #$0046,Dx => Dx: 0008BFBA
Dx: nnnnFFFF => MULU #$FFFF,Dx => Dx: FFFE0001

No OPeration

NOP -  zajmuje czas procesora nie wykonując żadnej operacji.
Kod szesnastkowy tej instrukcji, to: $4E71.

logical complement

NOT.b ARG - zamienia każdy bit na przeciwny, w najmłodszym bajcie ARG (negacja).

beq.s X - skok do X, jeśli najmłodszy bajt w ARG=$00 po negacji.
bne.s X - skok do X, jeśli najmłodszy bajt w ARG>$00 po negacji.
bpl.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG jest zerem po negacji.
bmi.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG jest jedynką po negacji.

SEQ Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG=$00
        po negacji; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG>$00
        po negacji; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie ARG
        jest zerem po negacji; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie ARG
        jest jedynką po negacji; w przeciwnym razie Dx=$nnnnnn00.

Przykłady:  Dx: nnnnnn01 => NOT.b Dx => Dx: nnnnnnFE
Dx: nnnn8000 => NOT.w Dx => Dx: nnnn7FFF
Dx: 0ABCDEF1 => NOT.l Dx => Dx: F543210E

Push Effective Address

PEA X(pc) -  umieszcza w rejestrze A7 adres etykiety X,
która znajduje się w programie głównym.

ROtate Left

ROL.b #v,De -  przesuwa zawartość najmłodszego bajtu w rejestrze De, o #v-bitów w lewo.
Bity, które nie mieszczą się w nim, są umieszczane na najmłodszych pozycjach.

Instrukcje warunkowe takie same, jak za instrukcją LSL.

Przykłady:  Dx: nnnnnnAB => ROL.b #4,Dx => Dx: nnnnnnBA
Dx: nnnn40E3 => ROL.w #8,Dx => Dx: nnnnE340
Dx: ABCD0123 => ROL.l #5,Dx => Dx: 79A02475

ROtate Right

ROR.b #v,De -  przesuwa zawartość najmłodszego bajtu w rejestrze De, o #v-bitów w prawo.
Bity, które nie mieszczą się w nim, są umieszczane na najstarszych pozycjach.

Instrukcje warunkowe takie same, jak za instrukcją LSL.

Przykłady:  Dx: nnnnnnAB => ROR.b #4,Dx => Dx: nnnnnnBA
Dx: nnnn40E3 => ROR.w #8,Dx => Dx: nnnnE340
Dx: ABCD0123 => ROR.l #5,Dx => Dx: 1D5E6809

ReTurn from Subroutine

RTS -  zakończenie wykonywania programu lub powrót z rozgałęzienia BSR lub JSR.
Instrukcją tą musi być zakończony każdy program. W przeciwnym razie
zostanie wyświetlony systemowy komunikat o błędzie (Software Failure).
Kod szesnastkowy tej instrukcji, to: $4E75.

Set False

SF ARG - zeruje najmłodszy bajt w ARG.

Przykład: Dx: nnnnnnnn => SF Dx => Dx: nnnnnn00

Set True

ST ARG - zapełnia najmłodszy bajt w ARG.

Przykład: Dx: nnnnnnnn => ST Dx => Dx: nnnnnnFF

SUBtract

SUB.b ARG1,ARG2 -  odejmuje wartość najmłodszego bajtu z ARG1 od najmłodszego bajtu
Wynik odejmowania znajdzie się w najmłodszym bajcie ARG2.
Na podstawie tego wyniku, są ustawiane odpowiednie kody warunkowe
(CC). W ten sposób następuje porównanie wartości, jakie obydwa
argumenty miały przed odejmowaniem.

Instrukcje warunkowe takie same, jak za instrukcją CMP.
Przykłady:  Dx: nnnnnn78 => SUB.b #$28,Dx => Dx: nnnnnn50
Dx: nnnnF045 => SUB.w #$10A2,Dx => Dx: nnnnDFA3
Dx: 0000000F => SUB.l #$00000010,Dx => Dx: FFFFFFFF

SUBtract Quick

SUBQ.b #v,ARG -  odejmuje wartość #v od najmłodszego bajtu w ARG. Wynik odejmowania
znajdzie się w najmłodszym bajcie ARG. Na podstawie tego wyniku, są
ustawiane odpowiednie kody warunkowe (CC). W ten sposób następuje
porównanie wartości, jakie obydwa argumenty miały przed odejmowaniem.

Instrukcje warunkowe takie same, jak za instrukcją CMP,
przyjmując że: ARG1=#v, ARG2=ARG.
Przykłady:  Dx: nnnnnn06 => SUBQ.b #5,Dx => Dx: nnnnnn01
Dx: nnnnF029 => SUBQ.w #8,Dx => Dx: nnnnF021
Dx: 00000001 => SUBQ.l #3,Dx => Dx: FFFFFFFE

SWAP register words

SWAP De - przesuwa zawartość rejestru De o 16-bitów.

beq.s X - skok do X, jeśli rejestr De=$00000000.
bne.s X - skok do X, jeśli rejestr De>$00000000.
bpl.s X - skok do X, jeśli najstarszy bit w rejestrze De jest zerem po przesunięciu.
bmi.s X - skok do X, jeśli najstarszy bit w rejestrze De jest jedynką po przesunięciu.

SEQ Dx - Dx=$nnnnnnFF, jeśli rejestr De=$00000000; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli rejestr De>$00000000; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w rejestrze De jest zerem
        po przesunięciu; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w rejestrze De jest jedynką
        po przesunięciu; w przeciwnym razie Dx=$nnnnnn00.

Przykład: Dx: ABCD1234 => SWAP Dx => Dx: 1234ABCD.

TeST operand

TST.b ARG - sprawdza najmłodszy bajt w ARG.

beq.s X - skok do X, jeśli najmłodszy bajt w ARG=$00.
bne.s X - skok do X, jeśli najmłodszy bajt w ARG>$00.
bpl.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG jest zerem.
bmi.s X - skok do X, jeśli najstarszy bit w najmłodszym bajcie ARG jest jedynką.

SEQ Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG=$00; w przeciwnym razie Dx=$nnnnnn00.
SNE Dx - Dx=$nnnnnnFF, jeśli najmłodszy bajt w ARG>$00; w przeciwnym razie Dx=$nnnnnn00.
SPL Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie
        ARG jest zerem; w przeciwnym razie Dx=$nnnnnn00.
SMI Dx - Dx=$nnnnnnFF, jeśli najstarszy bit w najmłodszym bajcie
        ARG jest jedynką; w przeciwnym razie Dx=$nnnnnn00.

take ILLEGAL instruction trap

ILLEGAL -  nieobsługiwana ("nielegalna") instrukcja. Jej wykonanie powoduje wystąpienie
wewnętrznego wyjątku procesora nr 4 (Illegal Instruction), co skutkuje wyświe-
tleniem systemowego komunikatu o błędzie (Software Failure).
Kod szesnastkowy tej instrukcji, to: $4AFC.