Grundlagen der Rechnerarchitektur und -organisation Technische Informatik II Organisation und Technologie von Rechensystemen IV

Transkript

1 Grundlagen der Rechnerarchitektur und -organisation Technische Informatik II Organisation und Technologie von Rechensystemen IV Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo

2 Organisatorisches Vorlesung Dozent: Dr.-Ing. Volkmar Sieh Übungen Leitung: Dr.-Ing. Matthias Sand erste Übungen ab Montag, logo

3 Organisatorisches Schein für OTRS-IV nach alter Prüfungsordnung mündliche Prüfung nach Absprache Schein für TI-II für IuK-ler Vergabe bei Vorrechnen von Aufgaben während der Übungen Pflicht für Teilnahme an Klausur! Klausur OTRS-IV, TI-II und GRa nach neueren Prüfungsordnungen während des nächsten Prüfungszeitraums (Termin vom Prüfungsamt) es sind keine Hilfsmittel zugelassen! Ausnahme: handschriftliches Blatt DIN-A4 mit eigenen Notizen logo

4 Organisatorisches Folien, Unterlagen, Übungsaufgaben, alte Klausuren usw. im Web unter logo

5 Einleitung Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Einleitung 1/

6 Übersicht Einleitung Hochsprache - Assembler Speicher, Register, I/O-Register, Adressierungsarten Arithmetik (Integer, Floating-Point) Kontrollstrukturen, Unterprogramme, Interrupts, Exceptions Assembler - Hardware Aufbau Speicher, I/O-Register Aufbau einer CPU (ALU, Register, Busse, Tore, Steuerwerk) Mikroprogramm interpretiert Assembler-Code Caching Schutzmechanismen Priviligierungsstufen Segmentierung, Paging logo Einleitung 2/

7 Voraussetzungen Kenntnisse über und Programmierung in einer problemorientierten Programmiersprache (z.b. C, C++, Java, Pascal,...) Darstellung von Zahlen (speziell im 2er- und 16er-System) AND-, OR-, XOR- und NOT-Gatter, Register, Schalter persönlicher Einsatz! logo Einleitung 3/

8 Aufgaben Aufgaben sind Prüfungs-relevant! logo Einleitung 4/

9 Literatur Es existieren viele Bücher über Assembler-Programmierung Hardware-Komponenten und Rechnerarchitektur Mikroprogrammierung alles Prüfungs-relevante steht auch auf den Folien/Aufgabenblättern sinnvoll: Blick in ein gutes Handbuch eines Prozessors logo Einleitung 5/

10 Literatur Beispiele: Hennessy, Patterson, Rechnerorganisation und -entwurf, Spectrum, 2005 W. Stallings, Computer Organization & Architecture, Prentice Hall, logo Einleitung 6/

11 Assembler - Einleitung Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler - Einleitung 1/

12 Hochsprache / Assembler-Code Teil 1: Hochsprache Assembler-Code logo Assembler - Einleitung 2/

13 Hochsprache / Assembler-Code Hochsprache (z.b. C, C++, Java, Pascal,...) nicht direkt ausführbar Übersetzung der Hochsprache in die Muttersprache (Maschinensprache) des Rechners (symbolische Maschinensprache: Assembler-Code) Transformation normalerweise Aufgabe eines Compilers Assembler-Programmierung in Ausnahmefällen: Ausnutzung von Spezialfällen, für die die CPU bessere Befehle kennt Compiler erzeugt schlechten/falschen Code Programmteile, die in Hochsprache nicht programmierbar sind; z.b. I/O-Operationen Interrupt-/Exception-/System-Call-Handler logo Assembler - Einleitung 3/

14 Hochsprache / Assembler-Code Nachfolgend ein paar Beispiele für Effekte, die man nur mit Assembler-Wissen erklären kann. logo Assembler - Einleitung 4/

15 Hochsprache / Assembler-Code short int x; for (x = SHRT_MIN; x <= SHRT_MAX; x = x + 1) {... } Hinweis vom Compiler (hier: gcc): comparison is always true due to limited range of data type Das Programm durchläuft nicht wie wohl erhofft alle zulässigen Werte für x genau einmal. Statt dessen ist obige Schleife eine Endlos-Schleife! logo Warum? Assembler - Einleitung 5/

16 Hochsprache / Assembler-Code double array[10000][10000]; double sum; int x; int y; sum = 0.0; for (x = 0; x < 10000; x++) { for (y = 0; y < 10000; y++) { sum += array[y][x]; } } Vertauscht man beim Array-Zugriff x und y ist das Programm u.u. um Größenordnungen schneller! Warum? logo Assembler - Einleitung 6/

17 Hochsprache / Assembler-Code int mean(int x, int y) { return (x + y) / 2; } Diese Funktion liefert als Mittelwert von und (beides korrekte 32-Bit-Integer-Zahlen) den Wert zurück. Warum? logo Assembler - Einleitung 7/

18 Hochsprache / Assembler-Code struct element { char code[n]; int val; }; Für N = 4 braucht diese Struktur/Klasse 8 Bytes Speicher. Für N = 5 erhöht sich der Bedarf auf 12 Bytes. Bei weiterer Vergrößerung von N auf z.b. N = 6, N = 7 oder N = 8 wird dagegen nicht nochmals mehr Speicher gebraucht. Warum? logo Assembler - Einleitung 8/

19 Hochsprache / Assembler-Code Assembler-Code-Wissen unverzichtbar für Hardware-Entwurf und -Bewertung Compiler-Bau, Programmiersprachenentwurf Realzeit- und Embedded-System-Programmierung Betriebssystem-Programmierung (auch in Hochsprache!) Programmierung effizienter Algorithmen (auch in Hochsprache!) Programmierung System-naher Programmteile (auch in Hochsprache!) logo Assembler - Einleitung 9/

20 Hochsprache / Assembler-Code Assembler-Code-Wissen hilft bei Grafik-Programmierung Programmierung für Mustererkennung Datenbank-Programmierung logo Assembler - Einleitung 10/

21 Hochsprache / Assembler-Code Beispiel L0:.byte n, =, %, d, \n, \0 demo: void demo(void) { pushl %ebx int n; movl $0, %ebx n = 0; jmp L2 goto L2; L1: pushl %ebx L1: pushl $L0 call printf printf("n=%d\n", n); addl $8, %esp addl $1, %ebx n = n + 1; L2: cmp $10, %ebx L2: if (n!= 10) jne L1 goto L1; logo popl %ebx ret Assembler - Einleitung 11/19 }

22 Hochsprache / Assembler-Code Maschine soll in der Lage sein, alle, in beliebigen (problemorientierten) Hochsprachen geschrieben Programme effizient (schnell, geringer Speicheraufwand) abzuarbeiten. Instruktionssatz-Architektur (ISA): Ziel der Rechner-Architekten sollte sein: grundlegende Befehle finden Balance zwischen viele Befehle => aufwändige Dekodierung wenige Befehle => ineffiziente Berechnung logo Assembler - Einleitung 12/

23 Hochsprache / Assembler-Code Konstrukte von Hochsprachen: Datenzugriffe (I/O-Operationen) Arithmetik Kontrollstrukturen Unterprogramme (Interrupts, Exceptions, System-Calls) Zerlegung von Datenzugriffen, arithmetischen Ausdrücken, Schleifen usw. in einfachere Bestandteile logo Assembler - Einleitung 13/

24 Hochsprache / Assembler-Code normalerweise Beispiele für Intel-Prozessoren der i80x86-serie (ab i80386) in GNU-Schreibweise geeignet für eigene Versuche auf Linux-PCs (Windows-PCs) viele Infos unter zum Teil Beispiele für Motorola-Micro-Controller m68x05 in Motorola-Schreibweise logo Assembler - Einleitung 14/

25 Hinweise für eigene Versuche Grundgerüst: Datei file.s.text /* Programmsegment */ _start:.globl _start... /* <--- Testprogramm */ movl $0, %ebx /* exit-status des Programms */ movl $1, %eax /* exit-funktionsnummer */ int $0x80 /* System-Call */.data /* Datensegment */... /* <--- Testdaten */ Assemblieren mit as gstabs -o file.o file.s Linken mit ld -o file file.o logo Assembler - Einleitung 15/

26 Hinweise für eigene Versuche logo Assembler - Einleitung 16/

27 Hinweise für eigene Versuche Testen des Programms file mit./file (normaler Testlauf) gdb./file oder ddd./file (Lauf mit Debugger) logo Assembler - Einleitung 17/

28 Hinweise für eigene Versuche Debugger (gdb) stellt verschiedene Befehle zum Testen zur Verfügung: help allgemeine Hilfe break func Breakpoint setzen run Testlauf starten stepi Ausführung einer einzelnen Maschinen-Instruktion info register Anzeige der CPU-Register x &var Anzeige der Variablen x disassemble func Anzeige der Funktion func quit Beenden des Debuggers logo Assembler - Einleitung 18/

29 Eigene Versuche Jeder sollte eigene Versuche durchführen! Verständnis ohne praktische Programmierung unmöglich! C-Code schreiben vom C-Compiler erzeugten Code verstehen (oder andere problemorientierte Programmiersprache) Assembler-Code schreiben Programm testen logo Assembler - Einleitung 19/

30 Assembler - Variablen Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler - Variablen 1/

31 Variablen Variablen haben Namen, Typ und Geltungsbereich Name: für den Programmierer hilfreich; für die Semantik ohne Bedeutung (Umbenennung wäre möglich; z.b. var0, var1,...) Typ: definiert mögliche Inhalte und Größe (z.b. 8-Bit-Zeichen, 32-Bit-Int-Zahlen) definiert mögliche Operationen (Vergleiche, +, -,...) Geltungsbereich: für den Programmierer hilfreich; für die Semantik ohne Bedeutung (Ausnahme: Rekursion (später); alle Variablen könnten ansonsten global sein) logo Assembler - Variablen 2/

32 Variablen 1. Vereinfachung: Namen durch Nummern ersetzen: int global; int var0; static int module; static int var1; void func(int parameter) { void func(int var2) { int func_auto; int var3; static int func_static; static int var4; { { int block_local; int var5; for (int for_l = 0;...) for (int var6 = 0; } } } } logo Assembler - Variablen 3/

33 Variablen 2. Vereinfachung: Typ durch generischen Typ (Sequenz von Bits) ersetzen (Beispiel: soll nur die Idee vermitteln; funktioniert in Hochsprache so nicht!): int func(float x) { bit32 func(bit32 x) { int y; bit32 y; y = 10 * sin(x); return y; } } int(y) = 10 * sin(float(x)); return int(y); logo Assembler - Variablen 4/

34 Variablen 3. Vereinfachung: Geltungsbereiche auflösen: int global; static int module; int global; int module; int parameter; int func_auto; int func_static; int block_local; int for_local; void func(int parameter) { void func() { int func_auto; static int func_static; { int block_local; for (int for_local = 0;...) for (for_local = } } } Assembler - Variablen 5/ logo

35 Variablen 4. Vereinfachung: Man verwendet immer Variablen fester Länge (vielfach 8-Bit-Elemente Bytes ). Variablen mit weniger Bits (z.b. vom Typ boolean) verschenken Speicherplatz Variablen mit vielen Bits (z.b. 32-Bit-Integer-Variablen) werden auf mehrere Teil-Variablen aufgeteilt. Teil-Variablen bekommen aufeinander folgende Nummern. ggf. Aufteilen beim Schreiben, Zusammenfügen beim Lesen Beispiel: 32-Bit-Integer-Variable wird aufgeteilt in 4-Byte-Variablen: <=> logo Assembler - Variablen 6/

36 Variablen 4. Vereinfachung: große Variablen durch Seqenzen von kleinen ersetzen (Beispiel: soll nur die Idee vermitteln; funktioniert in Hochsprache so nicht!): int func(short int x) { int func(bit8 x0, x1) { int y; bit8 y0, y1, y2, y3; y = 10 * x; return y; } } {y0,y1,y2,y3} = 10 * {x0,x1}; return {y0,y1,y2,y3}; logo Assembler - Variablen 7/

37 Byte-Order Frage: Welche Bits werden im ersten, zweiten, usw. Byte gespeichert (Byte-Order)? Big-Endian (Most Significant Byte First, Network-Byte-Order): Little-Endian (Least Significant Byte First): logo Assembler - Variablen 8/

38 Variablen Größen verschiedener Datentypen (typische Werte für C, C++, Java, Pascal): Character 1 Byte (z.t. 2 bzw. 4 Bytes) Short Integer 2 Byte Integer 4 Byte (z.t. 2 Bytes) Long Integer 4 Byte (z.t. 8 Bytes) Long Long Integer 8 Byte Single Precision Float 4 Byte Double Precision Float 8 Byte Pointer 4 Byte (z.t. 2 bzw. 8 Bytes) logo Assembler - Variablen 9/

39 Variablen Vordefinierte Standard-Typen in C/C++ (#include <inttypes.h>): int8_t, uint8_t 1 Byte int16_t, uint16_t 2 Byte int32_t, uint32_t 4 Byte int64_t, uint64_t 8 Byte intptr_t 2/4/8 Byte (je nach CPU) Vordefinierte Standard-Typen in Java: byte 1 Byte short 2 Byte int 4 Byte long 8 Byte logo Assembler - Variablen 10/

40 Variablen - Adressen Endergebnis: Zum Speichern und Wiedergeben von Variablen reichen eine eindeutige Zahl als Bezeichner / Adresse sowie die Kenntnis der Byte-Order! logo Assembler - Variablen 11/

41 Variablen - Speicher Hauptspeicher bietet genau diese Funktionalität: Speichern von Werten in durchnummerierten Speicherzellen logo Assembler - Variablen 12/

42 Variablen - Adressen logo Assembler - Variablen 13/

43 Variablen - Symbolische Adressen len EQU 15 from EQU 16 to EQU 32 LDA #16 LDA #16 STA 15 STA len LDX 15 LDX len DECX DECX LDA 16,X LDA from,x STA 32,X STA to,x DECX DECX BPL... BPL... logo Assembler - Variablen 14/

44 Variablen - Symbolische Adressen x EQU 192 ; int8_t-variable x hat Adresse 192 y EQU 193 ; int16_t-variable y hat Adresse 193 z EQU 195 ; int32_t-variable z hat Adresse 195 p EQU 199 ; Pointer-Variable p hat Adresse 199 array EQU 201 ; Array array hat Adresse 201 nachträgliches Einfügen oder Löschen von Variablen mühsam und sehr fehleranfällig äquivalente Schreibweise mit Pseudo-Operationen : ORG 192 ; Startadresse der Variablen x RMB 1 y RMB 2 z RMB 4 p RMB 2 array RMB 20 logo Assembler - Variablen 15/

45 Variablen - Symbolische Adressen Schreibweise i80x86-gnu-assembler:.data /* Datensegment */ x:.global x /* globale int8_t-variable x */.zero 1 y: /* lokale int16_t-variable y */.zero 2 z:.global z /* globale int32_t-variable z */.zero 4 p: /* lokale Pointer-Variable p */.zero 4 array: /* lokale Array-Variable array */.zero 20 Read-only-Variablen auch im Programmsegment möglich. logo Assembler - Variablen 16/

46 Variablen - Strukturen Moderne Programmiersprachen kennen Strukturen / Records Arrays sowie Kombinationen davon. Zur Speicherung von Variablen dieser Typen müssen mehrere (normalerweise aufeinander folgende) Speicherzellen verwendet werden. Beispiel: zur Speicherung eines Charakters benötigt man ein Byte zur Speicherung eines Arrays bestehend aus N Charakters benötigt man N Byte (die Struktur geht verloren) logo Assembler - Variablen 17/

47 Variablen - mehrdimensionale Arrays Speicher ist eindimensionales Array Problem: wie speichert man mehrdimensionale Arrays? Array mit N Zeilen und M Spalten enthält insgesamt N M Elemente. Diese werden von 0 bis N M 1 durchnummeriert => eindimensionales Array. Beispiel: zweidimensionales Array eindimensionales Array int f1[10][5]; int f2[10 * 5]; int i; int i; int j; int j;... = f1[i][j];... = f2[i * 5 + j]; logo Assembler - Variablen 18/

48 Variablen - Strukuren C-Struktur struct { int8_t c; /* 1 Byte */ int16_t i; /* 2 Bytes */ double f; /* 8 Bytes */ } x; Abbildung auf Speicher Adresse Inhalt N + 0 x.c N + 1 x.i (erstes Byte) N + 2 x.i (zweites Byte) N + 3 x.f (erstes Byte) N + 10 x.f (achtes Byte) logo Assembler - Variablen 19/

49 Variablen - Strukuren C-Struktur struct { int8_t c; /* 1 Byte */ int16_t i; /* 2 Bytes */ double f; /* 8 Bytes */ } x; GNU-Assembler für i80x86:.data.data x:.global x x.c:.global x.c.zero 11.zero 1 x.i:.global x.i.zero 2 x.f:.global x.f.zero 8 logo Assembler - Variablen 20/

50 Variablen - Alignment Zugriff auf 2-Byte-Werte (bzw. 4-Byte-, 8-Byte-Werte) schneller, wenn diese an geraden (bzw. durch 4, 8 teilbaren) Adressen beginnen (manche Architekturen erfordern korrekte Startadressen sonst Bus Error ). => Alignment Erreichbar durch das (automatische) Einfügen von Dummy -Variablen. logo Assembler - Variablen 21/

51 Variablen - Alignment Beispiel (ohne Alignment): /* 4*N+0 */ int8_t c; /* 4*N+1 */ int16_t s; /* <- kein passendes Alignment */ Beispiel (mit Alignment): /* 4*N+0 */ int8_t c; /* 4*N+1 */ int8_t dummy; /* 4*N+2 */ int16_t s; /* <- passendes Alignment */ logo Assembler - Variablen 22/

52 Variablen - Operationen Folgende Speicher-Operationen stehen i.a. zur Verfügung: datum = load(address); store(address, datum); Die load- bzw. store-funktionalität des Speichers ist auch per CPU-Operation verfügbar direkt als Teil von komplexeren CPU-Operationen logo Assembler - Variablen 23/

53 Variablen - Register Register bieten gleiche Funktionalität wie Hauptspeicher: Speichern von Werten in durchnummerierten Registern logo Assembler - Variablen 24/

54 Variablen - Register Ähnlich Speicherzellen; aber: nur wenige Register verfügbar schnellerer Zugriff => meist für temporäre Variablen (einfache Datentypen) verwendet logo Assembler - Variablen 25/

55 Variablen - Register Register der i80x86-cpu: %eax, %ebx, %ecx, %edx, %edi, %esi, %ebp, %esp (je 32 Bit) z.t. auch als %ax, %bx, %cx, %dx, %di, %si, %bp, %sp ansprechbar (je 16 Bit) z.t. auch als %ah, %bh, %ch, %dh, %al, %bl, %cl, %dl, ansprechbar (je 8 Bit) Condition-Code/Flags-Register %eflags (32 Bit) Program-Counter/Instruction-Pointer %eip (32 Bit) logo Assembler - Variablen 26/

56 Variablen - Register Register der i80386-cpu: logo Assembler - Variablen 27/

57 Variablen - Register Register des m68x05-mikro-controllers: Akkumulator (A) (8 Bit) Index-Register (X) (8 Bit) Stack-Pointer (5 Bit) Condition-Code/Flags-Register (5 Bit) Program-Counter/Instruction-Pointer (12 Bit) logo Assembler - Variablen 28/

58 Variablen - Speicher-/Register-Zugriffe Zugriff auf Variablen im Speicher (i80x86): 1-Byte-Werte: movb address,...; movb..., address 2-Byte-Werte: movw address,...; movw..., address 4-Byte-Werte: movl address,...; movl..., address Zugriff auf Variablen in Registern (i80x86): 1-Byte-Werte: movb %reg,...; movb..., %reg 2-Byte-Werte: movw %reg,...; movw..., %reg 4-Byte-Werte: movl %reg,...; movl..., %reg Beispiel (i80x86): movw %ax, 16 # Kop. int16_t-wert im Reg. %ax nach Adresse 1 logo movl 4, %esp # Kop. int32_t-wert von Adresse 4,5,6,7 nach S Assembler - Variablen 29/

59 Variablen - Speicher-/Register-Zugriffe Speicher-/Register-Transfers (m68x05): 1-Byte-Werte: LDr address; STr address 2-/4-Byte-Werte: Beispiel (m68x05): sta 16 # Kop. Byte-Wert im Akku nach Adresse 16 lda 4 # Kop. Byte-Wert von Adresse 4 nach Akku ldx 7 # Kop. Byte-Wert von Adresse 7 ins Index-Reg. stx 9 # Kop. Byte-Wert vom Index-Reg. nach Adresse 9 logo Assembler - Variablen 30/

60 Assembler - Code und Instruction-Pointer Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler - Code und Instruction-Pointer 1/

61 Code und Instruction-Pointer Normale Hochsprachen-Programme werden in der Regel sequentiell abgearbeitet. Ähnliches gilt für Assembler-Programme: Befehle ( Befehls-Codes, Code ) stehen im Speicher an aufeinanderfolgenden Adressen Program-Counter (PC) oder Instruction Pointer (IP) enthält die (Start-) Adresse des nächsten, auszuführenden Befehls logo Assembler - Code und Instruction-Pointer 2/

62 Code und Instruction-Pointer Beispiel: Adresse Speicherinhalt 08049c66: 8b 04 9e 08049c69: c6a: c b c71: c75: e8 3a fb ff ff 08049c7a: 39 fb 08049c7c: 72 e8 %eip = 08049c71 logo Assembler - Code und Instruction-Pointer 3/

63 Code und Instruction-Pointer Moderne Assembler erlauben es, die Adressen der Befehle wegzulassen oder durch Labels ( symbolische Adressen ) zu ersetzen statt der kodierten Befehle ( Befehls-Codes, Opcodes ) Abkürzungen von Befehlen ( Mnemonics ) einzugeben logo Assembler - Code und Instruction-Pointer 4/

64 Code und Instruction-Pointer Beispiel: statt wird geschrieben 8049c66: 8b 04 9e 8049c69: c6a: c c71: c75: e8 3a fb ff ff 8049c7a: 39 fb 8049c7c: 72 e8 L1: mov (%esi,%ebx,4),%eax inc %ebx movl $0x805653b,(%esp) mov %eax,0x4(%esp) call 0x80497b4 cmp %edi,%ebx jb L1 logo Assembler - Code und Instruction-Pointer 5/

65 Assembler - Beispiele Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler - Beispiele 1/

66 Beispiele C-Code i n t 3 2 _ t x ; i n t 3 2 _ t y ; i n t 3 2 _ t z ; r e g i s t e r i n t 3 2 _ t tmp ; tmp = x ; tmp = y + tmp ; z = tmp ; Assembler-Code / x : A d r e s s e / / y : A d r e s s e / / z : A d r e s s e / / tmp : R e g i s t e r %eax / movl 50, %eax a d d l 54, %eax movl %eax, 58 logo Assembler - Beispiele 2/

67 Beispiele C-Code i n t 8 _ t c ; r e g i s t e r i n t 8 _ t tmp ; tmp = c ; tmp = tmp 32 c = tmp ; Assembler-Code / c : A d r e s s e 50 / / tmp : R e g i s t e r %a l / movb 50, %a l subb $32, %a l movb %al, 50 logo Assembler - Beispiele 3/

68 Beispiele C-Code s t r u c t { i n t 3 2 _ t a [ 2 ] ; i n t 3 2 _ t sum ; } x ; r e g i s t e r i n t 3 2 _ t tmp ; tmp = x. a [ 0 ] ; tmp = x. a [ 1 ] + tmp ; x. sum = tmp ; Assembler-Code / x. a [ 0 ] : A d r e s s e / / x. a [ 1 ] : A d r e s s e / / x.sum : A d r e s s e / / x : A d r e s s e / / tmp : R e g i s t e r %eax / movl 50, %eax a d d l 54, %eax movl %eax, 58 logo Assembler - Beispiele 4/

69 Assembler - Adressierungsarten Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler - Adressierungsarten 1/

70 Adressierungsarten Einführung Beispiel (C, C++, Java): i n t a, b, c [ 1 0 ] ; s t r u c t { char y ; i n t x ; i n t p } d, e, f [ 5 ] ;... = 1 3 ;... = a ;... = b ;... = c [ i ] ;... = d. x ;... = e >x ;... = f [ i ]. x ;... und Kombinationen davon: c [ f [ e >x ]. y ] =... ; f [ b ]. p =... ; a =... ; b =... ; c [ i ] =... ; d. x =... ; e >x =... ; f [ i ]. x =... ; logo Assembler - Adressierungsarten 2/

71 Adressierungsarten effektive Adresse Bei vielen Adressierungsarten wird eine sogenannte effektive Adresse dynamisch zur Laufzeit berechnet. Gründe (Beispiele): Basisadresse einer Datenstruktur fest, Index variabel (z.b. beim Array-Zugriff) Basisadresse einer Datenstruktur variabel, Displacement bekannt (z.b. beim Zugriff über Pointer auf Records) logo Assembler - Adressierungsarten 3/

72 Adressierungsarten effektive Adresse Beispiel: Zugriff auf Array-Elemente: short i n t i ; // A d r e s s e 8 short i n t f [ 5 ] ; // A d r e s s e 14 f [ i ] = 3 00; Adresse von i bekannt (8) Adresse von f bekannt (14) Größe der Elemente von f bekannt (2) Adresse(f [i]) = Adresse(f ) + i 2 logo Assembler - Adressierungsarten 4/

73 Adressierungsarten effektive Adresse Beispiel: Zugriff auf Record-Elemente über Pointer: s t r u c t r e c { short i n t x ; long i n t i ; short i n t y ; short i n t z ; } ; s t r u c t r e c p ; // A d r e s s e 8 s t r u c t r e c s ; // A d r e s s e 14 p >y = 9 ; Adresse von p bekannt (8) Displacement von s.y bezüglich s bekannt (6) Adresse(p > y) = p + 6 logo Assembler - Adressierungsarten 5/

74 Adressierungsarten Bei der Ausführung von Befehlen mit Parametern (z.b. Addition zweier Werte) sind folgende Punkte sind zu unterscheiden: wo stehen die eigentlichen Parameter (im Befehl, im Register oder im Speicher) wo stehen die Informationen, wie man an die Parameter kommt (i.a. sind diese Informationen Teil des Befehls) wie berechnet sich die effektive Adresse (wenn die Parameter im Speicher stehen) logo Assembler - Adressierungsarten 6/

75 Adressierungsarten Überblick Register Immediate Operand Direct (Absolute) Address Register Indirect Register Indirect with Index Register Indirect with Displacement / PC-relative Register Indirect with Index and Displacement Memory Indirect Register Indirect with Pre-/Post-Decrement Register Indirect with Pre-/Post-Increment... logo Assembler - Adressierungsarten 7/

76 Adressierungsarten Register Register-Name bzw. -Nummer ist Bestandteil des Befehls Operand liegt im Register Syntax-Beispiele (i80x86): movl %eax,... movb..., %a l Verwendung: Schreiben bzw. Lesen von in Registern gespeicherten Variablen r e g i s t e r short i n t r ; / r l i e g t im R e g i s t e r %ax / r e g i s t e r short i n t s ; / s l i e g t im R e g i s t e r %bx / r = s ; ergibt compiliert: movw %bx, %ax logo Assembler - Adressierungsarten 8/

77 Adressierungsarten Immediate Operand Operand ist Bestandteil des Befehls Syntax-Beispiele (i80x86): movl $14,... movl $0x14,... movb $ a,... Verwendung: Zuweisung von Konstanten an Variablen r e g i s t e r long i n t x ; / x l i e g t im R e g i s t e r %edx / x = 1 4 ; ergibt compiliert: movl $14, %edx logo Assembler - Adressierungsarten 9/

78 Adressierungsarten Immediate Operand Anmerkung: Viele Prozessoren (besonders RISC-CPUs) verwenden zur Kodierung der Befehle jeweils gleichlange Byte-Folgen (z.b. m88100: jeder Befehl ist genau 4 Bytes lang). Aber: unmöglich, z.b. einen movl 0x , %eax-befehl (allein Konstante ist 4 Byte lang) in 4 Bytes zu kodieren. Abhilfe: Aufteilen des Befehls in zwei Teil-Befehle: statt einem Befehl zwei Befehle s e t h i $0x1234, %eax movl $0x , %eax s e t l o $0x5678, %eax logo Assembler - Adressierungsarten 10/

79 Adressierungsarten Direct (Absolute) Address effektive Adresse ist Bestandteil des Befehls Operand liegt im Speicher Syntax-Beispiele (i80x86): movl 1236,... movb..., 4345 Hinweis: Statt der Adressen werden häufig lieber symbolische Werte geschrieben. Z.B.: movl varx,... movb..., f l a g Die symbolischen Werte müssen jedoch auf irgendeine Weise definiert werden (z.b. durch define- oder equ-anweisungen). Definition im Folgenden aus Platzgründen häufig weggelassen. logo Assembler - Adressierungsarten 11/

80 Adressierungsarten Direct (Absolute) Address Verwendung: Schreiben bzw. Lesen von im Speicher abgelegten Variablen char c ; / c hat A d r e s s e 1245 / char d ; / d hat A d r e s s e 1246 / c = A ; d = c ; ergibt compiliert: movb $65, 1245 movb 1245, 1246 oder (lesbarer) #d e f i n e c 1245 #d e f i n e d 1246 movb $ A, movb c, d c logo Assembler - Adressierungsarten 12/

81 Adressierungsarten Register Indirect Register-Name/-Nummer ist Bestandteil des Befehls Register enthält effektive Adresse Operand liegt im Speicher Syntax-Beispiele (i80x86): movl (%ebx ),... movb..., (%ebp ) logo Assembler - Adressierungsarten 13/

82 Adressierungsarten Register Indirect Verwendung: z.b. Schreiben bzw. Lesen von Variablen über Pointer, die in Registern liegen. r e g i s t e r short i n t p ; / p l i e g t im R e g i s t e r %edx short i n t x ; / x hat d i e A d r e s s e 1456 / p = &x ; p = 1 4 ; x = p ; ergibt compiliert: movl $1456, %edx movw $14, (%edx ) movw (%edx ), 1456 logo Assembler - Adressierungsarten 14/

83 Adressierungsarten Register Indirect with Index Register-Namen/-Nummern sowie Scale-Faktor sind Bestandteile des Befehls Register A enthält Anfangsadresse des Objektes ( Startadresse, Basisadresse ) Register B enthält Index effektive Adresse berechnet sich als Adresse = Basisadresse + Index ScaleFaktor Operand liegt im Speicher Syntax-Beispiele (i80x86): movl (%ebx, %ecx, 4 ),... movb..., (%ebp, %edi, 8) logo Assembler - Adressierungsarten 15/

84 Adressierungsarten Register Indirect with Index Verwendung: Schreiben bzw. Lesen von Array-Elementen short i n t f [ ] ; / f hat d i e A d r e s s e 1246 / r e g i s t e r short i n t p ; / p l i e g t im R e g i s t e r %ebx r e g i s t e r short i n t i ; / i l i e g t im R e g i s t e r %ecx p = &f [ 0 ] ; p [ i ] = 5 0 ; f [ 1 ] = p [ i ] ; ergibt compiliert: movl $1246, %ebx movw $50, (%ebx, %ecx, 2) movw (%ebx, %ecx, 2 ), 1248 logo Assembler - Adressierungsarten 16/

85 Adressierungsarten Register Indirect with Displacement Register-Name/-Nummer sowie Displacement sind Bestandteile des Befehls Register enthält Basisadresse effektive Adresse berechnet sich als Adresse = Basisadresse + Displacement Operand liegt im Speicher Syntax-Beispiele (i80x86): movl 4(%ebp ),... movb..., 17(% e s i ) logo Assembler - Adressierungsarten 17/

86 Adressierungsarten Register Indirect with Displacement Bemerkungen: wird für das Register der Instruction-Pointer/Program-Counter verwendet, spricht man auch von PC-relativer -Adressierung statt der Bezeichnung Displacement wird auch häufig die Bezeichnung Offset verwendet logo Assembler - Adressierungsarten 18/

87 Adressierungsarten Register Indirect with Displacement Verwendung: Schreiben bzw. Lesen von Record-Elementen über Pointer s t r u c t r e c { long i n t x ; char c ; short i n t s ; } ; s t r u c t r e c r ; / r hat d i e A d r e s s e 3456 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %eax p = &r ; p >c = A ; r. s = p >s ; ergibt compiliert: movl $3456, %eax movb $ A, 4(%eax ) movw 6(%eax ), 3462 / = ; mit Alignment / logo Assembler - Adressierungsarten 19/

88 Adressierungsarten Register Indirect with Index and Displacement Register-Name/-Nummer, Scale-Faktor sowie Displacement sind Bestandteile des Befehls Register A enthält Basisadresse Register B enthält Index effektive Adresse berechnet sich als Adresse = Basisadresse + Index ScaleFaktor + Displacement Operand liegt im Speicher Syntax-Beispiele (i80x86): movw 4(%ebp, %eax, 8 ),... movl..., 16(%edx, %ebx, 4) logo Assembler - Adressierungsarten 20/

89 Adressierungsarten Register Indirect with Index and Displacement Verwendung: Schreiben bzw. Lesen von Record-Elementen eines Arrays s t r u c t r e c { long i n t x ; char c ; short i n t s ; } ; s t r u c t r e c f [ ] ; / f hat d i e A d r e s s e 452 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %ecx r e g i s t e r long i n t i ; / i l i e g t im R e g i s t e r %eax p = &f [ 0 ] ; p [ i ]. c = A ; f [ 2 ]. s = p [ i ]. s ; ergibt compiliert: movl $452, %ecx logo movb $ A, 4(%ecx, %eax, 8) movw 6(%ecx, %eax, 8 ), 474 / = ; mit Alignm Assembler - Adressierungsarten 21/

90 Adressierungsarten Memory Indirect Speicheradresse ist Bestandteil des Befehls effektive Adresse ist der Inhalt der angegebenen Speicherzelle Operand liegt im Speicher Syntax-Beispiele: movl ( 2 4 ),... movb..., (465) logo Assembler - Adressierungsarten 22/

91 Adressierungsarten Memory Indirect Verwendung: Schreiben bzw. Lesen von Variablen über Pointer, die im Speicher liegen short i n t x ; / x hat d i e A d r e s s e 340 / short i n t p ; / p hat d i e A d r e s s e 342 / p = &x ; p = 4 5 ; x = p ; ergibt compiliert: movl $340, 342 movw 45, (342) movw ( ), 340 logo Assembler - Adressierungsarten 23/

92 Adressierungsarten Register Indirect with Pre-/Post-Increment/Decrement Register-Name/Nummer sowie die Größe des Operanden sind Bestandteile des Befehls Register enthält effektive Adresse Operand liegt im Speicher vor/nach dem Zugriff auf den Operanden wird Registerinhalt inkrementiert/dekrementiert (um die Größe des Operanden) Syntax-Beispiele (i80x86): movw (%esp ),... movb +(%eax ),... movl..., (%ebp)+ movw..., (%ecx) logo Assembler - Adressierungsarten 24/

93 Adressierungsarten Register Indirect with Pre-/Post-Increment/Decrement Verwendung: Push und Pop von Werten auf dem Stack (später) s t r u c t r e c { long i n t x ; short i n t y ; char c ; } ; s t r u c t r e c a ; / a hat d i e A d r e s s e 1232 / s t r u c t r e c b ; / b hat d i e A d r e s s e 344 / a = b ; ergibt compiliert: movl $1232, %eax movl $344, %ebx movl (%ebx )+, (%eax)+ movw (%ebx )+, (%eax)+ movb (%ebx )+, (%eax)+ logo Assembler - Adressierungsarten 25/

94 Adressierungsarten m68x05 tax / Reg. > Reg. / txa l d a #12 / Immediate Operand > Reg. / l d x #34 l d a 1234 / D i r e c t Address > Reg. / l d x 5678 s t a 1234 / Reg. > D i r e c t Address / s t x 5678 l d a, x / Reg. I n d i r e c t > Reg. / l d x, x s t a, x / Reg. > Reg. I n d i r e c t / s t x, x l d a 12, x / Reg. I n d i r e c t with Displacement > Re l d x 34, x logo s t a 56, x / Reg. > Reg. I n d i r e c t with Displaceme s t x 78, x Assembler - Adressierungsarten 26/

95 Adressierungsarten Hinweise nicht alle CPUs können alle Adressierungsarten (insbesondere viele Einschränkungen bei RISC-CPUs und kleinen Mikro-Controllern) nicht alle Adressierungsarten sind mit allen Registern möglich (z.b. ist der Instruction Pointer nicht als Basis- oder Index-Register erlaubt) nicht alle Kombinationen von Adressierungsarten (Ziel und Quelle) sind möglich (z.b. erlauben viele CPUs movl 1232, 432 nicht) es existieren i.a. Einschränkungen für die möglichen Werte bzw. die Größe von Scale-Faktor und Displacement (z.b. kann der Scale-Faktor nur 1, 2, 4 oder 8 betragen; Displacement häufig < 256) logo Assembler - Adressierungsarten 27/

96 Adressierungsarten Hinweise Zum Teil werden Befehle und Adressierungsarten (z.b. aus historischen Gründen) anders geschrieben. Beispiele (i80x86): statt movl %eax, (%esp ) movl (%esp )+, %eax movl %e f l a g s, (%esp ) movl (%esp )+, %e f l a g s wird verwendet p u s h l %eax p o p l %eax p u s h f l p o p f l movl $1234, %e i p jmp 1234 movl (%esp )+, %e i p r e t logo Assembler - Adressierungsarten 28/

97 Adressierungsarten lea-befehl Nicht alle Programmier-Konstrukte zum Zugriff auf Variablen innerhalb von (verschachtelten) Arrays und Records sind direkt umsetzbar. Z.B.: char f [ 1 0 ] [ 1 0 ] ; i n t i, j ; f [ i ] [ j ] =... ; Adresse(f [i][j]) wäre im Beispiel Adresse(f ) + i 10 + j. Dafür existiert keine Adressierungsart (bei den meisten Prozessoren). In diesen Fällen muss die Adresse explizit berechnet werden lea-befehl explizite Arithmetik (später) logo Assembler - Adressierungsarten 29/

98 Adressierungsarten lea-befehl s t r u c t r e c { short i n t v a l u e ; char name [ 6 ] ; } ; s t r u c t r e c r ; / r hat d i e A d r e s s e 432 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %eax r e g i s t e r long i n t i ; / i l i e g t im R e g i s t e r %ebx p = &r ; p >name [ i ] = A ; ist equivalent zu r e g i s t e r char n ; / n l i e g t im R e g i s t e r %ecx p = &r ; n = &p >name [ 0 ] ; n [ i ] = A ; ergibt compiliert movl $432, %eax l e a 2(%eax ), %ecx movb $ A, (%ecx, %ebx, 1) ; logo Assembler - Adressierungsarten 30/

99 Adressierungsarten Hinweise Ersatz für fehlende Adressierungsarten: movl , %eax movl $ , %eax movl (%eax ), %eax movl ( ), %eax movl $ , %eax movl (%eax ), %eax movl (%eax ), %eax movl 8(%eax,%ebx,1),% eax l e a l 8(%eax ), %eax movl (%eax,%ebx,1),% eax Weitere Adressierungsarten können über Arithmetik-Befehle nachgebildet werden. logo Assembler - Adressierungsarten 31/

100 Assembler Adressierungsarten Beispiele Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Adressierungsarten Beispiele 1/

101 Beispiele C-Code i n t a r r a y [ ] ; r e g i s t e r i n t i ; r e g i s t e r i n t v a l ; v a l=a r r a y [10+ i ] ; Assembler-Code / a r r a y : A d r e s s e / / i : R e g i s t e r %eax / / v a l : R e g i s t e r %ebx / movl $1000, %ecx movl 10 4(%ecx,%eax, 4 ), %ebx logo Assembler Adressierungsarten Beispiele 2/

102 Beispiele C-Code char a r r a y [ 1 6 ] [ 8 ] ; r e g i s t e r i n t x ; r e g i s t e r i n t y ; char v a l ; v a l = a r r a y [ x ] [ y ] ; Assembler-Code / a r r a y : A d r e s s e / / x : R e g i s t e r %eax / / y : R e g i s t e r %ebx / / v a l : A d r e s s e 999 / movb 1000(%ebx,%eax, 8 ), 999 logo Assembler Adressierungsarten Beispiele 3/

103 Beispiele C-Code s t r u c t r e c { s t r u c t r e c p r e v ; s t r u c t r e c next ;... } ; s t r u c t r e c f i r s t ; s t r u c t r e c l a s t ; r e g i s t e r s t r u c t r e c new ; Assembler-Code / p r e v : Offset 0 next : Offset 4... / / f i r s t : A d r e s s e 980 / l a s t : A d r e s s e 984 / / new : R e g i s t e r %eax f i r s t = new ; l a s t = new ; new >p r e v = NULL ; new >next = NULL ; movl %eax, 980 movl %eax, 984 movl $0, (%eax ) movl $0, 4(% eax ) logo Assembler Adressierungsarten Beispiele 4/

104 Assembler Integer-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Integer-Arithmetik 1/

105 Arithmetik Zerlegung von Ausdrücken Ziel: Vereinfachung von Ausdrücken Zerlegung der Ausdrücke entsprechend der Grammatik Einführung von temporären Variablen Beispiel: y = (x + 2z)/(z sinx) t1 = 2 z ; t2 = x + t1 ; t3 = s i n ( x ) ; t4 = z t3 ; y = t2 / t4 ; Optimierung =====> t1 = 2 z ; t1 = x + t1 ; t2 = s i n ( x ) ; t2 = z t2 ; y = t1 / t2 ; Optimierung: unnötig viele temporäre Variablen vermeiden Anzahl der (schnellen) Register beschränkt Speicherzugriffe langsam logo Assembler Integer-Arithmetik 2/

106 Arithmetik Zerlegung von Ausdrücken Jeder Ausdruck lässt sich in Teilausdrücke zerlegen, die die Form A = (B) A = op B mit op {, +,...} A = B op C mit op {+,,, /, mod,...} A = fn(b 0, B 1,..., B N 1 ) mit fn() beliebiger Funktion haben. logo Assembler Integer-Arithmetik 3/

107 Arithmetik Zerlegung von Ausdrücken Zur Berechnung von A = B op C werden drei effektive Adressen benötigt: A, B und C. Kodierung von drei Adressierungsarten in einem Befehl aufwändig A = B op C kann umgeschrieben werden als A = B und A = A op C; hier werden pro Befehl nur zwei effektive Adressen benötigt (einmal A und B; einmal A und C) A = B op C kann noch weiter vereinfacht werden: ACCU = B, ACCU = ACCU op C, A = ACCU; in diesem Fall wird je Befehl nur eine effective Adresse benötigt (ACCU: Akkumulator ) logo Assembler Integer-Arithmetik 4/

108 Arithmetik Ein-, Zwei- und Drei-Adress-CPUs Gemäß der pro Befehl möglichen effektiven Adressen werden CPUs eingeteilt in drei Klassen: Ein-Adress-CPU: Befehle haben die Formen ACCU = A ACCU = ACCU op A A = ACCU Beispiele: z80, 6502, m68x05 Zwei-Adress-CPU: Befehle haben die Formen A = B A = A op B Beispiele: i80x86, m680x0 Drei-Adress-CPU: Befehle haben die Form A = B op C Beispiele: m88100, Sparc logo Assembler Integer-Arithmetik 5/

109 Arithmetik Ein-, Zwei- und Drei-Adress-CPUs Beispiel: x = y + z Drei-Adress-CPU Zwei-Adress-CPU Ein-Adress-CPU add y, z, x l o a d y # accu = y mov y, x add z # accu += z add z, x s t o r e x # x = accu logo Assembler Integer-Arithmetik 6/

110 Arithmetik Rechengenauigkeit Da alle Variablen im Speicher bzw. in Registern abgelegt werden, können sie nicht beliebig große (genaue) Werte annehmen (siehe TI-I). Ähnliches gilt auch für die Arithmetik: Da alle Rechenwerke einer CPU nur für eine bestimmte Anzahl von Bits ausgelegt sind, können auch hier die Werte nicht beliebig groß (genau) werden. Dies gilt generell für alle Rechner! logo Assembler Integer-Arithmetik 7/

111 Arithmetik Rechengenauigkeit Beispiel: mit beliebig vielen Stellen gerechnet: (2) (2) = (2) 178 (10) (10) = 383 (10) mit 8 Stellen gerechnet: (2) (2) = (1) (2) 178 (10) (10) = (256 (10) ) (10) logo Assembler Integer-Arithmetik 8/

112 Arithmetik Rechengenauigkeit Aufgrund der Zerlegung von Ausdrücken ergeben sich folgende Forderungen: die Werte der Eingabe aller(!) Zwischenergebnisse der Ausgabe müssen ohne Überläufe speicherbar sein alle (Teil-) Rechenschritte müssen ohne Überläufe durchführbar sein logo Assembler Integer-Arithmetik 9/

113 Arithmetik Rechengenauigkeit Beispiel (Mittelwertberechnung): z = x ; z = ( x + y ) / 2 ; z = z + y ; z = z / 2 ; Bei der Addition z = z + y; kann ein Überlauf auftreten! logo Assembler Integer-Arithmetik 10/

114 Arithmetik Integer Negation: x = y 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, %a l negb %a l movw y, %ax negw %ax movl y, %eax n e g l %eax movb %al, x movw %ax, x movl %eax, x kürzer: 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, x movw y, x movl y, x negb x negw x n e g l x Je nachdem, ob die Variablen x, y im Speicher oder in Registern liegen, ist die kürzere Version langsamer oder schneller als die längere. logo Assembler Integer-Arithmetik 11/

115 Arithmetik Integer Addition: x = y + z 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, %a l movw y, %ax movl y, %eax addb z, %a l addw z, %ax a d d l z, %eax movb %al, x movw %ax, x movl %eax, x kürzer: 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, x movw y, x movl y, x addb z, x addw z, x a d d l z, x Entsprechend: Subtraktion, Multiplikation, Division logo Assembler Integer-Arithmetik 12/

116 Arithmetik Carry-/Borrow-Bit Problem: Rechnungen ausserhalb der normalen Rechengenauigkeit einer CPU Beispiel aus der Schule: <= Carry 1100 <= Carry Übertrag entweder 0 oder 1 ( Carry-, Borrow -Bit) logo Assembler Integer-Arithmetik 13/

117 Arithmetik Carry-/Borrow-Bit Beispiel für 64-Bit-Arithmetik mit 32-Bit-Rechenoperationen: (x 1 x 0 ) = (y 1 y 0 ) + (z 1 z 0 ) bzw. (x 1 x 0 ) = (y 1 y 0 ) (z 1 z 0 ) movl y0, %eax a d d l z0, %eax movl %eax, x0 movl y1, %eax a d c l z1, %eax < Carry movl %eax, x1 movl y0, %eax s u b l z0, %eax movl %eax, x0 movl y1, %eax s b b l z1, %eax < Borrow movl %eax, x1 logo Assembler Integer-Arithmetik 14/

118 Arithmetik Multiplikation/Division Beispiel x = y z und x = y/z (i80x86): movl y, %eax movl y, %eax movl $0, %edx i m u l l z i d i v l z movl %eax, x movl %eax, x / %edx : U e b e r l a u f / / %edx : Rest d. D i v i s i o n logo Assembler Integer-Arithmetik 15/

119 Arithmetik Multiplikation/Division Besonderheiten: Multiplikation kann große Überläufe erzeugen (Carry-Bit reicht nicht!) => Extra-Register für Überlauf idiv-befehl berechnet gleichzeitig y/z und y mod z Multiplikation ist aufwändig in Hardware implementierbar (=> nur selten in Mikro-Controllern als Maschinen-Befehl implementiert) Division ist sehr(!) aufwändig in Hardware und nicht als Schaltnetz implementierbar (=> fast nie in Mikro-Controllern als Maschinen-Befehl implementiert) logo Assembler Integer-Arithmetik 16/

120 Arithmetik Multiplikation/Division Ersatz für fehlende/langsame Multiplikations-Befehle: 1. Beobachtung: Häufig werden nur Multiplikationen mit einem konstanten Faktor durchgeführt. Diese können auf sukzessive Additionen zurückgeführt werden. Beispiel: y = 10 x kann umgeformt werden zu y = 2 (2 2 x + x) movl x, %eax a d d l %eax, %eax movl %eax, %ebx / => %ebx = 2 x / a d d l %eax, %eax a d d l %eax, %eax / => %eax = 8 x / a d d l %ebx, %eax movl %eax, y Nicht 10-mal addieren! logo Assembler Integer-Arithmetik 17/

121 Arithmetik Multiplikation/Division Ersatz für fehlende/langsame Multiplikations-Befehle: 2. Beobachtung: Häufig werden Multiplikationen/Divisionen mit konstanten 2-er-Potenzen durchgeführt Beispiel: Multiplikation mit 2er-Potenz: y = x 2 5 y N+4...y 2 y 1 y 0 (2) = x N 1...x 2 x 1 x (2) (entspricht dem Anhängen der entsprechenden Anzahl von Nullen) Beispiel: Division durch 2er-Potenz (mit Abrundung): y = x/2 5 y N 6...y 2 y 1 y 0 = x N 1...x 7 x 6 x 5 (2) (entspricht dem Löschen der entsprechenden Anzahl von Ziffern) logo Assembler Integer-Arithmetik 18/

122 Arithmetik Shift-Befehle arithmetic shift left (sal): übergebene vorzeichenbehaftete Binär-Zahl wird um eine Stelle nach links verschoben (entspricht Multiplikation mit 2) arithmetic shift right (sar): übergebene vorzeichenbehaftete Binär-Zahl wird um eine Stelle nach rechts verschoben (entspricht Division durch 2 mit Abrunden) (logical) shift left (shl): übergebene vorzeichenlose Binär-Zahl wird um eine Stelle nach links verschoben (entspricht Multiplikation mit 2) (logical) shift right (shr): übergebene vorzeichenlose Binär-Zahl wird um eine Stelle nach rechts verschoben (entspricht Division durch 2 mit Abrunden) Es existieren z.t. Befehle, Werte um mehrere Stellen zu verschieben. logo Assembler Integer-Arithmetik 19/

123 Arithmetik Shift-Befehle Beispiel: salw $3, %ax shrw $4, %ax shlw $6, %ax sarw $3, %ax / %ax = / / %ax = / / %ax = / / %ax = / / %ax = / logo Assembler Integer-Arithmetik 20/

124 Arithmetik And, Or, Xor, Not Für die Verarbeitung Bool scher Werte existieren die Bool schen Operationen and, or, xor und not. Es werden N Bits (N {8, 16, 32,...}) parallel verarbeitet: and: x N 1...x 1 x 0 = y N 1...y 1 y 0 and z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 and z N 1 )...(y 1 and z 1 )(y 0 and z 0 ) or: x N 1...x 1 x 0 = y N 1...y 1 y 0 or z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 or z N 1 )...(y 1 or z 1 )(y 0 or z 0 ) xor: x N 1...x 1 x 0 = y N 1...y 1 y 0 xor z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 xor z N 1 )...(y 1 xor z 1 )(y 0 xor z 0 ) not: x N 1...x 1 x 0 = not y N 1...y 1 y 0 x N 1...x 1 x 0 = (not y N 1 )...(not y 1 )(not y 0 ) logo Assembler Integer-Arithmetik 21/

125 Arithmetik And, Or, Xor, Not Beispiel: movw $0x1234, %ax andw $0xf61c, %ax / %ax hat j e t z t den Wert 0 x1214 / movl $0x , %eax o r l $0x , %eax / %eax hat j e t z t den Wert 0 x / movb $0x24, %a l xorb $ 0 x f f, %a l / %a l hat j e t z t den Wert 0 xdb / movl $ , %eax n o t l %eax / %eax hat j e t z t den Wert 0 xedcba987 / logo Assembler Integer-Arithmetik 22/

126 Arithmetik Hinweise Zur Beschleunigung/Verkürzung der Programme gibt es für sehr häufig vorkommende Ausdrücke Extra-Maschinenbefehle: Beispiele: a d d l $1, x subw $1, y movl $0, %eax => i n c l x decw y x o r l %eax, %eax logo Assembler Integer-Arithmetik 23/

127 Assembler Integer-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Integer-Arithmetik 1/

128 Integer-Arithmetik Beispiele Beispiel: Umsetzung von einem Hochsprachen-Ausdruck in Assembler-Code Erster Schritt: Zerlegung in einzelne Schritte i n t a, b, y ; i n t a, b, y ; i n t tmp0, tmp1, tmp2 ; y = ( a+b ) ( a b ) ; => tmp0 = a ; tmp0 = tmp0+b ; tmp1 = a ; tmp1 = tmp1 b ; tmp2 = tmp0 ; tmp2 = tmp2 tmp1 ; y = tmp2 ; logo Assembler Integer-Arithmetik 2/

129 Integer-Arithmetik Beispiele Zweiter Schritt: Vereinfachung i n t a, b, y ; i n t tmp0, tmp1, tmp2 ; tmp0 = a ; tmp0 = tmp0+b ; tmp1 = a ; tmp1 = tmp1 b ; tmp2 = tmp0 ; tmp2 = tmp2 tmp1 ; y = tmp2 ; => i n t a, b, y ; i n t tmp1 ; y = a ; y = y+b ; tmp1 = a ; tmp1 = tmp1 b ; y = y tmp1 ; logo Assembler Integer-Arithmetik 3/

130 Integer-Arithmetik Beispiele Dritter Schritt: Umsetzung in Assembler-Code i n t a, b, y ; i n t tmp0 ; y = a ; y = y+b ; tmp0 = a ; tmp0 = tmp0 b ; y = y tmp0 ; => movl a, y a d d l b, y movl a, %eax s u b l b, %eax i m u l l %eax, y logo Assembler Integer-Arithmetik 4/

131 Integer-Arithmetik Beispiele Beispiel: Umsetzung von einem Hochsprachen-Ausdruck in Assembler-Code Erster Schritt: Zerlegung in einzelne Schritte i n t a, b, y ; i n t a, b, y ; i n t tmp0, tmp1, tmp2 ; y = ( a&~b ) ( ~ a&b ) ; => tmp0 = b ; tmp0 = ~tmp0 ; tmp0 = tmp0 & a ; tmp1 = a ; tmp1 = ~tmp1 ; tmp1 = tmp1 & b ; tmp2 = tmp0 ; tmp2 = tmp2 tmp1 ; y = tmp2 ; logo Assembler Integer-Arithmetik 5/

132 Integer-Arithmetik Beispiele Zweiter Schritt: Vereinfachung i n t a, b, y ; i n t tmp0, tmp1, tmp2 ; i n t a, b, y ; i n t tmp1 ; tmp0 = b ; tmp0 = ~tmp0 ; tmp0 = tmp0 & a ; tmp1 = a ; tmp1 = ~tmp1 ; tmp1 = tmp1 & b ; tmp2 = tmp0 ; tmp2 = tmp2 tmp1 ; y = tmp2 ; => y = b ; y = ~y ; y = y & a ; tmp1 = a ; tmp1 = ~tmp1 ; tmp1 = tmp1 & b ; y = y tmp1 ; logo Assembler Integer-Arithmetik 6/

133 Integer-Arithmetik Beispiele Dritter Schritt: Umsetzung in Assembler-Code i n t a, b, y ; i n t tmp1 ; y = b ; y = ~y ; y = y & a ; tmp1 = a ; tmp1 = ~tmp1 ; tmp1 = tmp1 & b ; y = y tmp1 ; => movl b, y n o t l y a n d l a, y movl a, %eax n o t l %eax a n d l b, %eax o r l %eax, y logo Assembler Integer-Arithmetik 7/

134 Assembler Fließkomma-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Fließkomma-Arithmetik 1/

135 Fließkommaarithmetik Berechnung von Fließkomma-Ausdrücken entspricht weitgehend der Berechnung von Integer-Ausdrücken: Zerlegen der Ausdrücke gemäß der Grammatik Einführen von temporären Variablen Bei großen Prozessoren existieren entsprechende Assembler-Befehle (Beispiel: i80x86): Integer negb, negw, negl addb, addw, addl subb, subw, subl imulb, imulw, imull idivb, idivw, idivl Fließkomma fchs fadd fsub fmul fdiv logo Assembler Fließkomma-Arithmetik 2/

136 Fließkomma-Arithmetik Bei kleineren Prozessoren existieren keine Fließkomma-Befehle Berechnung über getrennte Behandlung des Vorzeichens, der Mantisse und des Exponenten Bei vielen Prozessoren existiert keine Fließkomma-Division Berechnung von x = y/z als x = y 1/z Berechnung von 1/z durch Newton-Raphson-Algorithmus logo Assembler Fließkomma-Arithmetik 3/

137 Fließkomma-Arithmetik Newton-Raphson-Algorithmus Berechnung von z = 1/y mit y 0: z = 1 y = 1 m2 e = 1 m 2 e = g2 e Vorzeichen bleibt Exponent bzw. Charakteristik läßt sich leicht berechnen Berechnung von g = 1/m (0.5 m < 1) durch Iterationsverfahren nach Newton-Raphson: g0 = 1 (besserer Startwert über Tabellen möglich) gn+1 = g n (2 mg n ) Anhaltspunkt für die Genauigkeit: 4 Iterationen reichen für 64-Bit; je Iteration verdoppelt sich die Anzahl der gültigen Bits logo Assembler Fließkomma-Arithmetik 4/

138 Fließkomma-Arithmetik Taylor-Reihen Problem: wie berechnet man (mit einfachen Mitteln) z.b. sin x, e x,...? Idee: Taylor-Reihen (siehe z.b. Bronstein/Semendjajew): Ist f (x) im Intervall (x 0 α, x 0 + α) n + 1-mal differenzierbar, dann gilt für x (x 0 α, x 0 + α): f (x) = n ν=0 f ν (x 0 ) ν! (x x 0 ) ν + R n (x) R n (x): Rest; bei hinreichend großem n und hinreichend kleinem x wird R n (x) so klein, dass R n (x) bei der Berechnung ignoriert werden kann. logo Assembler Fließkomma-Arithmetik 5/

139 Fließkomma-Arithmetik Taylor-Reihen Beispiele: e x = 1 + x 1! + x 2 2! + x 3 3! + x 4 4! +... sin x = x x 3 3! + x 5 5! x 7 7! + x 9 9!... cos x = 1 x 2 2! + x 4 4! x 6 6! + x 8 8!... arcsin x = x + x x x logo Assembler Fließkomma-Arithmetik 6/

140 Fließkomma-Arithmetik Taylor-Reihen Verschiedene Tricks, um die Konvergenz (Genauigkeit des Ergebnisses bzw. Geschwindigkeit der Berechnung) der Algorithmen zu verbessern: e x = (e x/2 ) 2 ln(m2 n ) = ln(m) + n ln(2), ln(1 x) = (x + x x x mit 0.5 x < 1 sin x = sin(x mod 2π)... logo Assembler Fließkomma-Arithmetik 7/

141 Fließkomma-Arithmetik Horner-Schema Horner-Schema (((a n 1 x + a n 2 )x +...)x + a 1 )x + a 0 ist schneller und genauer als Taylor-Schema: a n 1 x n 1 + a n 2 x n a 1 x + a 0 logo Assembler Fließkomma-Arithmetik 8/

142 Assembler Fließkomma-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Fließkomma-Arithmetik 1/

143 Fließkomma-Arithmetik Intel/AMD/... Fließkomma-Einheit war früher selbständige Hardware-Einheit ( Fließkomma-Coprozessor i80x87). Seit i80486 mit im Haupt-Prozessor integriert. Daher andere Ansteuerung, eigener Satz von Registern,... Hier im Beispiel: nur Nutzung eines Registers (%st(0) Akku ) logo Assembler Fließkomma-Arithmetik 2/

144 Fließkomma-Arithmetik Beispiele double accu, tmp ; y = ( x z ) / ( z s i n ( x ) ) ; => accu = z ; accu = accu + z ; accu = accu + x ; y = accu ; accu = x ; accu = s i n ( accu ) ; accu = accu ; accu = accu + z ; tmp = accu ; accu = y ; accu = accu / tmp ; y = accu ; logo Assembler Fließkomma-Arithmetik 3/

145 Fließkomma-Arithmetik Beispiele double accu, tmp ; accu = z ; accu = accu + z ; accu = accu + x ; y = accu ; accu = x ; accu = s i n ( accu ) ; accu = accu ; accu = accu + z ; tmp = accu ; accu = y ; accu = accu / tmp ; y = accu ; => f l d l z f a d d l z f a d d l x f s t p l y f l d l x f s i n fchs f a d d l z f s t p l tmp f l d l y f d i v l tmp f s t p l y logo Assembler Fließkomma-Arithmetik 4/

146 Assembler Kontrollstrukturen Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Kontrollstrukturen 1/

147 Kontrollstrukturen Hochsprachen bieten i.a. eine Vielzahl verschiedener Konstrukte zur bedingten und wiederholten Ausführung von Anweisungen. Beispiele: i f (... ) {... } e l s e {... } switch (... ) { case... :... d e f a u l t :... } while (... ) {... } do {... } while (... ) ; f o r (... ;... ;... ) {... } goto... ; l a b e l : logo Assembler Kontrollstrukturen 2/

148 Kontrollstrukturen Vereinfachungen Komplexere Kontrollstrukturen lassen sich auf einfachere zurückführen. Beispiel: f o r ( i = 0 ; i < 1 6 ; i ++) { anw ( ) ; } erster Vereinfachungsschritt: i = 0 ; while ( i < 16) { anw ( ) ; i ++; } logo Assembler Kontrollstrukturen 3/

149 Kontrollstrukturen Vereinfachungen i = 0 ; while ( i < 16) { anw ( ) ; i ++; } nächste Vereinfachung: i = 0 ; goto t e s t ; l o o p : anw ( ) ; i ++; t e s t : i f ( i < 16) goto l o o p ; logo Assembler Kontrollstrukturen 4/

150 Kontrollstrukturen Vereinfachungen Allgemeine Umwandlungsregeln existieren. Beispiel: f o r (<A>; <B>; <C>) <D> erster Vereinfachungsschritt: <A> while (<B>) { <D> <C> } logo Assembler Kontrollstrukturen 5/

151 Kontrollstrukturen Vereinfachungen <A> while (<B>) { <D> <C> } näechste Vereinfachung: <A> goto t e s t ; l o o p : <D> <C> t e s t : i f (<B>) goto l o o p ; logo Assembler Kontrollstrukturen 6/

152 Kontrollstrukturen Vereinfachungen Wichtig: Es gibt für alle Programmiersprachen allgemeingültige Regeln, wie komplexe Kontrollstrukturen auf einfachere abzubilden sind! logo Assembler Kontrollstrukturen 7/

153 Kontrollstrukturen Vereinfachungen Komplizierte Bedingungen lassen sich vereinfachen. Beispiel: i f ( a > b && a!= 0) { anw ( ) ; } erster Vereinfachungsschritt: i f (! ( a > b ) ) goto end ; i f (! ( a!= 0 ) ) goto end ; anw ( ) ; end : ; logo Assembler Kontrollstrukturen 8/

154 Kontrollstrukturen Vereinfachungen i f (! ( a > b ) ) goto end ; i f (! ( a!= 0 ) ) goto end ; anw ( ) ; end : ; nächste Vereinfachung: i f ( a <= b ) goto end ; i f ( a == 0) goto end ; anw ( ) ; end : ; logo Assembler Kontrollstrukturen 9/

155 Kontrollstrukturen Vereinfachungen Allgemeine Regeln zur Vereinfachung von bedingten Sprüngen: i f (<a> && <b> &&... && <c>) goto <l a b e l > kann vereinfacht werden zu next : i f (! <a>) goto <next> i f (! <b>) goto <next>... i f (<c>) goto <l a b e l > Kurzschluss-Und logo Assembler Kontrollstrukturen 10/

156 Kontrollstrukturen Vereinfachungen Allgemeine Regeln zur Vereinfachung von bedingten Sprüngen: i f (<a> <b>... <c>) goto <l a b e l > kann vereinfacht werden zu i f (<a>) goto <l a b e l > i f (<b>) goto <l a b e l >... i f (<c>) goto <l a b e l > Kurzschluss-Oder logo Assembler Kontrollstrukturen 11/

157 Kontrollstrukturen Vereinfachungen Für die Terme <a>, <b> usw. gilt: hat der Term die Form x OP y mit OP {<, >, <=, >=, ==,! =,...}, so existiert dafür ein passender Assembler-Befehl hat der Term die Form!(x OP y) so läßt sich eine Vergleichoperation OP finden, sodaß gilt:!(x OP y) = x OP y hat der Term die Form!(x y... z) so kann der Term zu!x &&!y &&... &&!z vereinfacht werden (Regel von de Morgan) hat der Term die Form!(x && y &&... && z) so kann der Term zu!x!y...!z vereinfacht werden (Regel von de Morgan) logo Assembler Kontrollstrukturen 12/

158 Kontrollstrukturen Vereinfachungen Generelle Beobachtung: alle bedingten Ausführungen von Anweisungen sowie alle Schleifenkonstrukte lassen sich auf folgende zwei Anweisungs-Typen abbilden: goto label; if (a OP b) goto label; mit OP {<, >, =,! =, <=, >=,...} logo Assembler Kontrollstrukturen 13/

159 Kontrollstrukturen Sprünge Assembler-Code für unbedingte Sprünge: goto l a b e l ; => jmp l a b e l ; Assembler-Code für bedingte Sprünge: i f ( a OP b ) goto l a b e l ; => jop a, b, l a b e l logo Assembler Kontrollstrukturen 14/

160 Kontrollstrukturen bedingte Sprünge jop a, b, l a b e l jop erfordert drei Adressen (a, b, label). Diesen Befehl gibt es daher nur auf Drei-Adress-CPUs. Für Zwei- bzw. Ein-Adress-CPUs muss der Befehl aufgespalten werden: Zwei-Adress-CPU cmp a, b jop l a b e l Ein-Adress-CPU l d a a cmp b jop l a b e l Für die Zwischenspeicherung des Vergleichsergebnisses ist ein Register notwendig: Condition-Codes - oder Flags -Register (%eflags) logo Assembler Kontrollstrukturen 15/

161 Kontrollstrukturen bedingte Sprünge Beispiel: char a, b ; i f ( a < b ) goto l a b e l ; ergibt compiliert für i80x86: cmpb b, a j l l a b e l / jump i f l e s s / ergibt compiliert für m68x05: l d a b cmp a b l o l a b e l / branch i f l o w e r / logo Assembler Kontrollstrukturen 16/

162 Kontrollstrukturen bedingte Sprünge mögliche Bedingungen: i80x86 m68x05 = je beq!= jne bne >, >= unsigned ja, jae bhi, bhs <, <= unsigned jb, jbe blo, bls >, >= signed jg, jge bpl, - <, <= signed jl, jle bmi, -... logo Assembler Kontrollstrukturen 17/

163 Kontrollstrukturen Flags-Register Auch viele Arithmetik-Befehle setzen die Condition-Codes ( CC ) im Flags-Register; Beispiele: Zero-Flag: gesetzt, wenn Ergebnis 0 ist Negative-/Sign-Flag: gesetzt, wenn das höchstwertige Bit des Ergebnisses 1 ist Carry-Flag: bei Übertrag gesetzt logo Assembler Kontrollstrukturen 18/

164 Kontrollstrukturen Flags-Register Bedingte Sprünge nutzen die Condition-Codes (Beispiel i80x86): je (jump if equal) verzweigt, wenn Zero-Bit gesetzt ist jl (jump if less) verzweigt, wenn Negative-Bit gesetzt ist jle (jump if less or equal) verzweigt, wenn Zero- oder Negative-Bit gesetzt sind... cmp-befehl subtrahiert die zwei Operanden, setzt die CC-Bits entsprechend, speichert aber das Subtraktionsergebnis nicht. logo Assembler Kontrollstrukturen 19/

165 Kontrollstrukturen Hinweise Statt einer Adresse als Sprungziel wird häufig die Differenz zur Adresse der aktuellen (oder nächsten) Instruktion angegeben (meist eine kleinere Zahl); Beispiel: 0 8 : : j l e :... => 0 8 : : j l e :... logo Assembler Kontrollstrukturen 20/

166 Kontrollstrukturen Hinweise Vorteile: weniger Speicheraufwand schnellere Befehlsausführung unabhängig von der tatsächlichen Lage des Programms im Speicher ( Position-Independant-Code (PIC)) Nachteile: mühsamere Berechnung (wird meist vom Assembler/Linker übernommen) nicht alle Sprungziele erreichbar (lange Version zusätzlich notwendig) logo Assembler Kontrollstrukturen 21/

167 Assembler Kontrollstrukturen Beispiele Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 logo Assembler Kontrollstrukturen Beispiele 1/

168 Kontrollstrukturen Beispiele r e g i s t e r short i n t a ; / Reg. %bx / short i n t b ; / Adr. 124 / i f ( a < b && a!= 0) a = b ; e l s e b = a ; a = a + 1 ; vereinfacht:... i f (! ( a < b ) ) goto i f e l s e i f (! ( a!= 0 ) ) goto i f e l s e a = b ; goto i f e n d ; i f e l s e : b = a ; i f e n d : a = a + 1 ; logo Assembler Kontrollstrukturen Beispiele 2/

169 Kontrollstrukturen Beispiele i f (! ( a < b ) ) goto i f e l s e i f (! ( a!= 0 ) ) goto i f e l s e a = b ; goto i f e n d ; i f e l s e : b = a ; i f e n d : a = a + 1 ; weiter vereinfacht: i f ( a >= b ) goto i f e l s e i f ( a == 0) goto i f e l s e a = b ; goto i f e n d ; i f e l s e : b = a ; i f e n d : a = a + 1 ; logo Assembler Kontrollstrukturen Beispiele 3/

170 Kontrollstrukturen Beispiele i f ( a >= b ) goto i f e l s e i f ( a == 0) goto i f e l s e a = b ; goto i f e n d ; i f e l s e : b = a ; i f e n d : a = a + 1 ; compiliert: cmpw 124, %bx j g e i f e l s e cmpw $0, %bx j e i f e l s e movw 124, %bx jmp i f e n d i f e l s e : movw %bx, 124 i f e n d : addw $1, %bx logo Assembler Kontrollstrukturen Beispiele 4/

171 Kontrollstrukturen Beispiele do { <A> i f (<B>) continue ; <C> i f (<D>) break ; <E> } while (<F>); vereinfacht: l o o p : <A> i f (<B>) goto t e s t ; <C> i f (<D>) goto end ; <E> t e s t : i f (<F>) goto l o o p ; end : ; logo Assembler Kontrollstrukturen Beispiele 5/

172 Kontrollstrukturen Beispiele switch (<A>) { case <B>: case <C>: break ; case <D>: <E> d e f a u l t : <F> } tmp = <A>; i f ( tmp == <B>) goto caseb ; i f ( tmp == <C>) goto casec ; i f ( tmp == <D>) goto cased ; goto c a s e d e f a u l t ; caseb : ; casec : goto end ; cased : <E> c a s e d e f a u l t : <F> end : ; Assembler Kontrollstrukturen Beispiele 6/ logo

173 Assembler Unterprogramme Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Unterprogramme 1/

174 Unterprogramme Unterprogramme: Prozeduren und Funktionen Unterprogramme sind aus modernen Programmiersprachen nicht mehr wegzudenken Ideen hinter der Unterprogrammtechnik sollten auch im Assembler-Code erhalten bleiben: Need-to-Know : Aufrufer des Unterprogramms sollte nur die Parameter, Rückgabewerte und den Namen des Unterprogramms kennen müssen Need-to-Know : aufgerufene Funktion sollte kein Wissen über den Aufrufer besitzen müssen Hauptprogramm und Unterprogramm sollten getrennt schreibund übersetzbar sein jede Art direkter oder indirekter Rekursion muss möglich sein jede beliebige Schachtelungstiefe muss möglich sein (nur begrenzt durch Speichergröße) Assembler Unterprogramme 2/

175 Unterprogramme Aufruf eines Unterprogramms (1. Lösungsansatz):... / Hauptprogramm / jmp uprog u p r o g r e t :... uprog :... / Unterprogramm / jmp u p r o g r e t Assembler Unterprogramme 3/

176 Unterprogramme Das Unterprogramm selbst muss in diesem Falle mit jmp uprogret zum Hauptprogramm zurückspringen. Problematisch, wenn Unterprogramm von mehreren Stellen aus dem Hauptprogramm heraus aufgerufen wird. Man muss sich merken, von wo aus das Unterprogramm aufgerufen wurde bzw. wohin zurückgekehrt werden soll ( Rückkehradresse, Return-Address ). Assembler Unterprogramme 4/

177 Unterprogramme Aufruf eines Unterprogramms (2. Lösungsansatz):... / Hauptprogramm / movl $uprogret1, %eax jmp uprog u p r o g r e t 1 :... movl $uprogret2, %eax jmp uprog u p r o g r e t 2 :... uprog :... / Unterprogramm / jmp %eax Assembler Unterprogramme 5/

178 Unterprogramme Unterprogramm kehrt jetzt zum jeweiligen Aufrufort zurück. Dennoch problematisch: verschachtelte Unterprogrammaufrufe (z.b. Rekursion) nicht möglich (jedes Register kann nur maximal eine Rücksprungadresse speichern, Anzahl der Register beschränkt) Unterprogramm-Aufrufer muss wissen, in welchem Register das Unterprogramm die Rückkehradresse erwartet, oder aufgerufene Funktion muss wissen, in welchem Register die Rückkehradresse steht Assembler Unterprogramme 6/

179 Unterprogramme Aufruf eines Unterprogramms:... / Hauptprogramm / movl $uprogret1, (%esp)+ jmp uprog u p r o g r e t 1 :... movl $uprogret2, (%esp)+ jmp uprog u p r o g r e t 2 :... uprog :... / Unterprogramm / jmp (%esp ) Assembler Unterprogramme 7/

180 Unterprogramme Stack %esp ( Stack-Pointer ) muss zu Programmbeginn die Adresse eines genügend großen Speicherbereiches ( Stack ) enthalten. Funktioniert für beliebig verschachtelte Unterprogramme (auch Rekursion)! Assembler Unterprogramme 8/

181 Unterprogramme Stack Vier verschiedene Möglichkeiten für die Stack-Verwaltung: Stack wird von den kleinen Adressen hin zu den großen beschrieben (1) von den großen Adressen hin zu den kleinen beschrieben (2) Stack-Pointer zeigt auf das zuletzt abgelegte Datum (A) den nächsten freien Speicherplatz (B) Dementsprechend sind zu verwenden: push pop 1A mov..., +(%esp) mov (%esp)-,... 1B mov..., (%esp)+ mov -(%esp),... 2A mov..., -(%esp) mov (%esp)+,... 2B mov..., (%esp)- mov +(%esp),... Assembler Unterprogramme 9/

182 Unterprogramme Stack Hinweise: Stack des i80x86 und m68x05 wächst von den hohen Adressen hin zu den niedrigeren Stack-Pointer des i80x86 zeigt auf das zuletzt abgelegte Datum Stack-Pointer des m68x05 zeigt auf den nächsten freien Speicherplatz andere Schreibweise: r a : movl $ra, (%esp ) jmp uprog i80x86 m68x05 c a l l uprog j s r uprog jmp (%esp)+ r e t r t s Assembler Unterprogramme 10/

183 Unterprogramme Parameter/Return-Wert Verschiedene Möglichkeiten: Register: Speicher: Stack: Anzahl beschränkt nicht geeignet für rekursive Unterprogramme langsam nicht geeignet für rekursive Unterprogramme langsam => Übergabe der Parameter über den Stack, Return-Wert über Register (z.t. Mischformen) Assembler Unterprogramme 11/

184 Unterprogramme Parameter/Return-Wert Beispiel: Übergabe der Parameter und des Return-Wertes über Register:... x = sub ( y, z ) ;... i n t sub ( i n t a, i n t b ) { return a b ; } => => sub :... movl y, %eax movl z, %ebx c a l l sub movl %eax, x... s u b l %ebx, %eax r e t Assembler Unterprogramme 12/

185 Unterprogramme Parameter/Return-Wert Beispiel: Übergabe der Parameter auf dem Stack und des Return-Wertes über ein Register (hier: %eax):... x = sub ( y, z ) ;... i n t sub ( i n t a, i n t b ) { return a b ; } => => movl $..., %esp... movl z, (%esp ) movl y, (%esp ) c a l l sub a d d l $8, %esp movl %eax, x... sub : movl 4(%esp ), %eax s u b l 8(%esp ), %eax r e t Assembler Unterprogramme 13/

186 Unterprogramme Parameter/Return-Wert Übergabe der Parameter auf dem Stack und des Return-Wertes über ein Register (i80x86: %eax) ist Standard-Verfahren. Unterprogrammaufrufe sollten daher immer folgendes Format haben:... p u s h l <paramn>... p u s h l <param2> p u s h l <param1> c a l l <subprog> a d d l $..., %esp movl %eax, <r e s u l t >... Assembler Unterprogramme 14/

187 Unterprogramme Parameter Dass die Parameter im umgekehrter Reihenfolge auf den Stack gepusht werden, hat folgende Vorteile: <param1> liegt (unabhängig von der Anzahl der Parameter) immer an bekannter Adresse (4(%esp)). Dies ermöglicht Unterprogramm-Aufrufe mit variabler Anzahl von Parametern (z.b. C-Funktion printf). Da der Stack von hohen Adressen hin zu kleinen Adressen wächst, liegen die Parameter wie in einem Array vor. Assembler Unterprogramme 15/

188 Unterprogramme Lokale Variablen Viele Unterprogramme verwenden lokale (temporäre) Variablen. Speicherung dieser Variablen in Registern schneller Zugriff, kurze Befehle (einfache Adressierungsarten), wenige Register, keine Rekursion (direkt) möglich in festen Speicherzellen i.a. genügend Speicherkapazität, langsamer Zugriff, keine Rekursion (direkt) möglich, alter Wert beim widerholten Aufruf des Unterprogramms noch intakt auf dem Stack i.a. genügend Speicherkapazität, kurze Befehle (einfache Adressierungsarten), Rekursion direkt möglich, langsamer Zugriff => Mischformen aus allen Speicherarten Assembler Unterprogramme 16/

189 Unterprogramme Lokale Variablen Register-Variablen für die am häufigsten verwendeten Variablen (z.b. Schleifen-Zähler, temporäre Variablen bei der Ausdrucksberechnung) Variablen in festen Speicherzellen für Werte, die beim widerholten Aufruf des Unterprogramms erhalten sein müssen (static-werte) Variablen auf dem Stack für seltener verwendete Variablen für große Variablen (z.b. Records, Arrays) Zwischenspeicher für Register-Variablen (z.b. für Rekursion) Assembler Unterprogramme 17/

190 Unterprogramme Lokale Register-Variablen Vorsicht bei der Verwendung von Register-Variablen! Man darf in einem Unterprogramm die Register-Variablen-Werte des Hauptprogramms nicht überschreiben. Zwei Möglichkeiten: call-used: Hauptprogramm sichert Register-Werte vor Aufruf des Unterprogramms und restauriert Werte nach Rückkehr call-saved: Unterprogramm sichert Register-Werte zu Beginn der Unterprogrammausführung restauriert Werte vor Rücksprung Assembler Unterprogramme 18/

191 Unterprogramme Lokale Register-Variablen Call-Used (i80x86: %eax, %ecx, %edx):... p u s h l %r e g... c a l l uprog < uprog kann %r e g verwenden... p opl %r e g... Assembler Unterprogramme 19/

192 Unterprogramme Lokale Register-Variablen Call-Saved (i80x86: %ebx, %ebp, %edi, %esi): p u s h l %r e g... < h i e r kann %r e g verwendet werden p opl %r e g r e t Assembler Unterprogramme 20/

193 Unterprogramme Stack-Variablen Benutzung von Variablen auf dem Stack (vorausgesetzt, %esp zeigt auf das Ende eines freien Speicherbereiches): Reservieren von Speicherplatz: s u b l $<nbytes >, %esp Nutzung der Variablen (Beispiele): movl 4(%esp ), %eax movb %bl, 8(%esp ) addw $4, 6(%esp )... Freigeben des Speicherbereiches: a d d l $<nbytes >, %esp Assembler Unterprogramme 21/

194 Unterprogramme Stack-Variablen Beispiel (i80x86): void proc ( void ) { long i n t a ; short i n t b ; } a =... ; b =... ;... => proc : s u b l $6, %esp movl..., 0(%esp ) movw..., 4(%esp )... a d d l $6, %esp r e t Assembler Unterprogramme 22/

195 Unterprogramme Stack-Frame Jedes Unterprogramm kann Aufruf-Parameter bekommen verfügt über eine Rückkehr-Adresse benutzt u.u. lokale Stack-Variablen verwendet ggf. Stack für neue Unterprogramm-Aufrufe Dieser Bereich des Stacks wird als Stack-Frame des Unterprogramms bezeichnet. Assembler Unterprogramme 23/

196 Unterprogramme Stack-Frame void A( i n t x, i n t y ) { long i n t z ; char c ;... B( z, c ) ; } Assembler Unterprogramme 24/

197 Unterprogramme Frame-Pointer Problem: relative Adressen (bzgl. %esp) der lokalen Stack-Variablen ändert sich bei jeder Ausführung eines push- bzw. pop-befehls. long i n t x ;... proc ( x, x ) ; ergibt compiliert: s u b l $4, %esp... p u s h l 0(%esp ) p u s h l 4(%esp ) // r e l. Adr. mit p u s h l m o d i f i z i e r t! c a l l proc a d d l $8, %esp... => Zugriff auf Stack-Variablen / Parameter sehr mühsam und Assembler Unterprogramme 25/ fehleranfällig!

198 Unterprogramme Frame-Pointer Extra-Register (Frame-Pointer; i80x86: %ebp) enthält Adresse für Stack-Variablen- und Parameter-Zugriff: Beispiel ergibt compiliert: p u s h l %ebp \ movl %esp, %ebp enter $4 s u b l $4, %esp /... p u s h l 4(%ebp ) p u s h l 4(%ebp ) // p u s h l a e n d e r t %ebp n i c h t! c a l l proc a d d l $8, %esp... movl %ebp, %esp \ p opl %ebp / leave r e t Assembler Unterprogramme 26/

199 Unterprogramme Frame-Pointer Stack-Frames mit Frame-Pointern: Durch Verfolgung der Frame-Pointer kann die gesamte Aufruf-Hierarchie der Unterprogramme verfolgt werden (Debugger). Assembler Unterprogramme 27/

200 Unterprogramme ABI ABI: Application Binary Interface Interface-Definition beschreibt: Namenskonvention Übergabeverfahren für Parameter Übergabeverfahren für Return-Werte Nutzung der Register ggf. Fehlerbehandlung ABI wird sinnvollerweise vom CPU-Hersteller definiert. Compiler-Hersteller sollten sich daran halten. Sonst sind von verschiedenen Compilern übersetzte Programmteile (z.b. Libraries) zueinander inkompatibel. Assembler Unterprogramme 28/

201 Unterprogramme ABI Namen Unterprogramm-Namen einfach für Sprachen wie z.b. C oder Pascal: Unterprogramm-Name im Assembler-Code entspricht dem Namen in der Hochsprache. Schwieriger bei überladenen Unterprogrammen. Dann existieren mehrere gleiche Hochsprachen-Unterprogramm-Namen. Lösung: Parameter- und Return-Typen in den Namen hineinkodieren. Beispiele: i n t f ( i n t x ) ; void f ( unsigned long x ) ; i n t _ f _ i n t : void_f_unsigned_long : Um Mehrdeutigkeiten (z.b. void f(unsigned long x); und void f(unsigned x, long y);) zu umgehen, ggf. noch aufwändiger. Assembler Unterprogramme 29/

202 Unterprogramme ABI Namen Um Kollisionen von vom Compiler vergebenen Namen (z.b. für Labels oder temporäre Variablen) und vom Programmierer vergebenen Namen zu vermeiden, wird ein _ vor die Hochsprachen-Namen oder zwei _ oder ein. vor die vom Compiler vergebenen Namen gesetzt. gcc: Hochsprachen-Namen bleiben erhalten, gcc nutzt. als Namensprefix für temporäre Namen/Labels. Assembler Unterprogramme 30/

203 Unterprogramme ABI Parameter/Return-Wert Standardmässig übergibt i386-gcc Parameter über den Stack. Parameter werden in Pascal: normaler C/C++: umgekehrter Java: undefinierter Reihenfolge auf dem Stack abgelegt. Return-Werte werden erwartet der i386-gcc in %eax: char-, short-, int-, long-werte und Adressen %edx/%eax: long-long-werte %st(0): float-, double, long-double-werte Strukturen und Arrays können standardmässig nicht übergeben werden! Assembler Unterprogramme 31/

204 Unterprogramme ABI Register ABI regelt für jedes Register, ob aufrufendes Unterprogramm oder aufgerufenes Unterprogramm benutztes Register sichern muss ( caller-saved-regs, callee-saved-regs ). Assembler Unterprogramme 32/

205 Unterprogramme ABI Register i386-standard: Aufrufendes Unterprogramm muss %eax, %ecx und %edx sichern, bevor es weiteres Unterprogramm aufruft. Nach dem Aufruf muss es die Werte wiederherstellen. aufgerufenes Unterprogramm muss %ebx, %edi und %esi sichern, bevor es sie verändert. Vor dem Rücksprung zum Aufrufer müssen Werte restauriert werden. %esp und %ebp werden als Stack-Pointer bzw. Frame-Pointer verwendet. (Natürlich nur, wenn die Register vom Unterprogramm verwendet werden.) Assembler Unterprogramme 33/

206 Unterprogramme ABI Register Beispiel: func : p u s h l %ebx // %ebx muss g e s i c h e r t werden p u s h l %edi // %edi muss g e s i c h e r t werden p u s h l %e s i // %e s i muss g e s i c h e r t werden... p u s h l %eax // %eax muss g e s i c h e r t werden p u s h l %ecx // %ecx muss g e s i c h e r t werden p u s h l %edx // %edx muss g e s i c h e r t werden c a l l... p opl %edx // %edx w i e d e r h e r s t e l l e n p opl %ecx // %ecx w i e d e r h e r s t e l l e n p opl %eax // %eax w i e d e r h e r s t e l l e n... p opl %e s i // %e s i w i e d e r h e r s t e l l e n p opl %edi // %edi w i e d e r h e r s t e l l e n p opl %ebx Assembler // %ebx Unterprogramme w i e34/43 d e r h e r s t e l l e n r e t

207 Unterprogramme Verschachtelte Unterprogramme Z.B. Pascal oder C-Erweiterungen erlauben verschachtelte Unterprogramme. Beispiel: i n t main ( ) { i n t y ; i n t f ( i n t x ) { return x y ; } y =... ; } return f ( 4 ) ; Assembler Unterprogramme 35/

208 Unterprogramme Verschachtelte Unterprogramme Verschachtelte Unterprogramme haben jeweils Zugriff auf ihre Parameter, ihre lokalen Variablen, die Parameter ihrer übergeordneten Unterprogramm(e), die lokalen Variablen ihrer übergeordneten Unterprogramm(e), globale Variablen. Assembler Unterprogramme 36/

209 Unterprogramme Verschachtelte Unterprogramme Lösung: Als Parameter werden solchen Unterprogrammen Adressen von Stack-Frames höherer Unterprogramme mitgegeben. Über diese Adressen können sie dann auf die Variablen/Parameter ihrer übergeordneten Unterprogramme zugreifen. Das funktioniert ggf. auch rekursiv und/oder mehrstufig. Assembler Unterprogramme 37/

210 Unterprogramme Fehlerbehandlung i n t proc ( ) { i n t e r r o r ; } f o r (... ;... ;... ) { e r r o r = func1 (... ) ; i f ( e r r o r ) return e r r o r ; e r r o r = func2 (... ) ; i f ( e r r o r ) return e r r o r ;... } return 0 ; Probleme: fehleranfällig zu programmieren zeitraubende if-abfragen für (hoffentlich) nie auftretende Fälle Assembler Unterprogramme 38/

211 Unterprogramme Fehlerbehandlung Übersichtlicher, schneller, kürzer (Java): void proc ( ) throws E r r o r { t r y { f o r (... ;... ;... ) { func1 (... ) ; func2 (... ) ; } } c atch ( E r r o r e r r o r ) { throw e r r o r ; } } Assembler Unterprogramme 39/

212 Unterprogramme Fehlerbehandlung e r r o r _ i p :. l o n g 0 e r r o r _ s p :. l o n g 0 proc :. g l o b l proc p u s h l e r r o r _ i p p u s h l e r r o r _ s p movl $catch, e r r o r _ i p movl %esp, e r r o r _ s p... // Try Part movl $0, %eax // No E r r o r catch : p opl e r r o r _ s p p opl e r r o r _ i p cmpl $0, %eax j e no_err movl e r r o r _ s p, %esp // throw e r r o r p u s h l e r r o r _ i p no_err : r e t Assembler Unterprogramme 40/

213 Unterprogramme Fehlerbehandlung Übersichtlicher(?), schneller, kürzer (C, C++): jmpbuf s t a t e ; void proc ( ) { jmpbuf o l d s t a t e = s t a t e ; i n t e r r o r ; } e r r o r = setjmp ( s t a t e ) ; i f ( e r r o r == 0) { f o r (... ;... ;... ) { func1 (... ) ; func2 (... ) ; } } e l s e { s t a t e = o l d s t a t e ; longjmp ( s t a t e, e r r o r ) ; } Assembler Unterprogramme 41/

214 Unterprogramme Fehlerbehandlung setjmp :. g l o b l setjmp movl 4(%esp ), %edx // A d r e s s e von " s t a t e " movl (%esp ), %eax // Return A d r e s s e movl %eax, (%edx ) l e a 4(%esp ), %eax // Stack P o i n t e r movl %eax, 4(%edx ) movl $0, %eax r e t // No E r r o r longjmp :. g l o b l longjmp movl 8(%esp ), %eax // E r r o r movl 4(%esp ), %edx // A d r e s s e von " s t a t e " movl 4(%edx ), %esp // Stack P o i n t e r p u s h l (%edx ) // Return A d r e s s e r e t Assembler Unterprogramme 42/

215 Unterprogramme Fehlerbehandlung Eigenschaften setjmp/longjmp: keine echten Unterprogramme Unterprogramme mit unvorhersehbarem Kontrollfluss wiederhergestellt werden nur %eip, %esp (und ggf. %ebp) Register-Variablen nicht wiederherstellbar Stack-Variablen behalten aktuellen Wert Assembler Unterprogramme 43/

216 Assembler Unterprogramme Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Unterprogramme 1/

217 Unterprogramme Beispiele Ein Aufruf eines Unterprogramms kann i.a. in folgender Art und Weise durchgeführt werden:... p u s h l <paramn 1>... p u s h l <param1>... p u s h l <param0> c a l l <uprog> a d d l $N 4, %esp movl %eax, <r e s >... Assembler Unterprogramme 2/

218 Unterprogramme Beispiele Hinweis (i80x86): Um das Alignment für Stack-Zugriffe zuzusichern (z.b. sollten die 4-Byte großen Rückkehradressen an durch 4 teilbaren Adressen liegen) werden i.a. immer 4-Byte-Werte als Parameter übergeben. Beispiel: movb $ A, %a l p u s h l %eax c a l l output a d d l $4, %esp Assembler Unterprogramme 3/

219 Unterprogramme Beispiele Ein Unterprogramm sollte i.a. die folgende Form haben (Version ohne Frame-Pointer): <uprog >: p u s h l %r e g / S i c h e r u n g b e n u t z t e Reg V a r.... s u b l $M 4, %esp / M e i n f a c h e l o k a l e V a r i a b l e n / e i g e n t l i c h e r Code /... a d d l $M 4, %esp... p opl %r e g / R e s t. b e n u t z t e Reg V a r. / r e t Assembler Unterprogramme 4/

220 Unterprogramme Beispiele Ein Unterprogramm sollte i.a. die folgende Form haben (Version mit Frame-Pointer): <uprog >: p u s h l %ebp movl %esp, %ebp s u b l $M 4, %esp / M e i n f a c h e l o k a l e V a r i a b l e n... p u s h l %r e g / S i c h e r u n g b e n u t z t e Reg V a r / e i g e n t l i c h e r Code /... p opl %r e g / R e s t. b e n u t z t e Reg V a r. /... movl %ebp, %esp p opl %ebp r e t Assembler Unterprogramme 5/

221 Unterprogramme Beispiele Manche Compiler beachten Cache-Alignment auf dem Stack. D.h. das alle gemeinsam benötigten Werte (z.b. Parameter und Return-Adresse eines Unterprogrammaufrufs) in einer gemeinsamen Cache-Zeile liegen sollten. Ist eine Cache-Zeile z.b. 2 N Bytes groß, sollte die Rückkehr-Adresse an einer durch 2 N teilbaren Adresse liegen. Für die i80x86-reihe ist N häufig 4. Assembler Unterprogramme 6/

222 Unterprogramme Beispiele In der ersten Funktion eines Programmes (z.b. main) wird daher dafür gesorgt, dass der Stack-Pointer zunächst auf die nächstkleinere, durch 16 teilbare Zahl abgerundet wird: main : movl %esp, %ebp a n d l $ 0 x f f f f f f f 0, %esp... movl %ebp, %esp r e t Assembler Unterprogramme 7/

223 Unterprogramme Beispiele In allen normalen Unterprogrammen wird dann dafür gesorgt, dass der jeweilige Stack-Pointer immer ein Vielfaches von 16 erniedrigt/erhöht wird. Daher findet sich häufig z.b. folgender Code: s u b l $12, %esp... movl <param2 >, 8(%esp ) movl <param1 >, 4(%esp ) movl <param0 >, (%esp ) c a l l <uprog>... a d d l $12, %esp Assembler Unterprogramme 8/

224 Unterprogramme Beispiele unsigned mean ( unsigned count, unsigned p0,... ) { unsigned p ; unsigned sum ; unsigned i ; } p = &p0 ; sum = 0 ; f o r ( i = 0 ; i < count ; i ++) { sum += p [ i ] ; } return sum / count ; m = mean ( 3, 10, 4, 1 6 ) ; Assembler Unterprogramme 9/

225 Unterprogramme Beispiele mean : movl 4(%esp ), %ebx l e a l 8(%esp ), %edx x o r l %eax, %eax x o r l %ecx, %ecx jmp.l2.l1 : a d d l (%edx,%ecx, 4 ), %eax i n c l %ecx.l2 : cmpl %ebx, %ecx jb.l1 x o r l %edx, %edx d i v l %ebx r e t Assembler Unterprogramme 10/

226 Assembler Interrupts Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Interrupts 1/

227 Interrupts In vielen Fällen möchte man ein Unterprogramm aufrufen, wenn ein bestimmtes Ereignis aufgetreten ist. Polling while ( 1 ) { i f ( e v e n t ( ) ) { handle_event ( ) ; } e l s e { do_normal_work ( ) ; } } kostet Rechenzeit hat u.u. lange Reaktionszeit umständlich zu programmieren (besonders in Multi-User-Systemen!) => Interrupts Assembler Interrupts 2/

228 Interrupts Aufruf eines handle_event -Unterprogramms automatisch durch die CPU bei Signalisierung eines event -Ereignisses. Über Tabelle einstellbar welche Ereignisse ( Interrupts ) welche Unterprogramme ( Interrupt-Handler ) anstoßen sollen. Assembler Interrupts 3/

229 Interrupts Beispiele: lfd. Nr Event Unterprogramm 0 Taste gedrückt Tastatur-Leseprozedur 1 Netzwerk-Paket angekommen Ethernet-Leseprozedur 2 Hardware-Uhr getickt Uhrzeit-Leseprozedur die Interrupts werden durch Zahlen kodiert (Tabellenindex) Adressen der Interrupt-Handler ( Interrupt-Vektoren ) werden in der Tabelle gespeichert Tabelle liegt an festgelegter Stelle im Hauptspeicher (z.b. ab Adresse 0) Assembler Interrupts 4/

230 Interrupts Interrupts-Handler sind normale Unterprogramme ohne Parameter ohne Rückgabewert. Sie dürfen Register nicht verändern (sonst stören sie u.u. den Ablauf des unterbrochenen Hauptprogramms). Daher speichern Interrupt-Handler meist Register zu Beginn auf dem Stack und restaurieren sie vor der Rückkehr zum normalen Programmablauf. Assembler Interrupts 5/

231 Interrupts CPUs sichern/restaurieren einige/alle Register automatisch => iret-befehl (statt ret; i80x86) bzw. rti (statt rts; m68x05). i80x86 sichert/restauriert Instruction-Pointer, Condition-Code-Register m68x05 sichert/restauriert Instruction-Pointer, Condition-Code-Register, Index-Register, Akku Assembler Interrupts 6/

232 Interrupts Beispiel (i80x86): / I n t. Handler T a b e l l e / 0 x : 0 x x : 0 x0834bc00 0 x : 0 x0834af12 / Adr. der I n t. Handler / 0 x c : 0 x0835abdd... 0 x0834af12 : / I n t. Handler f. I n t 2 / p u s h l %eax... p opl %eax i r e t CPU sichert/restauriert %eip und %eflags => Condition-Codes dürfen modifiziert werden Interrupt-Handler sichert/restauriert %eax => %eax darf verwendet werden Assembler Interrupts 7/

233 Interrupt-Masken In einigen Programm-Bereichen ist es nicht erwünscht, dass das Hauptprogramm durch Interrupts unterbrochen wird: zeitkritische Bereiche (Unterbrechungen aus Zeitgründen grundsätzlich unerwünscht) Beispiel: Einlesen von Messwerten zu bestimmten Zeitpunkten Nebenläufigkeits-kritische Bereiche (während das Hauptprogramm einen kritischen Abschnitt durchläuft, darf ein Interrupt-Handler nicht einen bestimmten anderen kritischen Abschnitt durchlaufen) Beispiel: Hauptprogramm liest Tastatur-Puffer aus, Interrupt-Handler will neue Zeichen in Puffer eintragen => Möglichkeit nötig, Interrupts zeitweilig zu verbieten ( maskieren ) bzw. wieder zuzulassen Assembler Interrupts 8/

234 Interrupt-Masken Interrupts sperren und freigeben geschieht z.b. über Interrupt-Controller : jeder Interrupt kann einzeln freigegeben oder gesperrt werden Interrupt-Enable/Disable-Bit in der CPU: alle Interrupts werden gemeinsam freigegeben oder gesperrt i80x86: sti, cli m68x05: cli, sei Interrupt-Priorität in der CPU: Interrupts unter einer bestimmten Priorität werden gesperrt; alle höheren sind erlaubt Kombinationen sind möglich (z.b. IBM-PC: Interrupt-Controller und Interrupt-Enable-Bit) Assembler Interrupts 9/

235 Interrupt-Masken Da das Sperren von Interrupts u.u. den ganzen Rechner lahmlegen kann (z.b. funktioniert kein <Ctrl-C> mehr), sind die cli/sti-befehle nur im Supervisor-Mode des Rechners erlaubt. => cli/sti sind daher nicht in normalen Programmen verwendbar. Assembler Interrupts 10/

236 Interrupts Kritische Abschnitte Der typische Aufbau von eines kritischen Abschnitts sieht damit häufig wie folgt aus: c l i / Beginn des k r i t. A b s c h n i t t s /... s t i / Ende des k r i t. A b s c h n i t t s / Assembler Interrupts 11/

237 Interrupts Kritische Abschnitte Kommen kritische Abschnitte verschachtelt vor, findet man häufig folgenden Code: p u s h f l c l i / Beginn des k r i t. A b s c h n i t t s /... p o p f l / Ende des k r i t. A b s c h n i t t s / Das Interrupt-Enable/Disable-Bit ist ein Bit des %eflags-registers. Assembler Interrupts 12/

238 Exceptions Während ein Programm läuft, können Fehler auftreten. Zum Beispiel: Division by Zero Error : Programm versucht, durch Null zu teilen Page Fault : Programm versucht, auf nicht vorhandene Speicherzellen zuzugreifen Invalid Opcode : Programm versucht, unbekannten Befehl auszuführen Alignment Fault : Speicherzugriff mit fehlerhaftem Alignment Overflow : bei Addition o.ä. ist Überlauf aufgetreten Protection Fault : Programm versucht im User-Mode priviligierten Befehl auszuführen...:... Assembler Interrupts 13/

239 Exceptions Fehler können durch Überprüfungen vor Ausführung von Instruktionen (zum Teil) abgefangen werden. Zum Beispiel: vor dem Divisionsbefehl Divisor auf Null überprüfen vor dem Speicherzugriff die Adresse überprüfen... Das ist jedoch fehleranfällig mühsam zeitaufwändig und im Fehlerfall muss die CPU (irgendwie) definiert weitermachen können. Assembler Interrupts 14/

240 Exceptions CPU kann die Operanden während der normalen Programmausführung testen und ggf. eine Ausnahmebehandlung durchführen. Über Tabelle einstellbar welche Ausnahmen ( Exceptions ) welche Unterprogramme ( Exception-Handler ) anstoßen sollen. Assembler Interrupts 15/

241 Exceptions Beispiele: lfd. Nr Exception Unterprogramm 0 Division durch Null Meldung an User 1 Additions-Überlauf Register auf Maximum setzen 2 Speicher antwortet nicht Speichertest durchführen die Exceptions werden durch Zahlen kodiert (Tabellenindex) Adressen der Exception-Handler ( Exception-Vektoren ) werden in der Tabelle gespeichert Tabelle liegt an festgelegter Stelle im Hauptspeicher (meist gemeinsame Tabelle mit Interrupts) Assembler Interrupts 16/

242 Exceptions Exception-Handler sind normale Unterprogramme z.t. mit Parametern ohne Rückgabewerte (aber meist mit Nebeneffekten) Sie dürfen Register- und Speicherwerte verändern (der normale Ablauf des Programms ist sowieso gestört), um den weiteren Ablauf des Programms zu ermöglichen. Assembler Interrupts 17/

243 Exceptions Beispiel... / Hauptprogramm / movl %esp, e r r o r s p c a l l t e s t e r r o r :... t e s t : / Test Unterprogramm /... movl $0, %eax r e t e x c e p t i o n : / Exception Handler / movl $1, %eax movl e r r o r s p, %esp jmp e r r o r Assembler Interrupts 18/

244 System-Calls Prinzipiell könnte man Systemaufrufe durch call system o.ä. realisieren. Notwendig dazu wäre eine bekannte und feste Adresse der system-funktion. Problematisch, da sich die Adresse einer Funktion i.a. beim Ändern anderer Funktionen/Daten (z.b. Updates/Bug-Fixes) des Programms mit ändert. Anderer Ansatz: man provoziert eine Ausnahme. Der Exception-Handler (Teil des Betriebssystems) ruft dann die eigentliche Systemfunktion auf. Dafür existieren bei den meisten (größeren) CPUs Extra-Befehle: i80x86: int $... m680x0: trap #... m68x05: swi Assembler Interrupts 19/

245 System-Calls Beispiele Linux: BIOS: movl $<func >, %eax movl <param0 >, %ebx movl <param1 >, %ecx... i n t $0x80... movw <param0 >, %ax movw <param1 >, %bx... i n t $<func>... Assembler Interrupts 20/

246 Assembler Interrupts Beispiele Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Interrupts Beispiele 1/

247 System-Calls Beispiele Das write-unterprogramm unter Linux sieht vereinfacht so aus: extern i n t w r i t e ( i n t fd, char buf, i n t b u f s i z e ) ; w r i t e :. g l o b l w r i t e movl $4, %eax movl 4(%esp ), %ebx movl 8(%esp ), %ecx movl 12(%esp ), %edx i n t $0x80 cmpl $0, %eax jge write_ok n e g l %eax movl %eax, e r r n o movl $ 1, %eax write_ok : r e t Assembler Interrupts Beispiele 2/

248 System-Calls Beispiele Der Linux-System-Call-Handler sieht vereinfacht so aus: func :. l o n g 0, s y s _ e x i t, s y s _ f o r k, s y s _read. l o n g s y s _ w r i t e,... s y s c a l l :... p u s h l %edx p u s h l %ecx p u s h l %ebx movl func (, %eax, 4 ), %eax c a l l %eax p opl %ebx p opl %ecx p opl %edx... i r e t Assembler Interrupts Beispiele 3/

249 Assembler I/O Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler I/O 1/

250 I/O I/O-Adressen sind Teil des normalen Adress-Raumes: normale mov- bzw. load/store-befehle lesen/schreiben Controller-Register statt Hauptspeicher oder Teil eines speziellen I/O-Bereiches: spezielle Befehle (i80x86: inb, inw, inl, outb, outw, outl) lesen/schreiben Controller-Register Welche Technik verwendet wird, ist Prozessor-abhängig (m68x05 z.b. kennt keine in/out-befehle) Motherboard-abhängig (CPU sieht nicht, was sich hinter Hauptspeicher-Adressen verbirgt) Für den Programmierer kein echter Unterschied! Assembler I/O 2/

251 Assembler Kodierung Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Kodierung 1/

252 Kodierung Zu kodieren ist der auszuführende Befehl (z.b. add, jmp, mov,...) eventuell der/die Parameter die Adressierungsart(en) (z.b. immediate Op., Register, Memory, Register indirect,...) eventuell Register-Nummer(n) eventuell Adresse(n) eventuell Displacement(s) eventuell Scale-Faktor(en) eventuell Konstant(en) Assembler Kodierung 2/

253 Kodierung Disassembler Beispiel (i80x86): Welcher Befehl ist hier kodiert ( Disassemblierung )? 8b 7b d f c... Untersuchung der einzelnen Bit-Gruppen (Info: Prozessor-Handbuch): => " movl " ( Z i e l : Reg. ) xx111xxx => Z i e l r e g. 7 (%edi ) xxxxxx => Reg. i n d. m. D i s p l xxxxx => Base Reg. 3 (%ebx ) => D i s p l. : 8 => 8b 7b 08 <=> movl 8(%ebx ), %e d i 89 7d fc... beginnt neuen Befehl Assembler Kodierung 3/

254 Kodierung Assembler Beispiel (m68x05): Wie kodiert man ( Assemblierung )? LDA 1235 Info: Prozessor-Handbuch: "LDA" ( D i r e c t Address ) => xxxxxxxx xxxxxxxx A d r e s s e 1235 (= 0 x4d3 ) => xxxxxxxx => LDA 1235 <=> c e 0 e d3 Assembler Kodierung 4/

255 Assembler - Hochsprache - Instruction Set Architecture Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler - Hochsprache - Instruction Set Architecture 1/

256 Instruction Set Architecture Instruction Set Architecture: Schnittstelle Software-Hardware: Assembler - Hochsprache - Instruction Set Architecture 2/

257 Instruction Set Architecture Instruction Set Architecture sind die Eigenschaften eines Computer-Systems, die vom Programmierer/Compiler aus sichtbar sind. Dazu gehört z.b. konzeptionelle Struktur funktionale Verhalten... nicht dazu gehört z.b. Organisation des Datenflusses das elektronische Design die physikalische Implementierung... Assembler - Hochsprache - Instruction Set Architecture 3/

258 Instruction Set Architecture Die allgemeine Programmierer-Sicht eines Computers: Datentypen: Wie werden Daten und Datenstrukturen representiert? Speicher: Wo können Daten gespeichert werden? Adr.-Arten: Wie kann auf die Daten zugegriffen werden? Befehle: Welche Operationen können auf den Daten ausgeführt werden? Codierung: Wie sind die Instruktionen kodiert? Register: Organisation der Register... Assembler - Hochsprache - Instruction Set Architecture 4/

259 Instruction Set Architecture Adressierungsarten Assembler - Hochsprache - Instruction Set Architecture 5/

260 Instruction Set Architecture - CISC / RISC CISC: Complex Instruction Set Computing viele Befehle viele Adressierungsarten uneinheitliche Befehlskodierung wenige Register RISC: Reduced Instruction Set Computing wenige Befehle wenige Adressierungsarten (z.b. nur Imm. Op., Reg., Reg.-indirekt) nur Load-/Store-Befehle greifen auf Speicher zu alle Befehle gleiche Code-Länge (z.b. 32 Bit) viele Register Assembler - Hochsprache - Instruction Set Architecture 6/

261 Hardware - Einleitung Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Hardware - Einleitung 1/

262 Assembler-Code / Mikroprogramm Teil 2: Assembler-Code Mikroprogramm Hardware - Einleitung 2/

263 Hardware Einleitung Bisher: Aufbau von Datenstrukturen im Speicher Aufbau von Assembler-Programmen im Speicher => leblose Daten / lebloser Code Im Folgenden: CPU liest / schreibt Datenstrukturen im Speicher CPU führt Programm-Code aus => lebendige Daten Wie funktioniert ein Rechner?!? Hardware - Einleitung 3/

264 Hardware Einleitung viele Beispiele schematisch, vereinfacht aus Informatiker-Sicht wirkliche Implementierung weicht ab aus Performance-Gründen aus technischen Gründen Ziel hier: möglichst einfache, verständliche Darstellung Prinzip soll verstanden werden nicht Details sondern Zusammenhänge wichtig Hardware - Einleitung 4/

265 Übersicht Hardware - Einleitung 5/

266 Hardware Bus Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Hardware Bus 1/

267 Bus Zu übermitteln sind Adressen CPU -> ROM/RAM und I/O Daten beim Speicher-Lesen ROM/RAM -> CPU beim Speicher-Schreiben CPU -> (ROM/)RAM beim I/O-Lesen I/O -> CPU beim I/O-Schreiben CPU -> I/O Steuerinfos Lesen/Schreiben CPU -> (ROM/)RAM und I/O RAM/ROM- oder I/O CPU -> ROM/RAM und I/O Start eines Zugriffs CPU -> ROM/RAM und I/O Hardware Bus 2/

268 Bus Verschiedene Möglichkeiten, Steuerinformationen zu kodieren. Zum Beispiel: Bus mit vier Steuer-Signalen: MR: Memory-Read MW: Memory-Write IOR: I/O-Read IOW: I/O-Write mit folgender Bedeutung: MR MW IOR IOW kein Zugriff Speicher-Read Speicher-Write I/O-Read I/O-Write alle anderen Kombinationen der Steuerleitungen sind unzulässig Hardware Bus 3/

269 Bus Beispiel CPU liest von Adresse aus dem Speicher (z.b.: movb 0x6a, %al). Folgende Schritte laufen ab: Adresse Daten MR MW IOR IOW Ausgangszustand Adresse auf Bus Zugriff starten Speicher antwortet Zugriff beenden Speicher beendet Z Die Änderung des MR-Signals startet/beendet den Zugriff! Hardware Bus 4/

270 Bus Beispiel CPU schreibt an I/O-Adresse den Wert (z.b. outb $0xd7, 0x6a). Folgende Schritte laufen ab: Adresse Daten MR MW IOR IOW Ausgangszustand Adr. u. Daten auf Bu Zugriff starten I/O-Reg. übernimmt Zugriff beenden Die Änderung des IOW-Signals startet/beendet den Zugriff! Hardware Bus 5/

271 Hardware I/O / Speicher Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Hardware I/O / Speicher 1/

272 I/O (Input) Aufbau eines I/O-Input-Registers (schematisch): Hardware I/O / Speicher 2/

273 I/O (Output) Aufbau eines I/O-Output-Registers (schematisch): Hardware I/O / Speicher 3/

274 Chip-Select Wenn mehrere I/O-Register in einem Chip enthalten sind, kann der Adressvergleicher verkleinert werden: CS: Chip-Select-Signal ; schattierter Bereich ist der generelle Aufbau von Standard-I/O-Chips Hardware I/O / Speicher 4/

275 Speicher (ROM) Aufbau einer ROM-Speicherzelle (schematisch) (vergleiche I/O-Input): Hardware I/O / Speicher 5/

276 Speicher (RAM) Aufbau einer RAM-Speicherzelle (schematisch) (vergleiche I/O-Input + I/O-Output): Hardware I/O / Speicher 6/

277 Speicher Speicher ist organisiert in Einheiten ( Speicher-Worte ) zu je D-Bits typisch: 8-, 16-, 32- oder 64-Bits typische Benennungen: 8 Bits : 1 Byte 16 Bits : 1 Word 32 Bits : 1 Long Word / 1 Double Word 64 Bits : 1 Long Long Word / 1 Quad Word Interpretation der Bits im Speicher Programm-abhängig! Hardware I/O / Speicher 7/

278 Speicher Beziehungen zwischen Adressbus-Breite (A Bit), Maschinenwort/Datenbus-Breite (D Bit), Speichergröße (S): Speichergröße (maximal): S = 2 A D Bit (oder S = 2A D 8 Byte) Hinweise: Anzahl der adressierbaren Maschinenworte: 2 A Anzahl der Bits pro Byte: 8 Hardware I/O / Speicher 8/

279 Speicher Name Symbol Quantity Name Symbol Quantity kilobyte kb 2 10 (10 3 ) kibibyte KiB 2 10 megabyte MB 2 20 (10 6 ) mebibyte MiB 2 20 gigabyte GB 2 30 (10 9 ) gibibyte GiB 2 30 terabyte TB 2 40 (10 12 ) tebibyte TiB 2 40 Typische aktuelle Speichergrößen: Embedded Systems: 64 Byte Workstation: 4 GByte Mainframe: 64 GByte Hardware I/O / Speicher 9/

280 Speicher CPU kann über Datenbus nur auf ein Maschinenwort gleichzeitig zugreifen => zu holende/schreibende Daten sollten in einem Datenwort gespeichert sein (sonst sind mehrere Zugriffe notwendig => Hardware-Aufwand) Beispiel: Hardware I/O / Speicher 10/

281 Hardware I/O Beispiele Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Hardware I/O Beispiele 1/

282 Ampel-Hardware Fußgänger-Ampel: Hardware I/O Beispiele 2/

283 Ampel-Kommandos Fußgänger-Ampel Fahrzeug-Ampel Code aus aus 0x00 rot grün 0x24 rot gelb 0x22 rot rot 0x21 grün rot 0x11 rot rot-gelb 0x23 Hardware I/O Beispiele 3/

284 Ampel-Programm outb $0x24, 0 x f 0 / Fahrzeuge r o t / / Fahrzeuge gruen / / F u s s g a e n g e r grue / F u s s g a e n g e r r o t / c a l l wait_1min / Auf Knopfdruck warten / / Umschalten / loop : outb $0x21, 0 x f 0 i n b 0 xf0, %a l c a l l wait_5sec cmpb $1, %a l outb $0x23, 0 x f 0 jne loop c a l l wait_5sec outb $0x24, 0 x f 0 / Umschalten / outb $0x22, 0 x f 0 / Fahrzeuge gruen c a l l wait_5sec / F u s s g a e n g e r r o t outb $0x21, 0 x f 0 c a l l wait_5min c a l l wait_5sec outb $0x11, 0 x f 0 jmp loop Hardware I/O Beispiele 4/

285 Hardware ALU Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Hardware ALU 1/

286 ALU Die Arithmetic-/Logic-Unit ( ALU ) ist ein Schaltnetz, das verschiedene Funktionen berechnen kann. Prinzip: Operation und Operanden hinein; Ergebnis heraus. alle Werte (auch Operation) binär kodiert Breite der Operanden entspricht Maschinenwortbreite Schaltnetz besteht aus NOT-, AND-, OR-,...-Netzen Shifter(n) Addierer/Subtrahierer eventuell Multiplizierer eventuell Teile eines Dividier-Werkes... Ergebnis-Auswahl-Multiplexer Hardware ALU 2/

287 ALU Boolesche Funktionen Für NOT, AND, OR usw. existieren entsprechende Gatter-Netze: Hardware ALU 3/

288 ALU Scan-Funktionen Bit Scan Reverse ( bsr ) entsprechend: Bit Scan Forward ( bsf ) Hardware ALU 4/

289 ALU Shift-Funktionen Logical Shift Left ( shl ) Logical Shift Right ( shr ) Arithmetic Shift Right ( sar ) Hardware ALU 5/

290 ALU Rotate-Funktionen Rotate Left ( rol ) Rotate Right ( ror ) Hardware ALU 6/

291 ALU Rotate-Funktionen Rotate Left through Carry ( rcl ) Rotate Right through Carry ( rcr ) Hardware ALU 7/

292 ALU Mehrfach-Shift-/Rotate-Funktionen Shift/Rotate um mehrere Stellen: Hardware ALU 8/

293 ALU Konvertierungs-Funktionen Umwandlung einer N-Bit-Zahl x in eine M-Bit-Zahl (N < M): 0 x: trivial x < 0: Darstellung von x als N-Bit-Komplement-Zahl: a = 2 N + x Darstellung von x als M-Bit-Komplement-Zahl: b = 2 M + x b = 2 M + x = 2 M 2 N + 2 N + x = 2 M 2 N + a mit 2 M 2 N = (2) Hardware ALU 9/

294 ALU Konvertierungs-Funktionen Convert Byte To Word ( movsbw ), Convert Byte To Long ( movsbl ),... Hardware ALU 10/

295 ALU Addier-Netz Ripple-Carry-Adder Es existieren schnellere Addier-Netze. Hardware ALU 11/

296 ALU Addier-Netz Subtraktion auf Addition zurückführbar: z = x y => z = x + ( y) Notwendig: Negation (für das 2er-Komplement) (siehe OTRS-I/TI-I) 2er-Komplement: alle Bits invertieren und 1 addieren Beispiel: 1 (10) = (2) invertiert: (2) 1 addiert: (2) Ergebnis: 1 (10) = (2) Invertieren: NOT-Gatter 1 addieren: Carry-In auf 1 setzen Hardware ALU 12/

297 ALU Addier-Netz Hardware ALU 13/

298 ALU Multiplizier-Netz Einführendes Beispiel (Schul-Mathematik): * Multiplizierer zusammensetzbar aus AND-Gattern und Addierern Hardware ALU 14/

299 ALU Multiplizier-Netz Hardware ALU 15/

300 ALU Division Divisions-Werk ist meist kein Schaltnetz sondern Schaltwerk. Steuerwerk schleust die Daten mehrfach durch Shifter Subtrahierer (entspricht Software-Algorithmus) Hardware ALU 16/

301 ALU Condition-Code-Flags zusätzlich zum normalen Rechenergebnis müssen die Condition-Code-Flags berechnet werden; z.b.: Zero-Flag: alle berechneten Bits sind 0 Carry-Flag: Addition hatte Überlauf; Shift-Operationen liefern Extra-Bit Negative-Flag: berechnetes Ergebnis ist negativ... diese Berechnungen sind sehr einfach durchzuführen Hardware ALU 17/

302 ALU Condition-Code-Flags Zero-Flag Negative-Flag Carry-Flag (siehe Addierer bzw. Shifter) Hardware ALU 18/

303 ALU Gesamtstruktur Hardware ALU 19/