von-Neumann Rechner · von-Neumann Prinzip: Daten und Befehle im Hauptspeicher PC program counter...

Vorlesung T3: Kapitel 2

Vorlesung Technische Informatik 3 | WS 2003

Befehlsätze

von-Neumann Rechner:

Speicherorganisation,

Adressierungsarten,


mehrere Abstraktionsebenen

Maschinencode

Hochsprache (C, Java, ...)Assembler

Wiederholung: Software-Schichten

I/O-, UnterbrechungsstrukturSystemsoftware

Ausrichtung der DatenArt, Zahl der Operanden

Rechnerklasse

charakteristische Merkmale:

(Loader/Assembler/Compiler/Debugger)

(Wortbreite, Adressierung, ...)

(Alignment/Endianness)

(Anzahl/Wortbreite/Reg./Speicher)

(Stack-/Akku-/Registermaschine)

(Definition aller Befehle)Befehlssatz

Speichermodell

Klassifikation:

ISA= HW/SW-Schnittstelle einer Prozessorfamilie


= "instruction set architecture"

(Ein- und Ausgabe, Interrupts)

Artenvielfalt:


CAN,...

..32 bit16 .. 32 bit

I2C,...

ASIP

V.90

Safety

cardIO MIDIGSMdiverseRS232-Netzwerk

hard hardhardsofthardsoftsoftneinneinEchtzeit

keine mittel keine gering gering gering gering hoch hoch

1K .. 1M < 8K 1 K .. 10 M8 .. 64M

=>

=>

=>

ASIP

uP,

< 64 M

uP, DSP

~ 100 uC,1 uP,1 uP,

8 .. 64 bit32 bit32 bit

1 ASIC 1 uP DSPs1 uC1 uCASICs

1 .. 64M< 1KSpeicher

-8 bitProzessor

3 DSP DSP

Sensoren/Aktoren: Tasten, Displays, Druck, Temperatur, Antennen, CCD, ...

Echtzeit-, Sicherheits-, Zuverlässigkeitsanforderungen

4 .. 32 bit

riesiges Spektrum: 4 bit .. 64 bit Prozessoren, DSPs, digitale/analoge ASICs, ...

32 bit

1 .. 64M < 512M

statt dessen: Erläuterung von "Demo"-Architekturen

=> schlecht zum Einstieg geeignet

unübersichtliche Erweiterungenkomplizierte Befehlskodierungumfangreicher Befehlssatz"echte" Architekturen sind auf Effizienz optimiert

Motivation


D*COREMIPS

Y86

basiert auf:

Intel x86

MIPS R3000Motorola M*CORE

Bryant/O'Hallaron

Hennessy/PattersonT3-Praktikum

verwendet in:Architektur:

IJVM Java VM Tanenbaum

unliebsame Details werden einfach weggelassen...

(CISC, Verwendung in PCs)

(klassischer 32-bit RISC)

("Demo Rechner", 16-bit)D*CORE

MIPSx86

Systemprogrammierung (Status-"flags", Supervisor-Mode, ...)

(Definition aller Befehle)Befehlssatz(Byte-/Wortadresse, endianness, ...)Speichermodell(Anzahl und Art der Rechenregister)Registersatz

:= "instruction set architecture"ISA= HW/SW-Schnittstelle einer Prozessorfamilie


Instruction Set Architecture

Beispiele: (in dieser Vorlesung bzw. im Praktikum)


Speicherorganisation

Wie ist der Speicher eines von-Neumann-Rechners organisiert?

Wortbreite, Grösse (=Speicherkapazität)little-/big-endianAlignmentMemory-MapBeispiel PC

spätere Themen:

Cache-Organisation für schnelleren ZugriffVirtueller Speicher für MultitaskingMESI-Protokoll für MultiprozessorsystemeSynchronisation in Multiprozessorsystemen


Speicher: Wortbreite

Wortbreiten einiger historisch wichtiger Computer

erlaubt 8-bit ASCII, 16-bit Unicode, 32-/64-bit Floating-Pointheute vor allem 8/16/32/64-bit Systeme

Beispiel Intel x86: "byte", "word", "double word", "quad word"

diverse Varianten möglich

#Worte * #Bits/WortSpeicherkapazität

Hardwaretechnik | III/2002

Hauptspeicher: Organisation


Big- vs. Little Endian

Anordnung einzelner Bytes in einem Wort (hier 32-bit) ?!

big-endianlittle-endian

beide Varianten haben Vor- und Nachteilekomplizierte Umrechnung (siehe nächste Folie)

MSB ... LSB Anordnung, gut für ZahlenLSB ... MSB Anordnung, gut für Strings


Big vs. Little Endian: Beispiele

Umrechnung erfordert Kenntnis der jeweiligen Datentypen

(x86)(MIPS)


Misaligned Access

Speicher wird (meistens) Byte-weise adressiertaber Zugriffe lesen/schreiben jeweils ein ganzes Wort

was passiert bei "krummen" (misaligned) Adressen?

Programmabbruch automatische Umsetzung auf mehrere Zugriffe

"Memory Map"=>

aber nicht alle Systeme haben voll ausgebauten Speicher

CPU kann im Prinzip alle möglichen Adressen ansprechen

Beispiel: WindowsAufgabe des Adress-"Dekoders"Zuordnung von Adressen zu "realen" Speichern

zusätzliche Speicherbereiche für "memory mapped" I/O

ROM mindestens zum Booten notwendigAufteilung in RAM und ROM-Bereiche

"Memory Map"


(32-bit Adresse entspricht immerhin 4GB Hauptspeicher...)

Memory map: typ. 16-bit System


16-bit erlaubt 64K Adressen: 0x0000 .. 0xFFFF

ROM-Bereich für Boot / BetriebssystemkernRAM-Bereich für HauptspeicherRAM-Bereich für Interrupt-Tabellen

I/O-Bereiche für serielle / parallel SchnittstellenI/O-Bereiche für weitere Schnittstellen

Demo und Beispiele später

V86 Bereich 00000000h0010FFF0h

FFFFFFFFh

00400000h

80000000h

C0000000h

Systembereich

gemeinsamgenutzter

privaterAndreßbereichAnwendungen

1 GB

1 GB

knapp 2 GB

Anwendungengenutzt fürgemeinsam

4 MB

1 MB inklusive "8086 A20 bug": real mode Bereich

ungenutzt

DOS-Bereich immer noch für Boot / Geräte (VGA) notwendigKernel, Treiber, usw. im oberen 1 GB-Bereich


PC: Windows 9x Speicherbereiche

Aufteilung 1 GB / 1 GB / 2 GBAdressen 00000000h bis ffffffffhWindows 9x erlaubt bis 4 GByte Adressraum

BIOS (ROM) am oberen Endedes Adressbereichs

nutzbarer Hauptspeicher oberhalb ab 1 MB

Speicherbereiche fürSystemaufgaben (hierFramebuffer der Graphikkarten)

PC: Speicherbereiche, Beispiel


eingeschränkte Autokonfiguration über PnP-BIOS

I/O-Adressraum gesamt nur 64 KByteje nach Zahl der I/O-Geräte evtl. fast voll ausgenutzt

PC: IO-Adressen, Beispiel



Befehlszyklus:

von-Neumann Prinzip: Daten und Befehle im Hauptspeicher

PC program counter Adresse des BefehlsIR instruction register aktueller Befehl

ACC accumulatorregisterbank

ein oder mehrereRechenregister (Operanden)R0..R31

man braucht mindestens diese Register:=>

Befehlszyklus: (in Endlosschleife):

Programmzähler PC addressiert den Speicher

Befehl dekodierenBefehl ausführen

gelesener Wert kommt in das Befehlsregister IR

nächsten Befehl auswählen

Laden des Betriebssystems

Erkennung und Initialisierung von I/O-Komponenten

Initialisierung und Selbsttest des Prozessorsdort liegt ein ROM mit dem Boot-Programm

Konfiguration des ChipsatzesLöschen und Initialisieren der Caches

Prozessor greift auf die Startadresse zu

Befehlszyklus wird gestartetPC wird auf Startwert initialisiert (z.B. 0xFFFF FFEF)Reset für die zentralen Prozessor-Register (PC, ...)Chipsatz erzeugt Reset-Signale für alle ICs

Was passiert beim Einschalten des Rechners?


Beispiel: Boot-Prozess

abhängig von der Art (und Länge) des Befehlsbei CISC-Maschinen evtl. weitere Zugriffe notwendig,

Beispiel für 32-bit RISC mit 32-bit Befehlen:

Programmzähler wird inkrementiert

Lesezugriff auf den SpeicherProgrammzähler (PC) liefert Adresse für den Speicher

"Befehl holen" Phase im Befehlszyklus:

Instruction Fetch


Resultat wird im Befehlsregister (IR) abgelegt

IR = MEM[ PC ]

PC = PC + 4

oder mikroprogrammiert

Ausführungszeit abhängig vom Befehl


Instruction Execute

Befehl steht im Befehlsregister IRDecoder hat Opcode und Operanden entschlüsselt

Ausführung des Befehls durch Ansteuerungder Register, der ALU, des Speichers

Details abhängig von der Art des Befehls

Realisierung über festverdrahtete Hardware

Realisierung des Mikroprogramms für den D*COREDemo (bzw. im T3-Praktikum):

Beispiele:

Schiebe-Operationen

load, store, I/O

Befehls-"Klassen":


Welche Befehle braucht man?

arithmetische Operationen add, sub, mult, divlogische Operationen

shift-left, rotateand, or, xor

Vergleichsoperationen

jump, branchcall, return

Maschinensteuerung

Programm-Kontrollfluß

Datentransfers

cmpeq, cmpgt, cmplt

trap, halt, (interrupt)

Beispiele: Intel 80x86, Motorola 68K, DEC Vax

komplexe Befehle mit langer Ausführungszeit

sehr viele Befehle, viele Datentypen

Mischung von Register- und Speicheroperandenviele Adressierungsartenkomplexe Befehlskodierung, Befehle variabler Länge

typische Merkmale:mit irregulärem, komplexem BefehlssatzBezeichnung für (ältere) Computer-Architekturen

"Complex instruction set computer"

CISC


Problem: Compiler benutzen solche Befehle gar nicht


RISC

"reduced instruction set computer""regular instruction set computer"

Oberbegriff für moderne Rechnerarchitekturenentwickelt ab ca. 1980 bei IBM, Stanford, Berkeley

IBM 801, MIPS, SPARC, DEC Alpha, ARMDiskussion und Details CISC vs. RISC später

optimierende Compiler statt Assemblerprogrammierung

Load-Store Architektur, keine Speicheroperandenviele Register, keine Spezialaufgaben

reguläre Struktur, z.B. 32-bit Wortbreite, 32-bit Befehle

Dekodierung über mehrere, kleine Tabellen

=> "Befehlsformate"

unterschiedliche Aufteilung für unterschiedliche Befehle:

deshalb Aufteilung in Felder: Opcode und Operanden

Problem: Tabelle müsste 2^32 Einträge habendirekt in einer Tabelle nachschauen (Mikrocode-ROM)

Befehls-Dekodierung

Befehlsregister IR enthält den aktuellen Befehl


z.B. einen 32-bit Wert

Wie soll die Hardware diesen Wert interpretieren?

1111 1 0 0000 00 0 000 1 000011 001110010031

Beispiel:


Befehlsformat: Einteilung in Felder

Opcode Immediate-WertZielregister

1111 1 0 0000 00 0 000 1 000011 001110010031

unbenutzt

für Speicherzugriffe

add/sub/incr/shift/usw.ALU-Operation

Werte direkt im Befehl

Operanden / ResultatSpeicher-AdressenImmediate-Operanden

Opcode

Register-Indizes

eigentlicher Befehl

Lage und Anzahl der Felder abhängig vom jeweiligen Befehlssatz

Befehls"format": Aufteilung in mehrere Felder:

34="sub"

0="alu-op""r23"

"0""r3""r30"

=> r3 = r23 - r30sub r3, r23, r30

Rechenoperation(optionales Shiften)shift amount

ALU functionfunct:shift:

Zielregisterdestination registerrd:zweiter Operandsource register 2rt:

Typ des Befehlserster Operandsource register 1rs:

Opcodeop:

000 11 11 031 0

0 00 10 011 0 0 00000000011111

shiftop

R-Format

6 bits5 bits5 bits5 bits5 bits6 bits

functrdrtrs


Befehlsformat: Beispiel MIPS

Offset

r8 = MEM[ r5+addr ]

6"r5""r8"

lw r8, addr(r5)

35="lw"

=>

BasisadresseZielregister

base registerdestination register

10001 10 0000001111

address offsetaddr:

address

16 bits

I-Format

Befehlsformat: Beispiel MIPS


rs rt

6 bits 5 bits 5 bits

op

0 000 00 0 00000031

0 10

op: Opcoders:

Typ des Befehls

rt:

MIPS

sehr einfacher Befehlssatz, 3-Adress-Befehle

SW muß sogar HW-Konflikte ("Hazards") vermeidenkeinerlei HW-Unterstützung für "komplexe" SW-Konstrukte

Koprozessor-Konzept zur Erweiterung

32 Register: R0 ist konstant Null, R1 .. R31 Universalregister32-bit Wortbreite, 32-bit Speicher, 32-bit Befehleklassische 32-bit RISC Architektur

"Microprocessor without interlocked pipeline stages"


Einsatz: eingebettete Systeme, SGI Workstations/Serverentwickelt an der Univ. Stanford, seit 1982

Load-Store Architektur, nur base+offset Adressierung

MIPS: Register


R0 ist konstant Null (ignoriert Schreiboperationen)R1 bis R31 sind Universalregister32 Register, R0 .. R1, jeweils 32-bit

dies erlaubt einige Tricks:

R5 = -R5 sub R5, R0, R5R4 = 0 add R4, R0, R0R3 = 17 addi R3, R0, 17

bne R2, R0, labelif (R2 == 0)...

keine separaten StatusflagsVergleichsoperationen setzen Zielregister auf 0 bzw. 1:

R1 = (R2 < R3) slt R1, R2, R3

MIPS: Befehlssatz


Übersicht und Details: siehe Hennessy&Patterson3 Befehlsformate: ALU, ALU Immediate, Load/Store, Branch

MIPS: Hardwarestruktur


PCI-Cache ($0 .. $31)

Register ALUs SpeicherD-Cache

oder Simulator mit Assembler (winT3asm.exe / t3asm.jar)

gleiches Registermodell, aber nur 16-bit WortbreiteSubset der Befehle, einfachere Kodierungvollständiger Hardwareaufbau in Hades verfügbar

32-bit RISC Architektur, Motorola 1998

M*CORE

PCR0 .. R15C ("carry flag")

(um Programmspeicher zu sparen)

D*CORE:

1 Statusregister

Program Counter,16 Universalregister

16-bit Befehle

besonders einfaches Programmiermodell:

Programmierer sieht nur R0..R15, PC, C (carry flag)

D*CORE: Register

C

(Link)

R0

R1

R2

R3

R4

R5

R6

R7

R8

R9

R10

R11

R12

R13

R14

15 0

R15

(SP)

MAR

MDR

MRR

IRPC

015

nWE

nOE

- Befehlsregister

- Bus-Interface

- Programmzähler

- 16 Universalregister

- 1 Carry-Flag

D*CORE: Befehlssatz

movaddu, addcsubuand, or xorlsl, lsr, asrcmpe, cmpne, ...

ldw, stw

bt, bfjsr

br, jmp

traprfi

move register

logische Operationen

Addition (ohne, mit Carry)Subtraktion

logische, arithmetische ShiftsVergleichsoperationen

Speicherzugriffe, load/storeunbedingte Spüngebedingte SprüngeUnterprogrammaufruf

Software interruptreturn from interrupt

movi, addi, ... Operationen mit Immediate-Operanden

einfaches Zerlegen des Befehls in die einzelnen Felder4-bit Opcode, 4-bit Registeradressen

D*CORE: Befehlsformate

015 4812

REG.RX

REG.RY

ALU.OPC

STW.XA

IR<11:0> IMM12

IR

15 0

8 41215 0

015 12 48

15 0

Immediate

Load/Store

Branch

ALU

OPC RX

RXsub-opcOPC imm4

OPC sub-opc RY RX

OPC 12-bit immediate

offset4 RY


Adressierungsarten

Woher kommen die Operanden / Daten für die Befehle?Hauptspeicher, Universalregister, Spezialregister

Wieviele Operanden pro Befehl?0- / 1- / 2- / 3-Adress-Maschinen

immediate / direkt / indirekt / indiziert / autoinkrement / usw.

wichtige Unterscheidungsmerkmale für Rechnerarchitekturen

Wie werden die Operanden adressiert?

Zugriff auf Hauptspeicher ist ~100x langsamer als Registerzugriffmöglichst Register statt Hauptspeicher verwenden (!)

=>

"load/store"-Architekturen

Resultat, zwei Operanden: X = Y + Z

und speichere das Resultat in R2""addiere den Inhalt von R4 und R5

add r2, r4, r5


Beispiel: Add-Befehl

Rechner soll "rechnen" könnentypische arithmetische Operation nutzt 3 Variablen

woher kommen die Operanden?wo soll das Resultat hin?

SpeicherRegister

reg2 = reg4 + reg5

entsprechende Klassifikation der Architektur

(floating point ops.)

interne Hilfsregister

compareshift, rotateand, or, xor

liefern Operanden

Register (-bank)

typ. Funktionen:

speichern Resultate

Datenpfad


add, add-carry, sub

ALU:

sehr aufwendig , extrem teuer, trotzdem langsam

Woher kommen die Operanden?


von-Neumann Prinzip: alle Daten im Hauptspeichertyp. Operation: zwei Operanden, ein Resultat

"Multiport-Speicher": mit drei Ports ?!

statt dessen:Register im Prozessor zur ZwischenspeicherungDatentransfer zwischen Speicher und Registern

RISC: Rechenbefehle arbeiten nur mit RegisternCISC: gemischt, Operanden in Registern oder im Speicher

Load reg = MEM[ addr ]Store MEM[ addr ] = reg

Speicher

Speicher

addr1

addr2

addr3

data1

data2

data3

Regs

n-Adress-Maschine


3-Adress-Format: X = Y + Zsehr flexibel, leicht zu programmierenBefehl muss 3 Adressen speichern

2-Adress-Format X = X + Zeine Adresse doppelt verwendet,für Resultat und einen OperandenFormat wird häufig verwendet

1-Adress-Formatalle Befehle nutzen das Akkumulator-Reg.ACC = ACC + Z

häufig in älteren / 8-bit Rechnern

0-Adress-Format TOS = TOS + NOSStapelspeicher (top of stack, next of stack)Adressverwaltung entfälltim Compilerbau beliebt


n-Adress-Maschine

Beispiel: Z = (A-B) / (C + D*E) T = Hilfsregister

2-Adress-Maschine

div Z, T

mul T, E

add T, C

mov T, D

sub Z, B

mov Z, A

3-Adress-Maschine

add T, T, C

mul T, D, E

div Z, Z, T

sub Z, A, B

1-Adress-Maschine

load D

mul E

add C

stor Z

load A

sub B

div Z

stor Z

0-Adress-Maschine

mul

add

sub

div

push D

push E

push C

push A

push B

pop Z

StackNOSTOS

(A-B)/(C+D*E)

A-B C+D*E

B A

A

C+D*E

C+D*E

C+D*E

C D*E

D*E

E D

D

0-Adress-Maschine

mul

add

sub

div

push D

push E

push C

push A

push B

pop Z

Stack-Maschine:


Beispiel: Z = (A-B) / (C + D*E) T = Hilfsregister

sehr flexibel (aber langsam)

erster Speicherzugriff liest Wert des Pointerszweiter Speicherzugriff liefert Operanden

Adresse eines Pointers steht im Befehl

"direkt"

"indirekt"

Adressbereich beschränkt ein zusätzlicher Speicherzugriffkeine zusätzliche AdressberechnungAdresse des Operanden steht im Befehl

aber Länge des Operanden beschränktkein zusätzlicher SpeicherzugriffOperand steht direkt im Befehl"immediate"


Adressierungsarten (1)

Adressierungsarten (2)

(andere Bezeichnung: "Versatz-Modus")Hauptmodus in RISC-Rechnernideal für Array- und ObjektzugriffeSpeicherzugriff auf (Basisaddresse+offset)

Angabe mit Register und OffsetInhalt des Registers liefert Basisadresse

"indiziert"

mit der Speicheradresse des OperandenBefehl spezifiziert ein Register"register-indirekt"

genug Platz für 2- oder 3-Adress Formate32 Register: benötigt 5 bit im Befehlwie Direktmodus, aber Register statt Speicher"register"

ein zusätzlicher Speicherzugriff


(ARM)

(Mips,SPARC)

(x86)2-Wort Befehle (zweites Wort für Immediate-Wert)

opcode regs immediate1631 015

opcode regs unused

immediate32

1-Wort Befehl

2-Wort Befehl

zur Darstellung grösserer Werte:

Immediate-Werte mit zusätzlichem Shiftmehrere Befehle, z.B. obere/untere Hälfte eines Wortes

Länge des Operanden ist kleiner als (Wortbreite - Opcodebreite)

Immediate-Adressierung

"immediate"


Operand steht direkt im Befehl, kein zusätzlicher Speicherzugriffz.B. R3 = Immediate16

Registerbank

Speicher

z.B. R3 = MEM[ addr32 ]

Adressbereich beschränkt, oder 2-Wort Befehl (wie Immediate)

direkte Adressierung

"direkt"

ein zusätzlicher Speicherzugriffkeine zusätzliche AdressberechnungAdresse des Operanden steht im Befehl


31 015

opcode regs unused

addr 32

typische CISC-Adressierungsart, viele Taktzyklenkommt bei RISC-Rechnern nicht vor

3

4

2

z.B. tmp = MEM[ addr32 ]; R3 = MEM[ tmp ]

tmp1

zwei zusätzliche Speicherzugriffekeine zusätzliche AdressberechnungAdresse eines Pointers steht im Befehl


31 015

opcode regs unused

addr 32

indirekte Adressierung

"indirekt"

Speicher

Registerbank

indizierte Adressierung, z.B. für Arrayzugriffe:

addr = (Sourceregister + offset)sourceregister = addr

addr = (Basisregister) + (Sourceregister i)


Indizierte Adressierung

Weitere Adressierungsarten


(immediate)

(register direct)

(index + offset)

(PC + offset)

(PC | offset)

später noch genügend Beispiele (und Übungen)

CISC-Rechner unterstützen diverse Adressierungsarten


Adressierung: Varianten

0-Adress (Stack-) Maschine: Java virtuelle Maschine1-Adress (Akkumulator) Maschine. 8-bit Microcontroller

2-Adress Maschine:einige x86 Befehleeinige x86 Befehle,16-bit Rechner

3-Adress Maschine: 32-bit RISC

RISC meistens nur indiziert mit offset

welche Adressierungsarten / Varianten sind üblich?

niemand erwartet, dass Sie sich die Details merken

Hinweis:

die folgenden Folien zeigen eine *vereinfachte* Version

ab 386 auch wie reguläre 8-Register Maschine verwendbar

vollständig irreguläre Struktur: CISChistorisch gewachsen: diverse Erweiterungen (MMX, SSE, ...)

von 8086, 80286, 80386, 80486, Pentium ... Pentium-IVübliche Bezeichnung für die Intel-Prozessorfamilie

x86:

oder "IA-32": Intel architecture, 32-bit

x86-Assemblerprogrammierung ist "grausam"

x86-Architektur



Beispiel: Evolution des Intel x86

"little endian": LSB eines Wortes bei der kleinsten Adresse

kleinste Adresse

Byte-Offset

Bit-Offset152331 8 7 0

28

24

20

16

12

8

4

0Byte 3 Byte 2 Byte 1 Byte 0


x86: Speichermodell

Speicher voll byte-adressierbar mis-aligned Zugriffe langsam


x86: Speichermodell

01531

079

status

index, string dst

base of stack segment

index, string src

stackptr

base addr

data, multiply/divide

count: String, Loop

accumulatorAH AL

CH CL

AX

CX

DX

BX

DH DL

BLBH

EAX

ECX

EDX

EBX

ESP

EBP BP

SP

ESI

EDI DI

SI

CS

SS

DS

ES

code segment

stack segment

data segment

extra data segment

FS

GSFPR7

FPR0

FP StatusEIP IP

EFLAGS

PC

8086

Exx ab 386


x86: Register

Statusregister (Pentium)

x86: EFLAGS Register


Adressen: N+4 N+3 N+2 N+1 N

high doubleword low doubleword

high word low word

high low

0313279 63

2**32-1 bits

2**32 -1 bytes

b

bb

(2-complement b/w/dw/qw)

(unsigned b/w/dw/qw)

(32 bit offset)

(16 bit segment + 32 bit offset)

bytes worddoublewordquadword

packed BCD

integerordinalBCD

near pointerfar pointerbit fieldbit stringbyte string

float / double / extended

(one digit per byte, multiple bytes)

(two digits per byte, multiple bytes)

63

15

31


x86: Datentypen: CISC . . .

Stack-Befehle push, pusha, pop, popa

Datenzugriff mov, xchg

Typumwandlung cwd, cdq, cbw (byte->word), movsx, . . .

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)

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, . . .

CISC zusätzlich diverse Ausnahmen/Spezialfälle=>

x86: Befehlssatz


immediate operanddisplacementscale-index-baseaddress mode specifierregister specifieropcodeprefix

ausser dem Opcode alle Bestandteile optionalunterschiedliche Länge der Befehle, von 1 .. 37 Byte

extrem aufwendige Dekodierung=>

2)3)4)5)6)7)

1)(eigentlicher Befehl)

(repeat / segment override / etc.)

(diverse Varianten)

außergewöhnlich komplexes Befehlsformat:

(Speicheradressierung)

(Offset)

(Ziel / Quellregister)

x86: Befehlsformate: CISC . . .


alle Befehle können mit "Modifiern" ergänzt werden:

segment override Addr. aus angewähltem Segmentregister

repeat für Stringoperationen

Umschaltung 16/32-bit

lock Speicherschutz für Multiprozessoren

Operation auf allen Elementen ausführen

address sizeoperand size Umschaltung 16/32-bit

x86: Modifier


Beispiel: x86 Befehlskodierung


1 Byte .. 36 Bytesvollkommen irregulär

Beispiel: x86 Befehle


002a C3 ret 0029 5D popl %ebp 0027 89EC movl %ebp,%esp 0024 8B5DFC movl -4(%ebp),%ebx | } .L18: 0022 75E8 jne .L19 001f 803B00 cmpb $0,(%ebx) 001c 83C408 addl $8,%esp | } 001b 43 incl %ebx | s++; FF 0016 E8FCFFFF call _IO_putc 0015 50 pushl %eax 0012 0FBE03 movsbl (%ebx),%eax 0011 50 pushl %eax 000c A100000000 movl stdout,%eax | putc( *s, stdout ); .L19: .align 4 000a 7418 je .L18 0007 803B00 cmpb $0,(%ebx) | while( *s != 0 ) { 0004 8B5D08 movl 8(%ebp),%ebx 0003 53 pushl %ebx 0001 89E5 movl %esp,%ebp 0000 55 pushl %ebp | void print( char* s ) { print: .text 36210A00 6F207838 0000 48656C6C .string "Hello x86!\n" .text .file "hello.c"------------------------------------------------------------------------------- addr opcode assembler c quellcode

x86: Assembler-Beispiel

------------------------------------------------------------------------------- addr opcode assembler c quellcode

.Lfe1: .Lscope0: 002b 908D7426 .align 16 00 main: 0030 55 pushl %ebp | int main( int argc, char** argv ) { 0031 89E5 movl %esp,%ebp 0033 53 pushl %ebx

0034 BB00000000 movl $.LC0,%ebx | print( "Hello x86!\n" ); 0039 803D0000 cmpb $0,.LC0 000000 0040 741A je .L26 0042 89F6 .align 4 .L24: 0044 A100000000 movl stdout,%eax 0049 50 pushl %eax 004a 0FBE03 movsbl (%ebx),%eax 004d 50 pushl %eax 004e E8FCFFFFFF call _IO_putc 0053 43 incl %ebx 0054 83C408 addl $8,%esp 0057 803B00 cmpb $0,(%ebx) 005a 75E8 jne .L24 .L26: 005c 31C0 xorl %eax,%eax | return 0; 005e 8B5DFC movl -4(%ebp),%ebx | } 0061 89EC movl %ebp,%esp 0063 5D popl %ebp 0064 C3 ret

x86: Assembler-Beispiel (2)

von-Neumann Rechner · von-Neumann Prinzip: Daten und Befehle im Hauptspeicher PC program counter...

Documents

Transcript of von-Neumann Rechner · von-Neumann Prinzip: Daten und Befehle im Hauptspeicher PC program counter...