Brauch Hilfe zum Thema Assembler

Hallo Leute,

ich hab ein kleines Problem bei der Lösung einer Übung. Und zwar sollen wir ein Asemblerprogramm schreiben, daß 2 Zahlen vergleicht und die Größere ausgibt.Ich habe hier mal die Befehle angegeben und unten meinen Ansatz. Meine Idee ist es die zwei Zahlen jeweils in Register1 und 2 einzulesen, dann reg1(zahl1) in den Akkumulator zu laden, reg2 (zahl2) zu subtrahieren und dann wenn die Differenz >Null ist, zahl1(reg1) als größte Zahl einzulesen ansonsten zahl2(reg2). Genauer ist es unten noch mal beschrieben. Ich glaube bloß, daß man es nicht ganz so schreiben kann und ich bestimmt einige Sachen vergessen habe. Wer sich
damit auskennt, kann ja seinen Senf dazu geben bzw. mir paar Verbesserungsvorschläge machen.

Ich bedanke mich schon mal für alle Antworten.

Ciao seppel

===============================================================

Es werde ein Prozessor betrachtet, der über einen Akkumulator und zwei weitere allgemeine Register R1 und R2 verfügt. Alle Rechenoperationen finden im Akkumulator statt. Ein Assembler für diesen Prozessor erlaube die folgenden Befehle:

LDA value - Lade den festen Wert value in den Akkumulator
LDA reg - Lade den Inhalt des Registers reg in den
Akkumulator
LD reg value - Lade den festen Wert value in das Register reg
STO reg - Lade den Wert des Akkumulators in das Register reg
INC - Erhöhe den Wert im Akkumulator um 1
DEC - Vermindere den Wert im Akkumulator um 1
ADD reg - Addiere den Wert des Registers reg zum
Akkumulator
SUB reg - Subtrahiere den Wert des Registers reg vom
Akkumulator
MUL reg -Springe zur Marke label
JZ label - Springe zur Marke label, wenn der Akkumulator
den Wert 0 enthält
JG label - Springe zur Marke label, wenn der Akkumulator
einen Wert größer 0 enthält

Eine Marke label werde vor dem Assemblerbefehl mit einem nachfolgenden Doppelpunkt : notiert. Kommentare stehen hinter dem Befehl nach einem Semikolon ;

Beispiel-Programm:

start: LDA 23; (Laden des Akkumulator mit dem Startwert)
cont : DEC; (Abwärtszählen)
JG cont; (Fortsetzen, wenn Null noch nicht erreicht)

Schreiben Sie die folgenden kleinen kommentierten Assemblerprogramme:
a) In den Registern reg1 und reg2 stehen zwei Werte. Laden Sie den größeren der zwei Werte in den Akkumulator!

===========================================
Mein Ansatz:

start: LD reg1 zahl1; (Lädt den Wert zahl1 ins Register1)
LDA reg1; (Lädt den Inhalt des Registers1 in den
Akkumulator)
LD reg1 zahl2; (Lädt den Wert zahl2 ins Register2)
(>> Bis hierher wurden beide Werte zahl1 und zahl2 in die
jeweiligen Register geladen und die zahl1 in den
Akkumulator gelesen)

cont: SUB R2; (Subtrahiere den Wert des reg2 (zahl2)
vom Akkumulator (zahl1) >> jetzt
ergeben sich zwei Mgl. des weiteren
Verlaufes:
a: wenn zahl1 größer als zahl2 ergibt sich
eine positive Zahl bei der
Subtraktion, d.h. das Programm ließt
<JG ende> und springt auf label
(ende) und ließt dort reg1 in den
Akkumulator als größeren Wert ein)
b: wenn zahl1 kleiner als zahl2 ergibt sich
eine negative Zahl bei der
Subtraktion, d.h. <JG ende> wird
übersprungen und zahl2 wird in
den Akkumulator als größere Zahl
gelesen)
JG ende; (Springe auf label <ende> wenn der Wert
des Akkumulator größer 0)
LDA reg2; (Lädt den Inhalt des Registers 2 (reg2) in
den Akkumulator)

ende: LDA reg1; (Lädt den Inhalt des Registers 1 (reg1) in
den Akkumulator)

 

Wenn bei dir Zahl2 größer ist als Zahl1, würde erst mal Zahl2 in den Akku geladen werden und dann Zahl1. Das ist falsch.

Ich weiß nicht ganz wie das mit dem LDA Befehl zu handhaben ist aber ich probiers einfach. Außerdem fehlt meiner Meinung nach ein unbedingter Sprung(muss nicht sein ist aber sinnvoll).
Meine Lösung würde so aussehen. Ich hoffe du kannst erkennen was ich meine.

LDA zahl1 ;1.Zahl in Akku
LD reg1, zahl2 ;2.Zahl in Reg
SUB reg1 ;Subtrahieren
JG z1groesser ;1.Zahl größer? springen
LDA zahl2 ;sonst lade Akku mit zahl2
JMP ende ;springe zu ende
z1groesser:
LDA zahl1 ;lade Akku mit zahl1
ende:

JMP ist hier der unbedingte Sprung. Es wird immer zum Label ende gesprungen.

Ohne JMP müsste das so gehen.

LDA zahl1 ;1.Zahl in Akku
LD reg1, zahl2 ;2.Zahl in Reg
SUB reg1 ;Subtrahieren
JG z1groesser ;1.Zahl größer? springen
LDA zahl2 ;sonst lade Akku mit zahl2
JG ende ;springe zu ende
z1groesser:
LDA zahl1 ;lade Akku mit zahl1
ende: