Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Michael Wahl Rainer Brück Seite 1 Befehlssatz des MIPS R2000 Prozessors.

Ähnliche Präsentationen


Präsentation zum Thema: "Michael Wahl Rainer Brück Seite 1 Befehlssatz des MIPS R2000 Prozessors."—  Präsentation transkript:

1 Michael Wahl Rainer Brück Seite 1 Befehlssatz des MIPS R2000 Prozessors

2 Michael Wahl Rainer Brück Seite 2 Die fünf klassischen Rechnerkomponenten Control: Steuerung Datapath: Datenpfad

3 Michael Wahl Rainer Brück Seite 3 Die fünf klassischen Rechnerkomponenten Der Datenpfad enthält funktionale Einheiten zur Manipulation von Daten, insbesondere klassische Recheneinheiten wie Addierer, Multiplizierer, etc.

4 Michael Wahl Rainer Brück Seite 4 Die fünf klassischen Rechnerkomponenten Das Steuerwerk enthält funktionale Einheiten zur Koordination des Ablaufs von Programmen. Es regelt das Zusammenspiel aller Prozessorkomponenten.

5 Michael Wahl Rainer Brück Seite 5 Die fünf klassischen Rechnerkomponenten Der Speicher enthält die Programme und Daten vor, während und nach der Ausführung der Programme.

6 Michael Wahl Rainer Brück Seite 6 Die fünf klassischen Rechnerkomponenten Die Eingabeeinheiten übertragen Programme und zu verarbeitende Daten in den Speicher.

7 Michael Wahl Rainer Brück Seite 7 Die fünf klassischen Rechnerkomponenten Die Ausgabeeinheiten lesen Ergebnisdaten aus dem Speicher und stellen sie der Umwelt zur weiteren Nutzung zur Verfügung.

8 Michael Wahl Rainer Brück Seite 8 Die fünf klassischen Rechnerkomponenten Damit das Ganze auch sinnvoll funktioniert braucht man aber noch etwas mehr: Eine formale Schnittstelle, die die Kommunikation zwischen Rechner und Umwelt organisiert.

9 Michael Wahl Rainer Brück Seite 9 Der Instruktionssatz: Schnittstelle zwischen Compiler und Rechner

10 Michael Wahl Rainer Brück Seite 10 Grundlegende Ideen Instruktionssatz Formale Sprache zur Beschreibung der einzelnen Aktionen, die ein Prozessor ausführen kann. Primitive Form einer Programmiersprache Maschinensprache Eigenschaften Die Instruktionssätze aller Prozessoren sind sich relativ ähnlich (es gibt keine babylonische Sprachverwirrung wie bei natürlichen Sprachen). Sie sind so einfach wie möglich gehalten, um gleichzeitig die Möglichkeiten der Hardware und die Fähigkeiten der Compiler zu unterstützen. Beispiel: Der MIPS-R2000-Instruktionssatz: einfach, überschaubar, mit allen wichtigen Konzepten

11 Michael Wahl Rainer Brück Seite 11 Erstes Beispiel: add a, b, c Addiere die Werte der beiden Variablen b und c und weise das Ergebnis der Variablen a zu. Assemblersprache Die gewählte symbolische Darstellung ist nicht unmittelbar vom Prozessor zu verarbeiten. Sie ist durch einenAssembler in eine geeignete Eingaberepräsentation zu übersetzen (s.u.) (Assembler-)befehle sind stark formalisiert Arithmetische Operationen werden immer mit zwei Argument- und einem Ergebnisoperanden angegeben. (3-Adress-Maschine) Eine Addition von mehr als 2 Zahlen muss aus mehreren Additionsbefehlen zusammen gesetzt werden.

12 Michael Wahl Rainer Brück Seite 12 Übersetzung eines einfachen C- Programms CMIPS-Assembler a = b + c; d = a - e; add a, b, c sub d, a, e f=(g+h)-(i+j) … oder etwas komplizierter: add t0, g, h add t1, i, j sub f, t0, t1 Temporäre Variable Beachten von Operator-Prioritäten (=> Reihenfolge)

13 Michael Wahl Rainer Brück Seite 13 Operanden in Hardware Variable Variable werden auf elementare Speichereinheiten innerhalb des Prozessors abgebildet: Register Register sind Teile der Rechner/Programmierer-Schnittstelle. Sie können direkt vom Programm aus zugegriffen werden. Register Feste, identische Länge: Wortbreite, typisch heute 32 bit (64- bit-Maschinen in Kürze) Feste Anzahl: 32 Register. MIPS: 32 Register mit je 32 bit Register mit spezieller Funktion:Register 0 und 31 Frei benutzbare Register: Register 1 … 30 Register werden entsprechend der Nutzung im GNU C Compiler benannt.

14 Michael Wahl Rainer Brück Seite 14 GNU MIPS C Registerbenutzung NameNummerFunktion $zero0constant 0 $at1assembler $v0... $v12-3result value registers $a0... $a34-7arguments $t0... $t78-15temporary variables $s0... $s716-23saved $t8... $t924-25temporary variables $k0... $k126-27operating system $gp28global pointer $sp29stack pointer $fp30frame pointer $ra31return address

15 Michael Wahl Rainer Brück Seite 15 Das alte Beispiel mit Registern f=(g+h)-(i+j) add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0, $t1 Die Variablen der C-Anweisung wurden der Reihe nach den Registern $s0 - $s4 zugeordnet: f: $s0, g: $s1, h: $s2, i: $s3, j: $s4

16 Michael Wahl Rainer Brück Seite 16 0 Speicherbefehl: store word: Datenübertr. Register - Speicher $s2 $s1 $s0 0 sw $s0, 16($s1) … aber wie kommen die Variablenwerte in die Register? C-Beispiel: int V[6]; a = V[2]; V[4] = a; $s1: Basisadr. V, $s0: a Ladebefehl: load word: Datenübertragung Speicher - Register lw $s0, 8($s1) $s2 $s1 $s0 0 Kein anderer Befehlstyp greift auf den Speicher zu: Load/Store-Architektur

17 Michael Wahl Rainer Brück Seite 17 C-Programme mit variablen Array- Indizes C-Code: g = h + A[i] add $t1, $s4, $s4 # $t1 = 2 * i add $t1, $t1, $t1 # $t1 = 4 * i Index auf Speicheradressen abbilden (mit 4 multiplizieren) Speicher wird Byte-weise adressiert add $t1, $t1, $s3 # $t1 = 4*i + &A Wortadresse zu Basisadresse addieren Array-Element laden add $s1, $s2, $t0 # $s1 = h + A[i] Addition ausführen $s1: g $s2: h $s3: &A $s4: i Registerzuweisung lw $t0, 0($t1) # $t0 = A[i]

18 Michael Wahl Rainer Brück Seite 18 Wie werden Instruktionen im Rechner dargestellt? Grundlage: Binärdarstellung Digitale Informationsverarbeitung bedeutet, dass alle Informationen als Folgen von zwei unterscheidbaren Zuständen dargestellt werden. Alle Informationen im Rechner lassen sich als Binärzahlen darstellen. Sowohl Daten, als auch Befehle werden durch Binärzahlen dargestellt. Die typische Verarbeitungseinheit ist ein Wort: 32-stellige Binärzahl. Maschinenbefehle werden durch 32-stellige Binärzahlen dargestellt. Unterschied zur Mic, 8086: dort haben Maschinen-Befehle unterschiedliche Länge Register als Teile in Instruktionen werden durch Binärzahlen bezeichnet.

19 Michael Wahl Rainer Brück Seite 19 Beispiel: Repräsentation eines Additionsbefehls MIPS-Assembler add $t0, $s1, $s2 Dezimaldarstellung Addition Zielregister Operandenregisterhier unbenutzt Binärdarstellung Bit5 Bit 6 Bit

20 Michael Wahl Rainer Brück Seite 20 MIPS-Instruktionsformate: R (Register) Das R-Format op: opcode; Grundtyp der Instruktion rs: erster Operand (Register) rt: zweiter Operand (Register) rd: Ziel (Register) shamt: Shift amount. Wichtig für Schiebeoperationen (s.u.) funct: Funktionscode; Ergänzung zum op-Feld. Genaue Spezifikation der durchzuführenden Operation oprsrtrdshamtfunct 6 Bit5 Bit 6 Bit

21 Michael Wahl Rainer Brück Seite 21 MIPS-Instruktionsformate: I (Immediate) Manche Operationen benötigen längere Felder für ihre Operanden. Bsp: lw-Operation spezifiziert eine Konstante als Array-Offset. Diese sollte länger als 5 oder 6 Bit sein dürfen. Das I-Format op: opcode; Grundtyp der Instruktion rs: Basisadressregeister rt: Zielregister address: Konstante, die Offset bzgl. Basisregister angibt oprsrt 6 Bit5 Bit adress 16 Bit

22 Michael Wahl Rainer Brück Seite 22 Beispiel: Vom C-Programm zur Maschinensprache C-Programmcode A[300] = h + A[300] Maschinencode symbolisch Machinencode binär MIPS-Assembler lw $t0, 1200($t1) add $t0, $s2, $t0 sw $t0, 1200($t1)

23 Michael Wahl Rainer Brück Seite 23 … und wie übersetzt man Kontrollstrukturen? Alternative Pfade der Programmausführung Bedingte Programmausführung: if … then … [else …] switch … case … Wiederholte Programmausführung: for … while … Bedingte und unbedingte Sprunginstruktionen beq reg1, reg2, label (branch if equal) bne reg1, reg2, label (branch if not equal) j addr (jump to address) Auf der Ebene der Maschinensprache gibt es keine goto-lose (strukturierte) Programmierung!

24 Michael Wahl Rainer Brück Seite 24 Erstes Beispiel: C-If-statement C-Programmcode if (i == j) goto L1; f = g + h; L1:f = f - i; MIPS-Assembler beq $s3, $s4, L1 Testen auf Registergleichheit; ggf. Verzweigen zur Subtraktion add $s0, $s1, $s2 # $s0 = g + h Addition (ausgeführt im FALSE-Fall) L1:sub $s0, $s0, $s3 # $s0 = f - i Subtraktion; Sprungziel (immer ausgeführt) Register-Zuordnung: i: $s3 j: $s4 g: $s1 h: $s2 f: $s0

25 Michael Wahl Rainer Brück Seite 25 Etwas komplizierter: If…then…else C-Programmcodeif (i == j) f = g + h; else f = g - h; MIPS-Assembler bne $s3, $s4, ElseTesten und Verzweigen add $s0, $s1, $s2Addition (im TRUE-Fall) Else:sub $s0, $s1, $s2Subtraktion (im FALSE-Fall) j ExitElse-Fall überspringen Exit:Ausgang Register- Zuordnung: i: $s3 j: $s4 g: $s1 h: $s2 f: $s0

26 Michael Wahl Rainer Brück Seite 26 Schleifen sind auch nicht viel schwieriger: C-Programmcodewhile (save[i] == k) i = i + j; MIPS-Assembler Loop:add $t1, $s3, $s3 add $t1, $t1, $t1 add $t1, $t1, $s6 # $t1 = &save +4*i lw $t0, 0($t1) # $t0 = save[i] Schleifenanfang und Laden des Array-Elements bne $t0, $s5, ExitTest Schleifenkriterium add $s3, $s3, $s4Schleifenrumpf j Loop Exit: Rücksprung/Ausgang

27 Michael Wahl Rainer Brück Seite 27 Die MIPS-Architektur verwendet ein spezielles Register, das konstant den Wert 0 enthält. Es wird in der Assemblersprache als $zero bezeichnet. Weitere Vergleichsmöglichkeiten Wie realisiert man einen Vergleich der Art if a < b? slt $t0, $s1, $s2 If $s1 < $s2 then $t0 := 1 else $t0 := 0 Damit lässt sich if a < b goto less wie folgt übersetzen: slt$t0, $s1, $s2 bne$t0, $zero, less

28 Michael Wahl Rainer Brück Seite 28 Resümee – Das Grundkonzept: Speicherprogrammierbarer Rechner Grundprinzip heutiger Rechnerarchitekturen Instruktionen werden als (binäre) Zahlen repräsentiert. Programme werden im Speicher abgelegt und können dort gelesen und geschrieben werden wie Zahlen. Es gibt keinen Unterschied zwischen Daten und Programmen. Dies ist das Prinzip des speicherprogrammierbaren Rechners (stored-program-computer). Stärken des Konzepts Daten und Programme können beliebig im Speicher angeordnet werden. Programmstart erfolgt einfach durch Angabe einer Speicheradresse. Programme können auch als Daten interpretiert werden (Bsp.: Compiler betrachten Programme als Daten).

29 Michael Wahl Rainer Brück Seite 29 Höhere Konstrollstrukturen: Prozeduren HW-Unterstützung für Prozeduren Prozeduren stellen das wichtigste Strukturierungskonzept in modernen Programmiersprachen dar. Alle modernen Instruktionssatzarchitekturen bieten Mittel zur effizienten Bearbeitung von Prozeduren an. Schritte bei der Ausführung einer Prozedur Parameter so plazieren, dass die Prozedur darauf zugreifen kann Kontrolle an die Prozedur übergeben Prozedur ausführen Ergebniswert so plazieren, dass aufrufendes Programm darauf zugreifen kann Kontrolle an die Aufrufstelle zurück geben

30 Michael Wahl Rainer Brück Seite 30 GNU-MIPS-Unterstützung von Prozeduren Zuordungen von Registern $a0 - $a3: Argumente $v0, $v1: Ergebniswertregister $ra: Rücksprungadresse Befehl für den Aufruf jal Prozedur (jump and link) Spezialbefehl für Prozedurausführung: Springt zu Prozedur speichert Adresse der folgenden Instruktion in $ra: $ra = PC + 4 Befehl für den Rücksprung jr $ra Gewöhnlicher Sprungbefehl, liest Sprungziel aus $ra

31 Michael Wahl Rainer Brück Seite 31 … und was passiert bei Prozeduren mit mehr als 4 Argumenten? Argumentspeicher und Zustandssicherung Im Speicher wird ein Stack verwaltet, der dynamisch die Prozedurverwaltung unterstützt. Er enthält Argumentwerte, wenn mehr als 4 auftreten Register, die vor Prozeduraufruf gesichert wurden. Stackverwaltung Ein Register weist auf den ersten freien Platz im Stack (Stackpointer $sp) Der Stack ist am oberen Ende des Speichers angeordnet, wächst in Richtung kleinerer Speicheradressen.

32 Michael Wahl Rainer Brück Seite 32 Ein einfaches Prozedurbeispiel C-Programmcode int first_proc (int g, int h, int i, int j) {int f; f = (g + h) - (i + j); return f; } MIPS-Assembler Stack first_proc: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s1, 0($sp) Phase 1: Registerinhalte auf den Stack retten

33 Michael Wahl Rainer Brück Seite 33 Ein einfaches Prozedurbeispiel C-Programmcode int first_proc (int g, int h, int i, int j) {int f; f = (g + h) - (i + j); return f; } MIPS-Assembler Stack first_proc: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s1, 0($sp) Phase 2: Berechnungen durchführen add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s1, $t0, $t1 Register: $a0: g $a1: h $a2: i $a3: j

34 Michael Wahl Rainer Brück Seite 34 Ein einfaches Prozedurbeispiel C-Programmcode int first_proc (int g, int h, int i, int j) {int f; f = (g + h) - (i + j); return f; } MIPS-Assembler Stack first_proc: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s1, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s1, $t0, $t1 Phase 3: Returnwert speichern add $v0, $s1, $zero

35 Michael Wahl Rainer Brück Seite 35 Ein einfaches Prozedurbeispiel C-Programmcode int first_proc (int g, int h, int i, int j) {int f; f = (g + h) - (i + j); return f; } MIPS-Assembler Stack first_proc: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s1, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 Phase 4: Register zurückspeichern add $v0, $v0, $zero … lw $s1, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) addi $sp, $sp, 12

36 Michael Wahl Rainer Brück Seite 36 Ein einfaches Prozedurbeispiel C-Programmcode int first_proc (int g, int h, int i, int j) {int f; f = (g + h) - (i + j); return f; } MIPS-Assembler Stack first_proc: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s1, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $v0, $zero … lw $s1, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) addi $sp, $sp, 12 Phase 5: Rücksprung jr $ra

37 Michael Wahl Rainer Brück Seite 37 Warum eigentlich ein Stack? Prozeduren, die andere aufrufen Probleme Alle Prozeduren verwenden $a0 - $a3 für Argumente Alle Prozeduren verwenden $ra als Rücksprungregister Alle Prozeduren verwenden dieselben Arbeitsregister Register: $s0 - $s7, $t0 -$t9 Mögliche Lösung Aufrufende Prozedur sichert Argumentregister auf Stack Aufrufende Prozedur sichert temporäre Arbeitsregister auf Stack: temporäre Register: $t0 - $t9 Aufgerufene Prozedur sichert Rücksprungregister $ra und verwendete gespeicherte Register auf Stack gespeicherte Register: $s0 - $s7 Beim Rücksprung aus aufgerufener Prozedur werden alle gesicherten Register zurück geladen.

38 Michael Wahl Rainer Brück Seite 38 Beispiel: Rekursiver Prozeduraufruf C-Sourcecode: Fakultätsberechnung MIPS-Assembler: Fakultätsberechnung Registerzuordnung: $a1 enthält n Vor rekursivem Aufruf zu sichern: $a1 (wird nach rekursiven Aufruf benötigt) $ra (weil Prozedur rekursiv)

39 Michael Wahl Rainer Brück Seite 39 Beispiel: Rekursiver Prozeduraufruf MIPS-Assembler: Fakultätsberechnung

40 Michael Wahl Rainer Brück Seite 40 GNU-MIPS-Stack-Konventionen Struktur des Stack Stack-Segment, das zu Prozedur gehört, heißt Frame. Frame pointer ($fp) zeigt auf Anfang des Frames. Dadurch lassen sich lokalen Variablen unabhängig von $sp adressieren: Bequem, da $sp sich ändern kann.

41 Michael Wahl Rainer Brück Seite 41 Die Welt besteht nicht nur aus Zahlen Byteweise Zugriffe und Zeichen Daten werden nicht immer als Zahlen interpretiert. In der heutigen Praxis ist die Verarbeitung von Texten (Zeichenketten) mindestens genau so wichtig. Zeichen werden durch einzelne Bytes repräsentiert. Instruktionssätze verfügen daher über Byte-Lade- und Speicheroperationen. Ladeoperation lb $t0, 0($sp) Lädt ein Byte aus dem Speicher und plaziert es in die rechts gelegenen (niederwertigen) Bits eines Registers Speicheroperation sb $to, 0($a1) speichert die niederwertigen acht Bits eines Registers in die bezeichnete Speicherposition

42 Michael Wahl Rainer Brück Seite 42 Beispiel: Text kopieren MIPS-Assembler: C-Sourcecode:

43 Michael Wahl Rainer Brück Seite 43 Beispiel: String kopieren MIPS-Assembler:

44 Michael Wahl Rainer Brück Seite 44 Mehr Komfort beim Datenzugriff: Adressierungsarten Mängel der derzeitigen Instruktionen Die Verwendung von Konstanten ist unhandlich Man muss entweder spezielles Register bereit stellen ($zero) oder Konstante im Speicher an bekannten Stellen ablegen. Da Konstanten (z.B. für Inkrement/Dekrement-Operationen bei Datenzugriffen in Schleifen) häufig auftreten, ist ein verbesserter Konstantenzugriff wünschenswert. Die Handhabung von Verzweigungsadressen ist unzulänglich Das ist bisher nicht aufgefallen, da wir immer auf Assembler-Ebene mit symbolischen Sprungzielen operiert haben! Für Verzweigungsziele sind nur Adressbereiche im Rahmen von 16 Bits erreichbar Als Sprungziele nur 16 Bit lange Adressen möglich

45 Michael Wahl Rainer Brück Seite 45 Verwendung von Konstanten Spezielle Befehle, die Konstanten in der Instruktion enthalten: Immediate-Adressierung addi, $sp, $sp, 4($sp = $sp + 4) slti $t0, $t1, 13 (if $t1 < 13 $t0 = 1)

46 Michael Wahl Rainer Brück Seite 46 Verwendung von Konstanten Und wie behandelt man große Konstanten? Der Befehl lui (load upper half word immediate) lädt die angegebene Konstante in die höherwertigen 16 Bit des Zielregisters. lui $t0, Beispiel: lui $s0, addi $s0, $s0,

47 Michael Wahl Rainer Brück Seite 47 Adressierung von Sprungzielen Unbedingte Sprungbefehle: Das j-Format j 10000(go to 10000) Die Implementierung von Verzweigungsbefehlen: PC-relative Adressierung PC: Program Counter: Befehlszähler; Register, das während des Programmablaufs die Speicheradresse des jeweils nächsten auszuführenden Befehls enthält bne $s0, $s1, 16 if $s0 - $s1 0 PC = PC Bit Bit

48 Michael Wahl Rainer Brück Seite 48 Beispiel: Maschinenprogramm mit Sprungbefehlen Achtung: Der PC wird jeweils vor der eigentlichen Befehls- ausführung um 4 inkrementiert PC = PC + 8 PC =

49 Michael Wahl Rainer Brück Seite 49 Wie realisiert man weite Verzweigungen? Verzweigungsbefehle können Verzweigungen um ± 2 15 Speicherworte realisieren. Das beschränkt die absolute Programmgröße Für weitere Verzweigungen wird vom Assembler eine indirekte Verzweigungsmethode implementiert: unbedingter Sprung zum Sprungziel (26 Bit Adresse) invertierter Verzweigungsbefehl. beq $s0, $s1, L1 bne $s0, $s1, L2 j L1 L2:

50 Michael Wahl Rainer Brück Seite 50 MIPS-Adressierungsarten addi $s0 $s1, 24 add $t0, $s1, $s2 lw $s0, 16($t0)

51 Michael Wahl Rainer Brück Seite 51 MIPS-Adressierungsarten bne $s1, $s2, 16 PC = PC + (Address || 00) j PC = PC.(31..28) || Address || 00

52 Michael Wahl Rainer Brück Seite 52 Was haben wir jetzt an MIPS- Instruktionen?

53 Michael Wahl Rainer Brück Seite 53 Vom C-Programm zur Ausführung im Rechner Vier grundsätzliche Schritte: C-Programm Assemblercode Objektocde: Maschinensprachmodul Objektcode: Bibliotheksroutinen Executable: Maschinenprogramm Speicher CompilerAssemblerLinkerLoader

54 Michael Wahl Rainer Brück Seite 54 Compiler Übersetzung von Hochsprachen in Assembler Hochsprachenprogrammierung wird verwendet, da die Programmiereffizienz hier ungleich höher ist als bei der Verwendung der Maschinensprache, da Programme in Hochsprachen (mehr oder weniger) maschinenunabhängig sind. Moderne Compiler erzeugen Assemblercode, der so gut optimiert ist, dass er manuell kaum besser erzeugt werden könnte. Während höhere Programmiersprachen (weitestgehend) maschinenunabhängig sind, muss für jede Zielarchitektur ein spezieller Compiler bereit gestellt werden.

55 Michael Wahl Rainer Brück Seite 55 Assembler Assemblersprache Symbolische Repräsentation der Maschineninstruktionen. Vereinfachte Anwendung durch Pseudoinstruktionen: Instruktionen, die der Befehlssatz nicht enthält, und die vom Assembler in gültige Maschineninstruktionen übersetzt werden mov $t0, $t1 -> add $t0, $zero, $t1 blt $s0, $s1, L1 -> slt $t0, $s0, $s1 bne $t0, $zero, L1 Zahlendarstellungen: Neben binären und dezimalen Zahlenrepräsentationen ist gewöhnlich auch die hexadezimale Darstellung gebräuchlich, die v.a. für Adressberechnung vorteilhaft ist.

56 Michael Wahl Rainer Brück Seite 56 Assembler Objektcode Objektfiles enthalten alle Informationen, die für die weitere Bearbeitung erforderlich sind. Beispiel: Unix- Objektfiles Header: Beschreibt die Größe und Position der übrigen Teile des Objektfiles Textsegment: Maschinensprachcode Datensegment: Statische Daten, die während der Programmlaufzeit alloziert werden, dynamische Daten, die während der Programmlaufzeit ihre Größe verändern Relokationsinformation: Identifikation von Instruktionen und Daten, die von absoluten Speicheradressen abhängig sind Symboltabelle: noch undefinierte Labels (z.B externe Sprungziele) Debugging Information: Informationen, die dem Debugger ermöglichen, Maschinenbefehle mit C-Sourcecode in Verbindung zu bringen

57 Michael Wahl Rainer Brück Seite 57 Linker Um eine weitgehende Wiederverwendung von Programmteilen zu ermöglichen, werden Programme Prozedur für Prozedur übersetzt. Für jedes einzelne der so entstehenden Programmstücke müssen die relativen Positionen innerhalb des Speichers bestimmt werden. Aufgaben des Linkers Symbolische Plazierung von Code und Daten im Speicher Bestimmung der Adressen von Daten- und Instruktionslabels Patchen von internen und externen Referenzen, d.h. Einsetzen der ermittelten Sprungweiten bzw. Sprungziele Das Executable hat dasselbe Format wie das Objektfile, nur mit aufgelösten Referenzen

58 Michael Wahl Rainer Brück Seite 58 Loader Betriebssystemroutine, die ein Programm zur Ausführung auf dem Rechner bringt. Dabei werden in Unix die folgenden Schritte ausgeführt: Lesen des Programms und Bestimmten der Programm- und Datensegmentgrößen Bereitstellen eines hinreichend großen Adressraums für Programm und Daten Kopieren der Instruktionen und Daten aus dem Programm in den Speicher Initialisierung der Maschinenregister; Setzen des Stackpointers auf die erste freie Position Sprung zu einer Start-up-Routine, die Parameter in die Argumentregister schreibt und zur main-Prozedur des Programms verzweigt

59 Michael Wahl Rainer Brück Seite 59 Ein umfassendes Beispiel Assembler-Programmierung (bzw. Übersetzung von Hochsprachenprogrammen in Assembler) Dreischrittiges Vorgehen Resgisterzuweisung für Programmvariablen Erzeugen des Assemblercodes für den Prozedurrumpf Einfügen von Umgebungssicherungsmaßnahmen Modulares Vorgehen Die o.g. Vorgehensweise wird modular für jede einzelne Prozedur durchgeführt Beispielprogramm Sortieren mit Hilfe des Bubblesort-Algorithmus Modularisierung in zwei Prozeduren swap: Vertauschen zweicher benachbarter Speicherinhalte sort: Sortieren aufeinanderfolgender Speicherworte

60 Michael Wahl Rainer Brück Seite 60 Die Prozedur swap C-Programm Registerzuweisung Parameter: $a0: v (Adresse des ersten Array-Elements) $a1: k lokale Varaible $t0: temp swap (int v[], int k) {int temp; temp = v[k]; v[k] = v[k+1], v[k+1] = temp; }

61 Michael Wahl Rainer Brück Seite 61 Prozedurrumpf Die Prozedur swap 1) Adressberechnung 1 2) Array-Elemente laden 2 3) Array-Elemente vertauscht abspeichern 3 4) Rücksprung 4

62 Michael Wahl Rainer Brück Seite 62 Die Prozedur swap Und was wird gesichert? Nichts! Denn … Es werden nur $t-Register verwendet, die gemäß Registerkonventionen nicht gesichert werden Es wird keine Unterprozedur aufgerufen: –Argumentregister –Rücksprungadressregister werden daher nicht überschrieben und müssen nicht gesichert werden.

63 Michael Wahl Rainer Brück Seite 63 Die Prozedur sort Bubblesort-Prozedur Der C-Code sort (int v[k], int n) {int i, j; for (i=0; i=0 && v[j] > v[j+1]; j=j-1) { swap (v, j); }

64 Michael Wahl Rainer Brück Seite 64 Die Prozedur sort Registerzuweisung Parameter $a0: v, Adresse des ersten Elements des zu sortierenden Arr ays $a1: n, Anzahl der zu sortierenden Elemente Register für lokale Variable $s0: i $s1: j Diese Register würden bei Aufruf weiterer Prozeduren gesichert (trifft in diesem Beispiel nicht zu!) temporäre Rechenregister $t0 - $t4, verwendet für Adressberechnungen

65 Michael Wahl Rainer Brück Seite 65 Die Prozedur sort: Prozedurrumpf Die äußere Schleife: 1) Initialisierung 1 2) Schleifentest 2 3) Inkrement und Iteration 3

66 Michael Wahl Rainer Brück Seite 66 Die Prozedur sort: Prozedurrumpf Die innere Schleife: 1) Initialisierung 2) Schleifentest 3) Inkrement und Iteration { for (j=i-1; j>=0 && v[j] > v[j+1]; j=j-1) { … }

67 Michael Wahl Rainer Brück Seite 67 Die Prozedur sort: Prozedurrumpf Parameterübergabe an swap und AufrufInitiale Parameterübergabe an sort

68 Michael Wahl Rainer Brück Seite 68 Die Prozedur sort: Prozedurrumpf

69 Michael Wahl Rainer Brück Seite 69 Die Prozedur sort: Gesamteinbindung Register sichernRegister zurückspeichernProzedurrücksprung

70 Michael Wahl Rainer Brück Seite 70 Instruktionssatzarchitekturen in der Praxis Realistische Beispiele Es wäre zu zeitaufwendig, in einer Überblicksveranstaltung wie dieser alle Details der komplexen realistischen Prozessorarchitekturen von heute zu behandeln. Wir werden uns immer wieder einzelnen interessanten Aspekten solcher Prozessoren zuwenden. Für Details folge man den WEB-Enhanced Verweisen aus dem Buch von Hennessy/Patterson (auch über die RS-WEB-Pages erreichbar)

71 Michael Wahl Rainer Brück Seite 71 Ein kurzer Blick auf den PowerPC IBM/Motorola Prozessorfamilie, Einsatz in IBM- Rechnern und Apple-Macintosh Registersatz 32 Register à 32 bit, Load/Store-Architektur Adressierungsarten Indizierte Adressierung Adressierungsart, die die Summe der Inhalte zweier Register als Adresse verwenden kann. Dies ist nützlich für die Adressierung von Arrays Die MIPS Instruktionsfolge kann beim PowerPC ersetzt werden durch

72 Michael Wahl Rainer Brück Seite 72 Ein kurzer Blick auf den PowerPC Adressierungsdarten (Forts.) Update-Adressierung (manchmal auch Autoinkrement/ Autodekrement-Adressierung genannt Datentransferoperationen erhöhen/erniedrigen nach der Befehlsausführung automatisch den Inhalt des Basisregisters. Dies ermöglicht schnelle Blocktransferoperationen Anstatt der MIPS-Instruktionsfolge reicht beim PowerPC der Befehl

73 Michael Wahl Rainer Brück Seite 73 Ein kurzer Blick auf den PowerPC Spezielle PowerPC-Instruktionen Mehrfach-Laden/Speichern Transfer von bis zu 32 Speicherworten mit einem Befehl aus dem Speicher in Register oder umgekehrt Instruktion zur Schleifenunterstützung Spezieller Befehl, der die Ausführung von for-Schleifen effizient implementiert. Die folgende C-for-Schleife wird in MIPS so übersetzt …, beim PowerPC so …

74 Michael Wahl Rainer Brück Seite 74 Ein kurzer Blick auf Intel-Architekturen Während MIPS und auch PowerPC bei ihrer Einführung neue Architekturen waren hat INTEL bei der Prozessorentwicklung über 20 Jahre lang auf Kompatibilität geachtet. Auf diese Weise mussten die Leistungsparameter neuer Architekturkonzepte immer unter Berücksichtigung der Möglichkeiten der alten Prozessoren eingeführt werden. Das Ergebnis sind leistungsfähige Prozessoren mit sehr komplexen und sehr irregulären Instruktionssatzarchitekturen.

75 Michael Wahl Rainer Brück Seite 75 Geschichte der Intel-Architekturen 1978: 8086 Erster 16 Bit-Prozessor als kompatible Erweiterung des erfolgreichen Register mit spezifischen Aufgaben. 1982: Erweiterter Adressraum (24 bit). Zusätzliche Instruktionen zur Abrundung des Befehlssatzes, speziell für Protection. 1985: Sowohl Adressraum, als auch Register auf 32 bit erweitert. Zusätzliche Operationen schaffen fast eine General- purpose-Register-Maschine. 1989: 80486; 1992: Pentium; 1995 Pentium Pro Erhöhte Performanz durch interne Maßnahmen. Nur 4 neue Instruktionen. 1997: Pentium MMX 57 zusätzliche Instruktionen für Multimedia-Anwendungen.

76 Michael Wahl Rainer Brück Seite 76 Der Registersatz ab der ursprünglichen 16 Bit- Register wurden auf 32 Bit erweitert und dienen als General-Purpose-Register Für einzelne Instruktionen dienen einzelne Register speziellen Zwecken

77 Michael Wahl Rainer Brück Seite 77 Instruktionstypen und Operanden 2-Adressbefehle Ein Register dient sowohl als Quell- als auch als Zielregister Operationen spezifizieren also höchstens zwei Register/Speicheradressen (2-Adress-Maschine) Alle Operationen mit Speicherzugriff Keine Load/Store-Architektur. Jede Instruktion kann Operanden aus dem Speicher nutzen

78 Michael Wahl Rainer Brück Seite 78 80x86-Instruktionsbeispiele Verzweigungen werden in Abhängigkeit von Condition Codes durchgeführt, die bei der Ausführung von Instruktionen (als Seiteneffekt) gesetzt werden! ( )

79 Michael Wahl Rainer Brück Seite 79 Adressierungsarten Intel-Architekturen verwenden recht vielfältige und komplexe Adressierungsarten mit uneinheitlichen Restriktionen hinsichtlich der Registernutzung.

80 Michael Wahl Rainer Brück Seite 80 Instruktionsformate (Beispiele) Intel-Instruktionen variieren zwischen 1 und 17 Byte Länge bei äußerst verschiedenartigen Aufteilungen. Dies mach die HW-Implementierung ausgesprochen aufwendig.

81 Michael Wahl Rainer Brück Seite 81 Klassische Architekturkonzepte Akkumulatorarchitekturen Zu Beginn der Geschichte der Mikroproprozessoren war Speicher so teuer, dass man sich nur möglichst wenig davon leisten durfte. Damals gab es in der Regel nur ein Register, den Akkumulator, auf den mit kurzen Instruktionen (eine Speicheradresse) zugegriffen wurde (1-Adress-Maschine) Nach und nach konnten mehr und längere Register bereit gestellt werden, was zu General-Purpose-Register-Architekturen und 2- bzw. 3-Adress-Maschinen führte. C.Code Assembler

82 Michael Wahl Rainer Brück Seite 82 Klassische Architekturkonzepte Stackarchitekturen In den frühen 60er Jahren wurden in der Annahme, Compiler könnten keine effiziente Registerverwaltung durchführen, Architekturen ganz ohne Register (!!) entworfen Operanden wurden direkt im Speicher mit Hilfe eines Stack-Modells (ähnlich wie in HP-Taschenrechnern) realisiert (0-Adress-Maschine) C.Code Assembler

83 Michael Wahl Rainer Brück Seite 83 Klassische Architekturkonzepte Ab 1980: RISC-Architekturen In den achziger Jahren war Speicher hinreichend billig geworden und die Compiler-Technik hinreichend weit fortgeschritten, so dass man sich erlauben konnte, beim Entwurf von Instruktionssatzarchitekturen konsequent auf Hardware- Optimierung zu setzen. Dies führte zu den sog. RISC-Architekturen (Reduced Instruction Set Computer), die hinsichtlich der Instruktionssätze über folgende Eigenschaften verfügen: eine feste Instruktionslänge Load/Store-Architekturen wenige, einander ähnliche Instruktionsformate wenige einfache Adressierungsarten wenige Instruktionen (insbes. wenige hochspezifische Spezialbefehle) (Ein weiteres definierendes Element von RISC-Architekturen: Pipelining wird im folgenden ausführlich behandelt) Das RISC-Konzept bietet gute Voraussetzungen für eine hocheffiziente HW-Realisieerung (s.u.)!


Herunterladen ppt "Michael Wahl Rainer Brück Seite 1 Befehlssatz des MIPS R2000 Prozessors."

Ähnliche Präsentationen


Google-Anzeigen