MiniCPU

1. Die drei Stufen

Jede Stufe behält alles von der vorigen und fügt eine Idee hinzu. Welche Stufe ein Programm braucht, steht in seiner ersten Zeile: .cpu 8, .cpu 8s oder .cpu 8x (in C #pragma cpu 8x). Ohne diese Zeile läuft ein Assembler-Programm auf der MiniCPU 8, ein C-Programm auf der 8X. Das Menü »CPU« in der Sandbox ändert die Zeile.

2. Vier Regeln für alle Befehle

Auf allen drei Stufen gelten dieselben Regeln. Wer eine Stufe weitergeht, muss nichts umlernen.

• Das Ziel steht vorn: LDI A, 5 lädt 5 in A, ADD A, B ändert A, STA [0x70], A schreibt nach 0x70.
• Eckige Klammern heißen »der Speicher an«. LDI A, 0x70 lädt die Zahl 0x70, LDA A, [0x70] das Byte, das an Adresse 0x70 steht, und LDA A, [B] das Byte an der Adresse, die in B steht.
• Der zweite Wert ist ein Register oder eine Zahl, bei allen Rechen-, Logik- und Vergleichsbefehlen: ADD A, B und ADD A, 16, AND A, 0x0F, CMP A, 10.
• Höhere Stufen bringen Register, keine neuen Schreibweisen. Auf der 8X funktionieren LDI, LDA, STA, MOV, ADD, SUB, CMP, INC, DEC, PUSH und POP auch mit X und Y.

Ob eine Zahl dezimal (112), hexadezimal (0x70) oder binär (0b0111_0000) dasteht, ist gleich; mehr dazu unter Assembler.

3. MiniCPU 8

Speicher und Register

• Ein RAM mit 256 Bytes, Adressen 0x00 bis 0xFF. Programm, Daten und Bildschirm teilen sich diesen Speicher; nichts hindert ein Programm daran, seine eigenen Befehle zu überschreiben.
• Vier Register A, B, C, D mit je 8 Bit, also Werten von 0 bis 255. Mehr passt nicht hinein: 255 + 1 ergibt 0, und das Flag CF merkt sich den Übertrag.
• Der Programmzähler PC enthält die Adresse des nächsten Befehls. Die CPU beginnt bei 0x00 und läuft, bis sie auf HLT trifft.
• Zahlen über 255 belegen zwei Bytes. ADC und SBC rechnen den Übertrag des Befehls davor mit, so addiert ADD B, D und danach ADC C, 0 den Wert D zur 16-Bit-Zahl in C (oben) und B (unten).

Beim Start stehen A bis D und die Flags auf 0.

Flags

Zwei Flags halten fest, wie der letzte Rechenbefehl ausgegangen ist. Die Sprungbefehle entscheiden danach.

Ein Beispiel: 3 − 5 passt nicht in ein Byte.

        LDI A, 3
        LDI B, 5
        SUB A, B            ; 3 − 5
        HLT

Nach SUB A, B steht in A 254, also 3 − 5 + 256, und CF = 1 sagt: Es musste geborgt werden. Die Sandbox hebt hervor, was der letzte Befehl geändert hat.

AND, OR und XOR setzen ZF nach ihrem Ergebnis und löschen CF immer; CLF löscht beide. Laden, Speichern, MOV, Sprünge, der Stack und die Geräte lassen die Flags, wie sie sind. In der Befehlstabelle steht , wo ein Befehl das Flag nach seinem Ergebnis setzt, 0, wo er es löscht, und –, wo er es nicht verändert.

Vergleichen. CMP A, B rechnet A − B, behält aber nur die Flags. Danach gilt (für Zahlen von 0 bis 255):

In der Sandbox erklärt die Maus über ZF und CF, warum der letzte Befehl das Flag gesetzt oder gelöscht hat.

Befehle

Alle Befehle der MiniCPU 8. Die Beispiele stehen für alle Register: Statt ADD A, B geht auch ADD C, D, statt 5 jede Zahl von 0 bis 255. Bei bedingten Sprüngen stehen zwei Taktzahlen: ohne Sprung / mit Sprung.

4. MiniCPU 8S

Der Stack

• SP, der Stackzeiger, beginnt bei 0x100, eins hinter dem Ende des RAMs. PUSH A zieht 1 von SP ab und speichert A dort; POP A liest das Byte und zählt SP wieder hoch. Der Stack wächst also durch das gewöhnliche RAM nach unten.
• CALL label legt die Adresse des nächsten Befehls auf den Stack und springt; RET holt sie wieder herunter und macht dort weiter. Aufrufe dürfen verschachtelt sein.
• LDA A, [SP+n] und STA [SP+n], A lesen und schreiben n Bytes über SP, ohne etwas vom Stack zu nehmen. SUB SP, n macht Platz für n Bytes, ADD SP, n gibt sie wieder frei.
• Stack, Programm und Bildschirm teilen sich weiterhin 256 Bytes: Zu viele PUSHes überschreiben, was unter dem Stack liegt. Die RAM-Ansicht der Sandbox markiert den Stack.

Befehle für den Stack

Diese Befehle kommen auf der 8S zu allen Befehlen der MiniCPU 8 hinzu.

Funktionen mit Argumenten

So rufen sich Funktionen gegenseitig auf; der C-Compiler macht es bei jeder Funktion genauso:

1. Der Aufrufer legt die Argumente mit PUSH auf den Stack und ruft die Funktion mit CALL auf.
2. Die Funktion macht mit SUB SP, n Platz für ihre lokalen Variablen.
3. Sie liest und schreibt lokale Variablen und Argumente mit [SP+n]: zuerst kommen die lokalen Variablen, dann die Rücksprungadresse, dann die Argumente.
4. Sie gibt ihre lokalen Variablen mit ADD SP, n frei und kehrt mit RET zurück, das Ergebnis in A.
5. Der Aufrufer gibt die Argumente mit ADD SP, n frei.

.cpu 8s
        LDI A, 21
        PUSH A              ; das Argument
        CALL double
        ADD SP, 1           ; Argument wieder freigeben
        OUT 0x11, A         ; zeigt 42
        HLT

double: LDA A, [SP+1]       ; [SP+0] ist die Rücksprungadresse
        ADD A, A
        RET

Nach CALL double liegt ganz oben im RAM, an 0xFF, das Argument 21 (15) und darunter, an 0xFE, die Rücksprungadresse 07: Dort steht ADD SP, 1. Die RAM-Ansicht markiert den Stack.

Jeder Aufruf hat seine eigenen Argumente und lokalen Variablen, deshalb darf eine Funktion sich selbst aufrufen. Einen eigenen Rahmenzeiger gibt es nicht, alle Abstände zählen ab SP. Jedes PUSH mitten in einer Funktion verschiebt sie deshalb um eins. Am einfachsten reserviert eine Funktion alle lokalen Variablen gleich am Anfang. Auf der 8X ist die Rücksprungadresse zwei Bytes lang, die Argumente beginnen dort ein Byte höher.

5. MiniCPU 8X

64 KiB und Adressen mit zwei Bytes

• 65.536 Bytes RAM, Adressen 0x0000 bis 0xFFFF: alles, was eine 16-Bit-Adresse erreicht, so wie 256 Bytes alles sind, was 8 Bit erreichen. Platz für Tabellen, große Bildschirme mit zwei Seiten und längere Programme.
• Jede Adresse hat zwei Bytes, das untere zuerst. LDA A, [0x0812], STA [0x0812], A, Sprünge und CALL werden dadurch ein Byte länger und einen Takt langsamer.
• PC und SP haben 16 Bit. SP beginnt bei 0x10000, ganz oben. X und Y stehen beim Start auf 0. CALL legt eine Rücksprungadresse mit zwei Bytes ab.
• LDA A, [B] gibt es weiter, aber B erreicht nur die ersten 256 Bytes. Für alles darüber sind X und Y da.

X und Y

X und Y sind zwei Register mit 16 Bit, gedacht als Zeiger. Sie brauchen keine neuen Befehle:

Bei X und Y beziehen sich ZF und CF auf alle 16 Bit. Schieben, Logik, ADC und SBC gibt es nur für A bis D, und ein 8-Bit-Register kann kein 16-Bit-Register aufnehmen: ADD A, X geht nicht.

XL, XH, YL, YH sind das untere und das obere Byte von X und Y. Sie funktionieren nur mit MOV, in beide Richtungen zwischen ihnen und A bis D: MOV XH, A, MOV B, YL.

Was die 8X kostet

Breiter ist langsamer: Eine Adresse hat zwei Bytes, eine Zahl für X oder Y auch, Laden und Speichern bewegen bei X und Y zwei Bytes, und die 8-Bit-Recheneinheit braucht für 16-Bit-Rechnungen einen Takt mehr. Die Tabelle nennt Bytes und Takte für jeden Befehl, der auf der 8X anders kostet oder X und Y kann; alle anderen kosten so viel wie auf der 8.

6. Takte

Der Regler »Clock« stellt den Takt von 1 Hz bis 64 MHz ein, und die CPU läuft in diesem Takt in Echtzeit. Wie viele Takte ein Befehl braucht, folgt aus einem einfachen Modell einer 8-Bit-CPU, deren Tempo der Speicherbus begrenzt:

• 1 Takt für jedes Byte des Befehls, das geholt wird,
• 1 Takt für jedes Datenbyte, das gelesen oder geschrieben wird (RAM, Stack, Rücksprungadresse, Port), 2 bei X und Y,
• 1 Takt, wenn PC einen neuen Wert bekommt (JMP, ein bedingter Sprung, der springt, CALL, RET),
• 1 Takt für eine 16-Bit-Rechnung (mit X, Y oder SP), weil die Recheneinheit nur 8 Bit breit ist.

So braucht ADD A, B 2 Takte, LDI A, 5 3, LDA A, [0x70] 4 (auf der 8X 5) und JNZ loop 2, wenn es nicht springt, und 3, wenn es springt. Die Statuszeile der Sandbox zeigt die verbrauchten Takte und wie lange sie beim gewählten Takt dauern; »Cycles« zeigt einen Befehl Takt für Takt.

7. Maschinencode

Neben dem Code zeigt die Sandbox die Adresse und die Bytes jeder Zeile:

loop:   LDI A, 5
        ADD A, B
        MOV B, A
        JMP loop

So entstehen sie:

• Der Opcode ist das erste Byte. Seine erste Hex-Ziffer nennt die Familie: 0x Steuerung, 1x Daten bewegen, 2x Rechnen, 3x Logik, 4x Vergleichen, 5x Stack, 6x Springen, 7x Ein- und Ausgabe. Höhere Stufen fügen Opcodes hinzu, nummerieren aber keine um.
• Ein Register ist ein Byte: A = 0, B = 1, C = 2, D = 3; auf der 8X auch XL = 4, XH = 5, YL = 6, YH = 7, X = 8, Y = 9.
• Zwei Register teilen sich ein Byte: erstes × 16 + zweites. ADD A, B ist 20 01, MOV B, A ist 15 10.
• Eine Zahl folgt dem Registerbyte: ein Byte, bei X und Y zwei (das untere zuerst). LDI A, 5 ist 10 00 05, LDI X, 0x0800 ist 10 08 00 08.
• Eine Adresse hat ein Byte (8, 8S) oder zwei, das untere zuerst (8X): JMP 0x23 ist auf der 8 60 23, auf der 8X 60 23 00.

Ein Byte, das kein Befehl ist, führt zu einer Fehlermeldung, ebenso ein Befehl, den die Stufe noch nicht kennt.

8. Assembler

Eine Zeile enthält höchstens einen Befehl. Groß- und Kleinschreibung der Befehle ist egal, Kommentare beginnen mit ;.

Werte schreibst du dezimal 42, hexadezimal 0x2A, binär 0b0010_1010 oder als Zeichen 'A' (65). Marken und Konstanten lassen sich mit + - * / & | << >> und Klammern verrechnen, etwa screen + 16 * 3 oder table >> 8. Negative Bytes laufen über: -1 ist 255.

Die Sandbox übersetzt schon beim Tippen. Fehler erscheinen unter dem Editor, ein Klick springt in die Zeile. Die Meldungen erklären mit diesen Regeln, was gemeint war: Auf LDA A, 0x70 antwortet sie, dass LDA den Speicher liest, und schlägt LDA A, [0x70] oder LDI A, 0x70 vor.

9. Zum Nachschlagen

Die MiniCPU gibt es nur in der CPU Sandbox; diese Seite ist ihre Referenz. Im Repository der Sandbox steht dazu:

• CPU Sandbox: die Anleitung, auf Deutsch: Sandbox und Klassen-Repository klonen, starten, Aufgaben bearbeiten und veröffentlichen, und was bei häufigen Problemen hilft.
• The three MiniCPU levels: die drei Stufen, Takte und Maschinencode noch einmal im Zusammenhang, auf Englisch.
• Beispielprogramme: fertige Programme in Assembler und C, von der Addition bis zum Raycaster, zum Lesen und Abwandeln.