Opens internal link in current window

Opens internal link in current window
Vorlesung Rechnerarchitektur
RISC Prozessoren am Beispiel ARM
CISC Kriterien
Befehle unterschiedlicher Länge von 1 - 17 Byte.
 Speichereffizient
 komplexe Befehlsdekodierung
Komplexer Befehlssatz
 Anpassung an Compiler
 Hochsprachenkonstrukte im Assembler zu Erleichterung der
Assemblerprogrammierung
 Kurze Programme, da mächtige Befehle
Direkte Operationen im Speicher
 Register waren teuer, daher nur wenige Register
 Unterschied in Zugriffszeit zwischen Register und Speicher war nicht sehr hoch
Komplexe Adressierung des Speichers
 Kurze CPU Wortlängen führen zu komplexen Zugriffsverfahren bei der
Vorlesung Rechnerarchitektur
© Gerhard
SS 2015,als
h_da - die
Fachbereich
Informatik
Adressierung in Bereichen
dieRaffius,,
größer
Wortlänge
der CPU sind
2
RISC Prinzipien
Befehle gleicher Länge (meist 32 Bit)
Abarbeiten mit gleicher Taktzahl: erlaubt Befehlspipelines
Eingeschränkter Befehlssatz (32 - 128 Befehle)
Explizite Lade/Speicher-Befehle
3-Adress-Befehle
Delayed Branches
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
3
Speicherorganisation Little/Big Endian
Little Endian
Speicherorganisation
8086, Windows
String
byte 0
byte 1
Halb Wort 1
byte 1 byte 0
byte 3
4D
byte 2
Big Endian
Speicherorganisation
Motorola, SPARC
String
byte 3
Halb Wort 2
byte 1 byte 0
Wort 1
byte 2 byte 1
3C
2B
byte 0
1A
aufsteigende Byteadressen
1000
byte 0
byte 1
Halb Wort 1
byte 0 byte 1
byte 0
1A
byte 2
byte 3
Halb Wort 2
byte 0 byte 1
Wort 1
byte 1 byte 2
2B
3C
byte 3
4D
aufsteigende Byteadressen
1003
1000
1003
Hexadezimal 1A2B3C4D = binär 0001 1010 0010 1011 0011 1100 0100 1101
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
4
Bedeutung des Befehlssatzes (ISA)
Befehlssatz = Instruction Set
Architecture (ISA)
Der ISA Level ist das Interface
zwischen der Software und der
Hardware
Der ISA Level definiert die
Sprache, die sowohl von der
Software als auch von der
Hardware verstanden werden
muß.
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
5
4 Adress Befehle
f Bit
n Bit
n Bit
n Bit
n Bit
Funktion
Funktion
Adr.
Adr. Op1
Op1
Adr.
Adr. Op2
Op2
Zieladr.
Zieladr.
Adr.
Adr. next
next
ADD d, s1, s2, next_i;
d = s1 + s2
Allgemeinste Form für ein Befehlsformat
schwierig zu programmieren
wird für Microcode verwendet
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
6
3 Adress Befehle
f Bit
n Bit
n Bit
n Bit
Funktion
Funktion
Adr.
Adr. Op1
Op1
Adr.
Adr. Op2
Op2
Zieladr.
Zieladr.
ADD d, s1, s2;
d = s1 + s2
Standard bei RISC Prozessoren
Die 3 Adressen benötigen Platz, so dass dieses Format erst ab einem 32 Bit
Befehlssatz sinnvoll ist
Die nächste Befehlsadresse ist implizit. Nur Sprungbefehle können das implizite
Verhalten ändern
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
7
2 Adress Befehlsformat
n Bit
f Bit
Funktion
Funktion
n Bit
Adr.
Adr. Op1
Op1
ADD d, s1;
Zieladr.
Zieladr.
d = d + s1
Standardformat für 8 und 16 Bit Mikroprozessoren
Format für die Intel Prozessoren
Risc Prozessoren mit komprimiertem 16 Bit Befehlssatz nutzen ebenfalls dieses
Format (ARM Thumb, MIPS)
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
8
1 Adress Befehle
f Bit
n Bit
Funktion
Funktion
Adr.
Adr. Op1
Op1
ADD s1; acc = acc + s1
Das Zielregister ist implizit und wird häufig Akkumulator genannt
Wird im MU0 Design benutzt
Hohe Befehlsdichte, aber geringe Flexibilität
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
9
0-Adress Befehle
f Bit
Funktion
Funktion
ADD
;
top_of_stack = top_of_stack + next_on_stack
Beide Operanden und das Ziel sind implizit
Befehlssatz ist nur für eine Stackarchitektur möglich
Wird benutzt in der Java Virtual Machine
Es sind weitere Befehle mit Operanden zum Speichern und Laden des Stacks nötig
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
10
Steuerung
Adressen
adress
adress register
register
Die ARM7
Datenpfad
Architektur
pp
cc
incrementer
incrementer
B Bus
register
register
bank
bank
A Bus
instruction
instruction
decode
decode
and
and
control
control
multiply
multiply
register
register
C Bus
barrel
barrel
shifter
shifter
Alu
Alu
data
data out
out register
register
data
data in
in register
register
Daten
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
11
Die ARM7 ALU
AA Operand
Operand Speicher
Speicher
BB Operand
Operand Speicher
Speicher
XOR
XOR Gatter
Gatter
XOR
XOR Gatter
Gatter
Logische
Logische
Funktionen
Funktionen
Addierer
Addierer
Ergebnis
Ergebnis Multiplexer
Multiplexer
Null
Null Erkennung
Erkennung
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
12
Die ARM7 Pipeline für ALU Befehle
fetch
fetch
decode
decode
execute
execute
fetch
fetch
decode
decode
execute
execute
fetch
fetch
decode
decode
execute
execute
Zeit
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
13
Pipelines
1
2
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
3
res
res
Zeit
fetch – den nächsten Befehl aus dem Speicher holen
dec - Befehl dekodieren um Befehlsart zu ermitteln
reg - Operanden aus der Registerbank holen
ALU – Alu Berechnung oder Speicheradresse berechnen
mem – Zugriff auf Speicher
res – Ergebnis in Registerbank zurückschreiben
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
14
Die ARM7 Pipeline für Load/Store Befehle
Hazard in von Neumann Architekturen
fetch
fetch Add
Add
decode
decode
execute
execute
fetch
fetch Str
Str
decode
decode
calc
calc Addr
Addr data
data xfer
xfer
fetch
fetch Add
Add
decode
decode
fetch
fetch Add
Add
execute
execute
decode
decode
execute
execute
fetch
fetch Add
Add
decode
decode
execute
execute
Zeit
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
15
Pipeline Hazard durch Registerzugriff
read after write Hazard
1
2
fetch
fetch
dec
dec
reg
reg
fetch
fetch
dec
dec
ALU
ALU
mem
mem
res
res
stall
stall
reg
reg
ALU
ALU
mem
mem
res
res
Zeit
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
16
Pipeline Hazard durch Sprungbefehl
Sprung Verhalten einer Pipeline
1
2
3
4
5
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
fetch
fetch
dec
dec
reg
reg
ALU
ALU
mem
mem
res
res
Zeit
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
17
Architektonisches Erbe der ARM Prozessoren
Verwendete RISC Merkmale
 Load/Store Architektur
 32 Bit Befehle fester Länge
 3 Adress Befehlsformat
Verworfene Merkmale
 Registerfenster
− wird nur bei SPARC Prozessoren genutzt
 Delayed Branches
− der dem Branch folgende Befehl wird ausgeführt bevor der Sprung durchgeführt wird
− Behandlung von Interrupts und anderen Exceptions wird deutlich schwieriger
 Ausführung aller Befehle in einem Taktzyklus
− setzt eine Harvard Architektur voraus
− Kompensation durch verbesserte Adressierungsmodi
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
18
ARM Registerstruktur
r0
r0
r1
r1
r2
r2
r3
r3
r4
r4
r5
r5
r6
r6
r7
r7
r8
r8
r9
r9
r10
r10
r11
r11
r12
r12
r13
r13
r14
r14
r15(PC)
r15(PC)
CPSR
CPSR
user mode
b10000
r8_fiq
r8_fiq
r9_fiq
r9_fiq
r10_fiq
r10_fiq
r11_fiq
r11_fiq
r12_fiq
r12_fiq
r13_fiq
r13_fiq
r14_fiq
r14_fiq
SPSR_fiq
SPSR_fiq
Fiq mode
b10001
r13_svc
r13_svc
r14_svc
r14_svc
SPSR_svc
SPSR_svc
r13_abt
r13_abt
r14_abt
r14_abt
SPSR_abt
SPSR_abt
r13_irq
r13_irq
r14_irq
r14_irq
SPSR_irq
SPSR_irq
Svc mode Abort mode Irq mode
b10011
b10111
b10010
r13_und
r13_und
r14_und
r14_und
SPSR_und
SPSR_und
Undefined mode
b11011
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
19
Current Program Status Register
31
N
Z
C
28
27
V
Q
24
23
16
undefined
15
8
undefined
Condition Code Flags
 N = Negatives ALU Ergebnis
 Z = Alu Ergebnis ist Null
 C = Alu Ergebnis erzeugte
Carry
 V = Alu erzeugte Overflow
Interrupt Disable Bits
 I = 1, disables IRQ
 F = 1, disables FIQ
7
6
5
I
F
T
4
0
mode
T Bit
 T = 0, Prozessor in Arm State
 T = 1, Prozessor in Thumb
State
Mode Bits
 Spezifizieren den Prozessor
Mode
Current Program Status Register (CPSR)
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
20
Die Statusberechnung am Beispiel eines 8 Bit
Rechners
or
xor
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
21
Arithmetische und logische Befehle
Die Arithmetischen Befehle der ARM
Befehl
Operation
Prozessoren sind 3 Register Befehle
AND
Rd = Op1 AND Op2
EOR
Rd = Op1 EOR Op2
SUB
Rd = Op1 - Op2
die beiden Operanden angegeben
RSB
Rd = Op2 – Op1
Beispiel
ADD
Rd = Op1 + Op2
ADC
Rd = Op1 + Op2 + Carrybit
SBC
Rd = Op1 - Op2 + Carrybit -1
RSC
Rd = Op2 – Op1 + Carrybit -1
TST
setzt CC bzgl. Op1 AND Op2
werden nur bei den Test und Compare
TEQ
setzt CC bzgl. Op1 EOR Op2
Befehlen automatisch gesetzt.
CMP
setzt CC bzgl. Op1 - Op2
CMN
setzt CC bzgl. Op1 + Op2
ORR
Rd = Op1 ORR Op2
MOV
Rd = Op2
BIC
Rd = Op1 AND NOT Op2
MVN
Rd = NOT Op2
Im Befehl werden das Zielregister und
 add r0, r0, r3
Die Bedingungsbits des Statusregisters
Alle anderen Befehle müssen die
Statusbits explizit setzen
Beispiel
 subs r0, r0, #1
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
22
Ein erstes ARM Programm (GNU)
.file „add.S"
.text
.align 2
.global
main
.type main,function
main:
MOV
r0, #0
LDR
r0, Zahl
ADD
r1, r0, #1
SUB
r2, r1, r0
MOV
pc, lr
Zahl:
.word
100
.Lfe1:
.size main,.Lfe1-main
.ident"GCC: (GNU) 3.2.1"
// terminiere
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
23
Benutzung des Barrel Shifters
Register, Optional kann eine Shift
Operation angwandt werden
Operand 1
Operand 2
Shift Werte können sein
5 Bit unsigned Integer
Wert in einem anderen Register
Barrel Shifter
ALU
Wird benutzt zur Multiplikation mit
Konstanten
Immediate Wert + Shift Operation
8 Bit Zahl im Bereich zwischen 0 und 255
kann nach links oder rechts verschoben werde
Ergebnis
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
24
Multiplikation mit einer Konstanten
Multiplikationen mit Konstanten die sich als 2x oder als 2x ± 1
darstellen lassen können in einem Zyklus durchgeführt werden
Beispiel: Multiplikation mit 5
 add r0, r1, r1, LSL #2
Durch Zusammensetzen mehrerer Instruktionen können auch
komplexere Multiplikationen durchgeführt werden
Beispiel: Multiplikation mit 10
 add r0, r1, r1, LSL #2
 mov r0, r0, LSL #1
Beipiel Multiplikation mit 119 = 17 * 7 = (16 + 1) * (8 - 1)
 add r2, r3, r3, LSL #4
 rsb r2, r2, r2, LSL #3
// r2 = r3 * 17
// r2 = r2 * 7
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
25
Multiplikation mit einer Konstanten
Multiplikationen mit Konstanten die sich als 2x oder als 2x ± 1
darstellen lassen können in einem Zyklus durchgeführt werden
Beispiel: Multiplikation mit 5
 add r0, r1, r1, LSL #2
Durch Zusammensetzen mehrerer Instruktionen können auch
komplexere Multiplikationen durchgeführt werden
Beispiel: Multiplikation mit 10
 add r0, r1, r1, LSL #2
 LSL r0, r0, #1
Beipiel Multiplikation mit 119 = 17 * 7 = (16 + 1) * (8 - 1)
 add r2, r3, r3, LSL #4
 rsb r2, r2, r2, LSL #3
// r2 = r3 * 17
// r2 = r2 * 7
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
26
Grundsätzliches zu ARM
Drei Befehlstypen
Befehle zur Datenverarbeitung (z.B. Addition)
Befehle zur Adressierung (z.B. Speicherzugriffe)
Ablaufsteuerung (z.B. Verzweigungen)
Regeln:
Alle Operanden sind 32 Bit (Quelle: Register, Konstanten)
Das Ergebnis ist 32 Bit und wird in einem Register abgelegt
3 Operanden: 2 als Input 1 Operand für das Ergebnis
Beispiel:
ADD R0, R1, R2
R0 := R1 + R2
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
27
Operation Codes - Arithmetik
Opcode
Mnemonic
Operation
0000
AND
Rd:= Op1 AND Op2
0001
EOR
Rd:= Op1 EOR Op2
0010
SUB
Rd:= Op1 - Op2
0011
RSB
Rd:= Op2 - Op1
0100
ADD
Rd:= Op1 + Op2
0101
ADC
Rd:= Op1 + Op2 + C
0110
SBC
Rd:= Op1 - Op2 + C - 1
0111
RSC
Rd:= Op2 - Op1 + C - 1
1000
TST
set condition codes on Op1 AND Op2
1001
TEQ
set condition codes on Op1 EOR Op2
1010
CMP
set condition codes on Op1 - Op2
1011
CMN
set condition codes on Op1 + Op2
1100
ORR
Rd:= Op1 OR Op2
1101
MOV
Rd:= Op2
1110
BIC
Rd:= Op1 AND NOT Op2
1111
MVN
Rd:= NOT Op2
bedingte Ausführung möglich
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
29
Bedingte Ausführung
Befehlsergänzung
Condition Codes im
CPSR
Bedeutung
EQ
Bits 28-31
einer
Instruktion
0000
Z gesetzt
gleich
NE
0001
Z gelöscht
ungleich
CS/HS
0010
C gesetzt
unsigned >=
CC/LO
0011
C gelöscht
unsigned <
MI
0100
N gesetzt
negativ
PL
0101
N gelöscht
positiv oder Null
VS
0110
V gesetzt
Überlauf
VC
0111
V gelöscht
kein Überlauf
HI
1000
C gesetzt und Z gelöscht
unsigned >
LS
1001
C gelöscht oder Z gesetzt
unsigned <=
GE
1010
N gleich V
signed >=
LT
1011
N ungleich V
signed <
GT
1100
Z gelöscht, N gleich V
signed >
LE
1101
Z gesetzt, N ungleich V
signed <=
AL
1110
Always
Default, falls nichts
angegeben
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
30
Operand 2 als Konstante
Befehlsformat für Datenverarbeitungsbefehle reserviert 12 Bits für Operand 2
 ergäbe einen Wertebereich von max. 2^12 = 4096
 aufgeteilt in Wertebereich mit 8 Bits ( 0 – 255 )
Diese 8 Bits können (rechts) rotiert werden mit einer geraden Anzahl von
Positionen (ROR mit 0, 2, 4,..30).
Ergibt eine weitaus größere Abdeckung des Zahlenbereiches.
Einige Konstanten müssen dennoch vom Speicher geladen werden.
immediate=(0→ 255)∗2 2n
0⩽ n⩽ 15
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
31
Operand 2 als Konstante
Wertebereich:
0 - 255
[0 - 0xff]
256,260,264,..,1020
[0x100-0x3fc, step 4, 0x40-0xff ror 30]
1024,1040,1056,..,4080
[0x400-0xff0, step 16, 0x40-0xff ror 28]
4096,4160, 4224,..,16320
[0x1000-0x3fc0, step 64, 0x40-0xff ror 26]
Beispiel MOV - Befehl:
MOV r0, #0xFF000000
; => MOV r0, #0xFF, 8
Beispiel MVN: erzeugt das bitweise Komplement (1er Komplement)
MOV r0, #0xFFFFFFFF
; umgesetzt zu MVN r0, #0
Falls die benötigten Konstanten nicht erzeugt werden können, erzeugt der
Assembler eine Fehlermeldung
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
32
Arithmetische und logische Befehle
31
28 27 26 25 24
cond
0
0
#
21 20 19
opcode
S
16 15
Rn
12 11
0
Rd
operand2
destination register
first operand register
set condition codes
arithmetic/logic function
11
1
8
7
0
#rot
8-bit-immediate
immediate alignment
11
7
#shift
6
5
SH
4
3
0
0
Rm
immediate shift length
0
shift type
second operand register
11
8
Rs
7
0
6
5
SH
4
1
3
0
Rm
register shift length
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
33
Multiplikation
31
28 27
cond
0
24 23
0
0
0
20 19
mul
S
16 15
Rd/RdHi
12 11
Rn/RdLo
Assembler Format
MUL{cond}{S} Rd, Rm, Rs
MLA{cond}{S} Rd, Rm, Rs, Rn
<mul>{cond}{S} RdHi, RdLo, Rm, Rs
Opcode [23:21]
8
Rs
7
1
4
0
0
3
1
0
Rm
Bit 7 ist bei den anderen
arithmetischen Befehlen 0,
wenn Bit 4 auf 1 steht!
Mnemonic
Bedeutung
Effekt
000
MUL
Multiply (32 Bit Ergebnis)
Rd := (Rm * Rs) [31:0]
001
MLA
Multiply-accumulate (32 Bit Ergebnis)
Rd := (Rm * Rs + Rn) [31:0]
100
UMULL
Unsigned multiply long
RdHi:RdLo := Rm * Rs
101
UMLAL
Unsigned multiply-accumulate long
RdHi:RdLo += Rm * Rs
110
SMULL
Signed multiply long
RdHi:RdLo := Rm * Rs
111
SMLAL
Signed multiply-accumulate long
RdHi:RdLo += Rm * Rs
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
34
Übung 1
1. Welche Befehle implementieren folgende Zuweisungen:
a) r0 = 16
b) r1 = r0 * 4
c) r0 = r1 / 16 ( r1 2er-Kompl. mit Vorz.) d) r1 = r2 * 7
2. Was machen folgende Befehle ?
a) ADDS r0, r1, r1, LSL #2
b) RSB r2, r1, #0
3. Was ergibt folgende Befehlssequenz ?
ADD r0, r1, r1, LSL #1
SUB r0, r0, r1, LSL #4
ADD r0, r0, r1, LSL #7
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
35
Übung 2
r0 = 0xAABBCCDD
EOR r1, r0, r0, ror #16
BIC r1, r1, #0xFF0000
ROR r0, r0, #8
EOR r0, r0, r1, lsr #8
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
36
Grundsätzliches zu ARM
Drei prinzipielle Befehlstypen
Befehle zur Datenverarbeitung (z.B. Addition)
Befehle zur Adressierung (z.B. Speicherzugriffe)
Befehle zur Ablaufsteuerung (z.B. Verzweigungen)
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
37
Sprungbefehle
Sprungbefehle dienen dazu den Kontrollfluss
Branch
Interpretation
von Programmen zu kontrollieren
B
ohne Bedingung
In der Kombination mit Vergleichsbefehlen
BAL
always
BEQ
equal
BNE
not equal
BPL
plus
BMI
minus
BCC
carry clear
Das Ziel einer Sprunganweisung ist immer
BLO
lower
eine Marke (engl. Label).
BCS
carry set
BHS
higher or same
BVC
overflow clear
BVS
overflow set
BGT
greater than
BGE
greater or equal
BLT
less than
BLE
less or equal
BHI
higher
BLS
lower or same
können mit Ihnen alle wichtigen
Kontrollflussanweisungen wie „if.. else“,
„while“, „for“ oder „switch“ realisiert werden.
Beispiel:
Beispiel:
CMP
CMP R0,
R0, #0
#0
BNE
Marke1
BNE
Marke1
…..
…..
…..
…..
…..
…..
…..
…..
Marke1:
Marke1: MOV
MOV R5,
R5, #5
#5
…..
…..
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
38
Grundsätzliches zu ARM
Drei prinzipielle Befehlstypen
Befehle zur Datenverarbeitung (z.B. Addition)
Befehle zur Adressierung (z.B. Speicherzugriffe)
Befehle zur Ablaufsteuerung (z.B. Verzweigungen)
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
39
Datentransfer Befehle
3 Arten von Datentransfer Befehlen
 Einzeltransfer Load/Store Befehle
 Blocktransfer Load/Store (multiple) Befehle
 Einzelregister Transfer Befehl (MOV, MVN, MRS, MSR)
Verschiedene Möglichkeiten der Adressierung
 Immediate Adressierung (z.B. MOV R1, #4)
 Register Adressierung (z.B. ADD R1, R2, R3)
 Register Indirekte Adressierung
 Laden von Adressen in Register
 Register Indizierte Adressierung
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
40
Immediate Adressierung
Bei der Immediate Adressierung wird ein Operand direkt im Befehl gespeichert
ARM:
mov R0, #8
; Lade in das Register R0 den Wert 8
Bei Intel Prozessoren kann der Immediate Wert eine Größe von 32 Bit besitzen
Bei den meisten Risc Prozessoren ist der Immediate Wert deutlich kleiner (12 Bit
bei ARM)
Da der Wert im Befehl enthalten ist, ist für Immediate Adressierung kein weiterer
Speicherzugriff erforderlich
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
41
Immediate Adressierung
Immediate
Immediate Adressierung
Adressierung
Register
Register
Speicher
Speicher
Instruction
Instruction
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
42
Direkte Adressierung
Die Adresse von der ein Wert geladen werden soll, befindet sich im Opcode.
Nachteil: die Adresse kann zur Laufzeit nicht mehr geändert werden
Risc Prozessoren können keine 32 Bit Adressen in ihrem Opcode unterbringen,
daher beherrschen sie diese Adressierungsart nicht
Beispiel Intel
mov
...
...
hugo
ax, hugo
dw
?
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
43
Direkte Adressierung
Speicher
Speicher Adressierung
Adressierung
Speicher
Speicher
Register
Register
Instruction
Instruction
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
44
Register Adressierung
Register Adressierung ist vom Konzept identisch zur direkten Adressierung, nur
dass jetzt statt der Speicheradresse eine Registeradresse benutzt wird.
Intel
add
ax, bx
ARM
add
r0, r1, r2
In Load-Store-Architekturen nutzen alle Befehle diese Adressierungsart, außer
den Load und Store Befehlen selbst. Aber auch bei diesen Befehlen ist das Ziel
oder die Quelle ein Register
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
45
Register Adressierung
Register
Register Adressierung
Adressierung
Registerbank
Registerbank
Register
Register
Instruction
Instruction
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
46
Register Indirekte Adressierung
In dieser Adressierungsart kommt auch einer der Operanden aus dem Speicher,
aber die Adresse des Speichers steht in einem Register. (Adressierung über
Pointer)
Der Vorteil dieser Adressierungsart ist, daß man den gesamten Speicherbereich
adressieren kann, ohne daß man eine Adresse in der Instruktion unterbringen
muss.
Intel
mov ax, [bx]
ARM
ldr r0, [r1]
Diese Adressierungsart ist in Load und Store Architekturen nur in den Load und
Store Befehlen erlaubt
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
47
Register indirekte Adressierung
Register
Register Indirekte
Indirekte Adressierung
Adressierung
Speicher
Speicher
Register
Register
Register
Register
Instruction
Instruction
Benutzt einen Registerwert (Basisregister) als Speicheradresse
zum Laden oder Speichern des Wertes an dieser Adresse
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
48
Laden von Adressen in Register
Wie kann das Basisregister initialisiert werden
Das Laden einer 32 Bit Adresse in ein Register erfolgt mit Hilfe von
Pseudoinstruktionen, die der Assembler mit Hilfe eines Satzes von Regeln auf
bestmögliche Art abbildet
ADR
R1, Table1
....
...
Table1
Die Umsetzung des ADR Befehls erfolgt vorzugsweise durch einen Offset zum
Program Counter (PC=R15). Der Offset kann bis zu 1 KB betragen.
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
49
Laden von Adressen in Register (2)
Beispiel: Kopieren von Daten aus Tabelle 1 in Tabelle 2
copy
copy
Table1
Table1
Table2
Table2
ADR
ADR
ADR
ADR
LDR
LDR
STR
STR
....
....
....
....
....
....
....
....
....
....
r1,
r1, Table1
Table1
r2,
r2, Table2
Table2
r0,
r0, [r1]
[r1]
r0,[r2]
r0,[r2]
;; r1
r1 zeigt
zeigt auf
auf Table1
Table1
;; r2
r2 zeigt
zeigt auf
auf Table2
Table2
;; lade
lade ersten
ersten Wert
Wert
;; speichere
speichere ihn
ihn in
in Tabelle2
Tabelle2
;; Quelle
Quelle der
der Daten
Daten
;; Ziel
Ziel der
der Daten
Daten
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
50
Laden von Adressen in Register (3)
Weiterentwicklung des Beispiels: Kopieren von Daten
copy
copy
Table1
Table1
Table2
Table2
ADR
ADR
ADR
ADR
LDR
LDR
STR
STR
ADD
ADD
ADD
ADD
....
....
....
....
....
....
....
....
r1,
r1, Table1
Table1
r2,
r2, Table2
Table2
r0,
r0, [r1]
[r1]
r0,[r2]
r0,[r2]
r1,
r1, #4
#4
r2,
r2, #4
#4
;; r1
r1 zeigt
zeigt auf
auf Table1
Table1
;; r2
r2 zeigt
zeigt auf
auf Table2
Table2
;; lade
lade ersten
ersten Wert
Wert
;; speichere
speichere ihn
ihn in
in Tabelle2
Tabelle2
;; Lesezeiger
Lesezeiger verschieben
verschieben
;; Schreibzeiger
Schreibzeiger verschieben
verschieben
;; Quelle
Quelle der
der Daten
Daten
;; Ziel
Ziel der
der Daten
Daten
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
51
Indizierte Adressierung
Es kommt sehr häufig vor, daß auf Speicher zugegriffen wird, der einen
Offset relativ zu einer Basisadresse besitzt
Adressierung über ein Register plus einem konstanten Offset wird
indexed adressing genannt
Beispiele:
 Zugriff auf Strukturen
 Zugriff in Arrays
ARM
ldr r0, [r1, #4]
ldr r0, [r1, #4]!
ldr r0, [r1], #4
; pre indexed
; pre indexed mit write back
; post indexed mit write back
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
52
Index Adressierung
Register
Register ++ Offset
Offset Adressierung
Adressierung
Speicher
Speicher
Register
Register
Register
Register
Instruction
Instruction
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
53
Indizierte Adressierung (2)
Optimierung des Beispiels: Kopieren von Daten
copy
copy
Table1
Table1
Table2
Table2
ADR
ADR
ADR
ADR
LDR
LDR
STR
STR
LDR
LDR
STR
STR
....
....
....
....
....
....
....
....
r1,
r1, Table1
Table1
r2,
r2, Table2
Table2
r0,
r0, [r1]
[r1]
r0,
r0, [r2]
[r2]
r0,
r0, [r1,
[r1, #4]
#4]
r0,
r0, [r2,
[r2, #4]
#4]
;; r1
r1 zeigt
zeigt auf
auf Table1
Table1
;; r2
r2 zeigt
zeigt auf
auf Table2
Table2
;; lade
lade ersten
ersten Wert
Wert
;; speichere
speichere ihn
ihn in
in Tabelle2
Tabelle2
;; lade
lade zweiten
zweiten Wert
Wert
;; speichere
speichere ihn
ihn in
in Tabelle2
Tabelle2
;; Quelle
Quelle der
der Daten
Daten
;; Ziel
Ziel der
der Daten
Daten
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
54
Indizierte Adressierung (3)
ARM
ldr r0, [r1, #4]
ldr r0, [r1, #4]!
ldr r0, [r1], #4
; pre indexed
; pre indexed mit write back
; post indexed, write back ist implizit
LDR
LDR r0,
r0, [r1,
[r1, #4]
#4]
;; r0
[r1+4]
r0 == mem
mem32
[r1+4]
32
LDR
LDR r0,
r0, [r1,
[r1, #4]!
#4]!
;; r0
[r1+4]
r0 == mem
mem32
[r1+4]
32
;; r1
r1 == r1
r1 ++ 44
LDR
LDR r0,
r0, [r1],
[r1], #4
#4
;; r0
[r1]
r0 == mem
mem32
[r1]
32
;; r1
r1 == r1
r1 ++ 44
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
55
Indizierte Adressierung (4)
Optimierung des Beispiels: Kopieren von Daten
copy
copy
loop
loop
Table1
Table1
Table2
Table2
ADR
ADR
ADR
ADR
LDR
LDR
STR
STR
???
???
....
....
....
....
....
....
....
....
r1,
r1, Table1
Table1
r2,
r2, Table2
Table2
r0,
r0, [r1],
[r1], #4
#4
r0,
r0, [r2],
[r2], #4
#4
;; r1
r1 zeigt
zeigt auf
auf Table1
Table1
;; r2
r2 zeigt
zeigt auf
auf Table2
Table2
;; lade
lade ersten
ersten Wert
Wert
;; speichere
speichere ihn
ihn in
in Tabelle2
Tabelle2
;; zurück
zurück zu
zu loop
loop
;; Quelle
Quelle der
der Daten
Daten
;; Ziel
Ziel der
der Daten
Daten
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
56
Basis indizierte Adressierung
Moderne Prozessoren besitzen häufig noch eine Adressierungsart in der zu dem
Indexregister noch ein Basisregister addiert wird
Anwendungen
 Vektoradressierung
 Stackadressierung
ARM
 ldr r1,[r2, r0, LSL #2]
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
57
Basis indizierte Adressierung
Basis
Basis ++ Index
Index <<
<< Scale
Scale
Speicher
Speicher
Zielregister
Zielregister
Indexregister
Indexregister
Basisregister
Basisregister
Instruction
Instruction
Dies ist die
komplizierteste
Adressierung die ein
ARM Prozessor
beherrscht.
Dabei wird das Basisregister auf den A-Bus
gelegt und das Indexregister wird auf dem BBus über den
Barrelshifter zur ALU
geführt.
Diese berechnet daraus
die endgültige Adresse
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
58
Basis indizierte Adressierung mit Offset
Register
Register ++ Index
Index ** Scale
Scale ++ Offset
Offset
Speicher
Speicher
Zielregister
Zielregister
Indexregister
Indexregister
Diese Adressierungsform findet man bei den
x86 Prozessoren als
kompliziertesten
Adressierungsmechani
smus
Basisregister
Basisregister
Instruction
Instruction
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
59
Die Befehle LDR und STR
Die Befehle LDR und STR dienen
LDR
LDR| |STR
STR{<cond>}
{<cond>}{B}
{B}Rd,
Rd,[Rn,
[Rn,
zum Laden und speichern von Daten
<offset>]
<offset>]{!}
{!}
Der Zugriff erfolgt indirekt, d.h. immer
relativ zu einem Register
LDR
LDR| |STR
STR{<cond>}
{<cond>}{B}
{B}Rd,
Rd,[Rn],
[Rn],
Die Speicherung kann auch indiziert
<offset>
<offset>
und mit einem Offset vorgenommen
werden
LDR
LDR| |STR
STR{<cond>}
{<cond>}{B}
{B}Rd,
Rd,LABEL
LABEL
Der zum Zugriff genutzte Zeiger kann
;;
PC
PCrelativ
relativ
vor oder nach dem Zugriff
inkrementiert oder dekrementiert
MOV
MOV
Rd,
Rd,#value
#value
werden
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
60
Beispiele für LDR und STR
STR R1,[R2,R4]!
LDR R1,[R2,R3,LSL#2]
STR R1,[R2],R4
LDREQB R1,[R6,#5]
LDR R1,[R2,#16]
STR R1,PLACE
...
PLACE
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
61
Beispiele für LDR und STR
STR R1,[R2,R4]!
LDR R1,[R2,R3,LSL#2]
Speichert R1 in die Adresse R2+R4
Lade R1 mit dem Inhalt an der Adresse
und schreibt diese Adresse nach
R2+R3*4.
R2.
LDREQB R1,[R6,#5]
STR R1,[R2],R4
Bedingtes Laden des Bytes an R6+5 in
Speichert R1 in R2 und schreibt
R1 (Bits 0 bis 7, Bits 8 bis 31= 0).
R2+R4 in R2.
STR R1,PLACE
LDR R1,[R2,#16]
Assembler generiert PC relativen Offset
Lade R1 von der Adresse R2+16, R2
bleibt unverändert.
zur Adresse PLACE.
...
PLACE
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
62
Zugriff auf Daten
RISC Prozessoren können keine
direkten Zugriffe auf Daten
durchführen (Die Adresse passt nicht
in den Befehlscode)
Die Adresse muss daher vor dem
Zugriff in ein Register geladen werden.
Das Laden der Adresse erfolgt
...
...
.L2:
.L2:
normalerweise über eine Konstante,
die PC relativ adressiert wird
adr
adr
adr
adr
ldr
ldr
ldr
ldr
mov
mov
str
str
r2,
r2, .L2
.L2
r3,
r3, .L2+4
.L2+4
r5,
r5, [r3,
[r3, #0]
#0]
r3,
r3, [r2,
[r2, #0]
#0]
r4,
r4, #0x40
#0x40
r4,
r4, [r2]
[r2]
.align
.align
22
.word
.word
.word
.word
.word
.word
.word
.word
yy
xx
zz
.LC0
.LC0
;; r2
r2 == ADR(y)
ADR(y)
;; r3
r3 == ADR(x)
ADR(x)
;; r5
r5 == xx
;; r3
r3 == yy
;; r4
r4 == 64
64
;; yy == 64
64
Der Befehl
 ldr Register, Label wird dabei vom
Assembler in einen Befehl
Vorlesung Rechnerarchitektur
Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
 ldr Register, [pc + Offset]©umgesetzt
63
Load und Store - Befehlsformat
31
28 27 26 25 24 23 22 21 20 19
cond
0
1
#
P
U
B
W
L
16 15
Rn
12 11
0
Rd
offset
Quell / Ziel Register
Basis Register
Load / Store
write-back ( auto-index )
unsigned byte / word
up / down
pre- / post index
11
0
0
12-bit-immediate
11
1
7
#shift
6
5
SH
4
0
3
0
Rm
immediate shift length
shift type
offset register
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
64
Vergleich der arithmetischen Befehle mit mul und Load/Store
31
28 27 26 25 24
cond
0
0
#
21 20 19
opcode
S
16 15
Rn
12 11
Rd
operand2
arithmetisch
31
28 27
cond
0
24 23
0
0
0
20 19
mul
S
16 15
Rd/RdHi
12 11
Rn/RdLo
arithmetisch - Multiplikation
31
28 27 26 25 24 23 22 21 20 19
cond
0
Load/Store
1
#
1
P
U
B
W
L
0
16 15
Rn
12 11
Rd
destination register
8 7
4
first operand register
Rs
1 0 0 1
set condition codes
3
Rm
arithmetic/logic function
11
8
7
0
offset
0
#rot
8-bit-immediate
Quell / Ziel Register
immediate alignment
Basis Register
11
Load7 / Store
6 5 4 3
write-back
(
auto-index
#shift
SH
0)
unsigned byte / word
0
Rm
up / down
immediate shift length
0
0
pre- / post index
shift type
second operand register
11
11
0
8
Rs
7 6 5 4 3
12-bit-immediate
0
SH
1
0
0
Rm
register shift length
1
11
#shift
Vorlesung Rechnerarchitektur
© immediate
Gerhard Raffius,,
SS 2015,
h_da - Fachbereich Informatik
shift
length
7
6
5
SH
4
0
3
0
Rm
65
Beispiel für Multiplikation
Skalar Produkt zweier Vektoren
adr
r8, Vektor1
// r8: Zeiger auf Vektor1
adr
r9, Vektor2
// r9: Zeiger auf Vektor2
mov
r11, #20
// Dimension des Vektors
mov
r10, #0
// Initialisierung
loop
….
….
bne
loop
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
66
Beispiel für Multiplikation
Skalar Produkt zweier Vektoren
mov
mov
r11, #20
r10, #0
ldr
ldr
mla
subs
bne
r0, [r8], #4
r1, [r9], #4
r10, r0, r1, r10
r11, r11, #1
loop
loop
// r10 = r0 * r1 + r10
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
67
Beispiel strlen
int strlen(char *str)
strlen:
mov
{
ldrb
char *start = str;
r2, r0
r0, [r0, #0]
cmp
bxeq
while (*str)
r0, #0
lr
mov
str++;
r0, r2
.L4:
return str - start;
}
ldrb
r3, [r0, #1]!
cmp
r3, #0
bne
.L4
rsb
r0, r2, r0
bx
lr
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
68
Beispiel memcpy
void* memcpy (void* dst0, void* src0, int len0)
memcpy:
cmp
r2, #0
char *dst = (char *) dst0;
bxeq
lr
char *src = (char *) src0;
mov
ip, #0
while (len0--)
ldrb
r3, [r1, ip]
{
strb
r3, [r0, ip]
add
ip, ip, #1
}
cmp
ip, r2
return save;
bne
.L3
bx
lr
{
void* save = dst0;
*dst++ = *src++;
}
.L3:
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
69
Beispiel cmpstr
int cmpstr (char *s1, char *s2)
Strings werden in C durch eine Zeichenkette
{
mit einer abschließenden 0 dargestellt ('\0')
while (*s1 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
das Stringende erreicht ist, und dass beide
Strings noch gleich sind
Die Rückgabe ist die Differenz der letzten
Zeichen.
return (*(unsigned char *) s1) (*(unsigned char *) s2);
}
cmpstr muss in einer Schleife überprüfen ob
Bei Gleicheit der Strings wird Null
zurückgegeben, bei Ungleicheit ein Wert
größer oder kleiner Null, der ein lexikalisches
Sortieren erlaubt
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
70
cmpstr in Assembler
cmpstr:
.L2:
ldrb r2, [r0, #0]
@ ersten String
ldrb r0, [r1, #0]
@ Zeichen von s2 holen
cmp r2, #0
@ auf Ende überprüfen
rsb
r0, r0, r2
@ *s1 - * s2 berechnen
bx
lr
@ return
beq
.L2
ldrb r3, [r1, #0]
@ erstes Zeichen
cmp r3, r2
@ auf Gleichheit prüfen
bne
.L2
add
r1, r1, #1
.L3:
@ s2 inkremetieren
ldrb r2, [r0, #1]
@ s1 auf Ende
cmp r2, #0
@ überprüfen
beq
.L2
add
r0, r0, #1
@ s1 inkrementieren
ldrb r3, [r1, #0]
@ Gleichheit von s1
cmp r3, r2
@ und s2 überprüfen
beq
.L3
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
71
Blocktransfer Befehle
LDR und STR Befehle übertragen jeweils (nur) ein 32 Bit Reg.
ARM erlaubt den Transfer von einer beliebigen Teilmenge der
16 Register in einem Befehl
STM
LDM
STore Multiple
LoaD Multiple (Beispiel)
LDM
LDM r1,
r1, {r0,
{r0, r2,
r2, r4}
r4}
;; r0
[r1]
r0 :=
:= mem
mem32
[r1]
32
;; r2
r2 :=
:= mem
mem32[r1
[r1 ++ 4]
4]
32
;; r4
[r1
r4 :=
:= mem
mem32
[r1 ++ 8]
8]
32
r4
r4
r3
r3
r2
r2
r1
r1
r0
r0
base_addr
base_addr ++ 88
base_addr
base_addr ++ 44
base_addr
base_addr
base_addr
base_addr
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
72
Blocktransfer Befehle
Alle 16 Register können benutzt werden
Achtung: Veränderung vom PC erzwingt Programmverzweigung
Beispiel: Store Multiple
STM
STM r1,
r1, {r0,
{r0, r2,
r2, r4}
r4}
;; mem
[r1]
mem32
[r1] :=
:= r0
r0
32
;; mem
mem32[r1
[r1 ++ 4]
4] :=
:= r2
r2
32
;; mem
[r1
mem32
[r1 ++ 8]
8] :=
:= r4
r4
32
r4
r4
r3
r3
r2
r2
r1
r1
r0
r0
base_addr
base_addr ++ 88
base_addr
base_addr ++ 44
base_addr
base_addr
base_addr
base_addr
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
73
Blocktransfer Befehle (Beispiel)
Beispiel: Kopieren von 8 Worten
ADR
ADR
ADR
ADR
LDM
LDM
r0,
r0, src_addr
src_addr
r1,
r1, dest_addr
dest_addr
r0!,
r0!, {r2-r9}
{r2-r9}
STM
STM
r1,
r1, {r2-r9}
{r2-r9}
;; initialisiere
initialisiere Quelladresse
Quelladresse
;; initialisiere
initialisiere Zieladresse
Zieladresse
;; hole
hole 88 Worte
Worte vom
vom Speicher
Speicher
;; und
und verändere
verändere r0
r0 (write
(write back)
back)
;; kopiere
kopiere 88 Worte
Worte zum
zum Speicher,
Speicher, r1
r1 unverändert
unverändert
Bei der Benutzung von LDM(IA) oder STM(IA) Befehlen:
- wird die Basisadresse inkrementiert (blau implizit)
- das Inkrementieren erfolgt nach der Benutzung der Adresse
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
74
Blocktransfer Befehle
Die Richtung in die sich der Basisregister bewegt wird durch den Befehl spezifiziert
 LDM / STM
: increment after
(bei UAL Syntax)
Beispiel
 R12 zeigt auf Quelle, R13 zeigt auf Ziel, R14 zeigt auf Ende
 loop:
ldmia
r12!, {r0-r11}
stmia
r13!, {r0-r11}
cmp
r12, r14
bne
loop
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
75
Blocktransfer Befehle
Bisher: Basisregister R1 blieb unverändert
mit ! kann das Basisregister verändert werden
LDM
LDM
r1
r1 !! ,, {r2-r9}
{r2-r9}
;; r2
[r1]
r2 :=
:= mem
mem32
[r1]
32
;; ......................
......................
;; r9
r9 :=
:= mem
mem32[r1+28]
[r1+28]
32
;; r1
r1 :=
:= r1
r1 ++ 32
32
load
load multiple
multiple
implizit:
implizit:
inkrementiere
inkrementiere
Basisadresse
Basisadresse
ändere
ändere r1
r1
nach
nach Nutzung
Nutzung
lade
lade Register
Register r2-r9
r2-r9
A
A –– Basisadresse
Basisadresse wird
wird
nach
nach Nutzung
Nutzung verändert
verändert
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
76
Blocktransfer Befehlsformat
31
28 27
cond
1
25 24 23 22 21 20 19
0
0
P
U
S
W
L
16 15
0
Rn
Register Liste
Basis Register
Load / Store
write-back ( auto-index )
restore PSR and force user bit
up / down
pre- / post index
Beispiel: STM R13!, {R0-R2, R14}
E8AD 4007
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
77
Stacks
LDM und STM Befehle können benutzt
vorher
werden, um einen Last-In First-Out
r13
(LIFO) Speicher zu realisieren
xxx
xxx
nachher
high
Einen solchen Speicher nennt man
r5
r5
r4
r4
STACK (Kellerspeicher)
Stacks werden benutzt, um temporär
Daten zu speichern
xxx
xxx
r14
high
r13
low
r3
r3
r1
r1
low
PUSH Befehl, um Daten „auf“ den
Stack abzulegen
Beispiel: PUSH
{R1, R3-R5,
R14}
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
78
Stacks
Eigenschaften des PUSH Befehls
R13 wird als Adresszeiger benutzt. Diesen nennt man auch Stack Pointer (SP).
Vereinbarung !
Stacks werden benutzt, um temporär Daten zu speichern
Der Stack wächst „nach unten“ zu kleineren Speicheradressen
Adresszeiger (= Stackpointer) zeigt auf den letzten belegten Speicherplatz
SP wird vor dem Speicherzugriff dekrementiert
ARM implementiert mit UAL einen direkten PUSH und POP Befehl
Dieser wird intern in die Blocktransferbefehle LDM und STM umgesetzt
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
79
Stacks
Komplementärer Befehl zu PUSH ist POP
POP überträgt den Inhalt vom Stack in Register
POP Befehl gibt es bei ARM seit der Implementierung von UAL (Unified Assembler
Language)
Beispiel: POP
{R1, R3-R5, R14}
vorher
xxx
r13
nachher
high
r13
xxx
xxx
r14
(r14)
r5
r5
(r5)
r4
r4
(r4)
r3
r3
(r3)
r1
r1
(r1)
low
high
low
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
80
Stackoperationen
push { lr }
Das Register lr wird auf den Stack
geschrieben und der Stackpointer
dabei nach unten verschoben
pop { pc }
Der Program Counter wird vom
Stack geholt
push {REGLIST}
Beispiel:
push {r4, r5, lr}
pop {REGLIST}
Die Liste der Register (REGLIST)
wird vom Stack geholt
Beispiel
pop {r4, r5, pc}
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
81
Stackoperationen
old SP
old SP
r6
r6
r5
r5
r4
r4
r3
SP
r3
r2
r1
SP
r3 = r0
r4 = r1
r6 = r2
r0
STMFD sp!, {r0 - r6}
LDMFD sp!, {r3, r4, r6}
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
82
Speicheraufteilung / Assembleranweisungen
.text
.global
 legt einen Textbereich an
 nimmt ein symbol in die globale
Symboltabelle auf
.data
 legt einen Datenbereich an
.comm symbol, size
 legt ein Symbol in die globale bss
Section für uninitialisierte Daten
.text
Programm Code + Konstanten
.data
initialisierte Daten
.bss
uninitialisierte Daten
Stack
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
83
Speicheraufteilung / Assembleranweisungen
.word Ausdruck
.label
 legt einen initialisierten Speicher
 legt ein Programmlabel (Marke)
an
an
.align #Bits
.end
 sorgt dafür, dass die
 das Ende des Programms
nachfolgende Anweisung auf
einer Speicherstelle steht, deren
unterste #Bits 0 sind
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
84
Alignment / Ausrichtung von Worten im Speicher
8 Bytes
8 Bytes
48
48
32
32
24
24
16
15
14
13
12
11
10
9
8
8
19
15
14
13
18
17
12
0
memory aligned
16
16
8
0
memory not aligned
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
85
Warum Alignment
Die Anordnung von Worten auf ausgerichteten Adressen erlaubt eine einfachere
Speicheranbindung, wenn wortweise gelesen wird
Cache Speicher ist mindestens nach Worten ausgerichtet. Würde man die Bytes
eines Wortes frei anordnen, könnte die eine Hälfte eines Wortes im Cache stehen,
die andere aber nicht verfügbar sein.
Wie macht es Intel? Dort kann jedes Wort auf jeder Adresse stehen – auch Intel
Prozessoren beachten das Alignment. Wörter auf nicht ausgerichtetn Adressen
benötigen dann 2 Speicherzugriffe. Alignment beschleunigt hier die Ausführung
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
86
Auswirkungen von Alignment auf höhere
Programmiersprachen
Die Anordnung der Attribute in einem Objekt muss dem Alignment unterliegen
Sind Adressen noch nicht ausgerichtet, so fügt der Compiler automatisch
Leerplätze ein, um ein Alignment zu erreichen
Die Anordnung der Attribute kann daher den benötigten Speicherplatz für ein
Objekt beeinflussen
class test1 {
private:
char a;
int b;
char c;
int d;
char e;
}
class test12{
private:
char a;
char c;
char e;
int b;
int d;
}
// Objektgröße ? Byte
// Objektgröße ? Byte
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
87
Auswirkungen von Alignment auf höhere
Programmiersprachen
Die Anordnung der Attribute in einem Objekt muss dem Alignment unterliegen
Sind Adressen noch nicht ausgerichtet, so fügt der Compiler automatisch
Leerplätze ein, um ein Alignment zu erreichen
Die Anordnung der Attribute kann daher den benötigten Speicherplatz für ein
Objekt beeinflussen
class test1 {
private:
char a;
int b;
char c;
int d;
char e;
}
class test12{
private:
char a;
char c;
char e;
int b;
int d;
}
// Objektgröße 20 Byte
// Objektgröße 12 Byte
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
88
Instruction Set der ARM Prozessoren
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
Opcode
4
3
2
1
Cond
Cond
Cond
0
0
0
0
0
0
0
0
0
0
0
1
0 0 A S
1 U A S
0 B 0 0
Cond
0
0
0
1
0
Cond
0
0
0 P U 0 W L
Rn
Rd
Cond
0
0
0 P U 1 W L
Rn
Rd
Cond
Cond
Cond
Cond
0
0
1
1
1
1
0
0
I P U B W L
1
0 P U S W L
1 L
Rn
Rd
Cond
1
1
0 P U N W L
Rn
CRd
CP#
Cond
1
1
1
0
CRn
CRd
CP#
CP
0
CRm
Cond
1
1
1
0
CRn
Rd
CP#
CP
1
CRm
Cond
1
1
1
1
CpOpc
CpOpc
L
Rn
RdLo
Rd
5
I
1
Rd
RdHi
Rn
6
0
0
Rd
7
0
1
Rn
8
Cond
0
S
9
1
1
1
1
1
1
Operand 2
1
0
Rs
Rn
0 0
0
1
1
1
0
0
0
0
0
0
1
1
1
Rm
Rm
Rm
1
1
1
1
0
0
0
1
Rn
0
0
0
0
1 S H 1
Rm
1 S H 1
Offset
Offset
Offset
1
Rn
Register List
Offset
Offset
ignored by processor
0
Data Processing /
PSR Transfer
Mutiply
Multiply long
Single Data Swap
Branch and
Exchange
Halword Data
Transfer: register
offset
Halfword Data
Transfer: Immediate
Offset
Single Data Transfer
Undefined
Block Data Transfer
Branch
Coprocessor Data
Transfer
Coprocessor Data
Operation
Coprocessor
Register Transfer
Software Interrupt
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
89
ARM Program Calling Standard (APCS)
Warum braucht man einen Calling Standard?
 In Projekten entwickeln mehrere Entwickler unabhängig voneinander Software.
 Es werden in einem Projekt verschiedene Compiler benutzt
 Es werden Objektbibliotheken genutzt, die von anderen entwickelt wurden
Ein Program Calling Standard definiert die Schnittstelle zwischen Programmen und
hilft, die genannten Anwendungsfälle zu beherrschen
Was definiert ein Program Calling Standard?
 Wie werden Parameter an Unterprogramme übergeben
 welche Register dürfen im Unterprogramm zerstört werden (Scratch Register) und
welche müssen erhalten werden (Variablen Register)
 Wie werden Ergebnisse aus einem Unterprogramm an das aufrufende Programm
zurückgegeben
 Wie sieht das Stackframe eines
Vorlesung
Rechnerarchitektur
Unterprogramms
aus
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
90
APCS Konvention zur Parameterübergabe
Die Parameter 1-4 werden beim
R0
ARG1/Result
R1
ARG2/Scratch
R2
ARG3/Scratch
R3
ARG4/Scratch
R4
Var1
R5
Var2
R6
Var3
R7
Var4
R8
Var5
R9
Var6
R10
Var7
FP
FP
IP
IP/Scratch
SP
SP
LR
LR
PC
PC
Unterprogrammaufruf in den Registern r0r3 übergeben
Der Rückgabewert von Funktionen steht
im Register r0 oder r0/r1
Die Register r0-r3 und das Register ip
sind Scratch Register und deren Inhalte
dürfen im Unterprogramm zerstört werden
Die Informationen in r4-r10, fp, sp
müssen erhalten bleiben
der Inhalt von lr wird zur Rückkehr ins
aufrufende Programm benötigt
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
91
Blattfunktionen
Eine Blattfunktion ruft keine weitere
Funktion auf (Bildlich wie ein Blatt am
Baum)
40% aller Funktionen sind
Blattfunktionen
Blattfunktionen können lokale
Variablen in den Scratch Registern
speichern
Die Rückkehradresse kann im
Linkregister bleiben
void
void swap(
swap( int*
int* x,
x, int
int *y)
*y)
{{
int
int temp;
temp;
temp
temp == *x;
*x;
*x
*x == *y;
*y;
*y
*y == temp;
temp;
}}
swap:
swap:
ldr
ldr
ldr
ldr
str
str
str
str
bx
bx
r2,
r2, [r0,
[r0, #0]
#0]
r3,
r3, [r1,
[r1, #0]
#0]
r3,
r3, [r0,
[r0, #0]
#0]
r2,
r2, [r1,
[r1, #0]
#0]
lr
lr
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
92
Nicht-Blattfunktionen
nicht Blattfunktionen rufen weitere
Die Variablenregister können
Unterprogramme auf
verwendet werden, wenn sie am
Das Linkregister wird dabei durch die
Anfang auf dem Stack gesichert
neue Rücksprungadresse
werden.
überschrieben und muss deshalb
vorher auf dem Stack gerettet werden
Die Scratchregister dürfen durch das
neue Unterprogramm frei verwendet
werden. In ihnen dürfen deshalb keine
lokalen Variablen über den
Funktionsaufruf hinweg gespeichert
werden.
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
93
Beispiel zu nicht Blattfunktionen
ggt:
ggt:
int
int ggt(
ggt( int
int x,
x, int
int yy ))
{{
int
int z;
z;
if
if (x
(x << y)
y) return
return ggt(
ggt( y,
y, x);
x);
if
if (( (z
(z == x%y)
x%y) ==
== 00 )) return
return y;
y;
else
else return
return ggt
ggt (( y,
y, z);
z);
}}
.L3:
.L3:
push
push
mov
mov
cmp
cmp
movlt
movlt
movlt
movlt
movlt
movlt
mov
mov
{r4,
{r4, lr}
lr}
r4,
r4, r1
r1
r0,
r0, r1
r1
r3,
r3, r1
r1
r4,
r4, r0
r0
r0,
r0, r3
r3
r1,
r1, r4
r4
@
@ lr
lr und
und r4
r4 retten
retten
@
@ yy wird
wird variable
variable
@
@ Vergleich
Vergleich xx << yy
@
@ yy und
und xx
@
@ vertauschen
vertauschen
bl
bl
subs
subs
beq
beq
mov
mov
bl
bl
mov
mov
__modsi3
__modsi3
r1,
r1, r0,
r0, #0
#0 @
@ speichern
speichern und
und
@
@ prüfen
prüfen auf
auf Null
Null
.L3
@
.L3
@ fertig
fertig ??
r0,
@
r0, r4
r4
@ yy ->
-> xx
ggt
ggt
r4,
@
r4, r0
r0
@ Ergebnis
Ergebnis ->
-> yy
mov
mov
pop
pop
r0,
r0, r4
r4
{r4,
{r4, pc}
pc}
@
@ x,y
x,y
@
@ Parameter
Parameter für
für %
%
@
@ Rückgabe
Rückgabe von
von yy
@
@ Rücksprung
Rücksprung
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
94
Methodenaufrufe bei Objekten
Eine Methode bekommt als ersten
Parameter immer einen Zeiger auf das
betreffende Objekt übergeben
(this-> Zeiger in C++)
Dadurch ist der Zugriff auf die Daten
des Objekts gewährleistet
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
95
„Hello World“ in Assembler
1
@ Programm Hello World
17
2
-
18
@ Exit from 'main'. This is like 'return 0' in C.
19
mov
3
.file "HelloW.S"
4
.text
20
5
.align2
21
6
.global
7
.typemain, %function
10
main
and pop the original lr
22
@ value directly into pc — the Program Counter —
to return.
main:
-
@ Stack the return address (lr) in addition to a
dummy register (ip) to
11
@ keep the stack 8-byte aligned.
12
push
23
pop
25
@ --------------------------------
26
@ Data for the printf calls. The GNU assembler's
".asciz" directive
27
@ automatically adds a NULL character
@ Load the argument and perform the call. This is
like 'printf("...")' in C.
-
15
ldr
r0, =message
-
16
bl
printf
{ip, pc}
24
{ip, lr}
13
14
@ Return 0.
@ Pop the dummy ip to reverse our alignment fix,
8
9
r0, #0
termination.
28
message:
29
.asciz "Hello ARM!\n"
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
96
Early Binding / statische Objektaufrufe
sind die Methoden einer Klasse nicht
als virtuell gekennzeichnet, so kann
der Compiler zur Compilezeit schon
die Klasse bestimmen und die Adresse
der Methode einsetzen
der Methodenaufruf entspricht einem
normalen Unterprogrammaufruf, dem
als ersten Parameter der Zeiger auf
das Objekt übergeben wird
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
97
late binding / dynamischer Methodenaufruf
methode
A
beim late binding wird erst zur Laufzeit
bestimmt, welche Methode zu einem
Objekt aufgerufen wird.
methode
B
in C++ erreicht man late binding durch
eine Kennzeichnung der Methode als
virtuell (virtual)
Objekt
das Objekt enthält jetzt als erstes
Datum einen Zeiger auf eine Tabelle
Virtual Table
liegt in der
text section
methode
C
(virtual Table), in der die Adresse der
gesuchten Methode steht
Code der
Methoden
Vorlesung Rechnerarchitektur
© Gerhard Raffius,, SS 2015, h_da - Fachbereich Informatik
98
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement