
Befehle des Assemblers		Anhang A : Ein

Befehle der RETII-CPU

Register

Als Register definiert die RETII-CPU die Bezeichner ACC, PC, IN1 und IN2 . Die Definition der Registernamen kann nicht geändert werden, man kann allerdings einen zusätzlichen Namen für ein Register vereinbaren.

Bedingungen

Für die Bedingung bei den Sprungbefehlen definiert die RETII-CPU folgende Bezeichner

Bezeichner	Bedeutung
lt	kleiner (< 0)
le	kleiner oder gleich ( $\leq 0$ )
eq	gleich (= 0)
ne	ungleich ( $\neq 0$ )
ge	größer oder gleich ( $\geq 0$ )
gt	größer (>0)

Befehle der RETII-CPU

In der folgenden Tabelle bedeutet eine Zahl in spitzen Klammern (z.B. <i>) , daß der Befehl die Zahl als vorzeichenlose Zahl verwendet, steht die Zahl in eckigen Klammern ( z.B. [i] ) wird die Zahl als vorzeichenbehaftete Zahl im 2'er Komplement interpretiert.

Alle Integer-Zahlen die bei RETII-Befehlen verwendet werden sind 24Bit-Zahlen.

Load-Befehle
Befehl	Wirkung
LOAD <Register reg>, <Integer i>	reg := RAM(<i>)
LOADI <Register reg>, <Integer i>	reg := [i]
LOADIN1 <Register reg>, <Integer i>	reg := RAM(<IN1> + [i])
LOADIN2 <Register reg>, <Integer i>	reg := RAM(<IN2> + [i])
Store-Befehle
Befehl	Wirkung
STORE <Integer>	RAM(<i>) := ACC
STOREIN1 <Integer>	RAM(<IN1>+[i]) := ACC
STOREIN2 <Integer>	RAM(<IN2>+[i]) := ACC
MOVE <Register src>, <Register dest>	dest := src
Compute-Befehle
Befehl	Wirkung
SUBI <Register reg>, <Integer i>	[reg] := [reg] - [i]
ADDI <Register reg>, <Integer i>	[reg] := [reg]+ [i]
OPLUSI <Register reg>, <Integer i>	reg := reg $\oplus$ <i>
ORI <Register reg>, <Integer i>	reg := reg $\vee$ <i>
ANDI <Register reg>, <Integer i>	reg := reg $\wedge$ <i>

SUB <Register reg>, <Integer i>	[reg] := [reg] - [RAM(<i>)]
ADD <Register reg>, <Integer i>	[reg] := [reg]+ [RAM(<i>)]
OPLUS <Register reg>, <Integer i>	[reg] := [reg] $\oplus$ RAM(<i>)
OR <Register reg>, <Integer i>	[reg] := [reg] $\vee$ RAM(<i>)
AND <Register reg>, <Integer i>	[reg] := [reg] $\wedge$ RAM(<i>)
Jump-Befehle
Befehl	Wirkung
NOP	-
JUMP gt , <Integer i>
JUMP eq , <Integer i>
JUMP ge , <Integer i>	<PC> := <PC>+[i] falls [ACC] <Bedingung> 0 erfüllt
JUMP lt , <Integer i>	<PC> := <PC>+1 sonst
JUMP ne, <Integer i>
JUMP le , <Integer i>

JUMP-Befehle und Sprungmarken

Wie aus der Tabelle hervorgeht, sind alle JUMP-Befehle relative Sprünge. Damit man nun aber eine Sprungmarke als Ziel des JUMP-Befehls verwenden kann, wird in bei der Verwendung von Sprungmarken als Argument nicht deren Wert eingesetzt. Stattdessen wird das Argument berechnet <Adresse des JUMP-Befehls> - <Inhalt der Sprungmarke>.

Beispiel :

marke1:     NOP                 ; der 1. Jump Befehl springt hierhin \
            define blub, 0      ; blub und marke1 haben den Wert 0, \
                                ; aber ... \
            JUMP marke1         ; ... springt zum NOP-Befehl \
            JUMP blub           ; ... ist eine Endlosschleife

Falls eine Sprungmarke in einem arithmetischen Ausdruck verwendet wird, wird das Ergebnis des Ausdrucks ebenfalls wie eine Sprungmarke behandelt , so daß folgendes funktioniert:

            NOP \
            JUMP marke2 + 1 \
marke2:     NOP                ; marke2 hat den Wert 2 \
            NOP                ; Ziel des Sprungs

Bei allen anderen Befehlen wird der Wert der Sprungmarke direkt eingesetzt.

Arithmetische Ausdrücke und 24-Bit Argumente

Bei allen RETII-Befehlen ist das Integer Argument nur 24 Bit lang, andererseits verwendet der Assembler intern 32-Bit Zahlen. Der Assembler prüft darum für die Integer Zahl i die Bedingung 2²⁴>i>-2²⁴ und liefert eine Fehlermeldung falls diese Bedingung verletzt wird.

Befehle des Assemblers		Anhang A : Ein

Andreas Hofmeister
1998-12-05