IM P label = Bedingte Verzweigungen

Transkript

1 298 6 MMIX-Prozessor Verzweigungsbefehle Unbedingte Verzweigung 23 0 opc X 4 z Befehl Operanden Name/Aktion Definition JMP XYZ u64 0 ( u(@) + 4 s(xyz)) IM P label = Bedingte Verzweigungen Befehl Operanden Name/Aktion Definition BZ $XYZ Branch if zero s($x) u64 0 ( u(@) + 4 s(yz)) PBZ $XYZ Probable br. if zero s($x) u64 0 ( u(@) + 4 s(yz)) BNZ $XYZ Branch if nonzero s($x) 6= u64 0 ( u(@) + 4 s(yz)) PBNZ $XYZ Prob. br. if nonzero s($x) 6= u64 0 ( u(@) + 4 s(yz)) BN $XYZ Branch if negative s($x) < 0 u64 0 ( u(@) + 4 s(yz)) PBN $XYZ Prob. br. if negative s($x) < 0 u64 0 ( u(@) + 4 s(yz)) BNN $XYZ Branch if nonneg. s($x) 0 u64 0 ( u(@) + 4 s(yz)) PBNN $XYZ Prob. br. if nonneg. s($x) 0 u64 0 ( u(@) + 4 s(yz)) BP $XYZ Branch if positive s($x) > 0 u64 0 ( u(@) + 4 s(yz)) PBP $XYZ Prob. br. if positive s($x) > 0 u64 0 ( u(@) + 4 s(yz)) BNP $XYZ Branch if nonpositive s($x) apple 0 u64 0 ( u(@) + 4 s(yz)) PBNP $XYZ Prob. br. if nonpos. s($x) apple 0 u64 0 ( u(@) + 4 s(yz)) BEV $XYZ Branch if even u 0 64 ( u(@)+4 s(yz)) PBEV $XYZ Prob. branch if even u 0 64 ( u(@)+4 s(yz)) BOD $XYZ Branch if odd u 0 64 ( u(@)+4 s(yz)) PBOD $XYZ Prob. branch if odd u 0 64 ( u(@)+4 s(yz)) # 4 Byte I = Befehl

2 6.5 MMIX Befehle 299 Betrachten Sie die folgenden Befehle: LOC Data_Segment A OCTA 1000 a IS $1 b IS $2 LOC #100 Main LDB aa Start SUB aa1 OR aa0 BZ aend End TRAP 000 3! JMP Start g.be?eseznni.aoxf1fffffd a) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls JMP Start. b) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls BZ aend. #

3 300 6 MMIX-Prozessor c) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren: C-Code: if(a == 0) { a = 1; was :* }. MMIX-Code: BNZ a Ende Ende SETL a 1 d) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren: C-code: int a;... if(a <= 0) { with a = 1; } else { a = 2; MMIX-Code: } ywiindffuffüsbeernsebtzt BP a Pos SET d 1 IMP Ende Pos SET d 2 Ende

4 6.5 MMIX Befehle 301 T e) Geben Sie den MMIX-Code an der nachfolgenden C-Code implementiert: C-Code: int a b;... if(a > 0 && b < 0) { a = 1; } else if(a > 0 b == 0) { a = 2; } else { a = 3; } MMIX-Code:: FPI:O Fook :] Ende 0 BNP a U BNN b U SET A 1 IMP Ende 21 BP a LZ BZ ab LZ SET a 3 JMP Ende ( 2 SET d 2 Ende

5 302 6 MMIX-Prozessor Befehle für Funktionsaufrufe Befehl Operanden Name/Aktion Definition $X$Y$Z Go to location $X u64 0 ( u(@) + 4) u64 0 GO ( u($y)+u($z)) ^ $X u64 0 ( u(@) + 4) ); $X$YZ Go to location u neuer 64 0 ( u($y)+u(z)) Befehls 2inch Sprung adresse T a) Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl? I äh T b) Wo speichern GO-Befehle die Rücksprungadresse ab? T c) Was ist die Rücksprungadresse? T d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit) im 32 Bit breiten Befehlswort abgelegt? e) Geben Sie den Befehl an mit dem Sie die Funktion fkt aufrufen und die Rücksprungadresse in Register 0 ablegen. 0 $0 fht

6 6.5 MMIX Befehle 303 Namensräume - der PREFIX-Befehl Der PREFIX-Befehl ist ein Assembler-Befehl. Er wird verwendet um in einem Programm vorkommenden Namen vom Assembler-Präprozessor durch Voranstellen einer Zeichenkette automatisiert ändern zu lassen. Dazu wird der PREFIX-Befehl mit der voranzustellenden Zeichenkette als Operand aufgerufen. PREFIX Zeichenkette Ab dieser Anweisung setzt der Assembler-Präprozessor vor jeden Namen die angegebene Zeichenkette. Hat beispielsweise die Zeichenkette den Wert abc: dann wird ein Name def. in abc:def geändert. Fügt man vor jede Funktion einen PREFIX-Befehl mit dem Funktionsnamen als Zeichenkette ein erzeugt man automatisch für jede Funktion einen eigenen Namensraum. Eine Variable i in der Funktion fkt bekommt dann den (globalen) Namen fkti und eine Variable i in der Funktion fkt2 den Namen fkt2i. Auf diese Weise kann der Assembler beide Variable als unterschiedliche Variable erkennen und es kommt zu keinem Konflikt wenn der Assembler beispielsweise i sowohl durch $1 ersetzen soll (für die Funktion fkt1) als auch durch $2 (für die Funktion fkt2). Um den Funktionsnamen besser vom Variablennamen abgrenzen zu können bietet es sich an an die Prefix-Zeichenkette noch ein markantes Zeichen anzuhängen beispielsweise einen Bindestrich oder einen Doppelpunkt. Um einen Namensraum zu beenden d.h. um den Assembler-Präprozessor anzuweisen vorkommenden Namen die Zeichenkette nicht mehr voranzustellen wird der PREFIX- Befehl mit einem Doppelpunkt als Operand aufgerufen. PREFIX : Will man innerhalb eines Namensraums verhindern dass der Assembler-Präprozessor einen Namen ändert schreibt man vor den betreffenden Namen einen Doppelpunkt z.b. :def statt def. Auf diese Weise kann man auf globale Namen wie z.b. den Stackpointer SP zugreifen. a) Geben Sie die Anweisung an mit denen Sie den Namensraum Main: eröffnen und in diesem Namensraum die globale Marke Main definieren.

7 304 6 MMIX-Prozessor b) Wie kann man einen Namensraum beenden d.h. wie kann man den Assembler anweisen Marken/Namen nicht mehr umzuwandeln? c) Wie kann man innerhalb eines Namensraums verhindern dass der Assembler einer bestimmten Marke bzw. einem bestimmten Namen die im PREFIX-Befehl angegebene Zeichenkette voranstellt? T d) Wozu dient der PREFIX-Befehl? T e) Welche Auswirkung hat der Befehl PREFIX mein_prefix auf darauf folgende MMIX- Anweisungen?

8 6.5 MMIX Befehle 305 T f) Geben Sie die Anweisungen an mit denen Sie den Namensraum Fkt: eröffnen und die globale Marke Fkt anlegen. Funktionsaufrufe Mit Funktionen werden logisch zusammengehörige Befehle zur Bereitstellung einer Gesamt-Funktionalität zusammengefasst und durch Funktionsaufrufe von beliebigen Stellen im Programm abrufbar. Durch diese Struktur gebende Maßnahme werden Programme übersichtlicher und kürzer: Übersichtlicher da der Programm-Code die Zerlegung eines großen Problems in kleinere Probleme durch Funktionsaufrufe widerspiegelt und kürzer da eine Funktionalität (viele Befehle) nur einmal aus Befehlen zusammengesetzt werden muss und durch Sprünge in die Funktion (wenige Befehle) beliebig oft verwendet werden kann. Beispiel: -Adresse von Personen aus einer csv-datei (csv = comma separated values = Werte durch Komma getrennt) extrahieren und jeder Person ein schreiben: Aufruf einer Funktion welche den Namen der csv-datei als Parameter übergeben bekommt und den Inhalt der Datei in den String s einliest. Aufruf einer Funktion welche den String s sowie das Zeichen \n als Parameter übergeben bekommt den String an den Zeichen \n in Teil-Stings s 1 s 2... auftrennt und als Ergebnis ein Array von Zeigern auf die Teil-Strings zurückliefert. Für jeden Teilstring s i : Aufruf einer Funktion welche den String s i und das Komma-Zeichen als Parameter übergeben bekommt den String an den Kommas in Teilstrings s ij auftrennt und als Ergebnis ein Array von Zeigern auf die Teil-Strings zurückliefert. Auswahl des Teil-Strings s ij in dem die -Adresse gespeichert ist. Für jede -Adresse s ij : Aufruf einer Funktion die als Parameter die - Adresse und den -Text bekommt und den -Text an die angegebene -Adresse verschickt.

9 306 6 MMIX-Prozessor Wert-Übergabe und Referenz-Übergabe Es gibt viele Möglichkeiten Funktionen Parameter zu übergeben. Prinzipiell unterscheidet man zwischen der Übergabe von Werten und der Übergabe von Referenzen. Bei der Wert-Übergabe (engl. call by value) wird der Funktion direkt der zu verarbeitende Wert übergeben z.b. eine Festkommazahl. Bei der Referenz-Übergabe (engl. call by reference) wird der Funktion die Adresse des zu verarbeitenden Werts übergeben z.b. die Adresse an der eine Festkommazahl im Speicher steht. In beiden Fällen wird bei der Parameterübergabe eine lokale Kopie erstellt. Bei der Wert-Übergabe wird eine Kopie des Werts erstellt. Ändert die Funktion die ihr übergebene Variable so hat das keinen Einfluss auf den Wert der Original-Variable. Bei der Referenz-Übergabe wird eine Adresse übergeben und somit eine Kopie der Adresse erstellt. Auch wenn es sich nur um eine Kopie der Adresse handelt die kopierte Adresse zeigt auf dieselbe Speicherstelle wie die originale Adresse. Damit kann die Funktion Änderungen an den Werten durchführen die an der übergebenen Speicheradresse stehen und der Funktionsaufrufer kann auf diese Änderungen zugreifen. Wert-Übergabe Referenz-Übergabe Speicher Funktionsaufrufer: Wert Adresse ruft auf wird kopiert wird kopiert zeigt auf zeigt auf wird kopiert wird kopiert Funktion: Wert Adresse Diese Variable steht hier im Speicher

10 6.5 MMIX Befehle 307 Aufrufkonventionen Eine Aufrufkonvention (engl. calling convention) legt fest wie einer Funktion Parameter übergeben werden und wie der Rückgabewert zurückgegeben wird. Damit spezifiziert eine Aufrufkonvention u.a. Antworten auf Fragen wie: Werden alle Parameter auf dem Stack übergeben oder werden die ersten n Parameter in Registern übergeben und die restlichen auf dem Stack? Welche Register werden zur Parameterübergabe verwendet? In welcher Reihenfolge werden die Parameter auf dem Stack bzw. in den Registern abgelegt? Werden Gleitkommazahlen in anderen Registern übergeben als Festkommazahlen? In welchen? Wer bereinigt den Stack: Der Funktionsaufrufer oder die Funktion? Wie wird der Rückgabewert zurückgegeben: Auf dem Stack oder in einem Register? In welchem? Da unterschiedliche Prozessorarchitekturen unterschiedliche Register haben (Anzahl Funktion...) und sich auch bezüglich der Verwendung des Stacks unterscheiden können sind Aufrufkonventionen architekturabhängig. Funktionen können auf einer Prozessorarchitektur in vielfältiger Art und Weise aufgerufen werden. Somit gibt es für jede Prozessorarchitektur in der Regel auch mehrere mögliche Aufrufkonventionen. Bei der Programmierung in Hochsprache ist das Einhalten der gewünschten Aufrufkonvention Aufgabe des Compilers. Parameterübergabe auf dem Stack beim MMIX Der Stack ist ein Bereich im Speicher des Prozessors in dem Funktionsparameter Rücksprungadressen und lokale Variable nacheinander aufgerufender Funktionen aufeinandergestapelt (engl. stack = Stapel) werden. Beim MMIX kann der Stack am Ende des Datensegments aufgebaut werden beginnend an Adresse 0x3FF...F8 in Richtung niedrigerer Adressen wachsend. Der Stack wird immer über den sog. Stackpointer angesprochen. Der Stackpointer wird realisiert durch ein Register in dem die Adresse der auf dem Stack ganz oben liegenden Daten abgelegt ist. Viele Prozessoren verwenden ein spezielles Stackpointer-Register. Beim MMIX verwenden wir ein globales Allzweckregister als Stackpointer.

11 308 6 MMIX-Prozessor Beim MMIX kann die Verwendung eines Stacks wie folgt umgesetzt werden: Beim Start eines Programmes wird mit der Anweisung SP GREG # ein globales Register angelegt mit 0x initialisiert und über die Marke SP angsprechbar gemacht. Über diese Marke wird der Stackpointer dann zukünftig angesprochen. 8 Byte SP 0x3FFFFFFFFFFFFFF8 0x Der Stackpointer zeigt jetzt auf den Beginn des Pool-Segments. Beim Aufruf einer Funktion mit n Parametern wird vom aktuellen Wert des Stackpointers n 8 subtrahiert. Der Stackpointer zeigt dann auf eine niedrigere Adresse d.h. er wandert nach oben. Im Falle n =3wird 3 8 subtrahiert. SUB :SP:SP3*8 Der Stackpointer zeigt dann auf Adresse 0x3FFFFFFFFFFFFFE8. Stackpointo nach Platz für 3 oben SP pp Parameter 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x

12 6.5 MMIX Befehle 309 Stackpoyinkr als Basis adresse Anschließend werden die Parameter mittels Stackpointer auf den Stack kopiert. STO a:sp0 STO STO b:sp1*8 c:sp2*8 offset SP 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Parameter für Fkt 2. Parameter für Fkt 3. Parameter für Fkt Nachdem die Parameter auf den Stack kopiert sind wird mit dem GO-Befehl in die Funktion gesprungen. Dazu wird die Einsprungs-Marke der Funktion angegeben z.b. Fkt. Als Register zur Speicherung der Rücksprungadresse sollte ein Register angegeben werden das keine Daten enthält die noch benötigt werden. Es bietet sich an die Rücksprungadresse immer in demselben Register abzulegen beispielsweise in Register 0. GO $0:Fkt

13 310 6 MMIX-Prozessor Als Aufrufkonvention legen wir fest dass die aufgerufene Funktion sicherstellen muss dass sie keine vom Funktionsaufrufer in Registern gespeicherten Daten überschreibt. Da die Funktion die vom Funktionsaufrufer verwendeten Register nicht zwingend kennt (z.b. Bibliotheksfunktion) sichert sie alle von ihr selbst verwendeten Register auf den Stack. Die Funktion kann die Register dann verwenden muss aber unmittelbar vor dem Rücksprung zum Funktionsaufrufer die alten Werte wieder vom Stack in die entsprechenden Register zurück kopieren. Verwendet die Funktion beispielsweise die Register 1 und 2 so sichert sie diese auf den Stack. SUB STO STO :SP:SP2*8 $1:SP0 $2:SP1*8 SP 0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt 0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt 'ÄÄAA pp ) Register sichern schaffen 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Parameter für Fkt 2. Parameter für Fkt 3. Parameter für Fkt } Parameter auslesen Sind die Register auf den Stack gesichert lädt die Funktion die für sie bestimmten Parameter vom Stack und verarbeitet sie. LDO $1:SP2*8 Parameter 1 LDO $2:SP3*8 Parameter LDO $2:SP4*8 Parameter

14 6.5 MMIX Befehle 311 Ruft die Funktion Fkt selbst eine andere Funktion Fkt2 auf so sichert sie zunächst die Rücksprungadresse auf den Stack kopiert die der Funktion Fkt2 zu übergebenden Parameter auf den Stack und ruft dann Funktion Fkt2 auf. SUB :SP:SP2*8 STO $0:SP1*8 Rücksprungadresse STO $1:SP0 Parameter für Fkt2 GO $0:Fkt2 putt schaften SP II. 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 Parameter für Fkt2 Sicherung $0 Fkt Sicherung $1 Fkt Sicherung $2 Fkt 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Parameter für Fkt 2. Parameter für Fkt 3. Parameter für Fkt

15 312 6 MMIX-Prozessor Die Funktion Fkt2 sichert nun ihrerseits die von ihr verwendeten Register auf den Stack lädt den ihr übergebenen Parameter vom Stack und führt damit Berechnungen durch. SUB :SP:SP2*8 STO $1:SP0 Sicherung $1 STO $2:SP1*8 Sicherung $2 LDO $2SP2*8 : Parameter laden SP in P 0x3FFFFFFFFFFFFFB8 0x3FFFFFFFFFFFFFC0 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt 2 Sicherung $2 Fkt 2 Parameter für Fkt2 Sicherung $0 Fkt Sicherung $1 Fkt Register sichern Parameter aus lesen 0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Parameter für Fkt 2. Parameter für Fkt 3. Parameter für Fkt

16 6.5 MMIX Befehle 313 Hat Fkt2 ihre Berechnungen abgeschlossen legt Sie den Rückgabewert an der Stelle auf dem Stack ab an der ihr der Parameter übergeben wurde. Sind mehrere Parameter übergeben worden wird der Rückgabewert an die Stelle desjenigen Parameters mit der höchsten Adresse geschrieben. Wurde kein Parameter übergeben so muss vor der Sicherung der Register auf dem Stack Platz freigehalten werden. STO $2:SP2*8 Rückgabewert SP 0x3FFFFFFFFFFFFFB8 0x3FFFFFFFFFFFFFC0 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Sicherung $1 Fkt 2 Sicherung $2 Fkt 2 Rückgabewert von Fkt2 Sicherung $0 Fkt Sicherung $1 Fkt Sicherung $2 Fkt 1. Parameter für Fkt 2. Parameter für Fkt 3. Parameter für Fkt Ergebnis auf stack als legen

17 ' MMIX-Prozessor Nach dem Ablegen des Rückgabewerts auf dem Stack muss die Funktion Fkt2 die auf den Stack gesicherten Register wieder herstellen. Anschließend muss der Stackpointer so angepasst werden dass er auf den Rückgabewert zeigt so dass er vom Funktionsaufrufer ausgelesen werden kann ohne die Anzahl der von Fkt2 auf den Stack gesicherten Register zu kennen. Anschließend springt die Funktion Fkt2 zurück zum Funktionsaufrufer. Als Rücksprungadresse dient Register 0 mit dem Offset 0. Für den GO-Befehl muss wieder ein Register zur Speicherung der Rücksprungadresse angegeben werden auch wenn nicht an das Ende der Funktion Fkt2 zurückgesprungen wird. Da der in Register 0 enthaltene Wert nach dem Rücksprung nicht mehr benötigt wird kann Register 0 auch wieder zur Abspeicherung dieser Rücksprungadresse verwendet werden (1. Parameter des GO-Befehls). SP Fdr. tr GO - +4 LDO $1:SP0 LDO $2:SP1*8 ADD :SP:SP2*8 GO $0$00 Bef P Ruck sprung TEIG sprung nach $0 +0 0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2 0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 Rückgabewert von Fkt2 Sicherung $0 Fkt 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 Sicherung $1 Fkt Sicherung $2 Fkt 0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt 0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt 0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt 0x Auf die Werte oberhalb des Stackpointers wird nicht mehr zugegriffen. Sie werden aber nicht explizit gelöscht/überschrieben.

18 6.5 MMIX Befehle 315 Die Funktion Fkt kann nun das ihr von Fkt2 übergebene Ergebnis vom Stack auslesen und mit ihren Berechnungen fortfahren. Nach dem Auslesen des Rückgabewerts von Fkt2 addiert die Funktion Fkt noch den Wert 8 zum Stackpointer. Damit zeigt der Stackpointer auf dieselbe Stelle wie vor dem Aufruf von Fkt2. Der Aufruf von Fkt2 ist damit offiziell abgeschlossen. LDO ADD $1:SP0 :SP:SP8 0x3FFFFFFFFFFFFFB8 Sicherung $1 Fkt 2 0x3FFFFFFFFFFFFFC0 Sicherung $2 Fkt 2 SP - 0x3FFFFFFFFFFFFFC8 tu 0x3FFFFFFFFFFFFFD0 Rückgabewert von Fkt2 Sicherung $0 Fkt 0x3FFFFFFFFFFFFFD8 Sicherung $1 Fkt 0x3FFFFFFFFFFFFFE0 Sicherung $2 Fkt 0x3FFFFFFFFFFFFFE8 1. Parameter für Fkt 0x3FFFFFFFFFFFFFF0 2. Parameter für Fkt 0x3FFFFFFFFFFFFFF8 3. Parameter für Fkt 0x

19 316 6 MMIX-Prozessor Die Funktion Fkt kann nun das Ergebnis von Fkt2 für ihre weiteren Berechnungen verwenden. Hat die Funktion Fkt ihre Berechnungen abgeschlossen kopiert sie ihren Rückgabewert auf den Stack stellt die von ihr gesicherten Register wieder her passt den Stackpointer so an dass er auf den Rückgabewert zeigt und kehrt schließlich zum Funktionsaufrufer zurück STO $1:SP5*8 LDO $0:SP0 LDO $1:SP1*8 LDO $2:SP2*8 ADD :SP:SP5*8 GO $0:$00 5*8 [ SP 0x3FFFFFFFFFFFFFB8 0x3FFFFFFFFFFFFFC0 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Sicherung $1 Fkt 2 Sicherung $2 Fkt 2 Rückgabewert von Fkt2 Sicherung $0 Fkt Sicherung $1 Fkt Sicherung $2 Fkt 1. Parameter für Fkt 2. Parameter für Fkt Rückgabewert von Fkt

20 6.5 MMIX Befehle 317 Der Funktionsaufrufer kann nun das Ergebnis der Funktion Fkt über den Stackpointer auslesen und danach den Stackpointer wieder anpassen so dass er auf die selbe Stelle zeigt wie vor dem Aufruf der Funktion Fkt. LDO ADD $1:SP0 :SP:SP8 SP Tui 0x3FFFFFFFFFFFFFB8 0x3FFFFFFFFFFFFFC0 0x3FFFFFFFFFFFFFC8 0x3FFFFFFFFFFFFFD0 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 0x3FFFFFFFFFFFFFF8 0x Sicherung $1 Fkt 2 Sicherung $2 Fkt 2 Rückgabewert von Fkt2 Sicherung $0 Fkt Sicherung $1 Fkt Sicherung $2 Fkt 1. Parameter für Fkt 2. Parameter für Fkt Rückgabewert von Fkt

21 318 6 MMIX-Prozessor Aufgaben a) Geben Sie den Befehl an mit dem Sie den Stackpointer als globales Register anlegen mit 0x initialisieren und über die Marke SP ansprechbar machen. SP GREG # O b) Geben Sie die Befehle an mit denen der Funktionsaufrufer aus dem Namensraum Main: heraus Register 3 und 4 als Parameter auf dem Stack ablegt und danach die global definierte Funktion Str aufruft. Die Rücksprungadresse soll in Register 0 abgelegt werden. SUB :P :S 2*8 STO $3 :P 0 STO $4 :S 8 GO $0 istr c) Geben Sie die Befehle an mit denen Sie den Namensraum Str: anlegen dann die Funktion Str beginnen und die Register 0 1 und 2 auf den Stack sichern. stristr sonstige PREFIX str : : str SUB :P :S 3*8 STO $0 :S 0 STO $1 :P 8 STO $2 :S 2*8

22 ... F8 Sicherung 1 OXIF. ( Sicherung F.. - Parameter OXIF... E- EO. 8.. FO P 0x4O. :-O Main ost SP GREG # 40. ' Rafäüetüeiffez oxeoo Fixum K anoy unosekfz Uxioc STO 9 SUB :S :P 2*8 :P 0 sto b :S 8 GO $0 Fht LDO a :S 0 ADD :P :S 8 Fht SUB :S :D 2*8 STO :D 0 STO :P g 8 LDO : x. SP 2*8 LDO Y :P 3*8 STOX LDO LDO :b 3*8 x. : SP 0 y :P 8 ADD :S :S 3*8 60 $ $00

23 6.5 MMIX Befehle 319 d) Tragen Sie in nachfolgende Abbildung die auf dem Stack gespeicherten Werte ein und geben Sie die Position des Stackpointers an. 0x3FFFFFFFFFFFFFD0 SP 0x3FFFFFFFFFFFFFD8 0x3FFFFFFFFFFFFFE0 0x3FFFFFFFFFFFFFE8 0x3FFFFFFFFFFFFFF0 Sicherung $0 Sicherung $1 Sicherung SK 2. Parameter 0x3FFFFFFFFFFFFFF8 1.EU#TiiseW - 0x : e) Geben Sie die Befehle an mit denen Sie die übergebenen Parameter in die Register 1 und 2 einlesen. DO $1 3*8 4*8 f) Geben Sie die Befehle an mit denen Sie den Wert aus Register 1 als Ergebnis auf dem Stack ablegen die auf den Stack gesicherten Register wieder herstellen den Stackpointer anpassen und zurück zum Funktionsaufrufer springen. Die Rücksprungadresse steht in Register 0 und soll auch wieder dort abgelegt werden. STO $1 :S 4*8 LDO $0 :S 0 LDO $1 :D 8 LDO $2 :S P 16 LDO $2 :# ADD :D :S 4*8 60 $0 $00

24 320 6 MMIX-Prozessor g) Geben Sie die Befehle an mit denen Sie den Namensraum Str: wieder beenden. PREFIX : h) Geben Sie die Befehle an mit denen der Funktionaufrufer das Ergebnis vom Stack in das Register 1 einliest und den Stackpointer anpasst. LDO $1 :P 0 ADD :P :S P 8

25 6.5 MMIX Befehle 321 T i) Was ist der Stack? T j) Wo beginnt der Stack und in welche Richtung wächst er? T k) Was ist der Stack-Pointer? T l) Wie werden Daten adressiert die auf dem Stack liegen?

26 322 6 MMIX-Prozessor T m) Welche Operationen muss man ausführen um die Werte zweier Register (acht Byte breite Datenworte) auf dem Stack abzulegen? T n) Wie wird der Stack bei Funktionsaufrufen verwendet?

27 6.5 MMIX Befehle 323 T o) Geben Sie den Befehl an mit dem Sie für den Stack-Pointer ein globales Register reservieren und dieses mit 0x initialisieren. T p) Warum initialisieren wir den Stack-Pointer mit 0x d.h. mit dem Beginn des Poolsegments und nicht mit dem Ende des Datensegments? T q) Geben Sie die MMIX-Befehle an mit denen Sie Register $1 und $2 auf den Stack schreiben und dann die Funktion fkt aufrufen. Nehmen Sie an dass Ihr Code im Namensraum Main: steht und fkt im Namensraum Fkt: unter dem Namen :fkt angelegt wurde. Sichern Sie die Rücksprungadresse in Register 0.

28 324 6 MMIX-Prozessor Nehmen Sie an dass Sie eine Funktion im Namensraum Fkt: implementieren. T r) Geben Sie die MMIX-Befehle an mit denen Sie die Register und 3 auf den Stack sichern und anschließend zwei acht Byte breite Parameter vom Stack in die Register 1 und 2 einlesen. T s) Zeichnen Sie wie der Stack nach diesen Operationen aussieht.

29 6.5 MMIX Befehle 325 T t) Im Hauptprogramm wurden die Parameter in die Register 1 und 2 geschrieben. Im Unterprogramm wurden Register 1 und 2 dann auf den Stack gesichert und dann dieselben Werte wieder vom Stack in Register 1 und 2 geladen obwohl sich die Werte von Register 1 und 2 in der Zwischenzeit nicht geändert hatten. Warum haben wir und diesen Schritt nicht gespart sondern dieselben Werte die in Registern 1 und 2 waren nochmal reingeschrieben? T u) Warum speichert man die Rücksprungadresse auf dem Stack? T v) Was würde passieren wenn der Stack so groß wird dass er mit den Daten zusammenstößt die am Beginn des Datensegments liegen?

30 326 6 MMIX-Prozessor T w) Geben Sie die MMIX-Befehle an mit denen Sie den Inhalt von Register 3 als Ergebnis auf dem Stack ablegen dann die Register und 3 wiederherstellen und anschließend zurück zum Funktionsaufrufer springen. T x) Nehmen Sie an Sie sind wieder im Hauptprogramm. Geben Sie die Befehle an mit denen Sie das Ergebnis der Funktion vom Stack in das Register 1 einlesen. T y) Warum muss der Stack-Pointer angepasst werden nachdem das Ergebnis vom Stack geladen wurde?

31 6.5 MMIX Befehle 327 Beispielprogramm: Quadratische Gleichung In dieser Übung schreiben Sie ein MMIX Programm zur Lösung der Quadratischen Gleichung a x 2 + b x + c =0mit der Formel x 12 = b±p b 2 4 a c 2 a zu lösen. Die Variable a b und c sind als Festkommazahlen gegeben; das Ergebnis soll als Gleitkommazahl angegeben werden. a) Geben Sie den MMIX Befehl an mit dem Sie den Stack-Pointer anlegen und über die Marke SP ansprechbar machen. SP GREG # 40. Zunächst soll das Hauptprogramm implementiert werden. b) Geben Sie den MMIX-Befehl an mit dem Sie den Namensraum Main: eröffnen.. - O PREFIX Main :O c) Reservieren Sie an Adresse 0x die 64 Bit breiten Speicherworte A B C X1 und X2 und initialisieren Sie A mit 2 B mit 4 und C mit 8. LOC # 20. A- OCTA 2 OCMA B ( OCTA OCTA 2 OLMA.. 0 d) Geben Sie den Befehl an mit dem Sie Register 1 durch buf ansprechbar machen. but 15 $1

32 MMIX-Prozessor e) Beginnen Sie das Hauptprogramm legen Sie A B und C auf dem Stack ab und rufen Sie dann die global definierte Funktion QuadGleich auf. Speichern Sie dabei die Rücksprungadresse in Register $0. : Main SUB :S :S 3*8 LDO buf A STO but :S 0 LDO buf B STO but :b LDO bnf C STO f) Geben Sie den MMIX Code an mit dem Sie die Ergebnisse x 1 und x 2 der Funktion vom Stack auslesen und im Arbeitsspeicher an den Marken X1 bzw. X2 ablegen. 8 bufiispilb GO $0 : Ovuadblexh xn xz Oxceo. LDO but :S 0 STO but IM LDO but :P 8 STO but XZ g) Geben Sie die Anweisungen an mit denen Sie das Programm und den Namensraum Main: beenden. ADD :S :P TRAP 0 : Halt 0 2*8 PREFIX :

33 6.5 MMIX Befehle 329 Im Folgenden soll die Funktion QuadGleich implementiert werden von der folgender Programm-Code bereits gegeben ist: PREFIX QuadGleich: a IS $1 b IS $2 c IS $3 x1 IS $4 x2 IS $5 disk IS $6 buf1 IS $7 buf2 IS $8 Der Funktion QuadGleich werden die Parameter a b und c wie folgt auf dem Stack übergeben: SP! a b c h) Geben Sie an der Marke :QuadGleich die Befehle an mit denen Sie die verwendeten Register auf den Stack sichern und die Parameter a b und c dann vom Stack in die Register a b und c einlesen. :QuadGleich SUB Sp :P 8*8 STO A :P 0 STO er :P 1*8 STO C :b 2*8. STO xs :P 3*8 STO X? :D 4*8 STO disk : SP 5*8 STO STO bnfne.sn bwf4.sp.tt#8 6*8

34 330 6 MMIX-Prozessor i) Geben Sie den MMIX-Befehlscode an der im Fall a =0das Ergebnis x = c/b berechnet dieses dann sowohl in x1 und x2 speichert und dann an die Marke Speichern springt und im Fall a 6= 0an die Marke Anicht0 springt. BNZ NEG FLOT FLOT a Anichto GO.cn GC lrib ORR H OFDN xd Gb MSET R x1 IMP Speichern j) Geben Sie an Marke Anicht0 den MMIX Code an mit dem Sie die Diskriminante b 2 4 a c mittels Festkomma-Arithmetik berechnen und das Ergebnis in Register disk ablegen. Anicht0 MUL bwha.cn MUL bufhbuf 14 MUL bnfzibib SUB disk buk luft