Assembler Code *YaY*

[Hülfe]

Hallo, ich habe seit Neustem im Studium (Wirtschaftsinformatik) den Kurs Informatik I. Im Zuge der ersten Übungen sollen wir, bevor es mit Java los/weiter geht mit Assembler Code bzw. auch in Maschinensprache programmieren.

Eine unserer ersten Aufgaben lautet, die Formel x = (x-5) * (x+3) in Assembler Code zu übersetzen. Dafür haben wir eine kleine Tabelle mit Befehlen in der Assembler Sprache bekommen:

1. Define x y
2. 27 Load x
3. 18 Store x
4. 03 Add c
5. 07 AddMem x
6. 05 Mult c
7. 09 MultMem x

Die Zahlen vor den Befehlen sind für spätere Übersetzungen des Assembler Codes in Maschinensprache wobei Dezimalzahlen, also diese (27, 18, 03..) verwendet werden sollen.

Meine Frage an die, die Erfahrung mit Assemblercode haben wäre, ob folgende Lösung richtig ist. Ich bin hierbei den Term so angegangen, erst die Klammern zu "lösen" und anschließend die Berechneten x Werte zu multiplizieren.

Define x 61		// Speicherzelle 61 wird x genannt
Load 61			// x wird geladen
Add -5			// -5 wird addiert
Store 61		// x wird mit dem Wert -5 gespeichert
Load 61			// x wird mit dem Wert -5 geladen
Add 5			// es wird 5 addiert um x wieder "zurückzusetzen"
Add 3			// 3 wird zu x addiert
MultiMem 61		// x wird mit dem Inhalt der Speicherzelle 61 multipliziert, dieser ist noch der alte Wert des letzten Speicherns (-5)
Store 61			// x wird gespeichert

Wenn die Infos nicht ausreichen, um die Frage zu beantworten bzw. noch andere Fragen aufkommen einfach Fragen, danke im Voraus

[​Tension]

Was ist das für ein Assembler?
Also ich würds so schreiben ( in normalen Assembler ):

//Angenommen X wäre der Wert im Register EDX
mov eax, edx
sub eax, 5 //(x-5)
mov ecx, edx
add ecx, 3 //(x+3)
imul eax, ecx //(x-5)*(x+3)
mov edx, eax //x=(x-5)*(x+3)

Zu deinem: Wieso definierst du X und benutzt es nicht?

Define x 61  // Adresse 61 => X
Define y 65  // Adresse 65 => Y
Load x       // X Laden
Add -5       // 5 abziehen
Store x      // In X speichern
Load y       // Y Laden
Add 3        // 3 addieren
Store y      // In Y speichern
Load x       // X laden
MultiMem y   // Mit Y mutliplizieren
Store x      // In X Speichern

hab leider keine Ahnung was das für ein Assembler ist und einfach ausprobiert, hoffe das es hilft.

[Hülfe]

Was genau das für ein Assembler ist weiß ich leider auch nicht, steht hier nicht bei. Wir haben halt nur die Tabelle mit diesen 7 Operatoren bekommen und sollten damit mal diese Zuweisung implementieren.

Das mit x definieren ist denke ich echt mal nicht so richtig. Es sollte ja ein Wert mit x verbunden sein, denke, der Operator Definde x y war nur in der Tabelle um das Lösen mit einer Hilfsvariablen zu ermöglichen, dafür habe ich auch noch etwas geschrieben, editiere es hier gleich mal rein. Meinst du denn, dass es so wie ich es geschrieben habe auch möglich wäre?

Define h 62		// Hilfsvariable h  wird definiert
Load 62			// h wird geladen
AddMem 61		// Variable x wird zu h addiert (x hat pos. 61)
Store 62		// h wird gespeichert
Load 61			// x wird geladen
Add -5			// 5 wird von x abgezogen
Store 61		// x wird gespeichert
Load 62			// h wird geladen
Add 3			// 3 wird z u h addiert
Store 62		// h wird gespeichert
Load 61			// x wird geladen
MultiMe 62		// x wird mit h multipliziert
Store 61		// x wird gespeichert

[​Tension]

Hat er euch kein Beispiel dazu gegeben?
also für mich ist das kein Assembler.
Ich weiß jetzt nicht wie der dann auch funktioniert, aber ja theoretisch müsste dein Code auch funktionieren. Habt ihr nicht einmal einen Compiler bekommen?

[Master674b]

Originally Posted by Ten$ion

Hat er euch kein Beispiel dazu gegeben?
also für mich ist das kein Assembler.
Ich weiß jetzt nicht wie der dann auch funktioniert, aber ja theoretisch müsste dein Code auch funktionieren. Habt ihr nicht einmal einen Compiler bekommen?

Oh Gott, das ist doch völlig unerheblich was das für ein Maschinencode ist. Er hat hier einfach einen vorgegebenen Befehlssatz und daraus soll er das Ergebnis der Formel oben berechnen...

Define x 10
Define y 11
Load x
Add -5
Store y
Load x
Add 3
MultMem y
Store x

[Hülfe]

Also Master674b, bei deinem Code gäbe es soweit ich weiß ein paar Probleme.
Wenn man mit einer Hilfsvariablen arbeitet möchte man deren Wert erstmal auf den von X setzen.

Define x 10		// Doch kein Define von x da x einen Wert haben kann den man ja benutzen möchte, mit Define x wird es = 0
Define y 11		// 
Load x			//
Add -5			//
Store y                 // Store x - Tippfehler denke ich :P
Load x			// Load y -     " 
Add 3			// Hier noch add x machen um das gleich zu setzen.
MultMem y		// Jetzt halt store y und load x noch
Store x			//

[Master674b]

Originally Posted by Hülfe

Also Master674b, bei deinem Code gäbe es soweit ich weiß ein paar Probleme.
Wenn man mit einer Hilfsvariablen arbeitet möchte man deren Wert erstmal auf den von X setzen.

Define x 10		// Doch kein Define von x da x einen Wert haben kann den man ja benutzen möchte, mit Define x wird es = 0
Define y 11		// 
Load x			//
Add -5			//
Store y                 // Store x - Tippfehler denke ich :P
Load x			// Load y -     " 
Add 3			// Hier noch add x machen um das gleich zu setzen.
MultMem y		// Jetzt halt store y und load x noch
Store x			//

Wieso? x steht in Speicherzelle 10, die definier ich im Programm erst mal damit ich nicht immer 10 schreiben muss. Wieso sollte ich die Hilfsvariable auf x setzen? Ich möchte sie auf x - 5 setzen.
Nein Store y, das ist kein Tippfehler.
Auch beim nächsten, das soll schon ein Load x sein!
Nein, Add 3
Nein, das Ergebnis von x + 3 ist noch im Arbeitsregister, also einfach MultMem y (da haben wir x - 5 abgelegt).
In x storen.

[Hülfe]

Aber dann würdest du doch wenn du Add -5 ausführst das auch für X machen und nicht nur für Y, das würde doch die ganze Rechnung falsch machen oder?

[Master674b]

Originally Posted by Hülfe

Aber dann würdest du doch wenn du Add -5 ausführst das auch für X machen und nicht nur für Y, das würde doch die ganze Rechnung falsch machen oder?

Nö, ich speichere x-5 ja in y und hol mir dann über Load x wieder den Ausgangswert von x, der liegt dann im Arbeitsregister. Dann mach ich Add 3 und anschließend multipliziere ich es mit dem Zwischenergebnis, das ich in y gestored hab und schreib den aktuellen Wert aus dem Arbeitsregister in x.

[​Tension]

Deine Funktion funktioniert zwar, jedoch hat dann y den Wert welchen x haben sollte.

<===Executing Code!===>
Defined x with the Address 10 //Define x 10
Defined y with the Address 11 //Define y 11
Akkumulator set to 0 // Load x
Added -5 to the akkumulator, its now: -5 // Add -5
Stored -5 in the cell y // Store y
Akkumulator set to 0 // Load x
Added 3 to the akkumulator, its now: 3 // Add 3
Multiplied y with the akkumulator 3 its now: -15 //MultMem y
<=== Done ===>

<=== Cells ===>
x(10)=0
y(11)=-15
Akkumulator=3
<=== ===>

dieser code funktioniert:

Define x 61
Define y 62
Load x
Add -5
Store x
Load y
Add 3
Store y
MultMem x

Output:

<===Executing Code!===>
Defined x with the Address 61
Defined y with the Address 62
Akkumulator set to 0
Added -5 to the akkumulator, its now: -5
Stored -5 in the cell x
Akkumulator set to 0
Added 3 to the akkumulator, its now: 3
Stored 3 in the cell y
Multiplied x with the akkumulator 3 its now: -15
<=== Done ===>

<=== Cells ===>
x(61)=-15
y(62)=3
Akkumulator=3
<=== ===>

[Master674b]

Originally Posted by Ten$ion

Deine Funktion funktioniert zwar, jedoch hat dann y den Wert welchen x haben sollte.




dieser code funktioniert:

Define x 61
Define y 62
Load x
Add -5
Store x
Load y
Add 3
Store y
MultMem x

Output:

Load y
Add 3
Store y

y ist doch eine bis dato uninitialisierte Hilfsvariable. Wie soll das bitte Funktionieren?

Deine Funktion funktioniert zwar, jedoch hat dann y den Wert welchen x haben sollte.

Nein, hats nicht. Ich store das Ergebnis doch in x. y hat nur den Wert x - 5, auch nachdem das Programm abgearbeitet wurde.

[​Tension]

Originally Posted by Master674b

Load y
Add 3
Store y

y ist doch eine bis dato uninitialisierte Hilfsvariable. Wie soll das bitte Funktionieren?

Nö. Define y 61
danach hat y den Wert 0. Dann:
Load y => Lade den Wert von y in den akkumulator
Add 3 => Addiere 3 zu den Akkumulator
Store y => Speicher den Akkumulator in y.

Originally Posted by Master674b

Nein, hats nicht. Ich store das Ergebnis doch in x. y hat nur den Wert x - 5, auch nachdem das Programm abgearbeitet wurde.

Nein. Guck dir meinen Output-Code an.
Du definierst x und y. Dann lädst du x und addierst -5 und speicherst es in y.
Danach lädst du x und addierst 3 und multiplizierst es mit dem Wert aus y. Danach packst du den Akkumulator in x welcher aber immer noch den Wert 3 hat. ( Mein Output hat irgendwie die letzte Zeile von dir ( Store x ) nicht mitgenommen trotzdem ist das so. )
Nun hat y den Wert -15, was eigentlich in x sollte.
Du könntest deinen Code im Grunde einfach umdrehen:

Define x 10
Define y 11
Load y
Add -5
Store x
Load y
Add 3
MultMem x
Store y

Wobei das Store y unnötig wäre.

[Schlüsselbein]

Wo steht dass y nach dem definieren den Wert 0 hat? Falls das nicht irgendwo exizit so festgehalten ist, kannst du davon nicht ausgehen.

[MrSm!th]

Es gibt keinen Set Befehl o.Ä. für Konstante Operationen, also wäre eine Initialisierung mit 0 bei Define die einzige Möglichkeit, einen determinierten Wert zu erhalten. Die Sprache ist unvollständig, wenn der Speicher nicht mit 0 initialisiert wird.

[Schlüsselbein]

Oder mit 1337 oder 666 oder... Die Aufgabenstellung bzw die Beschreibung des Befehlssatzes ist m.E. nicht komplett.