Grundlagen der Informatik III

Transkript

1 Grundlagen der Informatik III WS 2008 / 2009 [Folien basierend auf VL von Prof. Dr. Claudia Eckert, WS 07/08] Prof. Dr. rer. nat. Frederik Armknecht Sascha Müller Daniel Mäurer Fachbereich Informatik / CASED Mornewegstraße Darmstadt

2 Gliederung der Vorlesung GdI 3 1. Einführung 2. Assemblerprogrammierung 3. Leistungsbewertung 4. Speicherhierarchie 5. Assembler, Binder, Lader 6. Betriebssysteme und Ein-/Ausgabe (Grundlagen) 7. Rechnernetze (Grundlagen) 8. Compiler (Grundlagen) Fachbereich Informatik Prof. Dr. Frederik Armknecht 2

3 Gliederung dieses Kapitels 2.1 Instruktionssatz 2.2 Variablen und Register 2.3 Speicherorganisation 2.4 Speicherbefehle 2.5 Befehlsformate 2.6 Konzept der universellen Interpretierbarkeit 2.7 Übersetzung von Kontrollstrukturen 2.8 Verarbeitung von Zeichen 2.9 Höhere Kontrollstrukturen: Prozeduren 2.10 Adressierung 2.11 Fazit Ziel: systemnahes Programmieren auf der Assemblerebene unter Nutzung des MARS-Simulators für die MIPS-RISC-Architektur Achtung: Vorlesung ist kein Assemblerkurs; sie erläutert wichtige Prinzipien. Fachbereich Informatik Prof. Dr. Frederik Armknecht 3

4 Kapitel 2 Assemblerprogrammierung 2.1 Instruktionssatz (Befehlssatz, instruction set): Maschinen-Sprache zur Beschreibung der einzelnen Aktionen, die ein Prozessor ausführen kann so einfach wie möglich gehalten, primitive Sprache Beispiel in Vorlesung: MIPS-R2000-Instruktionssatz einfach, bietet alle wichtigen Konzepte Fachbereich Informatik Prof. Dr. Frederik Armknecht 4

5 High-level Instruktionssatz: language program Schnittstelle (Interface) zwischen Compiler und Rechner (in C) swap(int v[], int k) {int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; } Ccompiler Assembly language program (for MIPS) swap: muli $2, $5,4 add $2, $4,$2 lw $15, 0($2) lw $16, 4($2) sw $16, 0($2) sw $15, 4($2) jr $31 Assembler Binary machine language program (for MIPS) Fachbereich Informatik Prof. Dr. Frederik Armknecht 5

6 MIPS-Arithmetik: Erstes Beispiel Addiere die Werte der beiden Variablen b und c und weise das Ergebnis der Variablen a zu add a, b, c Assemblerbefehle (instructions) stark formalisiert: alle Arithmetikbefehle haben genau 3 Variablen: Zwei Argumente und einen Ergebnisoperanden feste Reihenfolge der Variablen (Ergebnis zuerst) jede Zeile ein Befehl Fachbereich Informatik Prof. Dr. Frederik Armknecht 6

7 Pseudobefehle Maschinensprache umfasst normalerweise nur eine kleine Anzahl an möglichen Instruktionen Manche Operationen sind nicht direkt implementiert, sondern müssen durch andere realisiert werden. Einige Assembler unterstützen sogenannte Pseudobefehle. Dies sind Befehle, die es in der Maschinensprache nicht gibt, aber häufig gebraucht werden. Der Assembler übersetzt diese dann in eine geeignete Sequenz von echten Assemblerbefehlen. Aus didaktischen Gründen werden wir im Folgenden gelegentlich Pseudobefehle verwenden. Diese sind mit eckigen Klammern markiert. Mehr dazu später Fachbereich Informatik Prof. Dr. Frederik Armknecht 7

8 Übersetzung einfacher C-Programme C a = b + c; d = a - e; MIPS-Assembler add a, b, c sub d, a, e... oder etwas komplizierter: temporäre Variable f=(g+h) (i+j) add t0, g, h add t1, i, j sub f, t0, t1 Fachbereich Informatik Prof. Dr. Frederik Armknecht 8 Beachten von Operator-Prioritäten ( Reihenfolge)

9 2.2 Variablen und Register Variablen Unterschied zu höheren Programmiersprachen: Operanden müssen auf begrenzte Anzahl elementarer Speichereinheiten ( Register ) des Prozessors abgebildet werden. Register: Register sind Teile der Programmierer-Schnittstelle direkt vom Programm aus zugreifbar besitzen eine feste, identische Länge (Wortbreite), derzeit typischerweise noch 32 bit (künftig 64 bit) Fachbereich Informatik Prof. Dr. Frederik Armknecht 9

10 2.2 Variablen und Register MIPS-Architektur besitzt 32 Register mit je 32 bit, Register mit spezieller Funktion: Register 0 und 31 frei benutzbare Register: Register 1, 2,..., 30 Register besitzen symbolische Namen: Benennung: $ <name> Patterson/Hennessy: Benennung der Register entsprechend der Nutzung im GNU C Compiler Fachbereich Informatik Prof. Dr. Frederik Armknecht 10

11 MIPS GNU C Registerbenutzung Name Nr. Funktion Gesichert? $zero 0 der konstante Wert 0 bleibt $at 1 reserviert für Assembler $v0, $v1 2, 3 Resultatwerte und Auswertung von Ausdrücken nein $a0... $a3 4-7 Argumente nein $t0... $t Zwischenwerte (temporär) nein $s0... $s gesichert (saved) ja Beispiel für Nutzung: add $t0, $s2, $t0 addiere Inhalte der Register $t0 und $s2 und speichere das Ergebnis in Register $t0 ab Fachbereich Informatik Prof. Dr. Frederik Armknecht 11

12 MIPS GNU C Registerbenutzung Name Nr. Funktion Gesichert? $t8... $t weitere Zwischenwerte nein $k0, $k1 26, 27 Betriebssystem (OS kernel) $gp 28 globaler Zeiger (global pointer) ja $sp 29 Zeiger auf Kellerspeicher (stack pointer) ja $fp 30 Rahmenzeiger (frame pointer) ja $ra 31 Rücksprungadresse (return address) ja (vgl. Patterson/Hennessy, Seite A-24, Figure A.6.1) Fachbereich Informatik Prof. Dr. Frederik Armknecht 12

13 Das Beispiel mit Registern add t0, g, h add t1, i, j sub f, t0, t1 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. Aber: Wie kommen die Variablenwerte in die Register? Fachbereich Informatik Prof. Dr. Frederik Armknecht 13

14 Register versus Speicher Problem: Arithmetische Instruktionsoperanden müssen Register sein nur 32 Register verfügbar Übersetzer weist den Variablen Register zu Was aber bei Programmen mit vielen Variablen? d.h. Datenstrukturen müssen im Speicher gehalten werden: wo, wie? Und wie kommen sie in Register? Fachbereich Informatik Prof. Dr. Frederik Armknecht 14

15 2.3 Speicherorganisation Antwort: Ablage im Speicher, Zugriff über Adresse, Load/Store Befehle im Assembler Byte-Adressierung Speicher: sehr großes, eindimensionales Bit-Feld Elemente des Feldes sind über Adressen identifizierbar Eine Speicheradresse ist als ein Index in das Feld zu interpretieren Byte Adressierung bedeutet, der Index zeigt auf ein Byte (=8 Bit) Fachbereich Informatik Prof. Dr. Frederik Armknecht 15

16 2.3.2 Worte Byte: relativ kleine Einheit Zur einfacheren Handhabung: größere Einheiten, die Worte, häufig: 1 word = 32 Bit (4 Byte) MIPS-Befehlssatz: jedes Wort besteht aus 4 Byte Ein Register enthält 32 Bit an Daten Mit dem Inhalt eines 32-bit Registers lassen sich 2 32 Byte mit Byte-Adressen von 0 bis adressieren 2 30 Worte mit Byte-Adressen 0, 4, 8, Fachbereich Informatik Prof. Dr. Frederik Armknecht 16

17 2.3.2 Worte Worte sind sequentiell abgelegt und dürfen nur an Adressen beginnen, die durch die Wortgröße teilbar sind: diese Eigenschaft heißt Alignment Dadurch erreicht man effizientere Speicherzugriffe: pro Wort ist nur eine Adressberechnung erforderlich Ausnutzen dieser Organisation: z.b. bei der Verarbeitung von Feldern Array-Elemente werden sequentiell abgelegt Ein Register z.b. $s3 enthält die Anfangsadresse (Basisadresse) Element-Adresse A[i]: i-tes Element des Feldes A: Basisadresse + 4* i Fachbereich Informatik Prof. Dr. Frederik Armknecht 17

18 2.3.3 Byte-Order Big Endian: das Byte mit höchstwertigsten Bits wird zuerst gespeichert, d.h. an der kleinsten Speicheradresse. Little-Endian das Byte mit niederwertigsten Bits wird zuerst gespeichert Beispiel aus dem täglichen Leben: Datumsformat yyyy-mm-dd : Big Endian dd-mm-yyyy : Little Endian Bem.: MIPS kennt Big- und Little Endian Order MARS-Simulator: arbeitet mit Little Endian Fachbereich Informatik Prof. Dr. Frederik Armknecht 18

19 2.4 MIPS Speicherbefehle: Lade und Speichere lw: load word (lade Wort), sw: save word (speichere Wort) Beispiel: C: A[8] = h + A[8] MIPS: lw $t0, 32($s3) ($s3 enthalt Startadresse von A) add $t0, $s2, $t0 sw $t0, 32($s3) bei sw Zieladresse am Schluss Arithmetikoperanden müssen Register, können nicht Speicheradressen sein! MIPS-Adressierungsmodus: Konstante (Basisregister): Adresse = Konstante + Inhalt des Basisregisters z.b. 32($s3) = Offset/Index (32) + Basis-(Index-)Register ($s3) lw und sw einzige Befehlstypen, die auf Speicher zugreifen! Fachbereich Informatik Prof. Dr. Frederik Armknecht 19

20 2.4 MIPS Speicherbefehle (Beispiel 1) Beispiel: C: int V[6]; a = V[2]; V[4] = a; MIPS: $s1: Basisadresse von V $s0: a Ladebefehl: Datenübertragung Speicher Register lw $s0, 8($s1) Speicherbefehl: Datenübertragung Register Speicher sw $s0, 16($s1) Fachbereich Informatik Prof. Dr. Frederik Armknecht 20

21 2.4 MIPS Speicherbefehle (Beispiel 2) swap(int v[], int k); {int temp; temp = v[k] v[k] = v[k+1] v[k+1]= temp; } swap: Adressberechnung von v[k] Datentransport Rücksprung Wert von k steht in Register $5 Startwert von v steht in Register $4 Erinnerung: Befehle in eckigen Klammern bezeichnen Pseudobefehle [mul $2, $5, 4] # $2 = k*4 add $2, $4, $2 # $2 = v + k*4 lw $16, 0($2) # lade Inhalt von v[k] lw $17, 4($2) # lade Inhalt v[k+1] sw $17, 0($2) # v[k] = v[k+1] sw $16, 4($2) jr $31 # fahre beim Aufrufer fort Fachbereich Informatik Prof. Dr. Frederik Armknecht 21

22 2.4 C-Programme mit variablen Array-Indizes Beispiel: C: g = h + A[i] MIPS Registerzuweisung: $s1: g $s2: h $s3: Basis von A $s4: i Index auf Speicheradressen abbilden (mit 4 multiplizieren): mul: Normale Multiplikation [mul $2, $5, 4] (effizienter) sll: Shift 2 Stellen nach links sll $t1, $s4, 2 Wortadresse zu Basisadresse addieren add $t1, $t1, $s3 Array-Element laden (Adresse von A(i) in $t1) lw $t0, 0($t1) Addition ausführen add $s1, $s2, $t0 Fachbereich Informatik Prof. Dr. Frederik Armknecht 22

23 2.4 Zwischenbilanz MIPS Laden von Worten, Adressieren von Bytes Arithmetik nur auf Registern Instruktionen Bedeutung add $s1, $s2, $s3 $s1 = $s2 + $s3 sub $s1, $s2, $s3 $s1 = $s2 - $s3 lw $s1, 100($s2) $s1 = Memory[$s2+100] sw $s1, 100($s2) Memory[$s2+100] = $s1 und auch bereits: Immediate Befehle, Shift Fachbereich Informatik Prof. Dr. Frederik Armknecht 23

24 2.5 MIPS Befehlsformate Background Auch Instruktionen sind 32 Bits lang Beispiel: Repräsentation eines Additionsbefehls Beispiel: MIPS-Assembler: add $t0, $s1, $s2 Jedes Register hat eigene Nummer: $t0=8,..., $t7=15, $s0=16,..., $s7=23 Dezimaldarstellung des Additionsbefehls: Addition Zielregister Operandenregister hier unbenutzt Fachbereich Informatik Prof. Dr. Frederik Armknecht 24

25 2.5 MIPS Befehlsformate Addition Zielregister Operandenregister hier unbenutzt In Binärdarstellung: Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit Beispiel: binär = = 18 dezl Fachbereich Informatik Prof. Dr. Frederik Armknecht 25

26 2.5.1 MIPS-Befehlsformat R (für Register) op rs rt rd shamt funct 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit op: opcode ; Grundtyp des Befehls (instruction) rs: erster Operand (Register!) rt: zweiter Operand (Register!) rd: Ziel (Register!) shamt: shift amount, für sogenannte Schiebeoperationen wichtig (siehe später) funct: Funktionscode ; Ergänzung zu op: genaue Spezifikation der durchzuführenden Operation Zusammenfassung der MIPS-Architektur bis hierher siehe: Patterson/Hennessy, Seite 67, Figure 2.7 Fachbereich Informatik Prof. Dr. Frederik Armknecht 26

27 2.5.2 MIPS-Befehlsformat I (Immediate) op rs rt adress 6 Bit 5 Bit 5 Bit 16 Bit op: opcode ; Grundtyp des Befehls (instruction) rs: Basisadressregister rt: Zielregister adress: Konstante, die Offset bzgl. Basisregister angibt lw, sw benötigen 2 Register und 1 Konstante als Array-Offset Konstante kann länger als 5 oder 6 Bit sein op-kodierung von lw ist 35 (dezimal) bzw (binär) op-kodierung von sw ist 43 (dezimal) bzw (binär) Fachbereich Informatik Prof. Dr. Frederik Armknecht 27

28 Beispiel C-Programmtext A[300] = h + A[300] Maschinencode dezimal MIPS-Assembler lw $t0, 1200($t1) add $t0, $s2, $t0 sw $t0, 1200($t1) Maschinencode binär Fachbereich Informatik Prof. Dr. Frederik Armknecht 28

29 2.5.3 MIPS-Befehlsformat J (Jump) op adress 6 Bit 26 Bit op: opcode ; Grundtyp des Befehls (instruction) adress: Zieladresse Fachbereich Informatik Prof. Dr. Frederik Armknecht 29

30 2.6 Konzept der universellen Interpretierbarkeit Hintergrund: Programme sind gespeicherte Daten Befehle sind Bitfolgen bzw. Binärzahlen Konsequenz: Programme werden im Speicher als Maschinencode abgelegt und sie werden gelesen und geschrieben wie Daten Speicher Speicher für Daten, Programme, Compiler, Editoren, etc. Fachbereich Informatik Prof. Dr. Frederik Armknecht 30

31 2.6.1 Uniforme Verwaltung Uniforme Verwaltung (Programme, Daten) keine speziellen Verwaltungsoperationen für Befehlsund Datenspeicher notwendig Bem: Es gibt spezielle Architekturen, die explizit zwischen Befehls- und Datenspeicher unterscheiden welche Vorteile hätte das ggf. doch? Uniformität Speicher ist als uniformer Bit-Container realisiert vereinheitlichte, einfache Abläufe, z.b. Grundzyklus der CPU Fachbereich Informatik Prof. Dr. Frederik Armknecht 31

32 2.6.1 Uniforme Verwaltung Grundzyklus der CPU Fetch and Execute Befehle werden aus dem Speicher geladen (fetch) und in ein spezielles Register abgelegt Die Bits in diesem Register steuern die nachfolgenden Aktionen (vgl. Kontrollpfad der CPU wie in Technischer Informatik behandelt) Befehl wird ausgeführt (execute) Holen des nächsten Befehls etc. Fachbereich Informatik Prof. Dr. Frederik Armknecht 32

33 2.6.2 Mögliche Probleme Mögliche Probleme durch universelle Interpretierbarkeit kein Schutz der Daten und Programme Daten können als Befehle interpretiert werden, auch wenn das so eigentlich nicht vorgesehen ist Beispiel: Buffer-Overflow-Exploits Programme können verändert werden und inkorrektes (schädliches) Verhalten aufweisen Beispiel: Schadsoftware: Viren, Trojaner Lösungsansatz: Aufteilung des Speicherbereichs eines Programms in Daten und Code-Bereich Fachbereich Informatik Prof. Dr. Frederik Armknecht 33

34 Typisches Speicherlayout eines Programms 0xff f Daten Code 0 Fachbereich Informatik Prof. Dr. Frederik Armknecht 34

35 64-bit Adressraum - 64-bit Adressräume erlauben es, gut 16 Millionen Terabyte Speicher zu adressieren => immenser Verwaltungsaufwand -Lösung: Adresse auf weniger Bits reduzieren -Beispiel (AMD64): Höchstes Bit wird entweder als 0xF..F bzw. als 0x0..0 interpretiert Bild: Wikipedia Fachbereich Informatik Prof. Dr. Frederik Armknecht 35

36 Bedeutung für die Assemblerprogrammierung Konzept der Segmentierung Trennen in Daten-, Code- (Text) und Stack-Segment Datensegment enthält die Daten Textsegment den Programmcode Stacksegment wird für Prozeduraufrufe benötigt dies ist eine übliche Aufteilung des Adressraums eines Prozesses in heutigen Betriebssystemen Frage: woher weiß der Assembler, welche Assemblerbefehle in welches Segment zu speichern sind? Antwort: über Direktiven:.text,.data Assembler sortiert dann automatisch Fachbereich Informatik Prof. Dr. Frederik Armknecht 36

37 2.7 Übersetzung von Kontrollstrukturen Background: In höheren Programmiersprachen gibt es programmiersprachliche Konzepte, um die sequentielle Ausführung von Befehlen zu beeinflussen bedingte Programmausführung: u.a. if... then... [else...] switch... case... wiederholte Programmausführung: u.a. for... while... repeat until Fachbereich Informatik Prof. Dr. Frederik Armknecht 37

38 2.7.1 Background Auf der Maschinenbefehlsebene gibt es keine Befehle, um Kontrollstrukturen direkt abzubilden Es stehen lediglich bedingte und unbedingte Sprungbefehle zur Verfügung Sprungbefehle im MIPS-Befehlssatz: beq reg1, reg2, label (branch if equal) bne reg1, reg2, label (branch if not equal) j addr (jump to address), unbedingter Sprung Problem: Die Semantik der Kontrollstrukturen muss mit den Sprungbefehlen effizient nachgebildet werden Fachbereich Informatik Prof. Dr. Frederik Armknecht 38

39 2.7.2 Übersetzung einfacher Kontrollstrukturen in Assemblercode Hier betrachtet: if-then-else, while IF-Anweisung einer höheren Programmiersprache: if <bedingung> then <statement1> else <statement2> Übersetzungsschritte: Variablen und Werte, die zur Auswertung der Bedingung benötigt werden, in Register ablegen Beginn der Befehlsfolge <statement2> mit Marke <marke> versehen Sprung zu <marke>, falls Bedingung nicht erfüllt Fachbereich Informatik Prof. Dr. Frederik Armknecht 39

40 Beispiel: If.. then.. else Anweisung C-Programmtext if (i==j) f = g + h; else f = g - h; MIPS-Assembler Testen und Verzweigen Addition (im TRUE-Fall) Else-Fall überspringen Subtraktion (im FALSE-Fall) Ausgang bne $s3, $s4, Else add $s0, $s1, $s2 j Exit Else: sub $s0, $s1, $s2 Exit: Fachbereich Informatik Prof. Dr. Frederik Armknecht 40

41 Beispiel: while Schleife Schleifen, z.b. while Schleife While <bedingung> do <statementlist> endwhile Übersetzungsschritte: analog zur If-Anweisung: Variablen und Werte zur Auswertung der Bedingung werden in Register geladen markiere den ersten Befehl der Statementlist mit einer Marke, z.b. LOOP füge als letzten Befehl der Statementliste einen bedingten Sprung zur Marke LOOP ein Fachbereich Informatik Prof. Dr. Frederik Armknecht 41

42 Weitere Kontrollfluss-Steuerungen Wie realisiert man einen Vergleich der Art if a < b? Neuer Befehl: slt $t0, $s1, $s2 (set on less than) Bedeutung: 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 Bem.: Die MIPS-Architektur verwendet ein spezielles Register, das konstant den Wert 0 enthält. Es wird in der Assemblersprache als $zero bezeichnet. Fachbereich Informatik Prof. Dr. Frederik Armknecht 42

43 Die MIPS-Architektur bis hierher Instruktion Bedeutung add $s1,$s2,$s3 $s1 = $s2 + $s3 sub $s1,$s2,$s3 $s1 = $s2 $s3 lw $s1,100($s2) $s1 = Memory[$s2+100] sw $s1,100($s2) Memory[$s2+100] = $s1 bne $s4,$s5,l nächste Instruktion ist bei L, wenn $s4!= $s5 beq $s4,$s5,l nächste Instruktion ist bei L, wenn $s4 = $s5 slt $t0,$s1,$s2 j Label wenn $s1 < $s2, dann $t0=1, sonst $t0=0 nächste Instruktion ist bei Label Fachbereich Informatik Prof. Dr. Frederik Armknecht 43

44 Die MIPS-Architektur bis hierher add immediate addi $s1,$s2,100 $s1= $s2+100 used to add constants Fachbereich Informatik Prof. Dr. Frederik Armknecht 44

45 addi I addi $s1,$s2,100 Quelle: Buch von Patterson/Hennessy, Seite 131, Figure 3.9 (2. A) R I J op rs rt rd shamt funct op rs rt 16 Bit Adresse op 26 Bit Adresse Fachbereich Informatik Prof. Dr. Frederik Armknecht 45

46 Zwischenfazit Grundprinzipien heutiger Rechnerarchitekturen: Instruktionen als (binäre) Zahlen repräsentiert. Programme im Speicher abgelegt und können dort gelesen und geschrieben werden wie Zahlen. Dies ist das Prinzip des speicherprogrammierbaren Rechners (stored program computer) Daten und Programme können beliebig im Speicher angeordnet werden. Programme können auch als Daten interpretiert werden (z.b. Compiler betrachten Programme als Daten.) Fachbereich Informatik Prof. Dr. Frederik Armknecht 46

47 2.8 Verarbeitung von Zeichen Darstellung von Zeichen: eine Möglichkeit: ASCII-Format (siehe nächste Folie) Darstellung eines Zeichens durch einen 8Bit Code Zugriffe auf einzelne Zeichen: Assemblerbefehle: Lade Byte (lb), speichere Byte (sb) Ladeoperation: lb $t0, 0($sp) (load byte) Lädt ein Byte aus dem Speicher und platziert es in die niederwertigen Bits eines Registers Speicheroperation: sb $t0, 0($a1) (save byte) niederwertiges Byte in Speicherposition speichern Fachbereich Informatik Prof. Dr. Frederik Armknecht 47

48 Darstellung von Zeichen: ASCII-Tabelle Mit acht Bit (ein Byte) lassen sich in ASCII (American Standard Code for Information Interchange) 2 8 =256 Zeichen darstellen gemäß Konvention: Groß- und Kleinbuchstaben unterscheiden sich um 32= 2 5 Nicht angegeben: u.a. Formatierungszeichen wie Tab (9), Carriage Return (13), Backspace (8), Null (0) (in C zur Markierung des Endes einer Zeichenkette verwendet). Fachbereich Informatik Prof. Dr. Frederik Armknecht 48

49 2.8.2 Zeichenketten Kombination von Zeichen zu Zeichenketten (strings) Darstellung von Zeichenketten: 3 typische Varianten Die erste Position der Zeichenkette wird reserviert für die Länge der Zeichenkette. Eine zweite, zusätzliche Variable enthält die Länge der Zeichenkette. Die letzte Position einer Zeichenkette wird durch ein Sonderzeichen markiert. (z.b. in C verwendet) Beispiel: Zeichenkette GdI3 in C dargestellt durch 5 Byte mit den ASCII-Werten: 71, 100, 73, 51, 0. Fachbereich Informatik Prof. Dr. Frederik Armknecht 49

50 2.8.2 Zeichenketten Typische Operation auf Strings: Kopieren Beispiel: Kopieren eines Zeichenstrings unter Prozedur strcpy kopiert Zeichenkette y auf x void strcpy (char x[], char y[]) { int i; } i = 0; while ((x[i]=y[i])!= 0) /* Kopieren, Prüfen des i-ten Byte*/ i = i + 1; Festlegung: Basisadresse des Feldes (array) x steht in $a0 und Adresse von y in $a1 $s0 wird für i verwendet. Fachbereich Informatik Prof. Dr. Frederik Armknecht 50

51 2.9 Höhere Kontrollstrukturen : Prozeduren Allgemeines Prozeduren (Unterprogramme, Methoden) wichtigstes Strukturierungskonzept moderner Programmiersprachen Moderne Rechner-Architekturen bieten Hardware-Unterstützung zur effizienten Bearbeitung von Prozeduren Konzept: Prozedurrahmen (procedure frame): Speicherblock, in dem alles abgelegt wird, was zur Verwaltung des Prozeduraufrufs notwendig ist. Fachbereich Informatik Prof. Dr. Frederik Armknecht 52

52 2.9.1 Allgemeines Vorteile des Konzeptes: Einheitliche Behandlung von Prozeduraufrufen, d.h. Abstraktion von unterschiedlichen Aufrufkonzepten: iterative und rekursive Prozeduren geschachtelte Prozeduren Im Prinzip wird auch ein entfernter Prozeduraufrufe (RPC, RMI) analog bearbeitet Bem.: Prinzip wird auch an anderer Stelle eingesetzt: u.a. beim Prozess- und Kontextwechsel durch das BS Retten von Zuständen, Kontrollwechsel etc. Fachbereich Informatik Prof. Dr. Frederik Armknecht 53

53 2.9.1 Allgemeines Schritte zur Ausführung einer Prozedur Parameter so bereit stellen, dass Prozedur darauf zugreifen kann: Argumentregister $a0, $a1, $a2, $a3 Eingangsparameter bleiben durch Prozedur unverändert Ablaufsteuerung (control) der Prozedur übergeben: jal Prozeduradresse (jump and link) Sonderbefehl für Prozedurausführung: springt zur angegebenen Adresse und speichert die Adresse der folgenden Instruktion in $ra Fachbereich Informatik Prof. Dr. Frederik Armknecht 54

54 2.9.1 Allgemeines Schritte zur Ausführung einer Prozedur (Forts.) Benötigten Speicherbereich für Prozedur bereit stellen Prozedur ausführen Ergebniswert so bereit stellen, dass aufrufendes Programm darauf zugreifen kann: Ergebniswertregister $v0,$v1 Ablaufsteuerung an Aufrufstelle zurückgeben durch Sprung zurück zum Ausgangspunkt: jr $ra (jr: jump register, ra: return address) Fachbereich Informatik Prof. Dr. Frederik Armknecht 55

55 2.9.1 Allgemeines Nutzung des speicherprogrammierbaren Rechners: zur Realisierung einer Prozedur wird ein Register mit Adresse der aktuell ausgeführten Instruktion benötigt Dieses Register nennt man traditionell program counter (PC), gemeint ist das instruction address register Problem: nach der Prozedurausführung muss bei der korrekten Instruktion beim Aufrufer weitergearbeitet werden: d.h. alter PC-Stand muss bewahrt werden Lösung: Befehl jal speichert PC+4 in Register $ra. Fachbereich Informatik Prof. Dr. Frederik Armknecht 56

56 2.9.2 Übersetzung von Prozeduren in Assembler Einfache Parameterübergabe über Register: Die Register $a0-$a3 dienen zur Übergabe der ersten vier Parameter $v0-$v1 dienen zur Speicherung der Return-Werte $ra enthält die Rücksprungadresse zum Aufrufer Probleme: Was ist bei mehr als 4 Parametern? Zur Bearbeitung der Prozedur werden auch Register benötigt, die enthalten ggf, noch Werte des Aufrufers: was soll damit geschehen? Retten? Überschreiben? Fachbereich Informatik Prof. Dr. Frederik Armknecht 57

57 2.9.2 Übersetzung von Prozeduren in Assembler Antworten: gespeicherte Registerwerte des Aufrufers (Zustand) werden in Form einer Keller-Datenstruktur (stack) im Speicher verwaltet (LIFO-Prinzip) Bem.: Stack-Verwaltung muss explizit in Assembler programmiert werden Ein Keller enthält: Argumentwerte, bei mehr als 4 Parametern die vor dem Prozeduraufruf gültigen Inhalte derjenigen Register, die von der Prozedur verwendet werden. Fachbereich Informatik Prof. Dr. Frederik Armknecht 58

58 2.9.2 Übersetzung von Prozeduren in Assembler Kellerverwaltung: Ein Register weist auf das letzte Element im Kellerspeicher ($sp: stack pointer) Der Keller ist am oberen Ende des Speichers angeordnet und wächst in Richtung kleinerer Speicheradressen (von oben nach unten) Push: erniedrigt den Stack-Pointer Pop: erhöht ihn $sp Synonyme Begriffe: Keller, Stapel, stack Fachbereich Informatik Prof. Dr. Frederik Armknecht 59

59 2.9.2 Übersetzung von Prozeduren in Assembler Notwendig für Verwaltung: Kellerpegel (engl. stack pointer) $sp muss vom Assemblerprogrammierer manuell verwaltet werden Anpassung des Kellerpegels in 1-Wort-Schritten für Speicherung oder Zurückspeicherung eines Registerwerts Fachbereich Informatik Prof. Dr. Frederik Armknecht 60

60 Einfaches Beispiel für Prozedur C-Programmtext MIPS-Assembler first_proc: int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 1: Registerinhalte auf den Stack retten Keller (stack) hohe Adresse Phase 2: Berechnungen durchführen Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern $sp (vor Phase 1) Phase 5: Rücksprung niedrige Adresse Fachbereich Informatik Prof. Dr. Frederik Armknecht 61

61 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; } f = (g + h) (i + j); return f; [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: Berechnungen durchführen Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern Phase 1: Registerinhalte auf den Stack retten sub ist ein Pseudobefehl, der mit Registern bzw. kleinen Konstanten arbeiten kann (siehe MIPS-R2000 Befehlssatz). $sp (vor Phase 1) Keller (stack) hohe Adresse Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 62 niedrige Adresse

62 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; } f = (g + h) (i + j); return f; [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: Berechnungen durchführen Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern Phase 1: Registerinhalte auf den Stack retten $sp (vor Phase 1) $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 63 niedrige Adresse

63 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; } f = (g + h) (i + j); return f; [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: Berechnungen durchführen Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern Phase 1: Registerinhalte auf den Stack retten $sp (vor Phase 1) $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 64 niedrige Adresse

64 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 1: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: Berechnungen durchführen Keller (stack) hohe Adresse Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern $sp (nach Phase 1) $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 65 niedrige Adresse

65 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 1: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 Phase 3: Resultatwert speichern Phase 4: Register zurückspeichern Phase 2: Berechnungen durchführen $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 66 niedrige Adresse

66 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 3: Resultatwert speichern Phase 1: Phase 2: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 Phase 4: Register zurückspeichern $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 67 niedrige Adresse

67 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 3: Resultatwert speichern Phase 1: Phase 2: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 [move $v0, $s0] Phase 4: Register zurückspeichern $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 68 niedrige Adresse

68 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 4: Register zurückspeichern Phase 1: Phase 2: Phase 3: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 [move $v0, $s0] $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 69 niedrige Adresse

69 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 4: Register zurückspeichern Phase 1: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 Phase 3: [move $v0, $s0] lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) [add $sp, $sp, 12] Phase 5: Rücksprung Fachbereich Informatik Prof. Dr. Frederik Armknecht 70 $sp (nach Phase 4) $sp (nach Phase 1) Keller (stack) hohe Adresse $t1 $t0 $s0 niedrige Adresse

70 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 5: Rücksprung Phase 1: Phase 2: Phase 3: Phase 4: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 [move $v0, $s0] lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) [add $sp, $sp, 12] Fachbereich Informatik Prof. Dr. Frederik Armknecht 71 $sp (nach Phase 4) Keller (stack) hohe Adresse niedrige Adresse

71 Einfaches Beispiel für Prozedur int first_proc (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } Phase 5: Rücksprung Phase 1: [sub $sp, $sp, 12] sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Phase 2: add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 Phase 3: [move $v0, $s0] Phase 4: lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) [add $sp, $sp, 12] jr $ra Fachbereich Informatik Prof. Dr. Frederik Armknecht 72 $sp (nach Phase 4) Keller (stack) hohe Adresse niedrige Adresse

72 Einfaches Beispiel für Prozedur Anmerkungen zum Beispiel: Annahme war: die Werte der verwendeten Register $t0, $t1, $s0 werden gesichert und müssen nach Beendigung der Prozedur zurück gespeichert werden. Zur Vermeidung von Speicheroperationen für Register, deren Werte nicht verwendet: zwei Klassen von Registern: $t0 - $t9: 10 Register für temporäre Variablen, deren Inhalte von der aufgerufenen Prozedur verändert werden können und nicht gesichert werden müssen. $s0 - $s7: 8 Register für langlebige Variablen, die von aufgerufenen Prozeduren nicht verändert werden dürfen. D.h. Inhalte müssen nach Aufruf und Abarbeitung einer Prozedur gesichert bzw. wiederhergestellt sein. Fachbereich Informatik Prof. Dr. Frederik Armknecht 73

73 2.9.3 Geschachtelte Prozeduren (nested) Beispiel zur Motivation der Problematik Hauptprogramm (main) ruft Prozedur A auf: Effekt: main belegt Argumentregister $a0 und Rücksprungregister $ra Prozedur A ruft Prozedur B auf: Effekt: A belegt Argumentregister $a0 und Rücksprungadresse $ra. Probleme: Konflikte in $a0 und Register $ra! Rücksprungadresse in das Hauptprogramm main geht verloren! Fachbereich Informatik Prof. Dr. Frederik Armknecht 74

74 2.9.3 Geschachtelte Prozeduren (nested) Schwierigkeiten: Alle Prozeduren verwenden dieselben Register für ihre Argumente ($a0 - $a3). Alle Prozeduren verwenden ein einziges (dasselbe) Rücksprungregister ($ra). Alle Prozeduren verwenden die Register ($s0 - $s7). Eine mögliche Lösung: Die aufrufende Prozedur (caller) sichert die jeweils benötigten der Argumentregister ($a0 - $a3) und temporären Register ($t0 - $t9) auf den Stack ( push -Operation). Fachbereich Informatik Prof. Dr. Frederik Armknecht 75

75 2.9.3 Geschachtelte Prozeduren (nested) Eine mögliche Lösung: (Forts.) Die aufgerufene Prozedur (callee) sichert auf dem Stack die Rücksprungregister ($ra) und die von ihr zu verwendenden langlebigen Register ($s0 - $s7) Der Kellerpegel (stack pointer) $sp wird angepasst gemäß der Anzahl der gespeicherten Register Beim Rücksprung aus der aufgerufenen Prozedur werden alle gesicherten Register zurück geladen ( pop -Operation) und der Kellerpegel zurück gesetzt. Bem.: Rekursive Prozeduraufrufe sind ein Spezialfall von geschachtelten Aufrufen, analoge Behandlung Fachbereich Informatik Prof. Dr. Frederik Armknecht 76

76 2.9.3 Geschachtelte Prozeduren (nested) Beispiel: Rekursiver Prozeduraufruf C-Programmtext: Berechnung der Fakultät n! int fact (int n) { if (n < 1) return (1); else return (n * fact(n-1)); } Zwischenüberlegung: Umformung in C int fact (int n) { int t0; if (n < 1) t0 = 1; else t0 = 0; if (t0 == 0) goto L1; return (1); L1: return (n * fact(n-1)); } Fachbereich Informatik Prof. Dr. Frederik Armknecht 77

77 Beispiel (Forts.): MIPS-Assembler (mit Verwendung direkter Addition/Subtration von Konstanten) fact: [sub $sp,$sp,8] # Anpassung des Kellerpegels um 2 Worte sw $ra, 4($sp) # Speicherung der Rücksprungadresse sw $a0, 0($sp) # Speicherung des Arguments n [slt $t0,$a0,1] # Test auf n < 1 beq $t0,$zero,l1 # falls n >=1, gehe zu L1 [add $v0,$zero,1] # Ergebnis ist 1 # Zurückspeichern von $a0, $ra unnötig bei n<1 [add $sp,$sp,8] # Entfernen ( pop ) zweier Worte vom Stapel jr $ra # Rücksprung hinter jal L1: [sub $a0,$a0,1] # falls n>=1: ersetze Argument n durch n-1 jal fact # Aufruf von fact mit (n-1) lw $a0, 0($sp) # Rückkehr von jal; Rückspeicherung Argument n lw $ra, 4($sp) # Rückspeicherung der Rücksprungadresse [add $sp,$sp,8] # Entfernen zweier Worte vom Kellerpegel mul $v0,$a0,$v0 # Ergebnis ist n * fact(n-1); Multiplikation s.kap.4 jr $ra # Rücksprung zum aufrufenden Programm Fachbereich Informatik Prof. Dr. Frederik Armknecht 78

78 Langlebige und temporäre Registerwerte Inhalte der Register nach Aufruf einer Prozedur: langlebig (bzw. zu erhalten) temporär (bzw. nicht zu erhalten) langlebige Register: $s0 - $s7 temporäre Register: $t0 - $t9 Kellerpegelregister: $sp Argumentregister: $a0 - $a3 Rücksprungadressregister: $ra Ergebniswertregister: $v0 Keller (stack) oberhalb des Kellerpegels (stack pointer) Keller (stack) unterhalb des Kellerpegels (stack pointer) Die Inhalte von Rahmenzeigerregister (frame pointer register) $fp und Globalem-Zeiger-Register (global pointer register) $gp sind gegebenenfalls auch zu erhalten. Fachbereich Informatik Prof. Dr. Frederik Armknecht 79

79 2.9.4 Speicherverwaltung: Prozedurrahmen Speicherung aller lokalen Variablen und Datenstrukturen einer Prozedur, die nicht in die verfügbaren Register passen, auf dem Stack Das Kellersegment (stack segment) mit den Daten eines Prozeduraufrufs heißt Prozedurrahmen (procedure frame, activation record). Rahmenzeiger (frame pointer) $fp zeigt auf Anfang des Prozedurrahmens. Über $fp sind lokale Prozedurdaten unabhängig vom aktuellen Kellerpegel ($sp) adressierbar Fachbereich Informatik Prof. Dr. Frederik Armknecht 80

80 Verwaltung der Prozedurrahmen vor Prozeduraufruf während Prozedurausführung nach Prozeduraufruf Rahmenzeiger $fp zeigt auf erstes Wort des Rahmens; er verändert sich während Prozedurausführung nicht. Kellerpegel $sp zeigt auf Anfang des Stacks; er kann sich während Prozedurausführung verändern. Fachbereich Informatik Prof. Dr. Frederik Armknecht 81

81 Aufgabenverteilung Frage: Welche Informationen schreibt Aufrufender (caller) welche Aufgerufener (callee) in den Rahmen? Antwort: allgemeine Konvention Fachbereich Informatik Prof. Dr. Frederik Armknecht 82

82 Prolog des Aufrufers Prolog des Aufrufers (caller) (vor Prozeduraufruf) Sichern aller Register, die der Aufrufer auch nach dem Aufruf benötigt. MARS: Register: $a0 - $a3, $t0 - $t9, $v0,$v1 Übergabe der Eingabeparameter beim MARS: Die ersten 4 Argumente in den Registern $a0,..., $a3 Die restlichen in umgekehrter Reihenfolge auf den Keller Bei Call-by-Value -Parametern: Laden des Wertes Bei Call-by-Reference -Parametern: Laden der Adresse (mit la-befehl) Fachbereich Informatik Prof. Dr. Frederik Armknecht 83

83 Beispiel für Prolog-Schema für Caller main: <...> # Berechnungen im Hauptprogramm # --- Prolog des Aufrufers: --- [sub $sp,$sp,8] # Platz auf Stack reservieren (2 Worte f. 2 Regist.) sw $t0, 4($sp) # Speicherung des noch benötigten Inhalts von sw $t1, 0($sp) # $t-registern (hier: $t0, $t1) vom Aufrufer selbst [move $a0, $t5] # Argumente übergeben (hier nur eines) Aufruf der Prozedur mit jal-befehl, d.h. Start der Prozedur durch Sprung zu deren erstem Befehl. Wichtig: jal sichert automatisch die Rücksprungadresse des Aufrufers im Register $ra. Fachbereich Informatik Prof. Dr. Frederik Armknecht 84

84 Epilog des Aufrufers Epilog des Aufrufers (caller) (nach Rückkehr vom Prozeduraufruf) Wiederherstellen der gesicherten Register Wiederherstellen des ursprünglichen Kellerpegels (stack pointer) (durch Pop der Einträge): $sp := $sp + ( Argumente + gesicherte Register ) 4 Fachbereich Informatik Prof. Dr. Frederik Armknecht 85

85 Beispiel für Prolog/Epilog-Schema main: <...> # irgendwelche Berechnungen im Hauptprogramm # --- Prolog des Aufrufers: --- [sub $sp,$sp,8] # Platz auf Stack reservieren (2 Worte f. 2 Regist.) sw $t0, 4($sp) # Speicherung des noch benötigten Inhalts von sw $t1, 0($sp) # $t-registern (hier: $t0, $t1) vom Aufrufer selbst [move $a0, $t5] # Argumente übergeben (hier nur 1) jal proc # --- Aufruf der Prozedur --- # --- Epilog des Aufrufers: --- lw $t1, 0($sp) # Registerinhalte wiederherstellen lw $t0, 4($sp) # [add $sp,$sp,8] # Kellerpegel zurücksetzen # Aufruf der Prozedur ist beendet Fachbereich Informatik Prof. Dr. Frederik Armknecht 86

86 Prolog des Aufgerufenen Prolog des Aufgerufenen (callee) (vor Ausführung der Prozeduranweisungen) Speicherplatz reservieren: Versetzen des Kellerpegels: $sp := $sp ( zu sichernde Register + lokale Variablen ) 4 Sichern aller Register, die von der Prozedur verändert werden; MARS: zuerst $fp sichern, restliche Register in beliebiger Reihenfolge, $ra sichern, falls weiterer Prozeduraufruf erfolgt! Rahmenzeiger $fp setzen: Element nach Eingabepar. Fachbereich Informatik Prof. Dr. Frederik Armknecht 87

87 Beispiel für Prolog-Schema (Callee) proc: # Einsprungadresse der Prozedur # --- Prolog des Aufgerufenen: --- [sub $sp,$sp,20] # Platz auf Stack reservieren (hier: 5 Worte) # hier: 5 Register sichern sw $fp, 16($sp)# alten Rahmenzeiger sichern sw $ra, 12($sp)# Rücksprungadresse sichern sw $s0, 8($sp)# die benötigten $s-register müssen von der sw $s1, 4($sp)# aufgerufenen Prozedur gesichert werden sw $s2, 0($sp)# [add $fp, $sp,20]# Rahmenzeiger erstellen <...> # Prozedurkörper mit eigentlichen Befehlen # --- Epilog des Aufgerufenen: --- Fachbereich Informatik Prof. Dr. Frederik Armknecht 88

88 Epilog des Aufgerufenen Epilog des Aufgerufenen (callee) (nach Ausführung des Prozedurkörpers) Rückgabe des Funktionswertes MARS: in den Registern $v0 bzw. $v1 Wiederherstellen der gesicherten Registerinhalte z.b. Rahmenzeiger $fp, Rücksprungadresse $ra Pop der für die Prozedur angelegten Werte durch Zurücksetzen des Kellerpegels (stack pointer) $sp $sp := $sp + ( gesicherte Register + lokale Variablen ) 4 Rücksprung zum Aufrufer: im MARS durch: jr $ra Fachbereich Informatik Prof. Dr. Frederik Armknecht 89

89 Beispiel für Prolog/Epilog-Schema (Forts.) proc: # Einsprungadresse der Prozedur # --- Prolog des Aufgerufenen: --- [sub $sp,$sp, 20] # Platz auf Stack reservieren (hier: 5 Worte) # hier: 5 Register sichern sw $fp, 16($sp) # alten Rahmenzeiger sichern sw $ra, 12($sp) # Rücksprungadresse sichern sw $s0, 8($sp) # die benötigten $s-register müssen von der sw $s1, 4($sp) # aufgerufenen Prozedur gesichert werden sw $s2, 0($sp) # [add $fp, $sp,20] # Rahmenzeiger erstellen <...> # Prozedurkörper mit eigentlichen Befehlen # --- Epilog des Aufgerufenen: --- lw $s2, 0($sp) # $s-registerinhalte wiederherstellen lw $s1, 4($sp) # lw $s0, 8($sp) # lw $ra, 12($sp) # Rücksprungadresse wiederherstellen lw $fp, 16($sp) # Rahmenzeiger wiederherstellen [add $sp, $sp,20] # Kellerpegel zurücksetzen (pop) jr $ra # Rücksprung zum Aufrufenden Fachbereich Informatik Prof. Dr. Frederik Armknecht 90

90 Pseudobefehle In den bisherigen Beispielen wurden unter anderem Pseuobefehle verwendet. Diese waren durch Klammern ( [ ] ) markiert. Pseudobefehle sind Befehle, die es nicht im Maschinenbefehlssatz gibt. Einige Assembler unterstützen bestimmte Pseudobefehle, um die Programmierung zu erleichtern. Beispiel: move $t0, $t1 (Kopiere Inhalt eines Registers ($t1) in ein anderes ($t0)) Einen solchen Befehl gibt es nicht! Mögliche Realisierung: add $t0, $t1, $zero (Addiere Null auf $t1 und schreibe das Ergebnis in $t0) Weiteres Beispiel: Arithmetik mit Konstanten (siehe folgende Folien) Fachbereich Informatik Prof. Dr. Frederik Armknecht 91

91 2.10 Adressierung MIPS-Befehlsformat R : Operanden sind immer Register Beispiele: add und sub Schwächen der bisherigen Instruktionen: Die Verwendung von Konstanten ist unhandlich: über ein spezielles Register ($zero) oder Ablage der Konstante im Speicher an bekannter Stelle, bzw. erst Laden in ein Register Fachbereich Informatik Prof. Dr. Frederik Armknecht 92

92 2.10 Adressierung Konstanten (z.b. für Inkrement/Dekrement-Operationen bei Datenzugriffen in Schleifen) treten häufig auf, z.b. C Compiler gcc: > 52% aller arithmetischen Befehle nutzen Konstanten Effizienter Zugriff speziell auf kleine Konstanten ist wünschenswert! Fachbereich Informatik Prof. Dr. Frederik Armknecht 93

93 Konstanten als unmittelbare Operanden Lösung: I- Befehlsformat (immediate): Konstanten als unmittelbare Operanden op rs rt immediate 6 Bit 5 Bit 5 Bit 16 Bit Beispiel: addi $sp, $sp, 4 # $sp = $sp + 4 Dezimaldarstellung Binärdarstellung Fachbereich Informatik Prof. Dr. Frederik Armknecht 94

94 Weiteres Beispiel MIPS: slt $t0, $s1, $s2 # falls $s1 < $s2: $t0=1, sonst $t0=0 unmittelbare Adressierung in MIPS: slti $t0, $s1, 10 # falls $s1 < 10: $t0=1, sonst $t0=0 Dezimaldarstellung Binärdarstellung Vorteil der direkten Adressierung: Die Verwendung häufig vorkommender, kleiner Konstanten wird effizient (schnell) ausgeführt! Frage: Was tun, wenn Konstante größer als = ist, und mehr als 16 Bit zur Darstellung benötigt? Fachbereich Informatik Prof. Dr. Frederik Armknecht 95

95 Behandlung großer Konstanten maximal 32 Bits große Konstanten (d.h = 4, ) Der Befehl lui (load upper half word immediate) lädt angegebene Konstante in die höherwertigen 16 Bits des Zielregisters. Beispiel: lui $t0, 255 Binärdarstellung Inhalt von $t Setzen der niederwertigen 16 Bits von $t0 z.b. mit addi $t0, $t0, 2304 Inhalt von $t Laden einer Zahl mit lui in höherwertige 16 Bits entspricht Multiplikation mit 2 16! Fachbereich Informatik Prof. Dr. Frederik Armknecht 96

96 Adressierung von Sprungzielen Einfachste Sprungzieladressierung in MIPS im J-Format: j # go to Position (eigentlich: 2500) 6 Bit 26 Bit (für Sprungadresse) Bedingte Verzweigung mit bne oder beq benötigt neben der Sprungadresse zwei Operanden: Beispiel: bne $s0,$s1,exit # go to Exit, if $s0!= $s1 Dezimaldarstellung Dezimaldarstellung Exit 6 Bit 5 Bit 5 Bit 16 Bit (für Sprungadresse) Problem: Wie kann man größere Adressen als realisieren? Beobachtung: Verzweigungen in Schleifen und Fallunterscheidungen haben Sprungadressen in der Nähe der aktuellen Instruktion Idee: Verwende relative Adressierung zum Instruktionsadress-Register PC Fachbereich Informatik Prof. Dr. Frederik Armknecht 97

97 Beispiel: Erneut: While-Schleife while (save[i] == k) i = i + j; MIPS: Loop: add $t1, $s3, $s3 # $t1=2 i add $t1, $t1, $t1 # $t1=4 i add $t1, $t1, $s6 lw $t0, 0($t1) bne $t0, $s5, Exit add $s3, $s3, $s4 # i = i + j j Loop Exit: Darstellung in Maschinencode (symbolisch): # $t1=adresse[save(i)] # $t0=save[i] # falls save[i]!= k, go to Exit # go to Loop Achtung: PC wird jeweils vor eigentlicher Befehlsausführung um 4 erhöht Fachbereich Informatik Prof. Dr. Frederik Armknecht PC= PC+8 (Byte) (oder PC+2 (words))

98 Verzweigungen mit Zielen, die weiter entfernt sind Verzweigungsbefehle können Verzweigungen um ± Speicherworte realisieren. Für weit entfernte Verzweigungen wird vom Assembler eine indirekte Verzweigungsmethode implementiert: invertierter Verzweigungsbefehl unbedingter Sprung zum Sprungziel (26 statt 16 Bit Adresse) Beispiel: beq $s0, $s1, L1 wird ersetzt durch L2: bne $s0, $s1, L2 # j L1 # unbedingter Sprung, weite Entfernung Fachbereich Informatik Prof. Dr. Frederik Armknecht 99

99 Zusammenfassung der Adressierungsmodi 1. Unmittelbare Adressierung: Operand ist Konstante im Befehl selbst. 2. Registeradressierung: Operand ist Register 3. Basisadressierung: Operandenadresse ist Summe von Registerinhalt und Konstante im Befehl Fachbereich Informatik Prof. Dr. Frederik Armknecht 100

100 Zusammenfassung der Adressierungsmodi 4. PC-relative Adressierung: Operandenadresse ist Summe von PC und Konstante im Befehl 5. Pseudodirekte Adressierung: Sprungadresse setzt sich aus 26 Bits im Befehl und (!) den oberen 4 Bits im PC zusammen Fachbereich Informatik Prof. Dr. Frederik Armknecht 101

101 Zusammenfassung: MIPS-Operanden einfache Befehle mit je 32 Bits sehr strukturiert, kein überflüssiges Gepäck nur drei Befehlsformate Aufgabe des Compilers ist es, Leistung zu erbringen: Als Programmierer dem Compiler wo immer möglich helfen! Fachbereich Informatik Prof. Dr. Frederik Armknecht 102

102 Bisherige MIPS-Instruktionen Fachbereich Informatik Prof. Dr. Frederik Armknecht 103

103 Design Alternative: CISC Bereitstellung leistungsfähigerer Operationen mit Ziel der Reduktion der auszuführenden Befehle Gefahr ist eine langsamere Taktzeit und/oder eine höhere, durchschnittliche Anzahl von Takten per Instruktion RISC (reduced instruction set computer) versus CISC (complex instruction set computer): fast alle neuen Instruktionssätze seit 1982 waren RISC z.b. MIPS, Sun SPARC, Hewlett-Packard PA-RISC, IBM/Motorola PowerPC, DEC Alpha Fachbereich Informatik Prof. Dr. Frederik Armknecht 104

104 2.11 Fazit: Vom C-Programm zur Ausführung C-Programm Compiler Assemblerprogramm Objektcode: Maschinensprachmodul Executable: Maschinenprogramm Speicher Fachbereich Informatik Prof. Dr. Frederik Armknecht 105 Assembler Binder (Linker) Lader (Loader) Objektcode: Bibliotheksroutinen

105 2.11 Fazit: Assemblerprogrammierung über Adressierung: Zugriff auf beliebige Objekte im Speicher: flexibel, hoch performant Aber: kein Schutz durch Typisierung, z.b. Integer- Wert kann beliebig als Adresse interpretiert werden Assemblerprogramme sind maschinenabhängig, d.h. nicht portierbar Assemblersprache: viel einfacher als mit Binärzahlen umzugehen niedriges Niveau der Konzepte, darum Programmentwicklung schwierig (bzw. herausfordernd!) Fachbereich Informatik Prof. Dr. Frederik Armknecht 106

106 2.11 Fazit: Assemblerprogrammierung Programmtext in Assembler wird schnell sehr lang und unübersichtlich und damit fehleranfällig nur wenige Konzepte für Kontrollstrukturen, Programmsteuerungsfluss: schwer wartbarbar kein Information Hiding : z.b. bei geschachtelten Prozeduren über Rahmenzeiger-Kette beliebiger Zugriff auf Daten der vorherigen Prozeduraufrufe! Einsatzbereiche für Assemblerprogrammierung: Bereiche die sehr effizienten Code benötigen, wie Eingebettete Systeme, Controller, elektronische Steuerungen: Auto, Flugzeug, Fachbereich Informatik Prof. Dr. Frederik Armknecht 107

107 2.11 Fazit: Eingebettete Systeme: Die Spitze des Eisbergs In Vorlesung betrachtet: Hochleistungsprozessoren für allgemeine Computeranwendungen. Aber: Die meisten Anwendungen der digitalen Datenverarbeitung findet man in Geräte des täglichen Lebens (embedded) Markt für eingebettete (Computer-)Systeme wächst sehr stark Deutschland hat eine führende Position bei der Entwicklung eingebetteter Systeme! Fachbereich Informatik Prof. Dr. Frederik Armknecht 108

108 2.11 Fazit: Prozessorklassen General Purpose Prozessoren Hohe Leistung Pentiums, Alphas, SPARC, nützlich für allgemeine Software komplexe Betriebssysteme Unix, Win XP Workstations, PCs Eingebettete Prozessoren und Prozessorkerne ARM, 486SX, Hitachi SH7000, nur ein Programm einfache, oft Realzeit-Betriebssysteme Mobiltelefone, Consumerelektronik Microcontroller extrem Kosten sensitiv geringe Wortbreite 8-bit üblich bei weitem die höchsten Stückzahlen Automobil, Fahrstühle, Rolläden, Klimaanlage, Toaster,.. Zunehmende Kosten Zunehmende Stückzahl Fachbereich Informatik Prof. Dr. Frederik Armknecht 109

109 2.11 Fazit: Der Prozessor-Design-Raum Leistung Anwendungsspezifische Architekturen für hohe Leistung Eingebettete Prozessoren Mikroprozessoren Leistung ist alles & Software regiert Microcontroller Kosten sind alles! Fachbereich Informatik Prof. Dr. Frederik Armknecht 110 Kosten