Einführung in die Systemprogrammierung

Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 15. April 2014

Veranstaltungsübersicht Kontakt: Prof. Dr. Christoph Reichenbach (reichenbach@cs.uni-frankfurt.de) Homepage: http://sepl.cs.uni-frankfurt.de/2014-ss/ b-sysp/index.de.html Veranstaltung besteht aus: Vorlesung (Di) Übungen (Mi) Klausur am 24.07, 10:00 12:00, Hörsaal V

Kompetenzen Jede Vorlesung und Übung behandelt bestimmte Kompetenzen Klausur: 80% reines Kompetenzwissen 20% Synthese (aus zwei oder mehr Kompetenzen) Bonuspunkte sammeln: 4 Testate

Literatur Rechnerorganisation und Rechnerentwurf, von David Patterson und John LeRoy Hennessy The C Programming Language, von Brian Kernighan und Dennis Ritchie (auch auf Deutsch in der Bibliothek erhältlich)

Warum Systemprogrammierung? Betriebssysteme bauen/erweitern Programmiersprachen bauen/erweitern Hohe Performanz Eingebettete Systeme programmieren Beurteilung des Nutzens von Hardware-Neuerungen Beurteilung der technischen Machbarkeit von Hochleistungsproblemen Systemanalyse

Ziele dieser Veranstaltung Fähigkeit, direkt mit Prozessor zu sprechen Grundlagen der Performanzmessung Verständnis der Systemabläufe bei Ausführung eines Programmes Grundlagen der C-Programmierung Grundlagen moderner Laufzeitsysteme Grundlagenverständnis der Quellen von Ineffizienzen bei der Programmausführung Grundlagenverständnis der Quellen von Sicherheitsproblemen in Systemprogrammen Beispiel: Heartbleed

Nicht-Ziele dieser Veranstaltung Wir bauen kein Betriebssystem Wir bauen keine Programmiersprache Wir behandeln keine elektronischen Details integrierter Schaltkreise Wir modellieren Systeme nicht vollständig formal

Systemprogrammierung im Kontext Programm Bibliotheken Laufzeitsystem Systemprogramm Systembibliotheken Betriebssystem Rechnerarchitektur Integrierte Schaltkreise

Systemprogrammierung im Kontext Programm Bibliotheken Laufzeitsystem Systemprogramm Systembibliotheken Betriebssystem Rechnerarchitektur Java, Python, Haskell, Scala, SML, PHP, C#, awk, Scheme, ADA, OCaml,... Integrierte Schaltkreise

Systemprogrammierung im Kontext Programm Bibliotheken Laufzeitsystem Systemprogramm Systembibliotheken Betriebssystem Rechnerarchitektur Integrierte Schaltkreise

Geplante Struktur Grundlagen der Rechnerarchitektur Assembler-Programmierung Performanz Grundlagen der Programmierung in C Grundlagen der Laufzeitsysteme moderner Programmiersprachen

Administrativa Einfu hrung Blinkanlage Taschenrechner Grundkonzepte der Rechnerarchitektur Speicher

Nexus 7-Mainboard SDRAM-Speicher (Hynix) Prozessor + GPU (Nvidia) Spannungsregulator (Max) WLan-Adapter (AzureWave) NFC-Chip (NXP) GPS-Empfänger (BroadCom) Gyroskop, Beschleunigungssensor (Invensense) Nexus 7 TM (Google, Asus) Mainboard. Bild von ifixit.com.

Funktionale Komponenten des Nexus 7-Mainboards SDRAM-Speicher Prozessor Grafikprozessor (GPU) GPU-Recheneinheit GPU-Grafikausgabe WLan-Adapter WLan-Sender WLan-Empfänger NFC-Chip NFC-Sender NFC-Empfänger GPS-Empfänger Gyroskop Beschleunigungssensor

Grundkonzepte der Rechnerarchitektur Speicher SDRAM-Speicher Eingabegeräte WLan-Empfänger NFC-Empfänger GPS-Empfänger Gyroskop Beschleunigungssensor Prozessorsystem Zentralprozessor Grafikprozessor Ausgabegeräte GPU-Grafikausgabe WLan-Sender NFC-Sender

Grundkonzepte der Rechnerarchitektur Speicher Eingabegeräte Prozessor- System Ausgabegeräte Rest der Welt

Beispiel: Programmierbare Blinkanlage Steuerung für Lampe Speicherzustand: 0: aus 1: an Speicher Prozessor

Beispiel: Programmierbare Blinkanlage Steuerung für Lampe Speicherzustand: 0: aus 1: an Kodierung eines Programmes: an aus an Speicher Prozessor

Beispiel: Programmierbare Blinkanlage Steuerung für Lampe Speicherzustand: 0: aus 1: an Kodierung eines Programmes: an 1 aus 0 an 1 Speicher Prozessor

Programmierbare Blinkanlage Speicher Wert: 1 0 1... Adresse: 0 1 2...

Programmierbare Blinkanlage Speicher Wert: 1 0 1... Adresse: 0 1 2... Prozessor Programmzähler = 0

Frei programmierbare Rechner Programmbefehle im Programmspeicher Programmzähler 1 zeigt auf nächsten Befehl Programmzähler schreitet automatisch vorwärts 1 Auch Instruktionszeiger ; gängige Abkürzungen: PC, IP

Frei programmierbare Rechner Programmbefehle im Programmspeicher Programmzähler 1 zeigt auf nächsten Befehl Programmzähler schreitet automatisch vorwärts Programmbefehle können aus mehreren Bits bestehen 1 Auch Instruktionszeiger ; gängige Abkürzungen: PC, IP

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x x einlesen

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x x einlesen Ausrechnen

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x x einlesen Ausrechnen Ergebnis ausgeben

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x x einlesen Ausrechnen Ergebnis ausgeben Problem: Wir müssen Rechenergebnisse zwischenspeichern

Beispiel: Programmierbarer Taschenrechner Taschenrechner speichert Berechnungen als Programme z.b.: (x + 2)x x einlesen Ausrechnen Ergebnis ausgeben Problem: Wir müssen Rechenergebnisse zwischenspeichern Register: Datenspeicher im Prozessor

Prozessor des programmierbaren Taschenrechners Prozessor Programmzähler = 0 $0 = 0 $1 = 0 $2 = 0 $3 = 0 Register $0, $1, $2, $3 speichern Zwischenergebnisse Maschinenbefehle lesen von und schreiben in Register Die Maschinenbefehle drücken die einprogrammierte Berechnung aus

Befehle des Taschenrechners Dateneingabe Datenausgabe Addieren Multiplizieren Konstante

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe Addieren Multiplizieren Konstante $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2)

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe ausgabe $z $z Addieren Multiplizieren Konstante $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2)

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe ausgabe $z $z Addieren add $z, $x, $y $z := $x + $y Multiplizieren Konstante $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2)

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe ausgabe $z $z Addieren add $z, $x, $y $z := $x + $y Multiplizieren mul $z, $x, $y $z := $x $y Konstante $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2)

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe ausgabe $z $z Addieren add $z, $x, $y $z := $x + $y Multiplizieren mul $z, $x, $y $z := $x $y Konstante li $z, v $z := v $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2)

Befehle des Taschenrechners Dateneingabe eingabe $z $z Datenausgabe ausgabe $z $z Addieren add $z, $x, $y $z := $x + $y Multiplizieren mul $z, $x, $y $z := $x $y Konstante li $z, v $z := v $x, $y, $z sind Variablen für Register. Beispiel eines echten Befehls: add $1, $1, $2 ($1 := $1 + $2) Diese Befehle müssen in Bitmuster kodiert werden, damit der Prozessor sie lesen kann.

Befehle des Taschenrechners: Bitmuster Wir folgen den Bitmustern des MIPS-Befehlssatzes Jeder MIPS-Befehl besteht aus 32 Bits

Befehle des Taschenrechners: Bitmuster Wir folgen den Bitmustern des MIPS-Befehlssatzes Jeder MIPS-Befehl besteht aus 32 Bits Beispiel: add $z, $x, $y 000000 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 100000

Befehle des Taschenrechners: Bitmuster Wir folgen den Bitmustern des MIPS-Befehlssatzes Jeder MIPS-Befehl besteht aus 32 Bits Beispiel: add $z, $x, $y 000000 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 100000 Operationscode (Opcode) $x $y $z Funktionscode

Vollständige Kodierung des add-befehls add $z, $x, $y : 000000 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 100000 Binärkodierung von Register $x (analog für $y, $z): Register x 1 x 0 $0 0 0 $1 0 1 $2 1 0 $3 1 1

Vollständige Kodierung des add-befehls add $z, $x, $y : 000000 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 100000 add $1, $2, $3 : 000000 00010 00011 00001 00000 100000 Binärkodierung von Register $x (analog für $y, $z): Register x 1 x 0 $0 0 0 $1 0 1 $2 1 0 $3 1 1

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0 Opcode $z Direktoperand v

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0 Opcode $z Direktoperand v li $2, 1000 : 001101 00010 00000 01...?

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0 Opcode $z Direktoperand v li $2, 1000 : 001101 00010 00000 01...? Kodierung von Zahlen im Binärsystem 1000 10 = 1111101000 2 Auffüllen mit 0

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0 Opcode $z Direktoperand v li $2, 1000 : 001101 00010 00000 0000001111101000 Kodierung von Zahlen im Binärsystem 1000 10 = 1111101000 2 Auffüllen mit 0

Vollständige Kodierung des li-befehls li $z, v : 001101 000z 1 z 0 00000 v 15, v 14,..., v 1, v 0 Opcode $z Direktoperand v li $2, 1000 : 001101 00010 00000 0000001111101000 Kodierung von Zahlen im Binärsystem 1000 10 = 1111101000 2 Auffüllen mit 0 Bei 16 Bits also maximal 2 16 1 = 65535

Befehle des Taschenrechners: Zusammenfassung Assemblersprache: Menschenlesbar Maschinensprache: Maschinenlesbar Assemblersprache Maschinensprache-Bitmuster eingabe $z 111111 000z 1 z 0 00000 00000 00000 000000 ausgabe $z 111111 000z 1 z 0 00000 00000 00000 000001 add $z, $x, $y 000000 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 100000 mul $z, $x, $y 011100 000x 1 x 0 000y 1 y 0 000z 1 z 0 00000 000000 li $z, v 001101 000z 1 z 0 00000 v 15 v 14... v 1 v 0

Ein Programm in der Taschenrechnersprache Wir schreiben (x + 2)x in Assemblersprache: Maschinensprache eingabe $0 111111 00000 00000 00000 00000 000000

Ein Programm in der Taschenrechnersprache Wir schreiben (x + 2)x in Assemblersprache: Maschinensprache eingabe $0 111111 00000 00000 00000 00000 000000 li $1, 2 001101 00001 00000 0000000000000010

Ein Programm in der Taschenrechnersprache Wir schreiben (x + 2)x in Assemblersprache: Maschinensprache eingabe $0 111111 00000 00000 00000 00000 000000 li $1, 2 001101 00001 00000 0000000000000010 add $1, $1, $0 000000 00001 00000 00001 00000 100000

Ein Programm in der Taschenrechnersprache Wir schreiben (x + 2)x in Assemblersprache: Maschinensprache eingabe $0 111111 00000 00000 00000 00000 000000 li $1, 2 001101 00001 00000 0000000000000010 add $1, $1, $0 000000 00001 00000 00001 00000 100000 mul $1, $1, $0 011100 00001 00000 00001 00000 000000

Ein Programm in der Taschenrechnersprache Wir schreiben (x + 2)x in Assemblersprache: Maschinensprache eingabe $0 111111 00000 00000 00000 00000 000000 li $1, 2 001101 00001 00000 0000000000000010 add $1, $1, $0 000000 00001 00000 00001 00000 100000 mul $1, $1, $0 011100 00001 00000 00001 00000 000000 ausgabe $1 111111 00001 00000 00000 00000 000001

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 (eingabe $0) Eingabe 5 Prozessor Programmzähler = 0 $0 = 0 $1 = 0 $2 = 0 $3 = 012 Ausgabe 5

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 (eingabe $0) (li $1, 2) Eingabe 5 Prozessor Programmzähler = 4 $0 = 5 $1 = 0 $2 = 0 $3 = 012 Ausgabe 5

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 (li $1, 2) (add $1, $1, $0) Eingabe 5 Prozessor Programmzähler = 8 $0 = 5 $1 = 2 $2 = 0 $3 = 012 Ausgabe 5

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 (add $1, $1, $0) (mul $1, $1, $0) Eingabe 5 Prozessor Programmzähler = 12 $0 = 5 $1 = 7 $2 = 0 $3 = 012 Ausgabe 5

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 (mul $1, $1, $0) (ausgabe $1) Eingabe 5 Prozessor Programmzähler = 16 $0 = 5 $1 = 35 $2 = 0 $3 = 012 Ausgabe 5

Berechnung im Programmierbaren Taschenrechner Addr Maschinencode 0: 11111100000000000000000000000000 4: 00110100001000000000000000000010 8: 00000000001000000000100000100000 12: 01110000001000000000100000000000 16: 11111100001000000000000000000001 Eingabe 5 Prozessor Programmzähler = 20 $0 = 5 $1 = 35 $2 = 0 $3 = 012 Ausgabe 35

Zusammenfassung: Programmierbarer Taschenrechner Register sind (Zwischen)speicher für Berechnungen Prozessorbefehle kontrollieren die Schritte im Prozessor Prozessorbefehle können auf zwei Weisen ausgedrückt werden: Maschinenbefehle (Prozessor-lesbar, Bitfolgen) Assemblerbefehle (Menschen-lesbar) Prozessorbefehle liegen im Programmspeicher Der Programmzähler zeigt immer auf die Adresse des nächsten Befehls

Der Speicher Bisher nur als Programmspeicher genutzt Kann auch als Datenspeicher genutzt werden

Der Speicher Bisher nur als Programmspeicher genutzt Kann auch als Datenspeicher genutzt werden Harvard-Architektur Programmspeicher Von-Neumann-Architektur Programm- und Datenspeicher Prozessorsystem Prozessorsystem Datenspeicher

Der Speicher Bisher nur als Programmspeicher genutzt Kann auch als Datenspeicher genutzt werden Harvard-Architektur Programmspeicher Von-Neumann-Architektur Programm- und Datenspeicher Prozessorsystem Prozessorsystem Datenspeicher IBM Archives, obtained via Encyclopaedia Britannica c University of Manchester

Vorteile der Speicherarchitekturen Harvard-Architektur Sicherheit vor versehentlichen Programm-Modifikationen und Viren Kann sequentielle Zugriffe auf Programmspeicher beschleunigen Von-Neumann-Architektur Erlaubt selbstmodifizierende Programme Programme können andere Programme laden Speicher nicht Zweckgebunden

Daten im Datenspeicher Typische Elemente des Datenspeichers: Ganze Zahlen (Integer) Kommazahlen Objekte (von objektorientierten Sprachen) Algebraische Werte (von funktionalen Sprachen) Zeichenketten Adressen anderer Stellen im Datenspeicher Maschinensprache-Programme (insbesondere bei Von-Neumann-Architektur) Bytecode-Programme... All diese Daten werden in Bits kodiert.

Daten-Repräsentation Daten können fast beliebig komplex kodiert werden Einfache Kodierungen meist effizienter Meist als Bytes: 1 B = 1 Byte = 8 Bits Effiziente Darstellung mit Hexadezimalziffern (Basis 16): 10 9 10 11 12 13 14 15 16 2 1001 1010 1011 1100 1101 1110 1111 10000 16 9 A B C D E F 10

Daten-Repräsentation Daten können fast beliebig komplex kodiert werden Einfache Kodierungen meist effizienter Meist als Bytes: 1 B = 1 Byte = 8 Bits Effiziente Darstellung mit Hexadezimalziffern (Basis 16): 10 9 10 11 12 13 14 15 16 2 1001 1010 1011 1100 1101 1110 1111 10000 16 9 A B C D E F 10 Eine Hexadezimalziffer entspricht genau 4 Bits ( nibble )

Daten-Repräsentation Daten können fast beliebig komplex kodiert werden Einfache Kodierungen meist effizienter Meist als Bytes: 1 B = 1 Byte = 8 Bits Effiziente Darstellung mit Hexadezimalziffern (Basis 16): 10 9 10 11 12 13 14 15 16 2 1001 1010 1011 1100 1101 1110 1111 10000 16 9 A B C D E F 10 Eine Hexadezimalziffer entspricht genau 4 Bits ( nibble ) Mögliche verschiedene Werte in Byte: 2 8 = 256 10 = 100 16 = 0x100 Wir lassen die Basis weg, wenn aus Kontext ersichtlich

Daten-Repräsentation: Natürliche Zahlen Kleine natürliche Zahlen in ein Byte: 12 10 = 0C 42 10 = 2A

Daten-Repräsentation: Natürliche Zahlen Kleine natürliche Zahlen in ein Byte: 12 10 = 0C 42 10 = 2A Natürliche Zahlen jenseits 255: 1000 10 = 3E8

Daten-Repräsentation: Natürliche Zahlen Kleine natürliche Zahlen in ein Byte: 12 10 = 0C 42 10 = 2A Natürliche Zahlen jenseits 255: 1000 10 = 3E8 Werden in mehreren Bytes in Folge gespeichert

Daten-Repräsentation: Natürliche Zahlen Kleine natürliche Zahlen in ein Byte: 12 10 = 0C 42 10 = 2A Natürliche Zahlen jenseits 255: 1000 10 = 3E8 Werden in mehreren Bytes in Folge gespeichert Komplikationen in der Praxis: Bytereihenfolge Speicherausrichtung

Bytereihenfolge 1000 10 = 3E8 Zwei übliche Bytereihenfolgen: 03 E8 (big endian großendig : SPARC, m68k) E8 03 (little endian kleinendig : x86, Alpha)

Bytereihenfolge 1000 10 = 3E8 Zwei übliche Bytereihenfolgen: 03 E8 (big endian großendig : SPARC, m68k) E8 03 (little endian kleinendig : x86, Alpha) Die vom Prozessor bevorzugte Bytereihenfolge kann in einem Befehl gelesen bzw. geschrieben werden Die andere Bytereihenfolge braucht mehrere Befehle

Speicherzugriffe Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor

Speicherzugriffe Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor 300 Zur Beschleunigung: Lesen und Schreiben von mehreren Bytes gleichzeitig

Speicherzugriffe Speicherausrichtung Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor Zur Beschleunigung: Lesen und Schreiben von mehreren Bytes gleichzeitig

Speicherzugriffe Speicherausrichtung Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor 00 E8 Zur Beschleunigung: Lesen und Schreiben von mehreren Bytes gleichzeitig Zur Vereinfachung der Architektur: Multi-Byte-Operationen nur ausgerichtet möglich

Speicherzugriffe Speicherausrichtung Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor 00 E8 03 00 Zur Beschleunigung: Lesen und Schreiben von mehreren Bytes gleichzeitig Zur Vereinfachung der Architektur: Multi-Byte-Operationen nur ausgerichtet möglich

Speicherzugriffe Speicherausrichtung Adresse:... 400 401 402 403 404 405... Inhalt:... 2C 01 00 E8 03 00... Prozessor 1000 Zur Beschleunigung: Lesen und Schreiben von mehreren Bytes gleichzeitig Zur Vereinfachung der Architektur: Multi-Byte-Operationen nur ausgerichtet möglich

Speicherausrichtung Adressenausrichtung (alignment): Adresse a ist k-bit ausrerichtet gdw a mod (k/8) = 0 0xa000 ist 64-Bit (somit 32, 16-Bit) ausgerichtet 0xa001 ist nicht 16-Bit (oder 32, 64-Bit) ausgerichtet 0xa002 ist 16-Bit, aber nicht 32, 64-Bit ausgerichtet Moderne Prozessoren bevorzugen k-bit Zugriff auf k-bit ausgerichtete Daten

Speicherausrichtung Adressenausrichtung (alignment): Adresse a ist k-bit ausrerichtet gdw a mod (k/8) = 0 0xa000 ist 64-Bit (somit 32, 16-Bit) ausgerichtet 0xa001 ist nicht 16-Bit (oder 32, 64-Bit) ausgerichtet 0xa002 ist 16-Bit, aber nicht 32, 64-Bit ausgerichtet Moderne Prozessoren bevorzugen k-bit Zugriff auf k-bit ausgerichtete Daten Nicht-ausgerichteter Zugriff: Langsamer (x86), oder Programmfehler (Alpha, MIPS, SPARC, PowerPC; SIGBUS-Ausnahme in UNIX)

Beispiel: MIPS-Speicherzugriffbefehle Assemblerbefehl Ausrichtung Wirkung lbu $z, v($x) 8 liest 1 Byte lhu $z, v($x) 16 liest 2 Bytes (Halbwort) lw $z, v($x) 32 liest 4 Bytes (Wort) sb $z, v($x) 8 schreibt 1 Byte sh $z, v($x) 16 schreibt 2 Bytes (Halbwort) sw $z, v($x) 32 schreibt 4 Bytes (Wort) Die verwendete Speicheradresse ist v + $x: li $1, 0x2000 lbu $2, 0x1f($1) ;; liest von 0x201f

Daten-Repräsentation: Ganze Zahlen Wie repräsentieren wir ganze Zahlen (inklusive negativer Zahlen) im Speicher?

Daten-Repräsentation: Ganze Zahlen Wie repräsentieren wir ganze Zahlen (inklusive negativer Zahlen) im Speicher? Wie immer: Bitmuster!

Daten-Repräsentation: Ganze Zahlen Positive Zahlen: wie bisher Negative Zahlen: verschiedene Verfahren: Vorzeichen-Betrag Exzesscode Einerkomplement Zweierkomplement Negative Repräsentierungen verwenden logische Negation (neg bzw. ): b neg(b) 0 1 1 0

Daten-Repräsentation: Ganze Zahlen Positive Zahlen: wie bisher Negative Zahlen: verschiedene Verfahren: Vorzeichen-Betrag Exzesscode Einerkomplement Zweierkomplement Negative Repräsentierungen verwenden logische Negation (neg bzw. ): b neg(b) 0 1 1 0 Im Folgenden betrachten wir 8-Bit Zahlen. Die Konzepte funktionieren analog mit größeren n-bit Zahlen.

Vorzeichen-Betrag-Darstellung Beispiel Bitfolge 5 00000101 2-5 10000101 2 0 00000000 2-0 10000000 2 repr( 5) = 10000101 Betrag Vorzeichen

Vorzeichen-Betrag-Darstellung Beispiel Bitfolge 5 00000101 2-5 10000101 2 0 00000000 2-0 10000000 2 repr( 5) = 10000101 Betrag Vorzeichen Negation x: Oberstes Bit negieren

Vorzeichen-Betrag-Darstellung Beispiel Bitfolge 5 00000101 2-5 10000101 2 0 00000000 2-0 10000000 2 repr( 5) = 10000101 Betrag Vorzeichen Negation x: Oberstes Bit negieren Arithmetik: Benötigt Fallunterscheidung

Vorzeichen-Betrag-Darstellung Beispiel Bitfolge 5 00000101 2-5 10000101 2 0 00000000 2-0 10000000 2 repr( 5) = 10000101 Betrag Vorzeichen Negation x: Oberstes Bit negieren Arithmetik: Benötigt Fallunterscheidung Zwei Nullen: 00000000 2, 10000000 2 Zahlenraum: 2 n 1 1... 2 n 1 1 (symmetrisch)

Exzess-N-code-Darstellung Beispiel Bitfolge 5 10000101 2-5 01111011 2 0 10000000 2-0 10000000 2 repr( 5) = 128 + 5 = 123 = 01111011 2 Hier: Exzess-128-Code (N = 128 = 10000000 2 )

Exzess-N-code-Darstellung Beispiel Bitfolge 5 10000101 2-5 01111011 2 0 10000000 2-0 10000000 2 repr( 5) = 128 + 5 = 123 = 01111011 2 Hier: Exzess-128-Code (N = 128 = 10000000 2 ) Negation x: 2N x

Exzess-N-code-Darstellung Beispiel Bitfolge 5 10000101 2-5 01111011 2 0 10000000 2-0 10000000 2 repr( 5) = 128 + 5 = 123 = 01111011 2 Hier: Exzess-128-Code (N = 128 = 10000000 2 ) Negation x: 2N x Arithmetik: Benötigt Fallunterscheidung

Exzess-N-code-Darstellung Beispiel Bitfolge 5 10000101 2-5 01111011 2 0 10000000 2-0 10000000 2 repr( 5) = 128 + 5 = 123 = 01111011 2 Hier: Exzess-128-Code (N = 128 = 10000000 2 ) Negation x: 2N x Arithmetik: Benötigt Fallunterscheidung Eine Null: 10000000 2 Zahlenraum: 2 n 1 1... 2 n 1 (asymmetrisch)

Einerkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111010 2 0 00000000 2-0 11111111 2 repr( 5) = neg(5) = neg(00000101 2 ) = 11111010 2

Einerkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111010 2 0 00000000 2-0 11111111 2 repr( 5) = neg(5) = neg(00000101 2 ) = 11111010 2 Negation x: Alle Bits negieren

Einerkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111010 2 0 00000000 2-0 11111111 2 repr( 5) = neg(5) = neg(00000101 2 ) = 11111010 2 Negation x: Alle Bits negieren Arithmetik: Ähnlich bei negativ/positiv

Einerkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111010 2 0 00000000 2-0 11111111 2 repr( 5) = neg(5) = neg(00000101 2 ) = 11111010 2 Negation x: Alle Bits negieren Arithmetik: Ähnlich bei negativ/positiv Zwei Nullen: 00000000 2, 11111111 2 Zahlenraum: 2 n 1... 2 n 1 (symmetrisch)

Zweierkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111011 2 0 00000000 2-0 00000000 2 repr( 5) = neg(5 1) = neg(00000100 2 ) = 11111011 2

Zweierkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111011 2 0 00000000 2-0 00000000 2 repr( 5) = neg(5 1) = neg(00000100 2 ) = 11111011 2 Negation x: Benötigt Fallunterscheidung

Zweierkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111011 2 0 00000000 2-0 00000000 2 repr( 5) = neg(5 1) = neg(00000100 2 ) = 11111011 2 Negation x: Benötigt Fallunterscheidung Arithmetik: Positive/negative Zahlen sehr ähnlich, nur Vorzeichenerweiterung nötig

Zweierkomplement-Darstellung Beispiel Bitfolge 5 00000101 2-5 11111011 2 0 00000000 2-0 00000000 2 repr( 5) = neg(5 1) = neg(00000100 2 ) = 11111011 2 Negation x: Benötigt Fallunterscheidung Arithmetik: Positive/negative Zahlen sehr ähnlich, nur Vorzeichenerweiterung nötig Eine Null: 00000000 2 Zahlenraum: 2 n 1 1... 2 n 1 (asymmetrisch) Einfache Arithmetik kleiner Prozessor

Zusammenfassung: Zahlen mit Vorzeichen Vorzeichen-Betrag: Vorzeichen-Bit repr( 1) = 10000001 2 Exzess-N-code: +N (hier N = 128) repr( 1) = 01111111 2 Einerkomplement: Negation repr( 1) = 11111110 2 Zweierkomplement: Negation, +1 repr( 1) = 11111111 2

Daten-Repräsentation: Zeichen ASCII: American Standard Code for Information Interchange Nummern 32 126: Zeichen; 0 31, 127: Kontrollzeichen

Daten-Repräsentation: Zeichen ASCII: American Standard Code for Information Interchange Nummern 32 126: Zeichen; 0 31, 127: Kontrollzeichen! " # $ % & ( ) * +, -. / 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 0 1 2 3 4 5 6 7 8 9 : ; < = >? 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F @ A B C D E F G H I J K L M N O 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F P Q R S T U V W X Y Z [ \ ] ˆ 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F a b c d e f g h i j k l m n o 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F p q r s t u v w x y z { } 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E

Daten-Repräsentation: Sonderzeichen Umlaute, Sonderzeichen etc. oft in 128 255 gepackt codepages definieren unterschiedliche Bedeutungen.

Daten-Repräsentation: Sonderzeichen Umlaute, Sonderzeichen etc. oft in 128 255 gepackt codepages definieren unterschiedliche Bedeutungen. Unicode: mehr als 110,000 Zeichen Als 32-Bit-Nummer (Manchmal 16-Bit-Nummer, bestimmte Zeichen werden dabei ausgeschlossen)

Daten-Repräsentation: Sonderzeichen Umlaute, Sonderzeichen etc. oft in 128 255 gepackt codepages definieren unterschiedliche Bedeutungen. Unicode: mehr als 110,000 Zeichen Als 32-Bit-Nummer (Manchmal 16-Bit-Nummer, bestimmte Zeichen werden dabei ausgeschlossen) Zeichen: ä 電 I Kodierung: E4 96FB 13001

Daten-Repräsentation: Sonderzeichen Umlaute, Sonderzeichen etc. oft in 128 255 gepackt codepages definieren unterschiedliche Bedeutungen. Unicode: mehr als 110,000 Zeichen Als 32-Bit-Nummer (Manchmal 16-Bit-Nummer, bestimmte Zeichen werden dabei ausgeschlossen) Zeichen: ä 電 I Kodierung: E4 96FB 13001 Zeichenketten (strings): Bytefolgen, pro Byte ein Zeichen

Daten-Repräsentation: Zeichenketten Zeichenkette = mehrere Zeichen in Folge + Längenangabe

Daten-Repräsentation: Zeichenketten Zeichenkette = mehrere Zeichen in Folge + Längenangabe Länge der Zeichenkette z.b.: Längenprefix: Länge als Zahl vor dem ersten Zeichen Terminiert mit Terminator (meist 00) Zeichenkette Längenprefix Terminiert "foo" 03 00 66 6F 6F 66 6F 6F 00

Unicode-Zeichenketten Unicode-Zeichenketten werden primär in drei Formaten abgelegt: UTF-32: Wie normale Zeichenkette, aber 32 Bit statt 8 Bit pro Zeichen

Unicode-Zeichenketten Unicode-Zeichenketten werden primär in drei Formaten abgelegt: UTF-32: Wie normale Zeichenkette, aber 32 Bit statt 8 Bit pro Zeichen UTF-16: Ein Unicode-Zeichen belegt 2 oder 4 Bytes: Nummer Bitmuster UTF-16 < 10000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx >= 10000 000uuuuuxxxxxxxxxxxxxxxx 110110wwwwxxxxxx 110111xxxxxxxxxx (wwww = uuuuu - 1) D800 DFFF: keine gültigen Unicode-Zeichen 16/32-Bit-Fassungen unterschiedlich je nach Endigkeit

Unicode-Zeichenketten Unicode-Zeichenketten werden primär in drei Formaten abgelegt: UTF-32: Wie normale Zeichenkette, aber 32 Bit statt 8 Bit pro Zeichen UTF-16: Ein Unicode-Zeichen belegt 2 oder 4 Bytes: Nummer Bitmuster UTF-16 < 10000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx >= 10000 000uuuuuxxxxxxxxxxxxxxxx 110110wwwwxxxxxx 110111xxxxxxxxxx (wwww = uuuuu - 1) D800 DFFF: keine gültigen Unicode-Zeichen 16/32-Bit-Fassungen unterschiedlich je nach Endigkeit UTF-8: Ähnlich UTF-16: 1 4 Bytes pro Zeichen

Beispiel: Daten im Datenspeicher user@host: $ hexdump -C hallo-welt.o... 0200 b8 01 00 00 00 bf 01 00 00 00 48 be 00 00 00 00...H... 0210 00 00 00 00 ba 0d 00 00 00 0f 05 b8 3c 00 00 00...<... 0220 bf 00 00 00 00 0f 05 00 00 00 00 00 00 00 00 00... 0230 48 61 6c 6c 6f 2c 20 57 65 6c 74 21 0a 00 e8 03 Hallo, Welt!... 0240 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00......

Beispiel: Daten im Datenspeicher user@host: $ hexdump -C hallo-welt.o... 0200 b8 01 00 00 00 bf 01 00 00 00 48 be 00 00 00 00...H... 0210 00 00 00 00 ba 0d 00 00 00 0f 05 b8 3c 00 00 00...<... 0220 bf 00 00 00 00 0f 05 00 00 00 00 00 00 00 00 00... 0230 48 61 6c 6c 6f 2c 20 57 65 6c 74 21 0a 00 e8 03 Hallo, Welt!... 0240 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00...... Zahl (1000)

Beispiel: Daten im Datenspeicher user@host: $ hexdump -C hallo-welt.o... 0200 b8 01 00 00 00 bf 01 00 00 00 48 be 00 00 00 00...H... 0210 00 00 00 00 ba 0d 00 00 00 0f 05 b8 3c 00 00 00...<... 0220 bf 00 00 00 00 0f 05 00 00 00 00 00 00 00 00 00... 0230 48 61 6c 6c 6f 2c 20 57 65 6c 74 21 0a 00 e8 03 Hallo, Welt!... 0240 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00...... Zahl (1000) Maschinensprache

Beispiel: Daten im Datenspeicher user@host: $ hexdump -C hallo-welt.o... 0200 b8 01 00 00 00 bf 01 00 00 00 48 be 00 00 00 00...H... 0210 00 00 00 00 ba 0d 00 00 00 0f 05 b8 3c 00 00 00...<... 0220 bf 00 00 00 00 0f 05 00 00 00 00 00 00 00 00 00... 0230 48 61 6c 6c 6f 2c 20 57 65 6c 74 21 0a 00 e8 03 Hallo, Welt!... 0240 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00...... Zahl (1000) Maschinensprache Zeichenkette ( Hallo, Welt!\n )

Beispiel: Daten im Datenspeicher user@host: $ hexdump -C hallo-welt.o... 0200 b8 01 00 00 00 bf 01 00 00 00 48 be 00 00 00 00...H... 0210 00 00 00 00 ba 0d 00 00 00 0f 05 b8 3c 00 00 00...<... 0220 bf 00 00 00 00 0f 05 00 00 00 00 00 00 00 00 00... 0230 48 61 6c 6c 6f 2c 20 57 65 6c 74 21 0a 00 e8 03 Hallo, Welt!... 0240 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00...... Zahl (1000) Maschinensprache Zeichenkette ( Hallo, Welt!\n ) Die Bedeutung von Speicherinhalten kann ohne Kontext nicht mit Sicherheit bestimmt werden

Speicherarchitektur Speicher Firmware / BIOS Allzweckspeicher Gerätespeicher Eingabegeräte Prozessor- System Ausgabegeräte

Rechnerarchitektur: Speicher Firmware / BIOS Allzweckspeicher Grafikspeicher Northbridge Eingabegeräte Prozessor- System Ausgabegeräte

Beispiel: IA32-Speicher (Real Mode) BIOS 0x100000 0xF0000 Gerätespeicher: RAM, ROM, EPROM, je nach Gerät Arbeitsspeicher: RAM BIOS/Firmware: EEPROM Gerätespeicher Arbeitsspeicher 0xA0000 BIOS 0x7C00 0x400

Nächste Woche: Assembler-Programmierung in MIPS