GOP Computertechnik. Computersysteme Probeklausur 2

Transkript

1 Prüfungsfähigkeit: Weitere Hinweise: Die Prüfungsdauer beträgt 75 Minuten. Es sind keine Hilfsmittel erlaubt, auch keine Taschenrechner! Heftung nicht öffnen - keine Blätter abtrennen! Lösungen bitte immer nur in den dafür vorgesehenen Abschnitt eintragen. An anderen Stellen eingetragene Lösungen werden nicht bewertet. Ggf. zweiten Angabebogen anfordern. Verwenden Sie zum Schreiben bitte einen dunklen Stift - die Prüfungen werden eingescannt! Die Prüfung besteht inkl. Anhang und Konzeptpapier aus 22 Seiten - bitte überprüfen! Die angegebene Anzahl zu erreichender Punkte ist als vorläufig zu betrachten. Alle Aufgaben sind unabhängig von der Lösung vorangegangener Aufgaben lösbar. Vorangegangene Angaben können benötigt werden. Bitte ausfüllen: GOP Computertechnik Computersysteme Probeklausur 2 Hiermit bestätige ich, dass ich vor Prüfungsbeginn darüber in Kenntnis gesetzt wurde, dass ich im Falle einer plötzlich während der Prüfung auftretenden Erkrankung das Aufsichtspersonal umgehend informieren muss. Dies wird im Prüfungsprotokoll vermerkt. Danach muss unverzüglich ein Rücktritt von der Prüfung beim zuständigen Prüfungsausschuss beantragt werden. Ein vertrauensärztliches Attest - ausgestellt am Prüfungstag - ist unverzüglich nachzureichen. Wird die Prüfung hingegen in Kenntnis der gesundheitlichen Beeinträchtigung dennoch regulär beendet, kann im Nachhinein kein Prüfungsrücktritt aufgrund von Krankheit beantragt werden. Wird die Prüfung wegen Krankheit abgebrochen, wird die Klausur mit der Note "5, - nicht erschienen" gemeldet und - unabhängig von einem Rücktrittsantrag - nicht bewertet. Name: Vorname: Matrikel-Nr.: Unterschrift: Hörsaal: Reihe: Platz: Fakultät: EI EDU BWL INF Hier Etikett einkleben (Prüfungsaufsicht): Aufg. Aufg. 2 Aufg. Aufg. 4 Aufg. 5 Aufg. 6 Aufg. 7 Punkte: Note:

2 Übersicht Komponenten Computer-Systeme (5 Punkte) 2 Darstellung von Zahlen und Zeichen (6 Punkte) Arithmetische Schaltungen ( Punkte) 4 4 Universalrechner (9 Punkte) 5 MMIX (2 Punkte) 2 5. Assembler- und Loaderbefehle ( Punkte) MMIX-Befehlsformat - Übersetzungstabelle (4 Punkte) Lade- und Speicher-Befehle Alignment (9 Punkte) Arithmetische Befehle (7 Punkte) Funktionsaufrufe/Stack (4 Punkte) Pipelining (6 Punkte) 6 7 Cache-Speicher (9 Punkte)

3 Komponenten Computer-Systeme (5 Punkte) a) Skizzieren Sie das Blockschaltbild des in der Vorlesung besprochenen Schaltnetzteils (4 Punkte) b) Wie groß muss bei einem optischen Datenträger der Abstand Pit Land sein, damit destruktive Interferenz auftreten kann? ( Punkt) 2 Darstellung von Zahlen und Zeichen (6 Punkte) a) Wie lässt sich im Falle der Addition zweier Zahlen im 2er-Komplement ein Überlauf feststellen? (2 Punkte) b) In welcher Zahldarstellung ist der Abstand zweier aufeinander folgender Zahlen stets gleich groß: Bei Festkommazahlen oder bei Gleitkommazahlen? ( Punkt) c) Geben Sie den Wert der gegebenen Gleitkommazahl dezimal an. ( Punkte)

4 4 Arithmetische Schaltungen Arithmetische Schaltungen ( Punkte) a) Tragen Sie in nachfolgende Abbildung die Realisierung eines Bit -auf-2 De- Multiplexers ein. (2 Punkte) Gegeben ist die aus der Vorlesung bekannte Volladdierer-Schaltung. x i y i c i- c i s i b) Geben Sie für die gezeigte Schaltung die Signale g i (x i, y i ) (generate) und p i (x i, y i ) (propagate) in Abhängigkeit ihrer Eingangswerte an. (2 Punkte)

5 5 Gegeben ist die aus der Vorlesung bekannte dreistufige Carry-Look-Ahead-Einheit. x y add/sub CLA-Einheit d CLA-Einheit c CLA-Einheit b CLA-Einheit a GG PP CC GG 2 PP 2 CC 2 GG PP CC GG PP CC CLA-Einheit e CC 4 Überlauf- Erkennung s c) Geben Sie an, wie sich das Signal CC 2 aus den Signalen PP i, GG i und CC zusammensetzt. Wieviele Gatterlaufzeiten τ werden im Fall Fan-In = 2 mindestens benötigt, um CC 2 aus PP i, GG i und CC zu bestimmen? ( Punkte) Gegeben ist der folgende logische Ausdruck: x = (a b c d) e (f g) h. d) Zeichen Sie für Fan-In = eine Gatterschaltung zur Bestimmung von x. (2 Punkte) a b c d e x f g h

6 6 Arithmetische Schaltungen Nachfolgende Schaltung zeigt einen Datenpfad, der die Anzahl der Buchstaben und Ziffern einer maximal 255 Zeichen langen ASCII-Zeichenkette bestimmt und im Speicher ablegt. Die Zeichenkette ist mit abgeschlossen. 2 Schreiben Adresse Speicher Daten Ausgang Daten Eingang Ziffern-Adresse Add Buchstaben-Adresse Ende? Ziffer? Buchstabe? A B RA clk_ra clk_mem ende mux_bz clk_bz Zeichenketten-Adresse mux_init RB Add Steuerung clk_init RZ Add mux_adr Schaltung A prüft, ob das vom Speicher ausgegebene Byte das String-Ende markiert (Byte mit Wert Null ). Ist das Ende erreicht, gibt Schaltung A am Ausgang eine aus. Anderenfalls gibt Schaltung A eine aus. e) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung A ein. (2 Punkte) A

7 7 Schaltung B gibt am Ausgang eine aus, wenn das vom Speicher ausgegebene Byte eine Ziffer ist (ASCII-Wert zwischen 4 und 57). Ansonsten gibt Schaltung B eine aus. f) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung B ein. (5 Punkte) B

8 Arithmetische Schaltungen Nachfolgende Abbildung zeigt noch einmal den Datenpfad. 2 Schreiben Adresse Speicher Daten Ausgang Daten Eingang Ziffern-Adresse Buchstaben-Adresse Add Ende? Ziffer? Buchstabe? A B RA clk_ra clk_mem ende mux_bz clk_bz Zeichenketten-Adresse mux_init RB Add Steuerung clk_init RZ Add mux_adr Die Steuerung des Datenpfads soll wie folgt funktionieren: In den Zuständen und 2 soll das Register RA mit der Zeichenketten-Adresse und die Register RB und RZ mit initialisiert werden (,5 Punkte). Ist in Zustand 2 die Zeichenkette leer, soll in den Zustand 5 verzweigt werden. Anderenfalls soll in Zustand verzweigt werden (,5 Punkte). Von Zustand wird immer in Zustand 4 verzweigt. Dabei soll der in Register RB stehende Wert um erhöht werden, falls das von Register RA adressierte Zeichen ein Buchstabe ist, d.h. wenn Block Buchstabe? eine ausgibt; der in Register RZ stehende Wert um erhöht werden, falls das vom Register RA adressierte Zeichen eine Ziffer ist. (,5 Punkte) Ist die Zeichenkette nicht leer, soll nach Zustand 4 wieder in Zustand verzweigt werden. Dabei soll im Speicher das nächste Byte der Zeichenkette adressiert werden. Anderenfalls soll in Zustand 5 verzweigt werden. (,5 Punkte) Von Zustand 5 soll immer in den Zustand 6 verzweigt werden. Dabei soll der im Register RB abgelegte Wert im Speicher an die Buchstaben-Adresse geschrieben werden. Von Zustand 6 soll immer in Zustand 7 verzweigt werden. (,5 Punkte)

9 9 Von Zustand 7 soll immer in Zustand verzweigt werden. Dabei soll der im Register RZ abgelegte Wert im Speicher an der Ziffern-Adresse abgelegt werden. (,5 Punkte) g) Vervollständigen Sie nachfolgenden Moore-Automaten so, dass er die Hardware in gewünschter Weise steuert. Geben Sie für irrelevante Werte X an. (9 Punkte) Initialisieren 2 Initialisieren Zählen 4 Zählen mux_init: mux_init: mux_init: mux_init: mux_adr: mux_adr: mux_adr: mux_adr: mux_bz: mux_bz: mux_bz: mux_bz: clk_bz: clk_bz: clk_bz: clk_bz: clk_ra: clk_ra: clk_ra: clk_ra: clk_mem: clk_mem: clk_mem: clk_mem: clk_init: clk_init: clk_init: clk_init: RZ/Ende 7 RZ 6 RB 5 RB mux_init: mux_init: mux_init: mux_init: mux_adr: mux_adr: mux_adr: mux_adr: mux_bz: mux_bz: mux_bz: mux_bz: clk_bz: clk_bz: clk_bz: clk_bz: clk_ra: clk_ra: clk_ra: clk_ra: clk_mem: clk_mem: clk_mem: clk_mem: clk_init: clk_init: clk_init: clk_init: immer

10 Arithmetische Schaltungen Nachfolgende Abbildung zeigt einen anderen Moore-Automaten. immer ende = ende = Initialisieren 2 Initialisieren Addieren 4 Schieben 5 Ende clk: clk: clk: clk: clk: clk2: clk2: clk2: clk2: clk2: init: init: init: init: init: reset: reset: reset: reset: reset: ende = immer ende = immer Dieser Moore-Automat soll mit folgender Schaltung implementiert werden: clk clk2 init reset ROM D-Register 2 ende h) Tragen Sie in nachstehende Tabelle binär die ROM-Inhalte für die angegebenen Adressen ein. Zustand wird mit kodiert, Zustand 2 mit,... (5 Punkte) Adresse Daten x2 x4 x9 xb xc

11 4 Universalrechner (9 Punkte) Gegeben ist der aus der Vorlesung bekannte Universalrechner. clk reset a b c M BZ R D2 K D4 D D D2 D D M4 D9 D D7 M A7 D6 D5 A D4 M2 D D2 D M D 2 Add 2 M M A D R7 R6 R5 R4 R R2 R R M M4 M4 MSB M A2 a SUB a-b b ADD MUL a DIV a/b b p X n- n M M2 a) Tragen Sie in nachstehende Tabelle binär den Speicherinhalt zur Berechnung von 2b a ein. Gehen Sie entsprechend der Kommentare vor. Geben Sie für alle irrelevanten Werte X an. (9 Punkte) K D M4 M M2 M Kommentar R = b R = 2 R = 2*b R = a R = sqrt(a) R = 2b-sqrt(a)

12 2 5 MMIX 5 MMIX (2 Punkte) Hinweis: Sie können in allen Aufgaben buf, buf,... als Pufferregister verwenden. 5. Assembler- und Loaderbefehle ( Punkte) a) Mit welcher Anweisung können Sie den Namensraum Main: eröffnen? ( Punkt) b) Wie kann innerhalb eines Namensraums auf globale Variable zugegriffen werden? ( Punkt) c) Geben Sie den Befehl an, mit dem Sie Register durch a ansprechbar machen. ( Punkt) d) Geben Sie die Befehle an, mit denen Sie im Speicher an Adresse x2 einen vierdimensionalen Vektor anlegen, dessen Elemente 2 Bit Gleitkommawerte sind. Der Vektor soll über die Marke V ansprechbar sein. Die Vektor-Elemente sollen jeweils mit, initialisiert werden. Stellen Sie ein geeignetes Basisregister zur Adressierung bereit. ( Punkte) e) Geben Sie den Befehl an, mit dem Sie ein Programm aus einem Namensraum heraus beenden. (2 Punkte)

13 5.2 MMIX-Befehlsformat - Übersetzungstabelle 5.2 MMIX-Befehlsformat - Übersetzungstabelle (4 Punkte) Beachten Sie nachfolgende Tabelle.! x.. x.. x..2 x.. x..4 x..5 x..6 x..7! x.. x.. x2.. x.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf.. TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 4ν FSQRT 4ν FREM 4ν FINT 4ν MUL[I] ν MULU[I] ν DIV[I] 6ν DIVU[I] 6ν ADD[I] ν 2ADDU[I] ν CMP[I] ν SL[I] ν BN[B] ν+π BNN[B] ν+π PBN[B] ν-π PBNN[B] ν-π CSN[I] ν ADDU[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] ν-π PBNZ[B] ν-π CSZ[I] ν SUB[I] ν ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] ν-π PBNP[B] ν-π CSP[I] ν SUBU[I] ν 6ADDU[I] ν NEGU[I] ν SRU[I]ν BOD[B] ν+π BEV[B] ν+π PBOD[B] ν-π PBEV[B] ν-π CSOD[I] ν CSNN[I] ν ZSN[I] ν CSNZ[I] ν ZSZ[I] ν CSNP[I] ν ZSP[I] ν CSEV[I] ν ZSOD[I] ν ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] 2µ+2ν LDUNC[I] µ+ν LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] ν STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] ν OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν POP ν RESUME 5ν [UN]SAVE 2µ+ν SYNC ν SWYM ν GET ν TRIP 5ν x.. x..9 x..a x..b x..c x..d x..e x..f Gegeben ist der folgende MMIX-Code: x.. x.. x2.. x.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf..! Start BZ $,Ende SRU $,$2, JMP Start Ende OR $,$, a) In welches Befehlswort wird der Befehl JMP Start übersetzt? (2 Punkte) b) In welches Befehlswort wird der Befehl BZ $,Ende übersetzt? (2 Punkte)

14 4 5 MMIX 5. Lade- und Speicher-Befehle Alignment (9 Punkte) Gegeben ist die folgende Speicherbelegung: LOC Data_Segment $254 x2.. X BYTE 2,27,29,26 Y OCTA a) Geben Sie hexadezimal alle Bit des Registers nach Ausführung der folgenden Befehle an. ( Punkte) LDB $,X: LDB $,$254,: LDW $,$254,: In folgendem Programmcode wird XXX XXXXXXXXXX als Platzhalter für einen einzelnen Befehl verwendet. LOC Data_Segment $254 x2.. A WYDE #2,#9 B TETRA #679 Z OCTA #FFFFFFFFFFFFFFFF LOC # Main LDO $,A LDB $2,B LDW $,$254,7 XXX XXXXXXXXXX TRAP,Halt, b) Geben Sie für das gezeigte Programm den Inhalt des Bit breiten Datenworts an, welches durch die Marke Z adressiert wird, wenn XXX XXXXXXXXXX jeweils durch den folgenden Befehl ersetzt wird: (6 Punkte) STT $,Z: STT $2,Z: STO $,Z:

15 5.5 Funktionsaufrufe/Stack Arithmetische Befehle (7 Punkte) a) Geben Sie MMIX-Befehle an, mit denen Sie die beiden an den Speicher-Adressen X und Y befindlichen Bit breiten Gleitkommazahlen in die Register x und y einlesen,, 5 x 2 + y berechnen und das Ergebnis als Bit breite Gleitkommazahl im Speicher an der Marke Z ablegen. (7 Punkte) Hinweis: Register x und y sowie Speicherstellen X, Y und Z sind bereits (im selben Namensraum) deklariert/definiert und können direkt verwendet werden. 5.5 Funktionsaufrufe/Stack (4 Punkte) Die Funktion fkt hat bei ihrem Aufruf einen Parameter auf dem Stack übergeben bekommen und die Register und 2 auf den Stack gesichert. Dabei wurde Register an der niederwertigeren Adresse abgelegt. Die Rücksprungadresse wurde in Register übergeben. Die Funktion hat ein Ergebnis berechnet und dieses in Register abgelegt. a) Geben Sie den MMIX-Code an, mit dem Sie das in Register gespeicherte Ergebnis zur Übergabe an den Funktions-Aufrufer auf dem Stack ablegen, die Register wiederherstellen und zum Funktions-Aufrufer zurückspringen. (4 Punkte) Hinweis: Der Stackpointer kann über SP angesprochen werden.

16 6 6 Pipelining 6 Pipelining (6 Punkte) Gegeben ist der bekannte Pipelining-Datenpfad. Sp.-Puls 4 BZ Add Adresse Befehls- Speicher Daten Clk Reg.-Puls X-Auswahl Reg.-Schreiben Ergebnisauswahl ES Sp.-Schreiben Zugriffs-Art 2 SP Steuerung ALU-Funktion Direktoperand AF Registerblock Schreiben Clk2 Schreib- Daten $X Lese Daten $X $X 2 Schreiben/ Lese- BR Lesen $X Daten $Y $Y Lese- $Z..5 Daten $Z Lesen $Y..7 Dir 2 Lesen $Z Op. Clk ALU ES SP $X Erg ALU 2 Zugriffs- Art Schreib- Daten Adr. Clk4 Daten- Speicher Schreiben Lese- Daten ES Lese Dat. Erg ALU X X X Betrachten Sie folgenden Ausschnitt aus einem MMIX-Programm: Start SUB $,$, Zeile BZ $,Ende Zeile 2 LDB $2,$,$ Zeile STB $2,$4,$ Zeile 4 JMP Start Zeile 5 a) Geben Sie alle auftretenden Datenkonflikte an. Nehmen Sie an, dass ein Datenwort, das gerade in den Registerblock hineingeschrieben wird, vom Registerblock nicht gleichzeitig am Ausgang ausgegeben werden kann. (4 Punkte) b) Muss zwischen Zeile und 4 ein Stall eingefügt werden, oder kann prinzipiell ein Forwarding-Pfad verwendet werden? Begründung! (2 Punkte)

17 7 c) Was versteht man unter einem Strukturkonflilkt? Geben Sie ein Beispiel an. (2 Punkte) Nehmen Sie folgende Register-Belegung an: $ = x, $2 = x22, $254 = x2. Nehmen Sie desweiteren an, dass im Speicher an Adresse x2 das Bit breite Datenwort x ABC DEF abgelegt ist. Nehmen Sie folgende Forwarding-Pfade an: Vom Ausgang der ALU zu den $X, $Y und $Z-Eingängen des auf die BD-Phase folgenden Pipeline-Registers. Vom Ende der SP-Phase (Ausgang Speicher sowie Ergebnis ALU) zu den $X, $Y und $Z-Eingängen des auf die BD-Phase folgenden Pipeline-Registers. d) Tragen Sie in nachfolgende Abbildung den Inhalt der Pipeline-Register für die unter den Pipeline-Registern angegebenen Befehle ein. Nehmen Sie an, dass die benötigten Forwarding-Pfade genutzt wurden. Geben Sie für alle irrelevanten Einträge X an. ( Punkte) Reg. Schr.: Erg. Ausw.: Sp. Schr.: Reg. Schr.: Zugr.-Art: egal Erg. Ausw.: ALU: 5 Sp. Schr.: Reg. Schr.: Dir. Op.: Zugr.-Art: Erg. Ausw.: $X: $X: Lese-Daten: $Y: STO $,$254, $Z: Erg. ALU: Erg. ALU: Dir. Op.: X: X: X: STO $,$254, SUB $,$2,$ MUL $2,$2,2 LDW $,$254,7

18 7 Cache-Speicher 7 Cache-Speicher (9 Punkte) Ein Programm besteht aus Lade- und 2 Speicher-Befehlen, für deren Ausführung insgesamt 2, µs beobachtet werden. a) Wie groß ist die Hit-Rate, wenn die Hit-Time ns und die Miss-Time ns betragen? ( Punkte) b) Warum werden bei einem Arbeitsspeicher-/Cache-Zugriff die oberen Bits der Arbeitsspeicher-Adresse als Schlüssel im Tag-RAM abgelegt? ( Punkte) c) Wie groß ist ein direkt-abgebildeter Cache, wenn bei Zugriffen 9 Schlüssel-Bits mit 9 Tag-Bits verglichen werden müssen, die Adressbreite 2 Bit beträgt und in einem einzelnen Rahmen 2 Byte abgespeichert werden können? ( Punkte)

19 9 Laden aus Speicher Schreiben in Speicher Befehl Operanden Name/Aktion Definition Befehl Operanden Name/Aktion Definition LDB LDBU LDW LDWU LDT LDTU LDO LDOU Schieben $X,$Y,$Z Load byte $X s (s(m [u($y)+u($z)])) $X,$Y,Z Load byte immediate $X s (s(m [u($y)+u(z)])) $X,$Y,$Z Load byte unsigned $X u (u(m [u($y)+u($z)])) $X,$Y,Z Load byte uns. immed. $X u (u(m [u($y)+u(z)])) $X,$Y,$Z Load wyde $X s (s(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde immediate $X s (s(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load wyde unsigned $X u (u(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde uns. immed. $X u (u(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load tetra $X s (s(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra immediate $X s (s(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load tetra unsigned $X u (u(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra uns. immed. $X u (u(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load octa $X M[u($Y)+u($Z)] $X,$Y,Z Load octa immediate $X M[u($Y)+u(Z)] $X,$Y,$Z Load octa unsigned $X M[u($Y)+u($Z)] $X,$Y,Z Load octa uns. immed. $X M[u($Y)+u(Z)] Befehl Operanden Name/Aktion Definition SL SLU SR SRU $X,$Y,$Z Shift left; with overflow $X,$Y,Z Shift left immediate; with ovf. $X,$Y,$Z Shift left uns., no overflow $X u $X,$Y,Z Shift left uns. immed.; no ovf. $X u $X u ( u($y u($z)) ) u($y) 2 u($z) 2 ) ra ra u (25 ) $X u ( u($y u(z)) ) u($y) 2 u(z) 2 ) ra ra u (25 ) ( u($y u($z)) ) ( u($y u(z)) ) $X,$Y,$Z Shift right; fill with sign $X $Y s u($z) $X,$Y,Z Shift right imm.; fill with sign $X $Y s u(z) $X,$Y,$Z Shift right unsigned; fill with $X $Y u u($z) $X,$Y,Z Shift right uns. imm.; fill w. $X $Y u u(z) STB STBU STW STWU STT STTU STO STOU Marken Befehl Operanden auflösen/adressen Name/Aktion laden Definition LDA $X,$Y,$Z Store byte; with overflow $X,$Y,Z Store byte immed.; ovf. $X,$Y,$Z Get address (absolute) $X u (u($y)+u($z)) $X,$Y,Z Get address immed. (absolute) $X u (u($y)+u(z)) GETA $X,YZ Get address (relativ) $X u M[u($Y)+u($Z)] ($X)7... s($x) 2 7 ) ra ra u (26 ) s($x) < 2 7 ) ra ra u (26 ) M[u($Y)+u(Z)] ($X)7... s($x) 2 7 ) ra ra u (26 ) s($x) < 2 7 ) ra ra u (26 ) $X,$Y,$Z Store byte unsigned M[u($Y)+u(Z)] ($X)7... $X,$Y,Z Store byte uns. imm. M[u($Y)+u(Z)] ($X)7... $X,$Y,$Z Store wyde; with overflow $X,$Y,Z Store wyde immed.; ovf. M2[u($Y)+u(Z)] ($X)5... s($x) 2 5 ) ra ra u (26 ) s($x) < 2 5 ) ra ra u (26 ) M2[u($Y)+u(Z)] ($X)5... s($x) 2 5 ) ra ra u (26 ) s($x) < 2 5 ) ra ra u (26 ) $X,$Y,$Z Store wyde unsigned M2[u($Y)+u(Z)] ($X)5... $X,$Y,Z Store wyde uns. imm. M2[u($Y)+u(Z)] ($X)5... $X,$Y,$Z Store tetra; with overflow $X,$Y,Z Store tetra immed.; ovf. M4[u($Y)+u(Z)] ($X)... s($x) 2 ) ra ra u (26 ) s($x) < 2 ) ra ra u (26 ) M4[u($Y)+u(Z)] ($X)... s($x) 2 ) ra ra u (26 ) s($x) < 2 ) ra ra u (26 ) $X,$Y,$Z Store byte unsigned M4[u($Y)+u(Z)] ($X)... $X,$Y,Z Store byte uns. imm. M4[u($Y)+u(Z)] ($X)... $X,$Y,$Z Store octa M[u($Y)+u(Z)] $X $X,$Y,Z Store octa immediate M[u($Y)+u(Z)] $X $X,$Y,$Z Store octa unsigned M[u($Y)+u(Z)] $X $X,$Y,Z Store octa uns. imm. M[u($Y)+u(Z)] $X (u(@) + 4 s(yz))

20 2 Arithmetische Befehle (Festkomma) BefehlOperanden Name/Aktion Definition $X,$Y,$Z Add; signed, with overflow ADD $X,$Y,Z Add immediate; signed, with overflow $X s (s($y)+s($z)) (s($y)+s($z) < 2 6 ) (s($y)+s($z) 2 6 ) ) ra ra u (25 ) $X s (s($y)+u(z)) (s($y)+s(z) < 2 6 ) (s($y)+s(z) 2 6 ) ) ra ra u (25 ) $X,$Y,$Z Add unsigned; no overflow $X u (u($y)+u($z)) ADDU $X,$Y,$Z Add unsigned; no overflow $X u $X,$Y,Z Add unsigned; no overflow $X u (u($y)+u(z)) $X,$Y,$Z Subtract; signed, with overflow SUB $X,$Y,Z Subtract immediate; signed, with overflow $X s (s($y) s($z)) (s($y) s($z) < 2 6 ) (s($y) s($z) 2 6 ) ) ra ra u (25 ) $X s (s($y) u(z)) (s($y) s(z) < 2 6 ) (s($y) s(z) 2 6 ) ) ra ra u (25 ) SUBU $X,$Y,$Z Subtract unsigned; no overflow $X u (u($y) u($z)) $X,$Y,Z Subtract unsigned immed.; no ovf. $X u (u($y) u(z)) $X,Y,$Z Negate; signed, with overflow NEG $X s (u(y) s($z)) u(y) s($z 2 6 ) ) ra ra u (25 ) $X,Y,Z Negate immediate; signed, with overflow $X s (u(y) s(z)) NEGU $X,Y,$Z Negate unsigned; no overflow $X s (u(y) s($z)) $X,Y,Z Negate unsigned immed.; no overflow $X s (u(y) u(z)) $X,$Y,$Z Multiply; signed, with overflow $X s (s($y) s($z)) MUL $X,$Y,Z Multiply immediate; signed, with ovf. $X s (s($y) u(z)) $X,$Y,$Z Multiply unsigned; rh ($Y $Z) rh$x u 2 (u($y) u($z)) MULU $X,$Y,$Z Multiply unsigned; rh ($Y $Z) $X,$Y,Z Multiply uns. imm.; rh ($Y Z) rh$x u 2 (u($y) u(z)) Divide; signed, with overflow $X s (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= ) rr s ( s($y)%s($z)) DIV $X,$Y,Z Divide immediate; signed, with ovf. $X u () (case $Z = ) rr $Y $X,$Y,$Z DIVU Divide unsigned; no overflow; $X u 2 ( bu(rd$y)/u($z)c ) (case u($z) > u(rd) ) rr u 2 ( u(rd$y)%u($z)) Divide unsigned; no overflow; $X rd no overflow (case u($z) apple u(rd) ) rr $Y Divide unsigned immediate; $X u 2 ( bu(rd$y)/u(z)c ) no overflow; (case u(z) > u(rd) ) rr u 2 ( u(rd$y)%u(z)) Divide; signed, with overflow $X s (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= ) rr s ( s($y)%s($z)) DIV $X,$Y,Z Divide immediate; signed, with ovf. $X u () (case $Z = ) rr $Y $X,$Y,$Z DIVU $X,$Y,Z Divide unsigned; no overflow; $X u 2 ( bu(rd$y)/u($z)c ) (case u($z) > u(rd) ) rr u 2 ( u(rd$y)%u($z)) Divide unsigned; no overflow; $X rd no overflow (case u($z) apple u(rd) ) rr $Y Divide unsigned immediate; $X u 2 ( bu(rd$y)/u(z)c ) no overflow; (case u(z) > u(rd) ) rr u 2 ( u(rd$y)%u(z)) Divide unsigned immedediate; $X rd no overflow (case u(z) apple u(rd) ) rr $Y Arithmetische Befehle (Gleitkomma) Befehl Operanden Name/Aktion Definition FADD $X,$Y,$Z Floating point add $X f ( f ($Y)+f($Z)) FSUB $X,$Y,$Z Floating point subtract $X f ( f ($Y) f($z)) FMUL $X,$Y,$Z Floating point multiplication $X f ( f ($Y) f($z)) FDIV $X,$Y,$Z Floating point divide $X f ( f ($Y)/f($Z)) p FSQRT $X,$Z Square root $ $X f f($z)) Umwandlung Befehl Operanden Festkomma Name/Aktion <-> Gleitkomma Definition FLOT $X,$Z Convert fixed to floating $X f ( s($z)) $X,Z Conv. fixed to float. imm. $X f ( u(z)) FLOTU $X,$Z Conv. uns. fixed to floating $X f ( u($z)) $X,Z Conv. uns. fixed to float. imm. $X f ( u(z)) Convert floating to fixed FIX $X,$Z with overflow $X s ( r( f ($Z))) f($z) < 2 6 ) ra ra u (25 ) f($z) > 2 6 ) ra ra u (25 ) Convert floating to fixed FIXU $X,$Z $X s without overflow ( r( f ($Z))) Spezialregister Befehl Operanden Name/Aktion Definition GET $X,Z Get value of special purpose register $X r[z] PUT X,$Z Put value to special purpose register r[x] $Z X,Z Put immed. value to spec. purp. reg. r[x] u (u(z))

21 2 Divide unsigned immedediate; $X rd no overflow (case u(z) apple u(rd) ) rr $Y Logische Operationen Verzweigungen Befehl Operanden Name/Aktion Definition Befehl Operanden Name/Aktion Definition AND ANDN $X,$Y,$Z Bitwise AND $X $Y & $Z $X,$Y,Z Bitwise AND $Y & u ( u(z)) immediate $X $Y & u $X,$Y,$Z Bitwise AND NOT $X $Y & $Z $X,$Y,Z Bitww AND NOT immed. $Y & u ( u(z)) $X $Y & u ANDNL $X,YZ Bitw. AND NOT low wyde $X $X & u ( u(yz)) BNZ $X,YZ Branch if nonzero s($x) 6= u ( u(@) + 4 s(yz)) ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X & ( u ( u(yz)) 6) PBNZ $X,YZ Prob. br. if nonzero s($x) 6= u ( u(@) + 4 s(yz)) ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X & ( u ( u(yz)) 2) BN $X,YZ Branch if negative s($x) < u ( u(@) + 4 s(yz)) ANDNH $X,YZ Bw. AND NOT high wyde $X $X & ( u ( u(yz)) 4) PBN $X,YZ Prob. br. if negative s($x) < u ( u(@) + 4 s(yz)) NAND OR $X,$Y,$Z Bitwise NOT AND $X ($Y & $Z) $X,$Y,Z Bitwise NOT AND ( $Y & u ( u(z))) immed. $X ( $Y & u $X,$Y,$Z Bitwise OR $X $Y $Z $X,$Y,Z Bitwise OR $Y u ( u(z)) immediate $X $Y u ORL $X,YZ Bitwise OR low wyde $X $X u ( u(yz)) ORML $X,YZ Bitw. OR med. low wyde $X $X ( u ( u(yz)) 6) ORMH $X,YZ Bitw. OR med. high wyde $X $X ( u ( u(yz)) 2) ORH $X,YZ Bitwise OR high wyde $X $X ( u ( u(yz)) 4) ORN NOR XOR NXOR $X,$Y,$Z Bitwise OR NOT $X $Y $Z $X,$Y,Z Bitwise OR NOT $Y u ( u(z)) immediate $X $Y u $X,$Y,$Z Bitwise NOT OR $X ($Y $Z) $X,$Y,Z Bitwise NOT OR ($Y u ( u(z))) immediate $X ($Y u $X,$Y,$Z Bitwise XOR $X $Y $Z $X,$Y,Z Bitwise XOR $Y u ( u(z)) immediate $X $Y u $X,$Y,$Z Bitwise NOT XOR $X ($Y $Z) $X,$Y,Z Bitw. NOT XOR immediate ($Y u ( u(z))) $X ($Y u Funktionsaufruf Befehl Operanden Name/Aktion Definition $X,$Y,$Z Go to location GO $X,$Y,Z Go to location immediate JMP XYZ u ( u(@) + 4 s(xyz)) Befehl Operanden Name/Aktion Definition BZ $X,YZ Branch if zero s($x) u ( u(@) + 4 s(yz)) PBZ $X,YZ Probable br. if zero s($x) u ( u(@) + 4 s(yz)) BNN $X,YZ Branch if nonneg. s($x) u ( u(@) + 4 s(yz)) PBNN $X,YZ Prob. br. if nonneg. s($x) u ( u(@) + 4 s(yz)) BP $X,YZ Branch if positive s($x) > u ( u(@) + 4 s(yz)) PBP $X,YZ Prob. br. if positive s($x) > u ( u(@) + 4 s(yz)) BNP $X,YZ Branch if nonpositive s($x) apple u ( u(@) + 4 s(yz)) PBNP $X,YZ Prob. br. if nonpos. s($x) apple u ( u(@) + 4 s(yz)) BEV $X,YZ Branch if even u ( u(@)+4 s(yz)) PBEV $X,YZ Prob. branch if even u ( u(@)+4 s(yz)) BOD $X,YZ Branch if odd u ( u(@)+4 s(yz)) PBOD $X,YZ Prob. branch if odd u ( u(@)+4 s(yz)) Direktoperanden Befehl Operanden Name/Aktion Definition SETL $X,YZ Set to low wyde u (u(yz)) $X u SETML $X,YZ Set to med. low wyde $X u (u(yz 6)) SETMH $X,YZ Set to med. high wyde $X u (u(yz 2)) SETH $X,YZ Set to high wyde $X u (u((yz 4)) INCL $X,YZ Increase by low wyde $X u (u($x)+u(yz)) $X u ( u(@) + 4) ); INCML $X,YZ Inc. by med. low wyde $X u (u($x)+u(yz u ( u($y)+u($z)) $X u INCMH $X,YZ Inc. by med. high wyde $X u (u($x)+u(yz 2)) ( u(@) + 4) u ( u($y)+u(z)) INCH $X,YZ Increase by high wyde $X u (u($x)+u(yz 4))

22 22 Konzeptpapier Konzeptpapier Verwenden Sie dieses Blatt für Notizen. Falls Inhalte dieses Blatts bewertet werden sollen, müssen Sie das auf diesem Blatt und bei der jeweiligen Teilaufgabe kennzeichnen.