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 24 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 Aufg. Summe Punkte: Note:

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

3 3 Komponenten Computer-Systeme (5 Punkte) a) Was ist die kleinste adressierbare Einheit einer Festplatte? ( Punkt) b) Was ist der Back-Buffer einer Grafikkarte? Was ist der Front-Buffer? (2 Punkte) c) Beschreiben Sie den Unterschied zwischen einer Harvard- und einer von Neumann- Architektur bzgl. der Speicherung von Befehlen und Daten. (2 Punkte) 2 Darstellung von Zahlen und Zeichen (6 Punkte) Der Wert einer vorzeichenlosen Festkommazahl lässt sich wie folgt darstellen: v = (a n b n + + a b + a b ) b r a) Tragen Sie in nachfolgender Abbildung für b = 2, r = - und n = 2 die darstellbaren Werte dezimal in die entsprechenden Kästchen ein. (3 Punkte) b) Geben Sie den Wert der gegebenen Gleitkommazahl dezimal an. (3 Punkte)

4 4 3 Arithmetische Schaltungen 3 Arithmetische Schaltungen (32 Punkte) a) Tragen Sie in nachfolgende Abbildung eine Schaltung ein, die bei der Addition zweier Zahlen im Zweier-Komplement einen Überlauf feststellt und am Ausgang ausgibt (: kein Überlauf; : Überlauf). (4 Punkte) n n n n Add Überlauf n b) Tragen Sie in die nachfolgend abgebildete Schaltung die beiden längsten Pfade für den Weg a/b/c e ein. Wieviele Gatterlaufzeiten τ benötigt die Schaltung für den Pfad a/b/c e mindestens? (3 Punkte) a b e c d Anzahl Gatterlaufzeiten:

5 5 c) Ändert sich bzw. wie ändert sich bei der gezeigten Schaltung die Mindest-Durchlaufzeit für den Fall Fan-In > 2? Begründung! (2 Punkte)

6 6 3 Arithmetische Schaltungen Nachfolgende Abbildung zeigt einen Datenpfad, der den im Datenspeicher an der Lese-Adresse abgespeicherten (null-terminierten) String an die Schreib-Adresse kopiert, wobei alle Kleinbuchstaben in Großbuchstaben umgewandelt werden. Add Steuerung null clkz groß Offset init clko lesen clks Daten- Speicher Schreib- Takt klein C Kleinbuchstabe? A NULL Lese-Adresse Schreib-Adresse Add Daten- Ausgang Adresse Daten- Eingang Großbuchstabe! B Zeichen Schaltung A gibt an ihrem Ausgang High-Pegel aus, wenn an ihrem Eingang die terminierende Null anliegt. Anderenfalls gibt Schaltung A an ihrem Ausgang Low-Pegel aus. d) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung A ein. (2 Punkte) A

7 7 Schaltung B wandelt den ASCII-Wert eines am Eingang anliegenden Kleinbuchstabens in den ASCII-Wert des zugehörigen Großbuchstabens um und gibt diesen am Ausgang aus. Liegt am Eingang ein nicht zu einem Kleinbuchstaben gehöriger ASCII-Wert an, kann die Schaltung einen beliebigen Wert ausgeben. e) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung B ein. Hinweis: ASCII-Wert a : 97; ASCII-Wert A : 65. (3 Punkte) B Schaltung C gibt an ihrem Ausgang High-Pegel aus, wenn an ihrem Eingang der ASCII-Wert eines Kleinbuchstabens anliegt, ansonsten Low-Pegel. f) Tragen Sie in nachfolgende Abbildung eine Realisierung der Schaltung B ein. Hinweis: ASCII-Wert a : 97; ASCII-Wert z : 22. (6 Punkte) C

8 3 Arithmetische Schaltungen Nachfolgende Abbildung zeigt noch einmal den Datenpfad. Add Steuerung null clkz groß Offset init clko lesen clks Daten- Speicher Schreib- Takt klein C Kleinbuchstabe? A NULL Lese-Adresse Schreib-Adresse Add Daten- Ausgang Adresse Daten- Eingang Großbuchstabe! B Zeichen In der nächsten Aufgabe soll folgender Teil der Datenpfad-Steuerung implementiert werden: In den Zuständen und 2 soll das Register Offset mit initialisiert werden ( Punkt). Sobald das Register initialisiert ist, soll am Adress-Eingang des Datenspeichers Lese-Adresse + Offset anliegen ( Punkte). Hat im Zustand 2 das Signal klein den Wert, soll in Zustand 4 verzweigt werden, anderenfalls in Zustand 5. ( Punkt) Beim Übergang von Zustand 4 auf 3 soll der von der Schaltung B ausgegebene Wert in das Register Zeichen übernommen werden ( Punkt). Dabei soll am Eingang der Schaltung B der im Datenspeicher an Adresse Leseadresse + Offset abgespeicherte Wert anliegen (,5 Punkte). Beim Übergang von Zustand 5 auf 6 soll der im Datenspeicher an Adresse Leseadresse + Offset abgelegte Wert in das Register Zeichen übernommen werden. (,5 Punkte) Beim Übergang von Zustand 7 auf soll der in Register Zeichen stehende Wert im Datenspeicher an der Adresse Schreibadresse + Offset abgelegt werden. ( Punkt)

9 9 g) Erweitern Sie nachfolgenden Moore-Automaten so, dass er die Hardware in gewünschter Weise steuert. Legen Sie gerade nicht benötigte Taktsignale auf und geben Sie für alle sonstigen irrelevanten Werte X an. (7 Punkte) immer Initialisieren 2 Initialisieren 3 Klein immer 4 Klein clko: clko: clko: clko: clks: clks: clks: clks: clkz: clkz: clkz: clkz: init: init: init: init: lesen: lesen: lesen: lesen: groß: groß: groß: groß: 5 Sonst 6 Sonst immer 7 Schreiben immer Schreiben clko: clko: clko: clko: clks: clks: clks: clks: clkz: clkz: clkz: clkz: init: init: init: init: lesen: lesen: lesen: lesen: groß: groß: groß: groß: immer immer

10 3 Arithmetische Schaltungen Nachfolgende Abbildung zeigt einen anderen Moore-Automaten. immer a = a = immer Init 2 Init 3 Sub 4 Sub 5 Ende clk: clk: clk: clk: clk: clk2: clk2: clk2: clk2: clk2: op: op: op: op: op: d: d: d: a = d: d: a = b = && a = b = b = && a = Dieser Moore-Automat soll mit folgender Schaltung implementiert werden: clk clk2 op d ROM D-Register a b h) Tragen Sie dazu 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 x4 xa x2 x4 xc

11 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 2a 2 + 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 = a R = a*a R = 2 R = 2*a*a R = b R = 2*a*a+b

12 2 5 Befehlssätze und deren Klassifikation 5 Befehlssätze und deren Klassifikation (3 Punkte) a) Welche Befehlssatz-Architektur verfügt in der Regel über größere Variationen in der Befehlswortlänge: CISC oder RISC? ( Punkt) b) Was versteht man unter einer Zweiadressmaschine? (2 Punkte)

13 6. Assembler- und Loaderbefehle 3 6 MMIX (32 Punkte) Hinweis: Sie können in allen Aufgaben buf, buf,... als Pufferregister verwenden. 6. Assembler- und Loaderbefehle (6 Punkte) a) Geben Sie die Befehle an, mit denen Sie im Speicher an Adresse x2 zwei Datenworte zur Aufnahme von 32 Bit Gleitkommazahlen anlegen. Machen Sie diese Datenworte über die Marken Float und Float2 ansprechbar. Fügen Sie auch einen geeigneten Befehl zur Reservierung eines Basisregisters zur Adressierung ein. (3 Punkte) b) Geben Sie die Anweisungen an, mit denen Sie den (globalen) Namensraum Sort: anlegen und in diesem Namensraum die Register und 2 durch a und b ansprechbar machen. (2 Punkte) c) Geben Sie den Befehl an, mit dem Sie einen Namensraum beenden. ( Punkt)

14 4 6 MMIX 6.2 MMIX Befehlsformat - Übersetzungstabelle (4 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! a) In welches Befehlswort wird der Befehl SLU $,$2,2 übersetzt? (2 Punkte) x.. x.. x2.. x3.. x4.. x5.. x6.. x7.. x.. x9.. xa.. xb.. xc.. xd.. xe.. xf..! Gegeben ist der folgende MMIX-Code: LOC Data_Segment $254 x2... D OCTA # LOC # Main LDOU $2,D b) In welches Befehlswort wird der Befehl LDOU $2,D übersetzt? (2 Punkte)

15 6.3 Lade- und Speicherbefehle Alignment Lade- und Speicherbefehle Alignment (6 Punkte) a) Tragen Sie in nachfolgende Tabelle den Speicherinhalt des MMIX-Prozessors ein, der sich nach Ausführung der angegebenen Befehle ergibt. Markieren Sie unbekannte Werte mit einem Fragezeichen (? ). (3 Punkte) LOC Data_Segment WYDE 32 TETRA 256 x2 x2 x22 x23 x24 x25 x26 x27

16 6 6 MMIX In folgendem Programmcode wird XXX XXXXXXXXXX als Platzhalter für einen einzelnen Befehl verwendet. LOC Data_Segment Y OCTA #FFFFFFFFFFFFFFFF Z TETRA # LOC # Main LDT $,Z XXX XXXXXXXXXX b) Geben Sie (hexadezimal) für das oben gezeigte Programm den Inhalt des Bit breiten Datenworts an, welches durch die Marke Y adressiert wird, wenn XXX XXXXXXXXXX durch folgende Befehle ersetzt wird: (3 Punkte) STBU $,Y: STO $,Y: STWU $,$254,7: 6.4 Spezialregister, Log. Operationen auf Bit-Ebene (5 Punkte) a) Geben Sie den Code an, mit dem Sie in Spezialregister ra Bit Nr. löschen. Alle anderen Bits sollen den ursprünglichen Wert behalten. (3 Punkte) b) Geben Sie den Code an, mit dem Sie Bit 5 in Register 4 ändern. Alle anderen Bits sollen den ursprünglichen Wert behalten. (2 Punkte)

17 6.6 Funktionsaufrufe/Stack Arithmetische Befehle (5 Punkte) a) Geben Sie MMIX-Befehle an, mit denen Sie X = (a 2 + b)/4 mit Gleitkommaoperationen berechnen und das Ergebnis im Speicher an der Marke X ablegen. Die Variable a und b sind bereits als Gleitkommazahlen in den Registern a und b abgelegt. (5 Punkte) 6.6 Funktionsaufrufe/Stack (6 Punkte) a) Geben Sie den MMIX-Code an, mit dem Sie, aus dem Namensraum Main: heraus, Register und 2 als Parameter auf dem Stack ablegen und die (global definierte) Funktion Mk aufrufen. Legen Sie die Rücksprungadresse in Register ab. Hinweis: Der Stackpointer kann über :SP angesprochen werden. (3 Punkte) b) Geben Sie den MMIX-Code an, mit dem Sie, aus dem Namensraum Main: heraus, nach dem Rücksprung aus der Funktion Mk das Ergebnis der Funktion Mk vom Stack in Register einlesen und dieses dann im Speicher an der global definierten Marke Erg ablegen. Passen Sie auch den Stackpointer an. (3 Punkte)

18 7 Pipelining 7 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: DIV c,a,b Zeile_ ADD a,b,c Zeile_2 MUL c,a,c Zeile_3 STO c,:a Zeile_4 a) Geben Sie alle auftretenden Datenkonflikte an. (4 Punkte)

19 9 Nehmen Sie folgende Register-Belegung an: $ = x, $2 = x22, $254 = x2. Nehmen Sie desweiteren an, dass im Speicher an der Adresse x2 das Octa x AC9 A92F 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: 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 $,$3,$2 ADD $2,$2, LDW $3,$254,4

20 2 Cachespeicher Cachespeicher ( Punkte) a) Bei der Ausführung eines Programms wird eine Miss-Rate von 2 % gemessen. Die Hit-Time beträgt ns, die Miss-Time 2 ns. Wie groß ist die mittlere Speicher- Zugriffszeit? (2 Punkte) b) Welcher Rahmen wird beim Zugriff auf einen Direkt-Abgebildeten Cache mit der Bit breiten Arbeitsspeicher-Adresse x ausgewählt, wenn der Schlüssel mit 44 Bit und die Byteauswahl mit Bit codiert wird? (2 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) d) In einem System mit 32 Bit Adress-Breite ist ein 4 fach Set-Assoziativer Cache mit 496 Cache-Sets verbaut. Zum Vergleich des Schlüssels mit den Tags werden 4 Ein-Bit-Vergleicher benötigt. Wie groß ist der Cache (in MB)? (4 Punkte)

21 2 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))

22 22 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))

23 23 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))

24 24 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.