von-neumann Rechner: Vorlesung T3: Kapitel 2 Klassifikation: Speicherorganisation, Adressierungsarten, Befehlsätze Wiederholung: Software-Schichten

Transkript

1 Vorlesung T3: Kapitel 2 Klassifikation: von-neumann Rechner: ISA = "instruction set architecture" = HW/SW-Schnittstelle einer Prozessorfamilie charakteristische Merkmale: Speicherorganisation, Adressierungsarten, Befehlsätze Rechnerklasse Speichermodell Befehlssatz Art, Zahl der Operanden Ausrichtung der Daten (Stack-/Akku-/Registermaschine) (Wortbreite, Adressierung,...) (Definition aller Befehle) (Anzahl/Wortbreite/Reg./Speicher) (Alignment/Endianness) I/O-, Unterbrechungsstruktur Systemsoftware (Ein- und Ausgabe, Interrupts) (Loader/Assembler/Compiler/Debugger) Wiederholung: Software-Schichten Artenvielfalt: Prozessor bit 8 bit bit 32 bit 32 bit 32 bit bit..32 bit Speicher 1K.. 1M < 8K < 1K M M < 512M M 1 K.. 1 M < 64 M ASICs 1 uc 1 uc 1 ASIC 1 up DSPs ASIP 1 up, 1 up, 3 DSP DSP ~ 1 uc, up, DSP up, ASIP Netzwerk cardio - RS232 diverse GSM MIDI V.9 CAN,... I2C,... mehrere Abstraktionsebenen Hochsprache (C, Java,...) Assembler Maschinencode Echtzeit Safety => => => nein nein soft soft hard soft hard hard hard keine mittel keine gering gering gering gering hoch hoch riesiges Spektrum: 4 bit.. 64 bit Prozessoren, DSPs, digitale/analoge ASICs,... Sensoren/Aktoren: Tasten, Displays, Druck, Temperatur, Antennen, CCD,... Echtzeit-, Sicherheits-, Zuverlässigkeitsanforderungen

2 Instruction Set Architecture Speicher: Wortbreite ISA := "instruction set architecture" = HW/SW-Schnittstelle einer Prozessorfamilie Registersatz (Anzahl und Art der Rechenregister) Speichermodell (Byte-/Wortadresse, endianness,...) Befehlssatz (Definition aller Befehle) Systemprogrammierung (Status-"flags", Supervisor-Mode,...) Beispiele: (in dieser Vorlesung bzw. im Praktikum) MIPS x86 D*CORE (klassischer 32-bit RISC) (CISC, Verwendung in PCs) ("Demo Rechner", 16-bit) Wortbreiten einiger historisch wichtiger Computer heute vor allem 8/16/32/64-bit Systeme erlaubt 8-bit ASCII, 16-bit Unicode, 32-/64-bit Floating-Point Beispiel Intel x86: "byte", "word", "double word", "quad word" Speicherorganisation Hauptspeicher: Organisation Wie ist der Speicher eines von-neumann-rechners organisiert? Wortbreite, Grösse (=Speicherkapazität) little-/big-endian Alignment Memory-Map Beispiel PC spätere Themen: Cache-Organisation für schnelleren Zugriff Virtueller Speicher für Multitasking MESI-Protokoll für Multiprozessorsysteme Synchronisation in Multiprozessorsystemen diverse Varianten möglich Speicherkapazität #Worte * #Bits/Wort Hardwaretechnik III/22

3 Big- vs. Little Endian Misaligned Access Anordnung einzelner Bytes in einem Wort (hier 32-bit)?! big-endian LSB... MSB Anordnung, gut für Strings little-endian MSB... LSB Anordnung, gut für Zahlen beide Varianten haben Vor- und Nachteile komplizierte Umrechnung (siehe nächste Folie) Speicher wird (meistens) Byte-weise adressiert aber Zugriffe lesen/schreiben jeweils ein ganzes Wort was passiert bei "krummen" (misaligned) Adressen? automatische Umsetzung auf mehrere Zugriffe Programmabbruch (x86) (MIPS) Big vs. Little Endian: Beispiele "Memory Map" CPU kann im Prinzip alle möglichen Adressen ansprechen aber nicht alle Systeme haben voll ausgebauten Speicher (32-bit Adresse entspricht immerhin 4GB Hauptspeicher...) Aufteilung in RAM und ROM-Bereiche ROM mindestens zum Booten notwendig zusätzliche Speicherbereiche für "memory mapped" I/O => "Memory Map" Umrechnung erfordert Kenntnis der jeweiligen Datentypen Zuordnung von Adressen zu "realen" Speichern Aufgabe des Adress-"Dekoders" Beispiel: Windows

4 Memory map: typ. 16-bit System PC: Speicherbereiche, Beispiel 16-bit erlaubt 64K Adressen: x.. xffff ROM-Bereich für Boot / Betriebssystemkern RAM-Bereich für Hauptspeicher RAM-Bereich für Interrupt-Tabellen I/O-Bereiche für serielle / parallel Schnittstellen I/O-Bereiche für weitere Schnittstellen nutzbarer Hauptspeicher oberhalb ab 1 MB Speicherbereiche für Systemaufgaben (hier Framebuffer der Graphikkarten) BIOS (ROM) am oberen Ende des Adressbereichs Demo und Beispiele später Windows 9x erlaubt bis 4 GByte Adressraum Adressen h bis ffffffffh Aufteilung 1 GB / 1 GB / 2 GB PC: Windows 9x Speicherbereiche PC: IO-Adressen, Beispiel gemeinsam genutzter Systembereich FFFFFFFFh 1 GB gemeinsam genutzt für Anwendungen Ch 8h 1 GB privater Andreßbereich Anwendungen ungenutzt V86 Bereich 4h 1FFFh h knapp 2 GB 4 MB 1 MB inklusive "886 A2 bug": real mode Bereich DOS-Bereich immer noch für Boot / Geräte (VGA) notwendig Kernel, Treiber, usw. im oberen 1 GB-Bereich I/O-Adressraum gesamt nur 64 KByte je nach Zahl der I/O-Geräte evtl. fast voll ausgenutzt eingeschränkte Autokonfiguration über PnP-BIOS

5 Befehlszyklus: Instruction Fetch von-neumann Prinzip: Daten und Befehle im Hauptspeicher Befehlszyklus: (in Endlosschleife): Programmzähler PC addressiert den Speicher gelesener Wert kommt in das Befehlsregister IR Befehl dekodieren Befehl ausführen nächsten Befehl auswählen "Befehl holen" Phase im Befehlszyklus: Programmzähler (PC) liefert Adresse für den Speicher Lesezugriff auf den Speicher Resultat wird im Befehlsregister (IR) abgelegt Programmzähler wird inkrementiert Beispiel für 32-bit RISC mit 32-bit Befehlen: => man braucht mindestens diese Register: PC program counter Adresse des Befehls IR instruction register aktueller Befehl ACC accumulator ein oder mehrere R..R31 registerbank Rechenregister (Operanden) IR = MEM[ PC ] PC = PC + 4 bei CISC-Maschinen evtl. weitere Zugriffe notwendig, abhängig von der Art (und Länge) des Befehls Beispiel: Boot-Prozess Instruction Execute Was passiert beim Einschalten des Rechners? Chipsatz erzeugt Reset-Signale für alle ICs Reset für die zentralen Prozessor-Register (PC,...) PC wird auf Startwert initialisiert (z.b. xffff FFEF) Befehlszyklus wird gestartet Prozessor greift auf die Startadresse zu dort liegt ein ROM mit dem Boot-Programm Initialisierung und Selbsttest des Prozessors Löschen und Initialisieren der Caches Konfiguration des Chipsatzes Erkennung und Initialisierung von I/O-Komponenten Laden des Betriebssystems Befehl steht im Befehlsregister IR Decoder hat Opcode und Operanden entschlüsselt Ausführung des Befehls durch Ansteuerung der Register, der ALU, des Speichers Details abhängig von der Art des Befehls Ausführungszeit abhängig vom Befehl Realisierung über festverdrahtete Hardware oder mikroprogrammiert Demo (bzw. im T3-Praktikum): Realisierung des Mikroprogramms für den D*CORE

6 Welche Befehle braucht man? RISC Befehls-"Klassen": arithmetische Operationen logische Operationen Schiebe-Operationen Beispiele: add, sub, mult, div and, or, xor shift-left, rotate "reduced instruction set computer" "regular instruction set computer" Oberbegriff für moderne Rechnerarchitekturen entwickelt ab ca. 198 bei IBM, Stanford, Berkeley Vergleichsoperationen Datentransfers Programm-Kontrollfluß Maschinensteuerung cmpeq, cmpgt, cmplt load, store, I/O jump, branch call, return trap, halt, (interrupt) reguläre Struktur, z.b. 32-bit Wortbreite, 32-bit Befehle Load-Store Architektur, keine Speicheroperanden viele Register, keine Spezialaufgaben optimierende Compiler statt Assemblerprogrammierung IBM 81, MIPS, SPARC, DEC Alpha, ARM Diskussion und Details CISC vs. RISC später CISC Befehls-Dekodierung "Complex instruction set computer" Bezeichnung für (ältere) Computer-Architekturen mit irregulärem, komplexem Befehlssatz typische Merkmale: sehr viele Befehle, viele Datentypen komplexe Befehlskodierung, Befehle variabler Länge viele Adressierungsarten Mischung von Register- und Speicheroperanden komplexe Befehle mit langer Ausführungszeit Problem: Compiler benutzen solche Befehle gar nicht Beispiele: Intel 8x86, Motorola 68K, DEC Vax Befehlsregister IR enthält den aktuellen Befehl z.b. einen 32-bit Wert Wie soll die Hardware diesen Wert interpretieren? direkt in einer Tabelle nachschauen (Mikrocode-ROM) Problem: Tabelle müsste 2^32 Einträge haben deshalb Aufteilung in Felder: Opcode und Operanden Dekodierung über mehrere, kleine Tabellen unterschiedliche Aufteilung für unterschiedliche Befehle: => "Befehlsformate"

7 Befehlsformat: Einteilung in Felder Befehlsformat: Beispiel MIPS unbenutzt Beispiel: Opcode Zielregister Immediate-Wert bits 5 bits 5 bits 16 bits I-Format op rs rt address 31 Befehls"format": Aufteilung in mehrere Felder: Opcode eigentlicher Befehl ALU-Operation add/sub/incr/shift/usw. Register-Indizes Operanden / Resultat op: rs: rt: addr: Opcode destination register base register address offset Typ des Befehls Zielregister Basisadresse Offset 35="lw" "r8" "r5" 6 Speicher-Adressen Immediate-Operanden für Speicherzugriffe Werte direkt im Befehl Lage und Anzahl der Felder abhängig vom jeweiligen Befehlssatz => lw r8, addr(r5) r8 = MEM[ r5+addr ] Befehlsformat: Beispiel MIPS MIPS bits 5 bits 5 bits 5 bits 5 bits 6 bits op rs rt rd shift funct R-Format "Microprocessor without interlocked pipeline stages" entwickelt an der Univ. Stanford, seit 1982 Einsatz: eingebettete Systeme, SGI Workstations/Server op: rs: rt: rd: shift: funct: Opcode source register 1 source register 2 destination register shift amount ALU function Typ des Befehls erster Operand zweiter Operand Zielregister Rechenoperation => sub r3, r23, r3 r3 = r23 - r3 (optionales Shiften) ="alu-op" "r23" "r3" "r3" "" 34="sub" klassische 32-bit RISC Architektur 32-bit Wortbreite, 32-bit Speicher, 32-bit Befehle 32 Register: R ist konstant Null, R1.. R31 Universalregister Load-Store Architektur, nur base+offset Adressierung sehr einfacher Befehlssatz, 3-Adress-Befehle keinerlei HW-Unterstützung für "komplexe" SW-Konstrukte SW muß sogar HW-Konflikte ("Hazards") vermeiden Koprozessor-Konzept zur Erweiterung

8 MIPS: Register MIPS: Hardwarestruktur 32 Register, R.. R1, jeweils 32-bit R1 bis R31 sind Universalregister R ist konstant Null (ignoriert Schreiboperationen) dies erlaubt einige Tricks: R5 = -R5 sub R5, R, R5 R4 = add R4, R, R R3 = 17 addi R3, R, 17 if (R2 == )... bne R2, R, label keine separaten Statusflags Vergleichsoperationen setzen Zielregister auf bzw. 1: R1 = (R2 < R3) slt R1, R2, R3 PC Register ALUs Speicher I-Cache ($.. $31) D-Cache MIPS: Befehlssatz M*CORE 32-bit RISC Architektur, Motorola 1998 besonders einfaches Programmiermodell: Program Counter, 16 Universalregister 1 Statusregister PC R.. R15 C ("carry flag") 16-bit Befehle (um Programmspeicher zu sparen) Übersicht und Details: siehe Hennessy&Patterson 3 Befehlsformate: ALU, ALU Immediate, Load/Store, Branch D*CORE: gleiches Registermodell, aber nur 16-bit Wortbreite Subset der Befehle, einfachere Kodierung vollständiger Hardwareaufbau in Hades verfügbar oder Simulator mit Assembler (wint3asm.exe / t3asm.jar)

9 D*CORE: Register D*CORE: Befehlsformate R (SP) PC IR R1 R2 C - Befehlsregister R3 R4-16 Universalregister R5 - Programmzähler MAR R6-1 Carry-Flag R7 MDR R8 R9 MRR R1 R11 R12 R13 R14 R15 (Link) - Bus-Interface Programmierer sieht nur R..R15, PC, C (carry flag) nwe noe OPC sub-opc RY RX OPC 15 OPC 15 OPC sub-opc offset4 imm4 RY 12-bit immediate RX RX 4-bit Opcode, 4-bit Registeradressen ALU Immediate Load/Store Branch einfaches Zerlegen des Befehls in die einzelnen Felder STW.XA ALU.OPC IR IR<11:> IMM12 REG.RY REG.RX D*CORE: Befehlssatz Adressierungsarten mov addu, addc subu and, or xor lsl, lsr, asr cmpe, cmpne,... movi, addi,... ldw, stw br, jmp bt, bf jsr trap rfi move register Addition (ohne, mit Carry) Subtraktion logische Operationen logische, arithmetische Shifts Vergleichsoperationen Operationen mit Immediate-Operanden Speicherzugriffe, load/store unbedingte Spünge bedingte Sprünge Unterprogrammaufruf Software interrupt return from interrupt => Woher kommen die Operanden / Daten für die Befehle? Hauptspeicher, Universalregister, Spezialregister Wieviele Operanden pro Befehl? - / 1- / 2- / 3-Adress-Maschinen Wie werden die Operanden adressiert? immediate / direkt / indirekt / indiziert / autoinkrement / usw. wichtige Unterscheidungsmerkmale für Rechnerarchitekturen Zugriff auf Hauptspeicher ist ~1x langsamer als Registerzugriff möglichst Register statt Hauptspeicher verwenden (!) "load/store"-architekturen

10 Beispiel: Add-Befehl Woher kommen die Operanden? Rechner soll "rechnen" können von-neumann Prinzip: alle Daten im Hauptspeicher addr1 typische arithmetische Operation nutzt 3 Variablen Resultat, zwei Operanden: X = Y + Z add r2, r4, r5 reg2 = reg4 + reg5 "addiere den Inhalt von R4 und R5 und speichere das Resultat in R2" woher kommen die Operanden? wo soll das Resultat hin? Speicher typ. Operation: zwei Operanden, ein Resultat "Multiport-Speicher": mit drei Ports?! sehr aufwendig, extrem teuer, trotzdem langsam statt dessen: Register im Prozessor zur Zwischenspeicherung Datentransfer zwischen Speicher und Registern Load reg = MEM[ addr ] Store MEM[ addr ] = reg Regs data1 addr2 data2 addr3 data3 Speicher Speicher Register entsprechende Klassifikation der Architektur RISC: Rechenbefehle arbeiten nur mit Registern CISC: gemischt, Operanden in Registern oder im Speicher Datenpfad n-adress-maschine Register (-bank) liefern Operanden speichern Resultate interne Hilfsregister ALU: typ. Funktionen: add, add-carry, sub and, or, xor shift, rotate compare (floating point ops.) 3-Adress-Format: 2-Adress-Format 1-Adress-Format -Adress-Format X = Y + Z sehr flexibel, leicht zu programmieren Befehl muss 3 Adressen speichern X = X + Z eine Adresse doppelt verwendet, für Resultat und einen Operanden Format wird häufig verwendet ACC = ACC + Z alle Befehle nutzen das Akkumulator-Reg. häufig in älteren / 8-bit Rechnern TOS = TOS + NOS Stapelspeicher (top of stack, next of stack) Adressverwaltung entfällt im Compilerbau beliebt

11 n-adress-maschine Adressierungsarten (1) Beispiel: Z = (A-B) / (C + D*E) T = Hilfsregister 3-Adress-Maschine sub Z, A, B mul T, D, E add T, T, C div Z, Z, T 2-Adress-Maschine mov Z, A sub Z, B mov T, D 1-Adress-Maschine load D mul E add C stor Z load A sub B div Z stor Z -Adress-Maschine push D push E mul push C add push A push B sub div mul T, E add T, C pop Z div Z, T "immediate" "direkt" "indirekt" Operand steht direkt im Befehl kein zusätzlicher Speicherzugriff aber Länge des Operanden beschränkt Adresse des Operanden steht im Befehl keine zusätzliche Adressberechnung ein zusätzlicher Speicherzugriff Adressbereich beschränkt Adresse eines Pointers steht im Befehl erster Speicherzugriff liest Wert des Pointers zweiter Speicherzugriff liefert Operanden sehr flexibel (aber langsam) Stack-Maschine: Adressierungsarten (2) Beispiel: Z = (A-B) / (C + D*E) -Adress-Maschine T = Hilfsregister "register" wie Direktmodus, aber Register statt Speicher 32 Register: benötigt 5 bit im Befehl genug Platz für 2- oder 3-Adress Formate push D push E mul push C add push A push B sub div pop Z TOS D E D*E C C+D*E A B A-B (A-B)/(C+D*E) NOS D D*E C+D*E A C+D*E C+D*E Stack "register-indirekt" "indiziert" Befehl spezifiziert ein Register mit der Speicheradresse des Operanden ein zusätzlicher Speicherzugriff Angabe mit Register und Offset Inhalt des Registers liefert Basisadresse Speicherzugriff auf (Basisaddresse+offset) ideal für Array- und Objektzugriffe Hauptmodus in RISC-Rechnern (andere Bezeichnung: "Versatz-Modus")

12 Immediate-Adressierung indirekte Adressierung opcode regs immediate16 1-Wort Befehl Registerbank opcode regs unused 2-Wort Befehl opcode regs unused 4 immediate32 "immediate" Operand steht direkt im Befehl, kein zusätzlicher Speicherzugriff z.b. R3 = Immediate16 Länge des Operanden ist kleiner als (Wortbreite - Opcodebreite) addr 32 1 "indirekt" Adresse eines Pointers steht im Befehl keine zusätzliche Adressberechnung zwei zusätzliche Speicherzugriffe tmp 2 3 Speicher zur Darstellung grösserer Werte: z.b. tmp = MEM[ addr32 ]; R3 = MEM[ tmp ] 2-Wort Befehle (zweites Wort für Immediate-Wert) mehrere Befehle, z.b. obere/untere Hälfte eines Wortes Immediate-Werte mit zusätzlichem Shift (x86) (Mips,SPARC) (ARM) typische CISC-Adressierungsart, viele Taktzyklen kommt bei RISC-Rechnern nicht vor direkte Adressierung Indizierte Adressierung Registerbank opcode regs unused addr 32 "direkt" Adresse des Operanden steht im Befehl keine zusätzliche Adressberechnung ein zusätzlicher Speicherzugriff z.b. R3 = MEM[ addr32 ] Speicher indizierte Adressierung, z.b. für Arrayzugriffe: addr = (Basisregister) + (Sourceregister i) Adressbereich beschränkt, oder 2-Wort Befehl (wie Immediate) addr = (Sourceregister + offset) sourceregister = addr

13 Weitere Adressierungsarten x86-architektur (immediate) x86: (register direct) (index + offset) übliche Bezeichnung für die Intel-Prozessorfamilie von 886, 8286, 8386, 8486, Pentium... Pentium-IV oder "IA-32": Intel architecture, 32-bit (PC + offset) vollständig irreguläre Struktur: CISC historisch gewachsen: diverse Erweiterungen (MMX, SSE,...) ab 386 auch wie reguläre 8-Register Maschine verwendbar Hinweis: (PC offset) die folgenden Folien zeigen eine *vereinfachte* Version niemand erwartet, dass Sie sich die Details merken x86-assemblerprogrammierung ist "grausam" Adressierung: Varianten Beispiel: Evolution des Intel x86 welche Adressierungsarten / Varianten sind üblich? -Adress (Stack-) Maschine: 1-Adress (Akkumulator) Maschine. 2-Adress Maschine: 3-Adress Maschine: Java virtuelle Maschine 8-bit Microcontroller einige x86 Befehle einige x86 Befehle, 16-bit Rechner 32-bit RISC CISC-Rechner unterstützen diverse Adressierungsarten RISC meistens nur indiziert mit offset später noch genügend Beispiele (und Übungen)

14 x86: Speichermodell x86: Register Bit-Offset EAX ECX AX CX AH CH AL CL accumulator count: String, Loop 886 Exx ab EDX DX DH DL data, multiply/divide 24 EBX BX BH BL base addr 2 ESP SP stackptr EBP ESI BP SI base of stack segment index, string src 79 FPR 8 EDI DI index, string dst Byte 3 Byte 2 Byte 1 Byte 4 kleinste Adresse CS SS code segment stack segment DS data segment ES extra data segment Byte-Offset FS GS FPR7 "little endian": LSB eines Wortes bei der kleinsten Adresse EIP EFLAGS IP PC status FP Status x86: Speichermodell x86: EFLAGS Register Speicher voll byte-adressierbar mis-aligned Zugriffe langsam Statusregister (Pentium)

15 x86: Datentypen: CISC... x86: Befehlsformate: CISC... bytes word doubleword quadword integer (2-complement b/w/dw/qw) ordinal (unsigned b/w/dw/qw) BCD (one digit per byte, multiple bytes) packed BCD (two digits per byte, multiple bytes) near pointer (32 bit offset) far pointer (16 bit segment + 32 bit offset) bit field bit string byte string float / double / extended 15 high low 31 high word low word 63 high doubleword low doubleword b b b 2**32-1 bits 2**32-1 bytes Adressen: N+4 N+3 N+2 N+1 N außergewöhnlich komplexes Befehlsformat: 1) prefix (repeat / segment override / etc.) 2) 3) 4) 5) 6) 7) opcode register specifier address mode specifier scale-index-base displacement immediate operand (eigentlicher Befehl) (Ziel / Quellregister) (diverse Varianten) (Speicheradressierung) (Offset) ausser dem Opcode alle Bestandteile optional unterschiedliche Länge der Befehle, von Byte => extrem aufwendige Dekodierung x86: Befehlssatz x86: Modifier Datenzugriff mov, xchg Stack-Befehle push, pusha, pop, popa Typumwandlung cwd, cdq, cbw (byte->word), movsx,... Binärarithmetik add, adc, inc, sub, sbb, dec, cmp, neg,... mul, imul, div, idiv, Dezimalarithmetik packed / unpacked BCD: daa, das, aaa, aas,... Logikoperationen and, or, xor, not, sal, shr, shr,... Sprungbefehle jmp, call, ret, int, iret, loop, loopne,... String-Operationen movs, cmps, scas, load, stos,... "high-level" enter (create stack frame),... diverses lahf (load AH from flags),... Segment-Register far call, far ret, lds (load data pointer) alle Befehle können mit "Modifiern" ergänzt werden: segment override Addr. aus angewähltem Segmentregister address size Umschaltung 16/32-bit operand size Umschaltung 16/32-bit repeat für Stringoperationen Operation auf allen Elementen ausführen lock Speicherschutz für Multiprozessoren => CISC zusätzlich diverse Ausnahmen/Spezialfälle

16 x86: Assembler-Beispiel addr opcode assembler c quellcode file "hello.c".text 48656C6C.string "Hello x86!\n" 6F A.text print: 55 pushl %ebp void print( char* s ) { 1 89E5 movl %esp,%ebp 3 53 pushl %ebx 4 8B5D8 movl 8(%ebp),%ebx 7 83B cmpb $,(%ebx) while( *s!= ) { a 7418 je.l18.align 4.L19: c A1 movl stdout,%eax putc( *s, stdout ); 11 5 pushl %eax 12 FBE3 movsbl (%ebx),%eax 15 5 pushl %eax 16 E8FCFFFF call _IO_putc FF 1b 43 incl %ebx s++; 1c 83C48 addl $8,%esp } 1f 83B cmpb $,(%ebx) 22 75E8 jne.l19.l18: 24 8B5DFC movl -4(%ebp),%ebx } 27 89EC movl %ebp,%esp 29 5D popl %ebp 2a C3 ret Beispiel: x86 Befehlskodierung 1 Byte.. 36 Bytes vollkommen irregulär x86: Assembler-Beispiel (2) Beispiel: x86 Befehle addr opcode assembler c quellcode Lfe1:.Lscope: 2b 98D7426.align 16 main: 3 55 pushl %ebp int main( int argc, char** argv ) { 31 89E5 movl %esp,%ebp pushl %ebx 34 BB movl $.LC,%ebx print( "Hello x86!\n" ); 39 83D cmpb $,.LC 4 741A je.l F6.align 4.L24: 44 A1 movl stdout,%eax 49 5 pushl %eax 4a FBE3 movsbl (%ebx),%eax 4d 5 pushl %eax 4e E8FCFFFFFF call _IO_putc incl %ebx 54 83C48 addl $8,%esp 57 83B cmpb $,(%ebx) 5a 75E8 jne.l24.l26: 5c 31C xorl %eax,%eax return ; 5e 8B5DFC movl -4(%ebp),%ebx } 61 89EC movl %ebp,%esp 63 5D popl %ebp 64 C3 ret