| Zeichenerklärung |
Der 68000 beherrscht etliche Adressierungsarten, die mit fast allen Befehlen kombiniert werden können. Befehle erhalten null bis drei Parameter. Arithmetikbefehle haben als ersten Parameter die Wortlänge, die mit einem Punkt direkt hinter dem Befehlswort steht. ".B" steht für Byte (8 Bit), ".W" für Wort (16 Bit) und ".L" für Langwort (32 Bit). Anschließend folgt zunächst die Quellangabe für den
Befehl und hinter einem Komma die Zielangabe.
Beispiel:
MOVE.L D3,(A0) kopiert den im Register D3 gespeicherten 32-Bit-Wert in den Arbeitsspeicher ab der Adresse, auf die das Register A0 verweist.
Die Adressierungsarten im Detail: |
| #n | fester Wert |
| nnnn.L | feste Adresse |
| nn.W | feste Adresse |
| Dn | Datenregister n |
| An | Adressregister n |
| (An) | Speicherstelle, auf die Adressregister n verweist. |
| (An)+ | Speicherstelle, auf die Adressregister n verweist. Nach dem Zugriff wird An um eins erhöht. |
| -(An) | Zunächst wird An um eins vermindert, danach auf die Speicherstelle zugegriffen, auf die Adressregister n verweist. |
| d(An) | Die Speicherstelle, auf die zugegriffen wird, errechnet sich aus dem Inhalt von Adressregister n plus dem festen Wert d. |
| d(An,Rx) | ? |
| d(PC) | Zugriff auf Speicherstelle relativ zum Programmzähler |
| d(PC,Rx) | ? |
| CCR / SR | Zugriff auf Statusregister |
| Hinter jedem Befehl der Befehlsliste stehen die Buchstaben x, n, z, v und c (oder auch nicht). Diese Buchstaben stehen für die Prozessorflags: |
| x | Übertrag für Additionen |
| n | Negative = Wird gesetzt, wenn beim letzten Ergebnis das höchstwertige Bit gesetzt war |
| z | Zero = Nullflag; Wird gesetzt, wenn Ergebnis = 0. |
| v | Overflow = Wird gesetzt, wenn es einen numerischen Überlauf gab |
| c | Carry = Übertrag; Wird gesetzt, wenn das Ergebnis außerhalb des verfügbaren Bereiches liegt, z.B. $80+$94=$14 mit c=1 |
| Die in der Befehlsliste am Zeilenende stehenden Flags werden durch den entsprechenden Befehl verändert. |
| 1. Arithmetikbefehle |
| Addition / Subtraktion |
| ABCD q,z | z=z+q+x | BCD-Addition mit Übertrag | x | n | z | v | c |
| ADD.a q,z | z=z+q | Addition ohne Übertrag | x | n | z | v | c |
| ADDA q,An | An=An+q | Addition mit Adressregister | | | | | |
| ADDI.a #nnnn,z | z=z+#nnnn | Addition eines festen Werts ohne Übertrag | x | n | z | v | c |
| ADDQ.a #n,z | z=z+#n | Addition eines festen Werts (0 <= #n < 8) ohne Übertrag | x | n | z | v | c |
| ADDX.a q,z | z=z+q+x | Addition mit Übertrag | x | n | z | v | c |
| SBCD q,z | z=z-q-x | BCD-Subtraktion mit Übertrag | x | n | z | v | c |
| SUB.a q,z | z=z-q | Subtraktion ohne Übertrag | x | n | z | v | c |
| SUBA q,An | An=An-q | Subtraktion mit Adressregister | | | | | |
| SUBI.a #nnnn,z | z=z-#nnnn | Subtraktion eines festen Werts ohne Übertrag | x | n | z | v | c |
| SUBQ.a #n,z | z=z-#n | Subtraktion eines festen Werts (0 <= #n < 8) ohne Übertrag | x | n | z | v | c |
| SUBX.a q,z | z=z-q-x | Subtraktion mit Übertrag | x | n | z | v | c |
| Multiplikation / Division |
| DIVS q,Dn | Dn=Dn/q | Division mit Vorzeichen 32-Bit-Wert durch 16-Bit-Wert. Im Ergebnisregister Dn steht der ganzzahlige Quotient in Bit 0-15, der Rest in Bit 16-31 | | n | z | v | c=0 |
| DIVU q,Dn | Dn=Dn/q | Division ohne Vorzeichen 32-Bit-Wert durch 16-Bit-Wert. Im Ergebnisregister Dn steht der ganzzahlige Quotient in Bit 0-15, der Rest in Bit 16-31 | | n | z | v | c=0 |
| MULS q,Dn | Dn=Dn*q | Multiplikation mit Vorzeichen zweier 16-Bit-Werte. Im Ergebnisregister Dn steht das 32 Bit breite Ergebnis. | | n | z | v=0 | c=0 |
| MULU q,Dn | Dn=Dn/q | Multiplikation ohne Vorzeichen zweier 16-Bit-Werte. Im Ergebnisregister Dn steht das 32 Bit breite Ergebnis. | | n | z | v=0 | c=0 |
| Binäre Verknüpfungen |
| AND.a q,z | z = z AND q | UND-Verknüpfung | | n | z | v=0 | c=0 |
| ANDI.a #nnnn,z | z = z AND #nnnn | UND-Verknüpfung mit festem Wert | | n | z | v=0 | c=0 |
| EOR.a Dn,z | z = z XOR Dn | Exklusiv-ODER-Verknüpfung mit Datenregister Dn | | n | z | v=0 | c=0 |
| EORI.a #nnnn,z | z = z XOR #nnnn | Exklusiv-ODER-Verknüpfung mit festem Wert | | n | z | v=0 | c=0 |
| NOT.a z | z = NOT z | Invertierung von z | | n | z | v=0 | c=0 |
| OR.a q,z | z = z OR q | ODER-Verknüpfung | | n | z | v=0 | c=0 |
| ORI.a #nnnn,z | z = z OR #nnnn | ODER-Verknüpfung mit festem Wert | | n | z | v=0 | c=0 |
| Rotier- und Schiebebefehle |
| ASL z | shift left z | Bitweises arithmetisches Linksschieben des Inhalts einer Speicherstelle (16 Bit) | x | n | z | v | c |
| ASL.a q,Dn | shift left Dn | q-maliges bitweises arithmetisches Linksschieben des Inhalts von Dn (16 Bit) | x | n | z | v | c |
| ASR z | shift right z | Bitweises arithmetisches Rechtsschieben des Inhalts einer Speicherstelle (16 Bit) | x | n | z | v | c |
| ASR.a q,Dn | shift right Dn | q-maliges bitweises arithmetisches Rechtsschieben des Inhalts von Dn (16 Bit) | x | n | z | v | c |
| LSL z | shift left z | Bitweises logisches Linksschieben des Inhalts einer Speicherstelle (16 Bit) | x | n | z | v | c |
| LSL.a q,Dn | shift left Dn | q-maliges bitweises logisches Linksschieben des Inhalts von Dn (16 Bit) | x | n | z | v | c |
| LSR z | shift right z | Bitweises logisches Rechtsschieben des Inhalts einer Speicherstelle (16 Bit) | x | n | z | v | c |
| LSR.a q,Dn | shift right Dn | q-maliges bitweises logisches Rechtsschieben des Inhalts von Dn (16 Bit) | x | n | z | v | c |
| ROL z | rotate left z | Bitweises Linksrotieren des Inhalts einer Speicherstelle (16 Bit) | | n | z | v=0 | c |
| ROL.a q,Dn | rotate left Dn | q-maliges bitweises Linksrotieren des Inhalts von Dn (16 Bit) | | n | z | v=0 | c |
| ROR z | rotate right z | Bitweises Rechtsrotieren des Inhalts einer Speicherstelle (16 Bit) | | n | z | v=0 | c |
| ROR.a q,Dn | rotate right Dn | q-maliges bitweises Rechtsrotieren des Inhalts von Dn (16 Bit) | | n | z | v=0 | c |
| ROXL z | rotate left z | Bitweises Linksrotieren des Inhalts einer Speicherstelle unter Einbeziehung des x-Flags (16 Bit) | | n | z | v=0 | c |
| ROXL.a q,Dn | rotate left Dn | q-maliges bitweises Linksrotieren des Inhalts von Dn unter Einbeziehung des x-Flags (16 Bit) | | n | z | v=0 | c |
| ROXR z | rotate right z | Bitweises Rechtsrotieren des Inhalts einer Speicherstelle unter Einbeziehung des x-Flags (16 Bit) | | n | z | v=0 | c |
| ROXR.a q,Dn | rotate right Dn | q-maliges bitweises Rechtsrotieren des Inhalts von Dn unter Einbeziehung des x-Flags (16 Bit) | | n | z | v=0 | c |
| Vergleichsbefehle |
| CMP.a q,Dn | compare | Vergleich von q mit Datenregister Dn, Ergebnis wird in den Flags codiert | | n | z | v | c |
| CMPA.a q,An | compare | Vergleich von q mit Adressregister An, Ergebnis wird in den Flags codiert | | n | z | v | c |
| CMPI.a #nnnn,z | compare | Vergleich des festen Werts #nnnn mit z, Ergebnis wird in den Flags codiert | | n | z | v | c |
| CMPM.a (An)+,(Am)+ | compare | Vergleich der Speicherstellen, auf die An und Am verweisen, Ergebnis wird in den Flags codiert,
An und Am werden anschließend inkrementiert. | | n | z | v | c |
| TAS z | test sign | Testet z auf Vorzeichen und setzt die Flags entsprechend (8 Bit) | | n | z | v=0 | c=0 |
| TST.a z | test | Testet z auf >, < oder = 0 und setzt die Flags entsprechend | | n | z | v=0 | c=0 |
| sonstige Arithmetikbefehle |
| BCHG q,z | change bit | Invertiert Bit Nr. q in z | | | z | | |
| BCLR q,z | clear bit | Setzt Bit Nr. q in z auf 0 | | | z | | |
| BSET q,z | set bit | Setzt Bit Nr. q in z auf 1 | | | z | | |
| BTST q,z | test bit | Prüft Bit Nr. q in z, Ergebnis im z-Flag | | | z | | |
| CLR.a z | clear | Setzt den Inhalt von z auf 0. | | n=0 | z=1 | v=0 | c=0 |
| EXT.a Dn | extend | Vorzeichenrichtige Erweiterung des Inhalts von Dn auf 16 oder 32 Bit. | | n | z | v=0 | c=0 |
| NBCD z | negative | x-Flag=0: Bildung des Zehnerkomplements von z
x-Flag=1: Bildung des Neunerkomplements von z | x | n | z | v | c |
| NEG.a z | negative | Bildung des Zweierkomplements von z
| x | n | z | v | c |
| NEGX.a z | negative | Bildung des Zweierkomplements von z unter Einbeziehung des x-Flags für die Verarbeitung von Zahlen >32 Bit.
| x | n | z | v | c |
| Scc z | set on condition | Setzt z auf 255, wenn Bedingung erfüllt ist, sonst auf 0. Bedingungen siehe Bcc. | | | | v=0 | |
| 2. Registerbefehle |
| Laden und Speichern |
| LEA q,An | load effective address | Lade Adressregister An mit der Adresse, die sich aus der Auswertung des Operanden q ergibt (nicht mit dem Inhalt dieser Adresse, wie bei allen anderen Befehlen) | | | | | |
| MOVE.a q,z | move | Kopiere Inhalt von q nach z | | n | z | v=0 | c=0 |
| MOVE q,CCR | move | Belege Flags mit dem Inhalt von q | x | n | z | v | c |
| MOVE.a q,SR | move | Belege Statusregister mit dem Inhalt von q | x | n | z | v | c |
| MOVEA.a q,An | move | Kopiere Inhalt von q nach An | | | | | |
| MOVEQ #nnnn,Dn | move | Kopiere festen Wert #nnnn ins Datenregister Dn | | n | z | v=0 | c=0 |
| PEA q,An | push effective address | Lege die Adresse, die sich aus der Auswertung des Operanden q ergibt, auf dem Stapel ab. (nicht mit dem Inhalt dieser Adresse, wie bei allen anderen Befehlen) | | | | | |
| Transfer |
| EXG Dn,Dm | exchange | Vertauschen der Inhalte von Dn und Dm | | | | | |
| EXG An,Am | exchange | Vertauschen der Inhalte von An und Am | | | | | |
| EXG An,Dm | exchange | Vertauschen der Inhalte von An und Dm | | | | | |
| Stapelbefehle |
| LINK An,#nnnn | link | Anlegen eines neuen Stapelbereichs der Größe #nnnn ab der Speicherstelle, auf die An verweist. | | | | | |
| UNLK An | unlink | Löst einen mit LINK angelegten Staperbereich wieder auf. | | | | | |
| sonstige Registerbefehle |
| SWAP Dn | swap | Vertauscht in Dn die Bits 0-15 mit Bits 16-31. | | | | v=0 | c=0 |
| 3. Sprungbefehle |
| Unbedingte Sprünge |
| BRA nn | PC = PC+nn | Sprung relativ zur aktuellen Position | | | | | |
| BSR nn | PC = PC+nn | Unterprogrammaufruf relativ zur aktuellen Position | | | | | |
| ILLEGAL | illegal | Aufruf von TRAP #4 wegen illegalem Befehl | | | | | |
| JMP z | PC = z | Unbedingter Sprung | | | | | |
| JSR z | PC = z | Unbedingter Unterprogrammaufruf | | | | | |
| RTE | return exception | Rückkehr aus Ausnahmebehandlung | | | | | |
| RTR | return exception | Rückkehr aus Ausnahmebehandlung | | | | | |
| RTS | return subroutine | Rückkehr aus Unterprogramm | | | | | |
| Bedingte Sprünge |
| Bcc nn | branch on condition | Sprung, wenn gemäß der Ergebnisse des letzten Befehls die Bedingung cc erfüllt ist.
Bedingungen:
CC: c-Flag = 0
CS: c-Flag = 1
EQ: q = z
GE: q >= z
GT: q > z
HI: q > z
LE: q <= z
LS: q <= z
LT: q < z
MI: n-Flag = 1
NE: q <> z
PL: n-Flag = 0
VC: v-Flag = 0
VS: v-Flag = 1
| | | | | |
| CHK q,Dn | check | Prüfung, ob 0 <= Dn <= q; wenn ja: weiter, wenn nein: TRAP #6 | | | | | |
| 4. Interruptbefehle |
| NOP | no operation | Nullbefehl | | | | | |
| RESET | reset | externe Bausteine zurücksetzen | | | | | |
| STOP #nnnn | stop | Schreibt #nnnn ins Statusregister und geht in den HALT-Zustand über. | x | n | z | v | c |
| TRAP #nn | trap | Startet Ausnahmebehandlung TRAP #nn. ( 0 <= nn <= 15 ) | | | | | |
| TRAPV #nn | trap | Startet Ausnahmebehandlung TRAP #nn, falls v-Falg gesetzt ist. ( 0 <= nn <= 15 ) | | | | | |
Info
Dokumentation
Anleitungen
Prozessoren
1979 brachte Motorola den 68000er heraus. Der Prozessor war nach den in ihm enthaltenen 68000 Transistoren benannt und Motorola verfolgte damit das erklärte Ziel, die Leistung eines Großcomputers in einem Chip zu konzentrieren.