GOP Computertechnik. Computersysteme

Transkript

1 Prüfungsfähigkeit: Weitere Hinweise: GOP Computertechnik Computersysteme 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. 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. Name: Vorname: Matrikel-Nr.: Unterschrift: Hörsaal: Reihe: Platz: Fakultät: EI EDU BWL INF Hier Etikett einkleben (Prüfungsaufsicht): Aufg. Aufg. 2 Aufg. 3 Aufg. 4 Aufg. 5 Aufg. 6 Aufg. 7 Summe Punkte: Note:

2 Übersicht Komponenten Computer-Systeme (6 Punkte) 3 2 Darstellung von Zahlen und Zeichen (5 Punkte) 3 3 Arithmetische Schaltungen (29 Punkte) 4 4 Universalrechner (9 Punkte) 9 5 MMIX (3 Punkte) 5. Assembler- und Loaderbefehle (7 Punkte) MMIX Befehlsformat - Übersetzungstabelle (2 Punkte) Lade- und Speicherbefehle Alignment (7 Punkte) Spezialregister, Log. Operationen auf Bit-Ebene (6 Punkte) Arithmetische Befehle (3 Punkte) Funktionsaufrufe/Stack (6 Punkte) Pipelining (2 Punkte) 6 7 Cachespeicher ( Punkte)

3 3 Komponenten Computer-Systeme (6 Punkte) a) Was ist eine typische Sektor-Größe bei heutigen Festplatten: 4 Byte, 4 kbyte, 4 MByte, 4 GByte oder 4 TByte? (2 Punkte) b) Wohin schreibt ein Prozessor Daten, die auf dem Bildschirm dargestellt werden sollen: In den Zylinder des Monitors, in die Sektoren der Grafikkarte, auf die Spuren des Displays oder in den Backbuffer der Grafikkarte? (2 Punkte) c) Wodurch wird beim Laden von Befehlen der Arbeitsspeicher adressiert: Befehlszähler, Frontbuffer oder Zylinderregister? (2 Punkte) 2 Darstellung von Zahlen und Zeichen (5 Punkte) a) Tragen Sie in nachfolgende Abbildung die Binärdarstellung von 7 und - im Zweierkomplement ein. (2 Punkte) 7 7 7: -: b) Bestimmen Sie für die Zahl 4,25 die 32 Bit Gleitkomma-Kodierung nach IEEE 754 und tragen Sie sie in nachfolgende Grafik ein. (3 Punkte)

4 4 3 Arithmetische Schaltungen 3 Arithmetische Schaltungen (29 Punkte) Der nachfolgend gezeigte Datenpfad bestimmt für eine im Text-Speicher an Adresse Textadresse stehende null-terminierte Zeichenkette die Anzahl der enthaltenen Buchstaben (z.b. mal A bzw. a, 5 mal B bzw. b,...), Ziffern (z.b. 4 mal, 2 mal,...) und sonstiger Zeichen (eine Zahl für alle sonstigen Zeichen) und legt diese ab der Histogramm-Basisadresse im Histogramm-Speicher ab ADD TAR Adress- Eingang Text- Speicher Daten- Ausgang C HIZ 6 clk_3 mux_3 clk_4 reset fertig Textadresse Ende? Ziffer-Offset A Buchst.-Offset Histogramm- Basisadresse Ziffer? Großbuchstabe? Kleinbuchstabe? Steuerung B ende mux_4 mux_5 2 2 clk_ mux_ clk_2 mux_2 ADD ADD ADD HAR 6 6 ADD 6 6 Adresse Schreiben Histogr.- Speicher Daten- Ausgang Daten- Eingang Die mit A gekennzeichnete Schaltung Ziffer-Offset wandelt anliegende Ziffer-Zeichen in entsprechende Zahlen um. Beispiel: Eingang = Zeichen 5, d.h. Wert 53 gemäß ASCII-Tabelle Ausgang = Zahl 5. a) Geben Sie eine Realisierung der Schaltung A an. (3 Punkte) Hinweis: In der ASCII-Tabelle hat den Wert 4. A Die mit B gekennzeichnete Schaltung Ziffer? ermittelt, ob das am Eingang anliegende Byte entsprechend der ASCII-Tabelle einer Ziffer entspricht (Ausgang = High-Pegel) oder nicht (Ausgang = Low-Pegel).

5 5 b) Geben Sie eine Realisierung der Schaltung B an. (6 Punkte) Hinweis: In der ASCII-Tabelle hat den Wert 4 und 9 den Wert 57. B Der mit C gekennzeichnete Histogramm-Initialisierungs-Zähler HIZ gibt nach 37 positiven Flanken am Eingang clk_4 am Ausgang fertig den Wert aus. Im Detail funktioniert die Schaltung wie folgt: Liegt die Leitung reset auf, dann wird bei einer positiven Flanke am Eingang clk_4 die in der Schaltung C gespeicherte Anzahl bisher gezählter positiver Flanken zurückgesetzt. Liegt die Leitung reset auf, wird jede positive Flanke am Eingang clk_4 gezählt. Nach 37 aufeinander folgenden positiven Taktflanken am Eingang clk_4 mit reset = wird das Signal fertig auf gesetzt. Anderenfalls hat fertig den Wert. c) Geben Sie eine Realisierung der Schaltung C an. (6 Punkte) C clk_4 reset fertig

6 6 3 Arithmetische Schaltungen Nachfolgende Abbildung zeigt noch einmal den Datenpfad ADD TAR Adress- Eingang Text- Speicher Daten- Ausgang C HIZ 6 mux_3 clk_3 clk_4 reset fertig Textadresse Ende? Ziffer-Offset A Buchst.-Offset Histogramm- Basisadresse Ziffer? Großbuchstabe? Kleinbuchstabe? Steuerung B ende mux_4 mux_5 2 2 clk_ mux_ clk_2 mux_2 ADD ADD ADD HAR 6 6 ADD 6 6 Adresse Schreiben Histogr.- Speicher Daten- Ausgang Daten- Eingang In der nächsten Aufgabe soll ein Moore-Automat für die Steuerung der Initialisierungsphase des Datenpfads entworfen werden. In den Zuständen und 2 soll das Histogramm-Adress-Register HAR mit initialisiert werden, das Text-Adress-Register TAR mit der Textadresse initialisiert werden, der Histogramm-Initialisierungs-Zähler (HIZ) dadurch zurückgesetzt werden, dass bei einer steigenden Flanke auf der Steuerleitung clk_4 das Signal reset auf High-Pegel liegt. (3 Punkte) Wenn in Zustand 3 das HIZ-Signal fertig Low-Pegel liefert, soll von Zustand 3 in den Zustand 4 verzweigt werden; anderenfalls in den Zustand 5 ( Punkt). Beim Übergang von Zustand 3 auf 4 soll im Histogramm-Speicher das an der durch das HAR-Register adressierten Speicherstelle befindliche Byte auf gesetzt werden (2 Punkte). Von Zustand 4 soll immer in den Zustand 3 zurückgekehrt werden. Dabei soll die im HAR gespeicherte Adresse um erhöht werden. (,5 Punkte) Beim Übergang in den Zustand 5 sollen sich die in den Registern und im Histogramm-Speicher befindlichen Werte nicht mehr ändern. (,5 Punkte)

7 7 d) Erweitern Sie nachfolgenden Moore-Automaten so, dass er die Hardware in gewünschter Weise steuert. Legen Sie nicht benötigte Taktsignale auf und geben Sie für alle sonstigen irrelevanten Werte X an. (9 Punkte) immer immer clk_ clk_ clk_ clk_ mux_ mux_ mux_ mux_ clk_2 clk_2 clk_2 clk_2 mux_2 mux_2 mux_2 mux_2 clk_3 clk_3 clk_3 clk_3 mux_3 mux_3 mux_3 mux_3 clk_4 clk_4 clk_4 clk_4 reset reset reset reset mux_4 mux_4 mux_4 mux_4 mux_5 mux_5 mux_5 mux_5 5 clk_ mux_ clk_2 mux_2 clk_3 mux_3 clk_4 reset immer mux_4 mux_5

8 3 Arithmetische Schaltungen Nachfolgende Abbildung zeigt einen anderen Moore-Automaten. f = immer immer immer a: a: a: a: a: b: b: b: b: b: c: c: c: c: c: d: d: d: d: d: f = e = && f = e = e = && f = Dieser Moore-Automat soll mit folgender Schaltung implementiert werden: a b c d ROM D-Register e f e) 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 x x3 xb x xb

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

10 5 MMIX 5 MMIX (3 Punkte) Hinweis: Sie können in allen Aufgaben buf, buf,... als Pufferregister verwenden. 5. Assembler- und Loaderbefehle (7 Punkte) a) Geben Sie die Befehle an, mit denen Sie den Namensraum Print: eröffnen und in diesem Namensraum Register und 2 durch argc und argv ansprechbar machen. (2 Punkte) b) Geben Sie die Befehle an, mit denen Sie im Speicher zu Beginn des Datensegments zwei 6 Bit breite Datenworte anlegen, mit 5 und initialisieren und über die Marken X und Y ansprechbar machen. Reservieren Sie ein Basisregister, mit dem Sie die Datenworte adressieren können. (3 Punkte) c) Geben Sie den Befehl an, mit dem Sie innerhalb des Namensraums Print: das Programm beenden. ( Punkt) d) Geben Sie den Befehl an, mit dem Sie den Namensraum Print: beenden. ( Punkt)

11 5.2 MMIX Befehlsformat - Übersetzungstabelle 5.2 MMIX Befehlsformat - Übersetzungstabelle (2 Punkte) Beachten Sie nachfolgende Tabelle.! x.. x.. x..2 x..3 x..4 x..5 x..6 x..7! x.. x.. x2.. x3.. 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] 3ν-π PBNN[B] 3ν-π CSN[I] ν ADDU[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν SUB[I] ν ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν SUBU[I] ν 6ADDU[I] ν NEGU[I] ν SRU[I]ν BOD[B] ν+π BEV[B] ν+π PBOD[B] 3ν-π PBEV[B] 3ν-π 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] 3ν 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] 3ν 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 3ν 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.. x3.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf..! LOC Data_Segment $254 x2... X OCTA,2,3,4 LOC # Main LDO $2,X a) In welches Befehlswort wird der Befehl LDO $2,X übersetzt? (2 Punkte)

12 2 5 MMIX 5.3 Lade- und Speicherbefehle Alignment (7 Punkte) a) Tragen Sie in nachfolgende Tabelle den Speicherinhalt des MMIX-Prozessors ein, der sich nach Ausführung der angegebenen Befehle ergibt. Kennzeichnen Sie unbekannte Werte mit einem Fragezeichen (? ). (4 Punkte) LOC Data_Segment TETRA 2 WYDE 256 TETRA #234 x2 x2 x22 x23 x24 x25 x26 x27 x2 x29 x2a x2b

13 5.4 Spezialregister, Log. Operationen auf Bit-Ebene 3 Betrachten Sie nachfolgenden MMIX-Code. LOC Data_Segment $254 x2.. X TETRA #FEDCBA9 Y OCTA #CAFE LOC # Main LDW $,X LDT $2,X LDT $3,Y b) Geben Sie hexadezimal jeweils alle Bits an, welche in den Registern, 2 und 3 nach Ausführung der Befehlssequenz abgespeichert sind. (3 Punkte) $: $2: $3: 5.4 Spezialregister, Log. Operationen auf Bit-Ebene (6 Punkte) a) Geben Sie den Code an, mit dem Sie in Register den Wert von Bit 6 auf setzen. Alle anderen Bits sollen den ursprünglichen Wert behalten. (2 Punkte) b) Geben Sie den Code an, mit dem Sie in Spezialregister ra den Wert von Bit Nr. ändern ( bzw. ). Alle anderen Bits sollen den ursprünglichen Wert behalten. (4 Punkte)

14 4 5 MMIX 5.5 Arithmetische Befehle (3 Punkte) a) Geben Sie MMIX-Befehle an, mit denen Sie y = 2x 2 mit Festkommaoperationen berechnen. Register x und y sind bereits im selben Namensraum deklariert; x ist bereits initialisiert. (3 Punkte)

15 5.6 Funktionsaufrufe/Stack Funktionsaufrufe/Stack (6 Punkte) Für diese Aufgabe wurde der Stackpointer ausserhalb jedes Namensraums als globales Register SP definiert. Der Code der beiden folgenden Teilaufgaben befindet sich in einem Namensraum. a) Geben Sie den MMIX-Code an, mit dem Sie vom Namensraum Fkt: aus den in Register gespeicherten Wert auf dem Stack ablegen und anschließend die im Namensraum Fkt2: definierte Funktion Fkt2 aufrufen. Legen Sie die Rücksprungadresse in Register ab. (3 Punkte) b) Geben Sie den MMIX-Code an, mit dem Sie in der im Namensraum Fkt2: definierten Funktion Fkt2 Register auf den Stack sichern und den auf dem Stack übergebenen Parameter ins Register einlesen. (3 Punkte)

16 6 6 Pipelining 6 Pipelining (2 Punkte) Gegeben ist der bekannte Pipelining-Datenpfad. Sp.-Puls 4 BZ Add Adresse Befehls- Speicher Daten Clk BR Reg.-Schreiben Ergebnisauswahl ES Sp.-Schreiben Reg.-Puls Zugriffs-Art 2 SP Steuerung ALU-Funktion Direktoperand AF 32 X-Auswahl Schreib- Daten $X Lese Daten $X $X 32 Schreiben/ Lese- Lesen $X Daten $Y $Y..5 Lesen $Y Lesen $Z Registerblock Schreiben Clk2 Lese- Daten $Z $Z Dir Op. Clk3 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: ADD a,a,5 Zeile_ SUB b,a,2 Zeile_2 MUL c,a,b Zeile_3 STO b,:b Zeile_4 a) Geben Sie alle auftretenden Datenkonflikte an. (4 Punkte)

17 7 Nehmen Sie folgende Register-Belegung an: $ = x, $2 = x22, $3 = x33, $254 = x2. Nehmen Sie desweiteren an, dass im Speicher an der Adresse x2 das Octa x 9999 AAAA BBBB abgelegt ist (Big Endian). Nehmen Sie folgende Forwarding-Pfade an: Vom Ausgang der ALU zu den $X, $Y und $Z-Eingängen des die BD-Phase beendenden Pipeline-Registers. Vom Ende der SP-Phase (Ausgang Speicher sowie Ergebnis ALU) zu den $X, $Y und $Z-Eingängen des die BD-Phase beendenden Pipeline-Registers. b) 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 werden. Geben Sie für alle irrelevanten Werte X an. ( Punkte) Reg. Schr.: Erg. Ausw.: Sp. Schr.: Reg. Schr.: Zugr.-Art: egal Erg. Ausw.: ALU: 23 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, ADD $,$5,$ SUB $,$, LDW $5,$254,4

18 7 Cachespeicher 7 Cachespeicher ( Punkte) a) Begründen Sie, warum ein direkt-abgebildeter Cache in der Regel schneller ist als ein voll-assoziativer Cache. (2 Punkte) b) Welches Set wird bei einen 4 fach set-assoziativen Cache beim Zugriff mit der Bit breiten Arbeitsspeicher-Adresse x2 23 ABCD 4567 ausgewählt, wenn zum Vergleich des Schlüssels mit den Tags (ohne valid-bits) 2 Ein-Bit- Vergleicher verwendet werden und die Rahmengröße 4 kbyte beträgt? Geben Sie den Rechenweg an! (3 Punkte) c) Bei einem 52 kb großen voll-assoziativen Cache beträgt die Adress-Breite 2 Bit, wovon Bit zur Codierung des Schlüssels verwendet werden. Wieviele Bit-Vergleicher (ohne Valid-Bits) werden zur Überprüfung des Schlüssels mit den Tags benötigt? (3 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)3... s($x) 2 3 ) ra ra u (26 ) s($x) < 2 3 ) ra ra u (26 ) M4[u($Y)+u(Z)] ($X)3... s($x) 2 3 ) ra ra u (26 ) s($x) < 2 3 ) ra ra u (26 ) $X,$Y,$Z Store byte unsigned M4[u($Y)+u(Z)] ($X)3... $X,$Y,Z Store byte uns. imm. M4[u($Y)+u(Z)] ($X)3... $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 63 ) (s($y)+s($z) 2 63 ) ) ra ra u (25 ) $X s (s($y)+u(z)) (s($y)+s(z) < 2 63 ) (s($y)+s(z) 2 63 ) ) 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 63 ) (s($y) s($z) 2 63 ) ) ra ra u (25 ) $X s (s($y) u(z)) (s($y) s(z) < 2 63 ) (s($y) s(z) 2 63 ) ) 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 63 ) ) 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 63 ) ra ra u (25 ) f($z) > 2 63 ) 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)) 32) 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)) 32) 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 32)) 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 32)) ( 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.