wiederholung: software-schichten vorlesung t3: kapitel 2 - uni … · 2003-10-31 · 4-bit opcode,...

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

Systemsoftware

Ausrichtung der Daten

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

(CISC, Verwendung in PCs)

(klassischer 32-bit RISC)

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

MIPS

x86

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


Speicher: Wortbreite

Wortbreiten einiger historisch wichtiger Computer

erlaubt 8-bit ASCII, 16-bit Unicode, 32-/64-bit Floating-Point

heute vor allem 8/16/32/64-bit Systeme

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

diverse Varianten möglich

#Worte * #Bits/Wort

Speicherkapazität

Hardwaretechnik | III/2002

Hauptspeicher: Organisation


Big- vs. Little Endian

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

big-endian

little-endian

beide Varianten haben Vor- und Nachteile

komplizierte Umrechnung (siehe nächste Folie)

MSB ... LSB Anordnung, gut für Zahlen

LSB ... 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 adressiert

aber 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: Windows

Aufgabe des Adress-"Dekoders"

Zuordnung von Adressen zu "realen" Speichern

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

ROM mindestens zum Booten notwendig

Aufteilung 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 / 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

Demo und Beispiele später

V86 Bereich00000000h0010FFF0h

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) notwendig

Kernel, Treiber, usw. im oberen 1 GB-Bereich


PC: Windows 9x Speicherbereiche

Aufteilung 1 GB / 1 GB / 2 GB

Adressen 00000000h bis ffffffffh

Windows 9x erlaubt bis 4 GByte Adressraum

BIOS (ROM) am oberen Ende

des Adressbereichs

nutzbarer Hauptspeicher

oberhalb ab 1 MB

Speicherbereiche für

Systemaufgaben (hier

Framebuffer der Graphikkarten)

PC: Speicherbereiche, Beispiel


eingeschränkte Autokonfiguration über PnP-BIOS

I/O-Adressraum gesamt nur 64 KByte

je 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 Befehls

IR instruction register aktueller Befehl

ACC accumulator

registerbank

ein oder mehrere

Rechenregister (Operanden)R0..R31

man braucht mindestens diese Register:=>

Befehlszyklus: (in Endlosschleife):

Programmzähler PC addressiert den Speicher

Befehl dekodieren

Befehl 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 Prozessors

dort liegt ein ROM mit dem Boot-Programm

Konfiguration des Chipsatzes

Löschen und Initialisieren der Caches

Prozessor greift auf die Startadresse zu

Befehlszyklus wird gestartet

PC 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 Befehls

bei CISC-Maschinen evtl. weitere Zugriffe notwendig,

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

Programmzähler wird inkrementiert

Lesezugriff auf den Speicher

Programmzä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 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

Realisierung über festverdrahtete Hardware

Realisierung des Mikroprogramms für den D*CORE

Demo (bzw. im T3-Praktikum):

Beispiele:

Schiebe-Operationen

load, store, I/O

Befehls-"Klassen":


Welche Befehle braucht man?

arithmetische Operationen add, sub, mult, div

logische Operationen

shift-left, rotate

and, or, xor

Vergleichsoperationen

jump, branch

call, 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 Speicheroperanden

viele Adressierungsarten

komplexe Befehlskodierung, Befehle variabler Länge

typische Merkmale:

mit irregulärem, komplexem Befehlssatz

Bezeichnung 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 Rechnerarchitekturen

entwickelt ab ca. 1980 bei IBM, Stanford, Berkeley

IBM 801, MIPS, SPARC, DEC Alpha, ARM

Diskussion und Details CISC vs. RISC später

optimierende Compiler statt Assemblerprogrammierung

Load-Store Architektur, keine Speicheroperanden

viele 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 haben

direkt 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 0 000 00 0 000 1 000011 001110010031

Beispiel:


Befehlsformat: Einteilung in Felder

Opcode Immediate-Wert

Zielregister

1111 1 0 0 000 00 0 000 1 000011 001110010031

unbenutzt

für Speicherzugriffe

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

Werte direkt im Befehl

Operanden / Resultat

Speicher-Adressen

Immediate-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 Befehls

erster 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"

=>

Basisadresse

Zielregister

base register

destination 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: Opcode

rs:

Typ des Befehls

rt:

MIPS

sehr einfacher Befehlssatz, 3-Adress-Befehle

SW muß sogar HW-Konflikte ("Hazards") vermeiden

keinerlei HW-Unterstützung für "komplexe" SW-Konstrukte

Koprozessor-Konzept zur Erweiterung

32 Register: R0 ist konstant Null, R1 .. R31 Universalregister

32-bit Wortbreite, 32-bit Speicher, 32-bit Befehle

klassische 32-bit RISC Architektur

"Microprocessor without interlocked pipeline stages"


Einsatz: eingebettete Systeme, SGI Workstations/Server

entwickelt 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 Universalregister

32 Register, R0 .. R1, jeweils 32-bit

dies erlaubt einige Tricks:

R5 = -R5 sub R5, R0, R5

R4 = 0 add R4, R0, R0

R3 = 17 addi R3, R0, 17

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

keine separaten Statusflags

Vergleichsoperationen setzen Zielregister auf 0 bzw. 1:

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

MIPS: Befehlssatz


Übersicht und Details: siehe Hennessy&Patterson

3 Befehlsformate: ALU, ALU Immediate, Load/Store, Branch

MIPS: Hardwarestruktur


PC

I-Cache ($0 .. $31)

Register ALUs Speicher

D-Cache

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

gleiches Registermodell, aber nur 16-bit Wortbreite

Subset der Befehle, einfachere Kodierung

vollständiger Hardwareaufbau in Hades verfügbar

32-bit RISC Architektur, Motorola 1998

M*CORE

PC

R0 .. R15

C ("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

mov

addu, addc

subu

and, or xor

lsl, lsr, asr

cmpe, cmpne, ...

ldw, stw

bt, bf

jsr

br, jmp

trap

rfi

move register

logische Operationen

Addition (ohne, mit Carry)

Subtraktion

logische, arithmetische Shifts

Vergleichsoperationen

Speicherzugriffe, load/store

unbedingte Spünge

bedingte Sprünge

Unterprogrammaufruf

Software interrupt

return from interrupt

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

einfaches Zerlegen des Befehls in die einzelnen Felder

4-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 Registerzugriff

mö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önnen

typische arithmetische Operation nutzt 3 Variablen

woher kommen die Operanden?

wo soll das Resultat hin?

Speicher

Register

reg2 = reg4 + reg5

entsprechende Klassifikation der Architektur

(floating point ops.)

interne Hilfsregister

compare

shift, rotate

and, 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 Hauptspeicher

typ. Operation: zwei Operanden, ein Resultat

"Multiport-Speicher": mit drei Ports ?!

statt dessen:

Register im Prozessor zur Zwischenspeicherung

Datentransfer zwischen Speicher und Registern

RISC: Rechenbefehle arbeiten nur mit Registern

CISC: 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 + Z

sehr flexibel, leicht zu programmieren

Befehl muss 3 Adressen speichern

2-Adress-Format X = X + Z

eine Adresse doppelt verwendet,

für Resultat und einen Operanden

Format wird häufig verwendet

1-Adress-Format

alle Befehle nutzen das Akkumulator-Reg.

ACC = ACC + Z

häufig in älteren / 8-bit Rechnern

0-Adress-Format TOS = TOS + NOS

Stapelspeicher (top of stack, next of stack)

Adressverwaltung entfällt

im 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 Pointers

zweiter Speicherzugriff liefert Operanden

Adresse eines Pointers steht im Befehl

"direkt"

"indirekt"

Adressbereich beschränkt

ein zusätzlicher Speicherzugriff

keine zusätzliche Adressberechnung

Adresse des Operanden steht im Befehl

aber Länge des Operanden beschränkt

kein zusätzlicher Speicherzugriff

Operand steht direkt im Befehl"immediate"


Adressierungsarten (1)

Adressierungsarten (2)

(andere Bezeichnung: "Versatz-Modus")

Hauptmodus in RISC-Rechnern

ideal für Array- und Objektzugriffe

Speicherzugriff auf (Basisaddresse+offset)

Angabe mit Register und Offset

Inhalt des Registers liefert Basisadresse

"indiziert"

mit der Speicheradresse des Operanden

Befehl spezifiziert ein Register"register-indirekt"

genug Platz für 2- oder 3-Adress Formate

32 Register: benötigt 5 bit im Befehl

wie Direktmodus, aber Register statt Speicher"register"



(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 Shift

mehrere 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 Speicherzugriff

z.B. R3 = Immediate16

Registerbank

Speicher

z.B. R3 = MEM[ addr32 ]

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

direkte Adressierung

"direkt"



Adresse des Operanden steht im Befehl


31 015

opcode regs unused

addr 32

typische CISC-Adressierungsart, viele Taktzyklen

kommt bei RISC-Rechnern nicht vor

3

4

2

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

tmp1

zwei zusätzliche Speicherzugriffe


Adresse 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 Maschine

1-Adress (Akkumulator) Maschine. 8-bit Microcontroller

2-Adress Maschine:

einige x86 Befehle

einige 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: CISC

historisch 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

word

doubleword

quadword

packed BCD

integer

ordinal

BCD

near pointer

far pointer

bit field

bit string

byte 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 operand

displacement

scale-index-base

address mode specifier

register specifier

opcode

prefix

ausser dem Opcode alle Bestandteile optional

unterschiedliche 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 size

operand size Umschaltung 16/32-bit

x86: Modifier


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)

Beispiel: x86 Befehlskodierung


1 Byte .. 36 Bytes

vollkommen irregulär

Beispiel: x86 Befehle


wiederholung: software-schichten vorlesung t3: kapitel 2 - uni … · 2003-10-31 · 4-bit opcode,...

Documents