Οργάνωση Υπολογιστών
5 “συστατικά” στοιχεία
-Επεξεργαστής:
datapath (δίοδος δεδομένων) (1) και control (2)
-Μνήμη (3)
-Συσκευές Εισόδου (4), Εξόδου (5) (Μεγάλη ‘ποικιλία’ !!)
Συσκευές γρήγορες π.χ. κάρτες γραφικών, αργές π.χ. πληκτρολόγιο.
Για το Ι/Ο έχει γίνει η λιγότερη έρευνα …..(I/O busses , I/O switched fabrics …)
Ιεραρχία Μνήμης: καταχωρητές, κρυφή μνήμη (L1), κρυφή
μνήμη (L2), κύρια Μνήμη
Μνήμη- ΠΟΛΥ ΣΗΜΑΝΤΙΚΟ ΣΤΟΙΧΕΙΟ!
7/2/2011
cslab@ntua 2010-2011
1
Αρχιτεκτονικές Συνόλου Εντολών
Instruction Set Architectures
Instruction
Fetch ((IF))
Instruction
Decode
(ID)
Operand
Fetch (OF)
Execute
(Ex)
Result
Store (WB)
Next
Instruction
7/2/2011
Αριθμός εντολών
Μορφή Εντολών:
Εν ολών:
μεταβλητό ή σταθερό μέγεθος bytes για κάθε
εντολή; (8086 1-17 bytes, MIPS 4 bytes)
Πώς γίνεται η αποκωδικοποίηση (ID);
Που βρίσκονται τα ορίσματα (operands) και το
αποτέλεσμα:
Μνήμη-καταχωρητές, πόσα ορίσματα, τι
μεγέθους;
Ποια είναι στη μνήμη και ποια όχι;
Πόσοι κύκλοι για κάθε εντολή;
cslab@ntua 2010-2011
2
Κατηγορίες Αρχιτεκτονικών Συνόλου Εντολών
(ISA Classes)
1 Αρχιτεκτονικές Συσσωρευτή (accumulator architectures)
1.
(μας θυμίζει κάτι?)
2 Α
2.
Αρχιτεκτονικές
έ επεκταμένου
έ
συσσωρευτή
ή ή καταχωρητών
ώ
ειδικού σκοπού (extended accumulator ή special purpose
register)
3. Αρχιτεκτονικές Καταχωρητών Γενικού Σκοπού
3α register
3α.
register-memory
memory
3b. register-register (RISC)
7/2/2011
cslab@ntua 2010-2011
3
Αρχιτεκτονικές Συσσωρευτή (1)
1η γενιά υπολογιστών: h/w ακριβό, μεγάλο μέγεθος καταχωρητή.
Ένας καταχωρητής για όλες τις αριθμητικές εντολές (συσσώρευε
όλες τις λειτουργίες → Συσσωρευτής (Accum)
Σύνηθες:
η ς 1ο όρισμα
ρ μ είναι ο Αccum,, 2o η μ
μνήμη,
ήμη, αποτέλεσμα
μ στον
Accum π.χ. add 200
Παράδειγμα:
A=B+C
Accum = Memory(AddressB);
Load AddressB
Accum = Accum + Memory(AddressC);
Add AddressC
Memory(AddressA) = Accum;
Store AddressA
Όλες οι μεταβλητές
Όλ
βλ έ αποθηκεύονται
θ ύ
στη μνήμη.
ή
Δ υπάρχουν
Δεν
ά
βοηθητικοί καταχωρητές
7/2/2011
cslab@ntua 2010-2011
4
Αρχιτεκτονικές Συσσωρευτή (2)
Κατά:
Χρειάζονται πολλές εντολές για ένα πρόγραμμα
Κάθε φορά πήγαινε-φέρε από τη μνήμη
(? Κακό είναι αυτό)
Bottleneck o Accum!
Υπέρ:
Εύκολοι compilers, κατανοητός προγραμματισμός,
εύκολη
ύ λ σχεδίαση
δί
h/
h/w
η; Πρόσθεση
ρ
η καταχωρητών
χ ρη
για
γ συγκεκριμένες
γ ρ μ ς λειτουργίες
ργ ς
Λύση;
(ISAs καταχωρητών ειδικού σκοπού)
7/2/2011
cslab@ntua 2010-2011
5
Αρχιτεκτονικές Επεκταμένου Συσσωρευτή
Καταχωρητές ειδικού σκοπού π.χ. δεικτοδότηση, αριθμητικές
πράξεις
Υπάρχουν εντολές που τα ορίσματα είναι όλα σε καταχωρητές
Κατά βάση (π.χ. σε αριθμητικές εντολές) το ένα όρισμα στη
μνήμη.
ή
7/2/2011
cslab@ntua 2010-2011
6
Αρχιτεκτονικές Καταχωρητών γενικού σκοπού
Register-memory
g
y
Register register (load
Register-register
store) (1980+)
Αφήνουν το ένα όρισμα
να είναι στη μνήμη (πχ.
80386)
Load R1, B
Add
dd R1,
1 C
Store A,
R1
Memory-memory
7/2/2011
A=B+C
Load R1, B
Load R2, C
Add R3, R1, R2
Store A, R3
extended-accumulator
accumulator
register-register
register-memory
cslab@ntua 2010-2011
7
Αρχιτεκτονική Στοίβας
Καθόλου registers! Stack model ~ 1960!!!
Στοίβα
Σ
ίβ που μεταφέρονται
έ
τα ορίσματα
ί
που αρχικά
ά βρίσκονται
β ί
στη μνήμη. Καθώς βγαίνουν γίνονται οι πράξεις και το
αποτέλεσμα ξαναμπαίνει στη στοίβα.
Θυμάστε τα HP calculators με reverse polish notation
A B+C
A=B+C
push Address C
push AddressB
add
pop AddressA
7/2/2011
cslab@ntua 2010-2011
8
Εντολές μεταβλητού μήκους:
1 17 bytes
1-17
b
80 86
80x86
1-54 bytes VAX, IBM
Γιατί??
Ιnstruction Memory ακριβή, οικονομία χώρου!!!!
Εμείς στο μάθημα: register-register ISA! (load- store)
1.
2.
3.
4.
Οι καταχωρητές είναι γρηγορότεροι από τη μνήμη
Μειώνεται η κίνηση με μνήμη
Δυνατότητα να υποστηριχθεί
θ σταθερό
θ
μήκος εντολών
λ
(τα ορίσματα είναι καταχωρητές, άρα ό αριθμός τους (πχ.
3 καταχωρητές)
αταχωρητές) όχι δ/νσεις μνήμης
1-32
Compilers πιο δύσκολοι!!!
7/2/2011
cslab@ntua 2010-2011
9
Βασικές Αρχές Σχεδίασης (patterson-hennessy COD2e)
1. Η ομοιομορφία των λειτουργιών συμβάλλει στην απλότητα
του υλικού (Simplicity favors Regularity)
2. Όσο μικρότερο τόσο ταχύτερο! (smaller is faster)
3. H καλή σχεδίαση απαιτεί σημαντικούς συμβιβασμούς (Good
design demands good compromises)
Γενικότητες? Θα τα δούμε στη συνέχεια......
7/2/2011
cslab@ntua 2010-2011
10
MIPS σύνολο εντολών:
Λέξεις των 32 bit (μνήμη οργανωμένη σε bytes, ακολουθεί το
μοντέλο big Εndian)
32 καταχωρητές γενικού σκοπού - REGISTER FILE
Θα μιλήσουμε για: εντολές αποθήκευσης στη μνήμη (lw, sw)
Αριθμητικές εντολές (add, sub κλπ)
Εντολές διακλάδωσης (branch instructions)
Δεν αφήνουμε τις εντολές να έχουν μεταβλητό πλήθος
ορισμάτων- π.χ. add a,b,c πάντα: a=b+c
μη
την
η 1η
η αρχή:
ρχή H ομοιομορφία
μ μ ρφ των λειτουργιών
ργ
Θυμηθείτε
συμβάλλει στην απλότητα του h/w
7/2/2011
cslab@ntua 2010-2011
11
Σύνολο Εντολών
Instruction Set
• Λέξεις της γλώσσας του υπολογιστή Λέξεις της γλώσσας του υπολογιστή – εντολές
• Γλώσσες των υπολογιστών – όμοιες
• Στο μάθημα, σύνολο εντολών MIPS
άθ
ύ λ
λώ
S
7/2/2011
cslab@ntua 2010-2011
12
Αφού οι καταχωρητές είναι τόσο....«γρήγοροι» γιατί να μην
μεγαλώσουμε το μέγεθος του register file?
2η αρχή: Όσο μικρότερο τόσο ταχύτερο!
Αν το register
i
file
fil πολύ
λ μεγάλο,
λ πιο πολύπλοκη
λ λ
η
αποκωδικοποίηση, πιο μεγάλος ο κύκλος ρολογιού (φάση ID)
άρα.....υπάρχει
ρ
ρχ tradeoff
Μνήμη οργανωμένη σε bytes:
(Κάθε byte και ξεχωριστή
δνση)
230 λέξεις μνήμης των 32 bit (4
bytes) κάθε μια
Memory [0]
32 bits
Memory [4]
32 bits
Memory [8]
32 bits
Memory [12]
32 bits
$s0, $s1,… καταχωρητές (μεταβλητές συνήθως)
$t0, $t1,… καταχωρητές (προσωρινές τιμές)
$zero ειδικός καταχωρητής περιέχει το 0
7/2/2011
cslab@ntua 2010-2011
13
Big Endian vs Little Endian
Big Endian: H δνση του πιο σημαντικού byte (MSB) είναι και δνση
της λέξης
Little Endian: H δνση του λιγότερο σημαντικού byte (LSB) είναι και
δνση της λέξης
H λέξη αποθηκεύεται πάντα σε συνεχόμενες θέσεις: δνση, δνση+1, ..,
δνση+33
δνση
LITTLE ENDIAN
LITTLE_ENDIAN
BIG_ENDIAN
A[0]
A[1]
A[2]
7/2/2011
0
1
2
3
4
5
6
7
8
9
10
11
MSB
8 bits
LSB
MSB
A[0]
A[1]
LSB
MSB
A[2]
LSB
cslab@ntua 2010-2011
0
1
2
3
4
5
6
7
8
9
10
11
LSB
MSB
LSB
MSB
LSB
MSB
14
MIPS ISA (βασικές εντολές)
Αριθμητικές εντολές add, sub: πάντα τρία ορίσματα - ποτέ
δνση μνήμης!
add $s1, $s2, $s3
#
$s1 = $s2+$s3
sub $s1, $s2, $s3
#
$s1 = $s2-$s3
Εντολές μεταφοράς δεδομένων (load-store):
Εδώ έχουμε αναφορά στη μνήμη (πόσοι τρόποι? Θα το
δούμε στη συνέχεια)
l $s1
lw
$s1, 100($s2) # $s1 = Memory(100+$s2) (load word)
sw $s1, 100($s2) # Memory(100+$s2) = $s1(store word)
7/2/2011
cslab@ntua 2010-2011
15
Λειτουργίες υλικού υπολογιστών
Αριθμητικές Πράξεις
• add
dd a, b
b, c #
a← b + c
a← b + c
• a = b + c + d + e;
– add a, b, c
– add a, a, d
– add a, a, e
3 εντολές για το άθροισμα 4 μεταβλητών
7/2/2011
cslab@ntua 2010-2011
16
Λειτουργίες υλικού υπολογιστών
Παράδειγμα:
Κώδ
Κώδικας σε C
C
a = b + c;
d = a – e;
Μετάφραση σε κώδικα MIPS
add a
a, b
b, c
sub d, a, e
7/2/2011
cslab@ntua 2010-2011
17
Λειτουργίες υλικού υπολογιστών
Παράδειγμα:
f = (g
( + h) – (i + j);
j)
Τι παράγει ο compiler?
add t0, g, h # προσωρινή μεταβλητή t0
add t1, i, j # προσωρινή μεταβλητή t1
sub f, t0, t1 # το f περιέχει
έ το t0 – t1
7/2/2011
cslab@ntua 2010-2011
18
Λειτουργίες υλικού υπολογιστών
Κατηγορία
ηγ ρ
Εντολή
ή
Παράδειγμα
ρ
γμ
add
add a, b, c
subtract
sub a, b, c
Σημασία
ημ
a=b+c
Πάντα
3 τελεστέοι
a=b-c
Πάντα
3 τελεστέοι
Αριθμητικές
Αριθ
η ικές
Πράξεις
7/2/2011
cslab@ntua 2010-2011
Σχόλια
χ
19
Τελεστέοι Υλικού Υπολογιστών
f = (g + h) – (i + j);
(f h i j) ανατίθενται
(f,g,h,i,j)
ίθ
σε ($s0,$s1,$s2,$s3,$s4)
($ 0 $ 1 $ 2 $ 3 $ 4)
$t0, $t1 προσωρινοί καταχωρητές
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
7/2/2011
cslab@ntua 2010-2011
20
Τελεστέοι Υλικού Υπολογιστών
Γλώσσες προγραμματισμού έχουν:
• απλές
λέ μεταβλητές
βλ έ
• σύνθετες δομές (π.χ. arrays, structs)
Πώς τις αναπαριστά ένας υπολογιστής;
Πάντα στη μνήμη
Εντολές μεταφοράς δεδομένων
7/2/2011
cslab@ntua 2010-2011
21
Τελεστέοι Υλικού Υπολογιστών
Εντολές μεταφοράς
δεδομένων
Π.χ. Διεύθυνση του 3
στοιχείου
ί είναι
ί
2
Τιμή στοιχείου Memory[2]
είναι 10
7/2/2011
cslab@ntua 2010-2011
22
Τελεστέοι Υλικού Υπολογιστών
Εντολή
Ε
λή μεταφοράς
ά δδεδομένων
δ έ
από
ό τη μνήμη
ή
load καταχωρητής, σταθερά(καταχωρητής)
πχ
π.χ.
lw $t1, 4($s2)
φορτώνουμε στον $t1 την τιμή M[$s2+4]
7/2/2011
cslab@ntua 2010-2011
23
Τελεστέοι Υλικού Υπολογιστών
Παράδειγμα:
Α πίνακας 100 λέξεων (4 bytes η λέξη)
g, h ανατίθενται
ίθ
σε $s1,
$ 1 $s2
$2
αρχική διεύθυνση του A στον $s3
Μεταγλωττίστε g = h + A[8];
offset
base register
g
lw $t0, 32($s3)
add $s1, $s2, $t0
7/2/2011
cslab@ntua 2010-2011
24
Τελεστέοι Υλικού Υπολογιστών
• Μνήμη είναι byte
addressable
• Δύο διαδοχικές λέξεις
δ έ
διαφέρουν
κατά
ά4
• alignment restriction
(ευθυγράμμιση)
– λέξεις ξεκινάνε πάντα σε
διεύθυνση πολ/σιο του 4
7/2/2011
cslab@ntua 2010-2011
25
Τελεστέοι Υλικού Υπολογιστών
Σταθερές:
Π ό θ
Πρόσθεση
της τιμής
ή 4 στον $s3
$3
lw $t0, AddrConstant4($s1)
add $s3, $s3, $t0
ή
addi $s3, $s3, 4
Make common case FAST
7/2/2011
cslab@ntua 2010-2011
26
Τελεστέοι Υλικού Υπολογιστών
Τελεστέοι
Τ
λ έ MIPS
32 καταχωρητές $s0, $s1, ...
230 θέσεις λέξεων στη μνήμη
232 θέσεις byte στη μνήμη
7/2/2011
cslab@ntua 2010-2011
27
Τελεστέοι Υλικού Υπολογιστών
Συμβολική γλώσσα MIPS
Π
Παραδείγματα
δ ί
add
dd $
$s1,
1 $
$s2,
2 $
$s3
3
sub $s1, $s2, $s3
addi $s1
$s1, $s2
$s2, 100
lw $s1, 100($s2)
sw $s1,100($s2)
,
7/2/2011
cslab@ntua 2010-2011
28
Τελεστέοι Υλικού Υπολογιστών
Πό γρήγορα
Πόσο
ή
πληθαίνουν
λ θ ί
οι καταχωρητές
έ
σε έναν επεξεργαστή;
1. Πολύ γρήγορα (Νόμος Moore, 2ος αριθμός
τρανζίστορ/18 μήνες)
2. Πολύ αργά (portable binary code)
Π.χ.
χ Θ
Θέλουμε
μ τα προγράμματά
ρ γρ μμ
μας
μ ς να τρέχουν
ρ χ
και στον Pentium III και στον Pentium IV
7/2/2011
cslab@ntua 2010-2011
29
Αναπαράσταση Εντολών στον Υπολογιστή
Δυαδικά
Δ
δ ά ψηφία,
ί Δυαδικό
Δ δ ό σύστημα
ύ
(bi
(binary))
Υλικό υπολογιστών, υψηλή-χαμηλή τάση, κλπ.
Kαταχωρητές
$s0, ..., $s7 αντιστοιχίζονται στους 16 ως 23
$ 0 ..., $$t7
$t0,
7 αντιστοιχίζονται
ίζ
στους 8 ως 15
7/2/2011
cslab@ntua 2010-2011
30
Αναπαράσταση Εντολών στον Υπολογιστή
Συμβολική αναπαράσταση:
add $t0
$t0, $s1
$s1, $s2
Assembly
Πώς την καταλαβαίνει ο MIPS?
$s1
0
17
$s2
18
$t0
8
add
unused
0
32
Κώδικας μηχανής
000000
10001
10010
01000
00000
10000
6 bit
5 bit
5 bit
5 bit
5 bit
6 bit
7/2/2011
cslab@ntua 2010-2011
31
Μορφή Εντολής - Instruction Format
Θυμηθείτε το 1ο κανόνα: Η ομοιομορφία των λειτουργιών
συμβάλλει στην απλότητα του υλικού
R-Type
(register type)
op
rs
rt
rd
shamt
funct
6 bits
5bits
5bits
5bits
5bits
6bits
Op: opcode
rs,rt: register source operands
Rd: register destination operand
Shamt: shift amount
F
Funct:
t op specific
ifi (function
(f ti code)
d )
add
dd $
$rd,
d $
$rs, $
$rt
t
7/2/2011
cslab@ntua 2010-2011
32
MIPS R‐Type (ALU)
R-Type: Όλες οι εντολές της ALU που χρησιμοποιούν 3 καταχωρητές
OP
6 bits
rs
5 bits
rt
5 bits
rd
shamt
funct
5 bits
5 bits
6 bits
• Παραδείγματα :
– add $1
$1,$2,$3
$2 $3
and $1
$1,$2,$3
$2 $3
– sub $1,$2,$3
or $1,$2,$3
Destination register in rd
Operand register in rt
Operand register in rs
7/2/2011
cslab@ntua 2010-2011
33
Αναπαράσταση Εντολών στον Υπολογιστή
op
rs
rt
rd
shamt
funct
6 bit
5 bit
5 bit
5 bit
5 bit
6 bit
Τι γίνεται με τη load?
Πώς χωράνε οι τελεστές της στα παραπάνω
πεδία? Π.χ. η σταθερά της lw.
lw $
$t1,
, 8000($s3)
($ )
σε ποιο πεδίο χωράει;
7/2/2011
cslab@ntua 2010-2011
34
Ερώτηση: Μας αρκεί το R-Type?
Τι γίνεται
Τ
ί
με εντολές
λέ που θέλ
θέλουν ορίσματα
ί
διευθύνσεις
δ θύ
ή σταθερές? Θυμηθείτε, θέλουμε σταθερό μέγεθος κάθε
εντολής
ής ((32 bit))
Απάντηση: Μάλλον όχι
Άρα: H καλή σχεδίαση απαιτεί σημαντικούς συμβιβασμούς (3η αρχή)
Ι-Type:
op
p
rs
rt
address_offset
6 bits
5 bits
5 bits
16 bits
lw $rt, address_offset($rs)
_
Τα 3 πρώτα
ρ
πεδία ((op,rs,
p, , rt)) έχουν
χ
το ίδιο όνομα
μ και μέγεθος
μ γ ς
όπως και πριν
7/2/2011
cslab@ntua 2010-2011
35
Αναπαράσταση Εντολών στον Υπολογιστή
Παράδειγμα:
Kαταχωρητές
χ ρη ς ((σκονάκι ☺))
$s0, ..., $s7 αντιστοιχίζονται στους 16
ως 23
$t0 ..., $t7 αντιστοιχίζονται στους 8 ως
$t0,
15
lw $t0
$t0, 32($s3)
I format
I-format
7/2/2011
op
rs
rt
σταθερά ή διεύθυνση
6 bit
5 bit
5 bit
16 bit
xxxxxx
19
8
32
cslab@ntua 2010-2011
36
Επεξεργαστής
Αριθμός καταχωρητών
γενικού σκοπού
Αρχιτεκτονική
Έτος
EDSAC
1
accumulator
1949
IBM 701
1
accumulator
1953
CDC 6600
8
load-store
1963
IBM 360
16
register-memory
1964
DEC PDP-8
1
accumulator
1965
DEC PDP-11
8
Register-memory
1970
Intel 8008
1
accumulator
1972
Motorola 6800
2
accumulator
1974
DEC VAX
16
register-memory, memory-memory
1977
I t l 8086
Intel
8
extended
t d d accumulator
l t
1978
Motorola 68000
16
register-memory
1980
Intel 80386
8
register-memory
1985
MIPS
32
l d
load-store
1985
HP PA-RISC
32
load-store
1986
SPARC
32
load-store
1987
PowerPC
32
load-store
1992
DEC Alpha
32
load-store
1992
7/2/2011
cslab@ntua 2010-2011
37
Κανόνες Ονοματοδοσίας και Χρήση των MIPS Registers
•
Εκτός από το συνήθη συμβολισμό των καταχωρητών με $ ακολουθούμενο από τον αριθμό του καταχωρητή, μπορούν επίσης να παρασταθούν και ως ή
εξής :
Αρ. Καταχωρητή
7/2/2011
Όνομα
0
1
23
2-3
$zero
$at
$ 0$ 1
$v0-$v1
4-7
8-15
16-23
24-25
26-27
28
29
30
31
$a0-$a3
$t0-$t7
$s0-$s7
$t8-$t9
$k0-$k1
$
$
$gp
$sp
$fp
$ra
Χρήση
Preserved on call?
Constant value 0
Reserved for assembler
Vl
Values
ffor result
l andd
expression evaluation
Arguments
Temporaries
Saved
More temporaries
Reserved for operating
p
g system
y
Global pointer
Stack pointer
Frame pointer
Return address
cslab@ntua 2010-2011
n.a.
όχι
ό
όχι
ναι
όχι
ναι
όχι
ναι
ναι
ναι
ναι
ναι
38
MIPS I‐Type : Load/Store
OP
rs
rt
6 bits
5 bits
5 bits
address
16 bits
– address: 16‐bit memory address offset in bytes added to base register.
• Παραδείγματα :
base register in rs
Offset
– Store word: sw
source register in rt
500($4), $3
– Load word: lw $1, 30($2)
Destination register in rt
7/2/2011
Offset
cslab@ntua 2010-2011
base register in rs
39
MIPS ALU I‐Type
Οι I-Type εντολές της ALU χρησιμοποιούν 2 καταχωρητές και μία σταθερή τιμή
I-Type είναι και οι εντολές Loads/stores, conditional branches.
OP
rs
rt
6 bits
5 bits
5 bits
immediate
16 bits
– immediate: Constant second operand for ALU instruction.
• Παραδείγματα :
Παραδείγματα :
– add immediate:
addi $1,$2,100
– and immediate
andi $1,$2,10
Constant operand
R lt register
Result
i t in
i rtt
i immediate
in
i
di t
Source operand register in rs
7/2/2011
cslab@ntua 2010-2011
40
MIPS data transfer instructions Παραδείγματα
Instruction
sw 500($4), $3
sh 502($2), $3
sb 41($3), $2
Σχόλια
Store word
Store half
Store byte
lw $1, 30($2)
$1 30($2)
lh $1, 40($3)
lhu $1, 40($3)
lb $1, 40($3)
lbu $1, 40($3)
Load word
Load
word
Load halfword
Load halfword unsigned
Load byte
Load byte unsigned
lui $1, 40
Load Upper Immediate (16 bits shifted left by 16)
LUI
R5
7/2/2011
cslab@ntua 2010-2011
R5
0000 … 0000
41
How about larger constants?
• We'd like to be able to load a 32 bit constant into a register
• Must use two instructions; new "load
load upper immediate
immediate" instruction
lui $t0, 1010101010101010
filled with zeros
1010101010101010
0000000000000000
Th must get the
Then
h lower
l
order
d bits
bi right,
i h i.e.,
i
ori $t0, $t0, 1010101010101010
ori
7/2/2011
1010101010101010
0000000000000000
0000000000000000
1010101010101010
1010101010101010
1010101010101010
cslab@ntua 2010-2011
42
Topics to Review
• Memory layout
• Text, data (static and heap), and the stack
• Procedure conventions
d
• Procedure call bookkeeping
• Caller Saved Registers:
g
•
•
•
•
Return address
Arguments
Return value
$t Registers
$t Registers
$ra
$a0, $a1, $a2, $a3
$v0, $v1
$t0 $t9
$t0 ‐
• Callee Saved Registers:
• $s Registers
$s0 ‐ $s7
• Procedure structure
Procedure structure
• Prologue:
• Body:
• Epilogue:
7/2/2011
allocate frame, save registers, assign locals
procedure code
restore registers free frame
restore registers, free frame
cslab@ntua 2010-2011
43
Overview
• Data types
– Application / HLL requirements
A li ti / HLL
i
t
– Hardware support (data and instructions)
• MIPS data types
MIPS data types
• Support for bytes and strings
• Addressing Modes
Add
i M d
– Data
– Instructions
• Large constants and far target addresses
• SPIM code
SPIM code
7/2/2011
cslab@ntua 2010-2011
44
Data Types
• Applications / HLL
• Hardware support
– Numeric data types
yp
– Integer
– Floating point Character – String
– Date – Currency
– Text, – Objects (ADT)
– Blob
– double precision
– Signed, unsigned
g
,
g
7/2/2011
– Integers
– 8 / 16 / 32 / 64 bits
– Signed or unsigned
– Binary coded decimal
(COBOL, Y2K!)
• Floating point
• 32 / 64 /128 bits
bi
– Nonnumeric data types
•
•
•
•
cslab@ntua 2010-2011
Characters
Strings
Boolean (bit maps)
Pointers
45
MIPS Data Types (1/2)
• Basic machine data type: 32‐bit word
– 0100 0011
0100 0011 0100 1001
0100 1001 0101 0011 0100 0101
0101 0011 0100 0101
– Integers (signed or unsigned)
• 1,128,878,917
– Floating point numbers
• 201.32421875
– 4 ASCII characters
4 ASCII h
• C I S E
– Memory addresses (pointers)
Memory addresses (pointers)
• 0x43495345
– Instructions
7/2/2011
cslab@ntua 2010-2011
46
MIPS Data Types (2/2)
• 16‐bit constants (immediates)
– addi $s0, $s1, 0x8020
ddi $ 0 $ 1 0 8020
– lw $t0, 20($s0)
• Half word (16 bits)
– lh (lhu): load half word lh $t0, 20($s0)
– sh: save half word
sh $t0, 20($s0)
• Byte (8 bits)
y (
)
– lb (lbu): load byte
– sb: save byte
sb: save byte
7/2/2011
cslab@ntua 2010-2011
sh $t0, 20($s0)
sh $t0, 20($s0)
sh $t0, 20($s0)
47
Byte Instructions
lb $s1, 4($s0)
Address
Memory Bytes
0x10000000
$s0:
0x10000000
$ : 0xFFFFFFAA
$s1
lbu $s1, 2($s0)
10101010
$s0:
0x10000000
$s1: 0x000000 AA
7/2/2011
cslab@ntua 2010-2011
48
String Manipulation
Void strcpy (char[], char y[]) {
int i;
i = 0;
while ((x[i]=y[i]) != 0)
i = i + 1;
}
C convention:
Null byte (00000000)
represents end of the string
Importance of comments in MIPS!
7/2/2011
strcpy:
subi $sp, $sp, 4
sw $s0, 0($sp)
add $s0, $zero, $zero
L1: add $t1,, $a1,, $s0
lb $t2, 0($t1)
add $t3, $a0, $s0
sb $t2,
$t2 0($t3)
beq $t2, $zero, L2
addi $s0, $s0, 1
j
L1
L2: lw $s0, 0($sp)
addi $sp, $sp, 4
jr $ra
cslab@ntua 2010-2011
49
Constants
• Small
Small constants are used frequently (50% of constants are used frequently (50% of
operands) – e.g., g,
A = A + 5;;
• Solutions
– Put 'typical constants' in memory and load them. – Create hard‐wired registers (like $zero) for constants like 1.
• MIPS Instructions:
slti $8,
$8 $18
$18, 10
andi $29, $29, 6
ori $29, $29, 0x4a
addi $29, $29, 4
7/2/2011
8
29
29
4
101011
10011
01000
0000 0000 0011 0100
cslab@ntua 2010-2011
50
Large Constants
To load a 32 bit constant into a register:
•
1. Load (16) higher order bits
lui $t0, 1010101010101010
1010 1010 1010 1010 0000 0000 0000 0000
2. Then must get the lower order bits right, i.e.,
ori
i $t0,
$t0 $t0
$t0, 1010101010101010
$t0:
ori
1010 1010 1010 1010 0000 0000 0000 0000
0000 0000 0000 0000 1010 1010 1010 1010
1010 1010 1010 1010 1010 1010 1010 1010
7/2/2011
cslab@ntua 2010-2011
51
Addressing Modes
• Addresses for data and instructions
Data (operands and results)
• Data (operands and results)
– Registers
– Memory locations
y
– Constants
• Efficient encoding of addresses (space: 32 bits)
g
(p
)
–
–
–
–
Registers (32) => 5 bits to encode address
Destructive instructions: reg2 = reg2 + reg1
Accumulator
Stack
• Orthogonality of opcodes and addressing modes
7/2/2011
cslab@ntua 2010-2011
52
Data Addressing Modes
• Register addressing
– The most common (fastest and shortest)
The most common (fastest and shortest)
– add $3, $2, $1
• Base addressing
B
dd
i
– Operand is at a memory location with offset
– lw $t0, 20 ($t1)
• Immediate addressing
– Operand is a small constant within the instruction
– addi $t0, $t1, 4
,
,
((signed 16‐bit integer)
g
g )
7/2/2011
cslab@ntua 2010-2011
53
Addressing
1. Immediate addressing
op
rs
rt
Immediate
2. Register addressing
op
rs
rt
rd
...
funct
Registers
Register
3. Base addressing
op
rs
rt
Memory
Address
+
Register
4. PC-relative addressing
op
rs
rt
Byte
Halfword
Word
Address
*4
PC
Memory
+
Word
5. Pseudodirect addressing
op
Address
*4
Memory
Word
PC
7/2/2011
cslab@ntua 2010-2011
54
Instruction Addressing Modes
• Addresses are 32 bits long
• Special purpose register PC
S i l
i t PC ((program counter) t )
stores the address of the current instruction
• PC‐relative addressing (branches)
– Address: PC + (constant in the instruction) * 4
– beq $t0, $t1, 20 (0x15090005)
• Pseudodirect addressing (jumps)
g (j p )
– Address: PC[31:28] : (constant in the instruction) * 4
7/2/2011
cslab@ntua 2010-2011
55
MIPS
PC
SPIM Code
machine code
Pseudo MIPS
main
[0x00400020]
add $9, $10, $11
(0x014b4820)
[[0x00400024]]
j
((0x08100012))
[0x00400028]
addi $9, $10, -50
[0x0040002c]
lw
$8, 5($9)
(0x8d280005)
lw
$t0, 5($t1)
[0x00400030]
lw
$8, -5($9)
(0x8d28fffb)
lw
$t0, -5($t1)
[0x00400034]
bne $8, $9, 20 [exit-PC]
(0x15090005)
bne $t0, $t1, exit
[0x00400038]
addi $9, $10, 50
(0x21490032)
addi $t1, $t2, 50
[0x0040003c]
bne $8, $9, -28 [main-PC]
(0x1509fff9)
bne $t0, $t1, main
[0x00400040]
lb
$8, -5($9)
(0x8128fffb)
lb
$t0, -5($t1)
[0x00400044]
j
0x00400020 [main]
j
main
[0x00400048]
exit
7/2/2011
0x00400048 [[exit]]
add
dd $9
$9, $10
$10, $11
(0x2149ffce)
(0x08100008)
(0 014b4820)
(0x014b4820)
cslab@ntua 2010-2011
main: add $t1, $t2, $t3
j
exit
addi $t1, $t2, -50
exit:
i add
dd $$t1,
1 $$t2,
2 $$t3
3
56
Far Target Address
Text Segment (252MB)
0x00400000
(0x07fe0000)
-217
PC (0x08000000)
beq $s0, $s1, L1
+217
(0x08020000)
bne $s0, $s1, L2
j
L1
(0x08200000) L1:
L2:
0x10000000
7/2/2011
cslab@ntua 2010-2011
57
Overview
•
•
•
•
•
•
7/2/2011
Pointers (addresses) and values
Argument passing
Storage lifetime and scope
Pointer arithmetic
Pointers and arrays
Pointers in MIPS
cslab@ntua 2010-2011
58
Pointers
• Pointer: a variable that contains the address of
another variable
– HLL version of machine language memory address
• Why use Pointers?
– Sometimes only way to express computation
– Often more compact and efficient code
• Why not?
– Huge source of bugs in real software, perhaps the
largest single source
1) Dangling reference (premature free)
2) Memory leaks (tardy free): can't have long-running
jobs without periodic restart of them
7/2/2011
cslab@ntua 2010-2011
59
C Pointer Operators
• Suppose c has
h value
l 100, it
i is
i located
l
d in
i memory at
address 0x10000000
• Unary
U
operator
t & gives
i
address:
dd
p = &c; gives address of c to p;
– p “points
points to
to” c
(p == 0x10000000)
• Unary operator * gives value that pointer points to
– if p = &c => * p == 100 (Dereferencing a pointer)
• Deferencing ⇒ data transfer in assembler
– ... = ... *p
p ...;
;
⇒ load
(get value from location pointed to by p)
– *p = ...;
⇒ store
(put value into location pointed to by p)
7/2/2011
cslab@ntua 2010-2011
60
Pointer Arithmetic
int x = 1, y = 2;
int z[10];
int *p;
/* x and y are integer variables */
/* an array of 10 ints, z points to start */
/* p is a pointer to an int */
x = 21;
z[0] = 2; z[1] = 3
p = &z[0];
p = z;
p = p+1;
p++;
*p = 4;
p = 3;
p = &x;
z = &y
/* assigns x the new value 21 */
/* assigns 2 to the first, 3 to the next */
/* p refers to the first element of z */
/* same thing;
g p[ i ] == z[[ i ]]*/
/* now it points to the next element, z[1] */
/* now it points to the one after that, z[2] */
/* assigns 4 to there
there, z[2] == 4*/
/* bad idea! Absolute address!!! */
/* p points to x, *p == 21 */
illegal!!!!! array name is not a variable
7/2/2011
cslab@ntua 2010-2011
p:
z[1]
[ ]
z[0]
4
3
2
y:
2
x:
21
61
Assembly Code
c is int, has value 100, in memory at address
0x10000000 p in $a0,
0x10000000,
$a0 x in $s0
1 p = &c;
1.
/* p gets 0x10000000*/
lui $a0,0x1000 # p = 0x10000000
2 x = *p;
2.
lw
/* x gets 100 */
$s0, 0($a0) # dereferencing p
3 *p
3.
p = 200; /*
/ c gets 200 */
/
addi $t0,$0,200
sw
$t0, 0($a0) # dereferencing p
7/2/2011
cslab@ntua 2010-2011
62
Example
int strlen(char *s) {
p = s;
/* p p
points to chars */
char *p
while (*p != ’\0’)
p++;
/* points to next char */
return p - s;
/* end - start */
/
/
}
mov $t0,$a0
lbu $t1,0($t0)
$
0 $ 0 /
/* derefence p */
/
beq $t1,$zero, Exit
Loop:addi $t0,$t0,1 /* p++ */
lbu $t1,0($t0) /* derefence p */
bne $t1,$zero, Loop
Exit:sub $v0,$t0,$a0
jr
$ra
7/2/2011
cslab@ntua 2010-2011
63
Argument Passing Options
• 2 choices
– “Call
Call by Value
Value”:: pass a copy of the item to the
function/procedure
– “Call byy Reference”: ppass a ppointer to the item
to the function/procedure
• Single word variables passed by value
• Passing an array? e.g., a[100]
– Pascal (call by value) copies 100 words of a[]
onto the stack
– C (call by reference) passes a pointer
(1 word) to the array a[] in a register
7/2/2011
cslab@ntua 2010-2011
64
Lifetime of Storage and Scope
• Automatic (stack allocated)
–T
Typical
i l local
l l variables
i bl off a function
f ti
– Created upon call, released upon return
– Scope
S
iis th
the function
f ti
• Heap allocated
Code
Static
Heap
– Created
C t d upon malloc,
ll released
l
d upon free
f
– Referenced via pointers
• External
E t
l / static
t ti
– Exist for entire program
7/2/2011
cslab@ntua 2010-2011
Stack
65
Arrays, Pointers, and Functions
•
4 versions of array function that adds two
arrays and puts sum in a third array (sumarray)
1. Third array is passed to function
2 Using
2.
U i a local
l l array (on
( stack)
t k) for
f result
lt andd passing
i
a pointer to it
3 Third array is allocated on heap
3.
4. Third array is declared static
•
7/2/2011
Purpose off example
P
l is
i to
t show
h interaction
i t
ti off C
statements, pointers, and memory allocation
cslab@ntua 2010-2011
66
Version 1
int x[100], y[100], z[100];
sumarray(x y,
sumarray(x,
y z);
• C calling convention means:
sumarray(&x[0],
(& [0] &y[0],
& [0] &
&z[0]);
[0])
• Really passing pointers to arrays
addi
addi
addi
jal
7/2/2011
$a0,$gp,0
# x[0] starts at $gp
$a1,$gp,400 # y[0] above x[100]
$a2,$gp,800 # z[0] above y[100]
sumarray
cslab@ntua 2010-2011
67
Version1: Compiled Code
void sumarray(int a[], int b[], int c[]) {
int i;
for(i = 0; i < 100; i = i + 1)
c[i] = a[i] + b[i];
}
Loop:
Exit:
7/2/2011
addi
beq
lw
lw
add
sw
addi
addi
addi
j
jr
$t0,$a0,400
$a0,$t0,Exit
$t1 0($a0)
$t1,
$t2, 0($a1)
$t1,$t1,$t2
$t1,, 0($a2)
$
($ )
$a0,$a0,4
$a1,$a1,4
$a2,$a2,4
Loop
$ra
# beyond end of a[]
# $t1
$t1=a[i]
a[i]
# $t2=b[i]
# $t1=a[i] + b[i]
# c[i]=a[i]
[ ] [ ] + b[i]
[]
# $a0++
# $a1++
# $a2++
cslab@ntua 2010-2011
68
Version 2
int *sumarray(int a[],int b[]) {
int i, c[100];
for(i=0;i<100;i=i+1)
c[i] = a[i] + b[i];
return c;
}
$sp
c[100]
a[100]
[
]
B[100]
7/2/2011
addi
addi
addi
addi
Loop: beq
lw
lw
add
s
sw
addi
addi
addi
ddi
j
Exit: addi
j
jr
cslab@ntua 2010-2011
$t0,$a0,400 # beyond end of a[]
$sp,$sp,-400 # space for c
$t3 $sp 0
$t3,$sp,0
# ptr for c
$v0,$t3,0
# $v0 = &c[0]
$a0,$t0,Exit
$t1 0($a0) # $t1=a[i]
$t1,
$t2, 0($a1) # $t2=b[i]
$t1,$t1,$t2 # $t1=a[i] + b[i]
$t1 0($t3) # c[i]
$t1,
c[i]=a[i]
a[i] + b[i]
$a0,$a0,4 # $a0++
$a1,$a1,4 # $a1++
$t3 $t3 4
$t3,$t3,4
# $t3++
Loop
$sp,$sp, 400 # pop stack
$
$ra
69
Version 3
int * sumarray(int a[],int b[]) {
int i;
int *c;
c = (int *) malloc(100);
for(i=0;i<100;i=i+1)
c[i] = a[i] + b[i];
return c;
}
Code
Static
c[100]
Heap
• Not reused unless freed
–C
Can lead
l d to memory leaks
l k
– Java, Scheme have garbage
collectors
ll t to
t reclaim
l i free
f space
7/2/2011
cslab@ntua 2010-2011
Stack
70
Version 3: Compiled Code
addi $t0,$a0,400 # beyond end of a[]
addi $sp
$sp,$sp,
$sp -12
12 # space for regs
sw
$ra, 0($sp) # save $ra
sw
$a0, 4($sp) # save 1st arg.
sw
$a1,
$
, 8($sp)
($ p) # save 2nd arg.
g
addi $a0,$zero,400
jal
malloc
addi $t3,$v0,0
# ptr for c
lw
$a0, 4($sp) # restore 1st arg.
lw
$a1, 8($sp) # restore 2nd arg.
Loop:
beq $a0,$t0,Exit
... (loop
(l
as before
b f
on prior
i slide
lid )
j
Loop
Exit:lw
$ra, 0($sp) # restore $ra
addi $sp
$sp, $sp
$sp, 12 # pop stack
jr
$ra
7/2/2011
cslab@ntua 2010-2011
71
Version 4
int * sumarray(int a[],int b[]) {
int i;
static int c[100];
[
]
for(i=0;i<100;i=i+1)
c[i] = a[i] + b[i];
return c;
}
Code
Static
c[100]
Heap
• Compiler allocates once for
function, space is reused
– Will be
b changed
h
d nextt time
ti
sumarray invoked
– Why describe? used in C libraries
7/2/2011
cslab@ntua 2010-2011
Stack
72
Review
MIPS operands
Name
Example
Comments
$s0-$s7, $t0-$t9, $zero, Fast locations for data. In MIPS, data must be in registers to perform
32 registers $a0-$a3, $v0-$v1, $gp, arithmetic. MIPS register $zero alw ays equals 0. Register $at is
$fp, $sp, $ra, $at
reserved for the assembler to handle large constants.
Memory[0],
Accessed only by data transfer instructions. MIPS uses byte addresses, so
230 memory Memory[4],
Memor [4] ...,
words
7/2/2011
Memory[4294967292]
sequential
ti l w ords
d diff
differ bby 44. MMemory hholds
ld ddatat structures,
t t suchh as arrays,
and spilled registers, such as those saved on procedure calls.
cslab@ntua 2010-2011
73
Review
MIPS assembly language
Category
Arithmetic
Instruction
add
Example
add $s1, $s2, $s3
Meaning
$s1 = $s2 + $s3
Three operands; data in registers
subtract
sub $s1, $s2, $s3
$s1 = $s2 - $s3
Three operands; data in registers
$s1 = $s2 + 100
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
Used to add constants
addi $s1, $s2, 100
lw $s1, 100($s2)
load word
sw $s1, 100($s2)
store word
lb $s1, 100($s2)
load byte
sb $s1, 100($s2)
store byte
load upper immediate lui $s1, 100
add immediate
Data transfer
Conditional
branch
Unconditional jump
7/2/2011
$s1 = 100 * 2
16
Comments
Word from memory to register
Word from register to memory
Byte from memory to register
Byte from register to memory
Loads constant in upper 16 bits
branch on equal
beq
$s1, $s2, 25
if ($s1 == $s2) go to
PC + 4 + 100
Equal test; PC-relative branch
branch on not equal
bne
$s1, $s2, 25
if ($s1 != $s2) go to
PC + 4 + 100
Not equal test; PC-relative
set on less than
slt
$s1, $s2, $s3
if ($s2 < $s3) $s1 = 1;
else $s1 = 0
Compare less than; for beq, bne
set less than
immediate
slti
jump
j
jr
jal
jjump
p register
g
jump and link
$s1, $s2, 100 if ($s2 < 100) $s1 = 1;
Compare less than constant
else $s1 = 0
2500
$ra
2500
Jump to target address
go to 10000
$ra
For switch, p
procedure return
go to
g
$ra = PC + 4; go to 10000 For procedure call
cslab@ntua 2010-2011
74
Conclusions
• Data can be anything
– Datatyping restricts data representations
– Applications restrict datatyping
• MIPS Datatypes: Number, String, Boolean
• Addressing: Pointers, Values
– Many addressing modes (direct, indirect,…)
y
g
(
,
, )
– Memory‐based address storage (jr
instruction)
• Arrays: big chunks of memory
– Pointers versus stack storage
– Be careful of memory leaks!
7/2/2011
cslab@ntua 2010-2011
75
Αναπαράσταση Εντολών στον Υπολογιστή
εντολή
μορφή
add
R
0
reg
reg
reg
0
32ten
δ.ε.
sub
R
0
reg
reg
reg
0
34ten
δ.ε.
addi
ddi I
8ten
reg
reg
δ
δ.ε.
δ
δ.ε.
δ
δ.ε.
σταθ.
θ
lw
I
35ten
reg
reg
δ.ε.
δ.ε.
δ.ε.
διευθ.
sw
I
43ten
reg
reg
δ.ε.
δ.ε.
δ.ε.
διευθ.
7/2/2011
op
rs
rt
rd
cslab@ntua 2010-2011
shamt
funct
address
76
Αναπαράσταση Εντολών στον Υπολογιστή
Παράδειγμα:
$t1
$t1 περιέχει base address πίνακα Α (32 bit/στοιχείο Α[i])
έ b
dd
ί
Α (32 bit/
ί Α[i])
$s2 αντιστοιχίζεται στη μεταβλητή h
Μεταγλωττίστε το A[300] = h + A[300];
Μεταγλωττίστε το A[300] = h + A[300];
lw $t0, 1200($t1)
add $t0, $s2, $t0
sw $t0, 1200($t1)
7/2/2011
cslab@ntua 2010-2011
77
Αναπαράσταση Εντολών στον Υπολογιστή
Παράδειγμα (συνέχεια):
lw $t0, 1200($t1)
add $t0, $s2, $t0
sw $t0, 1200($t1)
Κώδ
Κώδικας Μηχανής?
Μ
ή ?
op
35
0
43
7/2/2011
rs
9
18
9
rt
8
8
8
rd
8
cslab@ntua 2010-2011
shamt
1200
0
1200
funct
32
78
Αναπαράσταση Εντολών στον Υπολογιστή
Παράδειγμα (συνέχεια):
op
35
0
43
rs
9
18
9
rt
8
8
8
op
100011
000000
101011
rs
01001
10010
01001
rt
01000
01000
01000
7/2/2011
rd
8
shamt
1200
0
1200
funct
32
rd
shamt
funct
0000 0100 1011 0000
8
0
32
0000 0100 1011 0000
cslab@ntua 2010-2011
79
Αναπαράσταση Εντολών στον Υπολογιστή
Έννοια αποθηκευμένου προγράμματος
Ο υπολογιστής κάνει πολλές Ο
υπολογιστής κάνει πολλές
εργασίες φορτώνοντας δεδομένα στο μνήμη.
δεδομένα στο μνήμη.
Δεδομένα και εντολές είναι στοιχεία στη μνήμη.
χ
η μ ήμη
Π.χ. compilers μεταφράζουν στοιχεία σε κάποια άλλα χ
στοιχεία.
7/2/2011
cslab@ntua 2010-2011
80
Λογικές Λειτουργίες (Πράξεις)
Λογικές Λειτουργίες
Τελεστές C
Εντολές MIPS
<<
Sll (shift left
logical)
Shift right
>>
Srl (shift right
logical)
AND
&
and, andi
OR
|
or, ori
i
NOT
~
nor
Shift left
7/2/2011
cslab@ntua 2010-2011
81
Λογικές Λειτουργίες (Πράξεις)
SHIFT
$s0: 0000 0000 0000 0000 0000 0000 0000 1001 = 9ten ☺
$
sll $t2, $s0, 4
Κάνουμε shift αριστερά το περιεχόμενο του $s0 κατά 4 θέσεις
0000 0000 0000 0000 0000 0000 1001 0000 = 144ten
και τοποθετούμε το αποτέλεσμα στον $t2.
!!Το περιεχόμενο του $s0 μένει αμετάβλητο!!
7/2/2011
cslab@ntua 2010-2011
82
Λογικές Λειτουργίες (Πράξεις)
SHIFT
Kαταχωρητές (σκονάκι ☺)
$s0, ..., $s7 αντιστοιχίζονται στους 16
ως 23
$t0, ..., $t7 αντιστοιχίζονται στους 8 ως
15
sll $
$t2,
, $
$s0,
, 4
6 bit
5 bit
5 bit
5 bit
5 bit
6 bit
op
0
000000
rs
0
00000
rt
16
10000
rd
10
01010
shamt
4
00100
funct
0
000000
sll: opcode=0
opcode 0, funct=0
funct 0
7/2/2011
cslab@ntua 2010-2011
83
Λογικές Λειτουργίες (Πράξεις)
AND, OR
$ 0000 0000 0000 0000 0000 1101 0000 0000
$t2:
$t1: 0000 0000 0000 0000 0011 1100 0000 0000
and $t0, $t1, $t2
# Μάσκα
$t0: 0000 0000 0000 0000 0000 1100 0000 0000
or $t0,
, $t1,
, $t2
$t0: 0000 0000 0000 0000 0011 1101 0000 0000
7/2/2011
cslab@ntua 2010-2011
84
Λογικές Λειτουργίες (Πράξεις)
NOT NOR
NOT,
$t1: 0000 0000 0000 0000 0011 1100 0000 0000
$t3: 0000 0000 0000 0000 0000 0000 0000 0000
δεν υπάρχει γιατί θέλουμε πάντα 2
καταχωρητές source. Άρα χρησιμοποιούμε τη
nor:
A NOR 0 = NOT (A OR 0) = NOT A
not $t0, $t1
nor $t0, $t1, $t3
$t0: 1111 1111 1111 1111 1100 0011 1111 1111
7/2/2011
cslab@ntua 2010-2011
85
MIPS Arithmetic Instructions Παραδείγματα
Instruction
Παράδειγμα
add
add add $1,$2,$3
add $1,$2,$3
subtract
sub $1,$2,$3
add immediate
addi $1,$2,100 add unsigned
addu $1,$2,$3
subtract unsigned
bt t
i d subu $1,$2,$3
b $1 $2 $3
add imm. unsign. addiu $1,$2,100 multiply mult $2,$3
multiply unsigned
py
g
multu$2,$3
,
divide div $2,$3
divide unsigned divu $2,$3
Move from Hi
Move from Lo
mfhi $1
mflo $1
7/2/2011
Έννοια
Σχόλια
$1 = $2 $1 $2 + $3
$3
3 operands; exception possible
3 operands; exception possible
$1 = $2 – $3 3 operands; exception possible
$1 = $2 + 100
+ constant; exception possible
$1 = $2 + $3
3 operands; no exceptions
$1 $2 $3
$1 = $2 –
3
3 operands; no exceptions
d
ti
$1 = $2 + 100
+ constant; no exceptions
Hi, Lo = $2 x $3 64‐bit signed product
Hi, Lo = $2 x $3
,
64‐bit unsigned product
g
p
Lo = $2 ÷ $3,
Lo = quotient, Hi = remainder Hi = $2 mod $3 Lo = $2 ÷ $3,
Unsigned quotient & remainder Hi = $2 mod $3
Hi = $2 mod $3
$1 = Hi
Used to get copy of Hi
$1 = Lo
Used to get copy of Lo
cslab@ntua 2010-2011
86
MIPS Logic/Shift Instructions Παραδείγματα
Instruction
and or
xor
nor
and immediate
or immediate
xor immediate shift left logical
shift right logical
shift right arithm.
hift i ht ith
shift left logical
shift right logical
shift right arithm
shift right arithm.
7/2/2011
Παράδειγμα
and $1,$2,$3
or $1,$2,$3
xor $1,$2,$3
$ ,$ ,$
nor $1,$2,$3
andi $1,$2,10
ori $1,$2,10
xori $1, $2,10 sll $1,$2,10
srl $1,$2,10
sra $1,$2,10
$1 $2 10
sllv $1,$2,$3
srlv $1,$2, $3 srav $1 $2 $3
srav $1,$2, $3 Έννοια
$1 = $2 & $3
$1 = $2 | $3
$1 = $2 ⊕
$
$
$3
$
$1 = ~($2 |$3)
$1 = $2 & 10
$1 = $2 | 10
$1 = ~$2 &~10
$1 = $2 << 10
$1 = $2 >> 10
$1 $2 10
$1 = $2 >> 10
$1 = $2 << $3 $1 = $2 >> $3 $1 = $2 >> $3
$1 = $2 >> $3 cslab@ntua 2010-2011
Σχόλια
3 reg. operands; Logical AND
3 reg. operands; Logical OR
3 reg. operands; Logical XOR
g p
; g
3 reg. operands; Logical NOR
Logical AND reg, constant
Logical OR reg, constant
Logical XOR reg, constant
Shift left by constant
Shift right by constant
Shift i ht ( i
Shift right (sign extend) t d)
Shift left by variable
Shift right by variable
Shift right arith by variable
Shift right arith. by variable 87
Εντολές Λήψης Αποφάσεων
beq, bne
beq
q reg1,
g , reg2,
g , L1
#branch if equal
q
Αν οι καταχωρητές reg1 και reg2 είναι ίσοι,
πήγαινε στην ετικέτα L1
bne reg1
reg1, reg2
reg2, L1
#branch if not equal
Αν οι καταχωρητές reg1 και reg2 δεν είναι ίσοι,
πήγαινε
ή
στην ετικέτα
έ L1
7/2/2011
cslab@ntua 2010-2011
88
Εντολές Λήψης Αποφάσεων
Παράδειγμα:
Π
άδ
if(i == j) f = g + h; else f = g – h;
με f, g, h, i, j αντιστοιχούνται σε $s0, ..., $s4
version 1
version 2
bne $
$s3,
, $
$s4,
, Else
beq
q $s3,
$ , $
$s4,
, Then
add $s0, $s1, $s2
sub $s0, $s1, $s2
j Exit
j Exit
Else:sub $s0, $s1, $s2 Then: add $s0, $s1, $s2
Exit:
7/2/2011
Exit:
cslab@ntua 2010-2011
89
Εντολές Λήψης Αποφάσεων
Βρόχοι (Loops)
whilee (save[i]
w
(s ve[ ] == k)) i += 1;;
με i = $s3, k = $s5, save base addr = $s6
Loop:
sll
add
lw
bne
addi
j
$t1,
$t1,
$t0,
$t0,
$s3,
Loop
$s3, 2 #πολ/ζω i επί 4
$t1, $s6
0($t1)
$s5, Exit
$s3, 1
E it
Exit:
7/2/2011
cslab@ntua 2010-2011
90
Εντολές Λήψης Αποφάσεων
Συγκρίσεις
slt $t0, $s3, $s4
# set on less than
Ο καταχωρητής $t0 τίθεται με 1 αν η τιμή στον $s3
είναι μικρότερη από την τιμή στο $s4.
Σταθερές
ρ ς ωςς τελεστέοι είναι δημοφιλείς
ημ φ ς στιςς συγκρίσεις
γ ρ ς
slti $t0, $s2, 10
# set on less than
# i
immediate
di
Ο καταχωρητής $t0 τίθεται με 1 αν η τιμή στον $s2
είναι μικρότερη από την τιμή 10.
10
7/2/2011
cslab@ntua 2010-2011
91
MIPS Branch, Compare, Jump Παραδείγματα
Instruction
branch on equal
Παράδειγμα
Έννοια
beq $1,$2,100
if ($1 == $2) go to PC+4+100
Equal test; PC relative branch
q
branch on not eq. bne $1,$2,100
if ($1!= $2) go to PC+4+100
Not equal test; PC relative branch set on less than
slt $1,$2,$3
if ($2 < $3) $1=1; else $1=0
p
;
p
Compare less than; 2’s comp. set less than imm. slti $1,$2,100
if ($2 < 100) $1=1; else $1=0
Compare < constant; 2’s comp.
set less than uns. sltu $1,$2,$3
if ($2 < $3) $1=1; else $1=0
Compare less than; natural numbers
set l. t. imm. uns.
l i
sltiu
l i $1,$2,100
$ $
if ($
if ($2 < 100) $1=1; else $1=0
)$
l $
Compare < constant; natural numbers
jump
j 10000
go to 10000
Jump to target address
jump register
jr $31
$
go to $31
$
For switch, procedure return
jump and link
jal 10000
$31 = PC + 4; go to 10000
For procedure call
7/2/2011
cslab@ntua 2010-2011
92
Εντολές διακλάδωσης-branching instructions
branch if
equal
branch if
!equal
beq $s3, 4s4, L1 # goto L1 if $s3 equals $s4
bne $s3, 4s4, L1 # goto L1 if $s3 not equals $s4
unconditional
Jump
jr $t1 # goto $t1
..... είναι I –Type εντολές
slt $t0, $s3, $s4 #set $t0 to 1 if $s3 is less
than $s4;else set $t0 to 0
Όμως:
j L1 # goto L1
Πόσο μεγάλο είναι το μήκος του address L1;
Πόσο «μεγάλο» μπορεί να είναι το άλμα;
7/2/2011
cslab@ntua 2010-2011
93
MIPS Branch I‐Type
OP
rs
rt
6 bits
5 bits
5 bits
address
16 bits
– address: 16‐bit memory address branch target offset in words
added to PC to form branch address.
dd d t PC t f
b
h dd
• Παραδείγματα :
Παραδείγματα :
7/2/2011
Register in rs
Final offset is calculated in bytes,
equals to
Register in rt {instruction field address} x 4,
4
e.g. new PC = PC + 400
• Branch on equal
beq $1,$2,100
• Branch on not equal bne $1,$2,100
cslab@ntua 2010-2011
94
MIPS J‐Type
J-Type: jump j, jump and link jal
OP
jump target
6 bits
26 bits
– jump target: jump memory address in words.
final jump memory address in bytes is calculated
from {jump target} x 4
• Παραδείγματα :
Παραδείγματα :
– Branch on equal
j
10000
– Branch on not equal jal
7/2/2011
cslab@ntua 2010-2011
10000
95
Other Jump Instructions
• Jump (J‐type):
p ( yp )
– j 10000
# jump to address 10000
• Jump Register (NB: R‐type!):
– jr rs
jr rs
# jump to 32 bit address in register rs
# jump to 32 bit address in register rs
• Jump and Link (J‐type):
– jal 10000
# jump to 10000 and save PC in R31
– Use jal for procedure calls, it saves the return address (PC+4) in lf
d
ll
h
dd
(
)
register 31 ($ra)
– Use “jr $ra” to return from subroutine
– Nested procedures must save $ra on a stack, and should use registers N t d
d
t
$
t k d h ld
it
$sp (stack pointer) and $fp (frame pointer) manage the stack.
7/2/2011
cslab@ntua 2010-2011
96
Summary of MIPS instruction formats
• R
R‐type
type (add, sub, slt, jr)
(add sub slt jr)
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
• I‐type (beq, bne + addi, lui + lw, sw)
op
rs
rt
immediate value / address offset
6 bits
5 bits
5 bits
16 bits
• J‐type (j, jal)
Jt
(j j l)
op
6 bit
bits
7/2/2011
jump target address
26 bit
bits
cslab@ntua 2010-2011
97
Απ’ ευθείας διευθυνσιοδότηση- Σταθερές
Οι πιο πολλές αριθμητικές εκφράσεις σε προγράμματα,
περιέχουν
ρ χ
σταθερές:
ρ ς π.χ.
χ index++
Στον κώδικα του gcc: 52% εκφράσεων έχουν constants
Στον κώδικα του spice: 69% των εκφράσεων!
Τι κάνουμε με τις σταθερές (και αν είναι > 16bit;)
Θέλουμε: $s3=$s3+2
lw $t0, addr_of_constant_2($zero)
add $s3,$s3,$t0
Αλλιώς:
ς addi $s3,$s3,2 ((add immediate))
Όμοια: slti $t0,$s2, 10 # $t0=1 if $s2<10
7/2/2011
cslab@ntua 2010-2011
98
Τρόποι Διευθυνσιοδότησης στον MIPS:
1. Register Addressing
2. Base or Displacement Addressing
3. Immediate Addressingg
4. PC-relative addressing (address is the sum of the PC
and a constant in the instruction)
5. Pseudodirect addressing (the jump address is the 26
bits of the instruction, concatenated with the upper bits
off the
h PC)
7/2/2011
cslab@ntua 2010-2011
99
1. Immediate addressing
op
rs
rt
addi $rt,$rs,immediate
π.χ. lui $t0, 255
slti $t0, $s1, 10
Immediate
I-Type
2 Register addressing
2.
op
rs
rt
rd
...
funct
Registers
R-Type
Register
add $rd,$rs,$rt
π.χ. add $t0,$s1,$s2
3. Base addressing
op
rs
rt
+
Register
π.χ.
Memory
Address
Byte
Halfword
Word
I-Type
lw $rt,address($rs)
lw $t1,100($s2)
4. PC-relative addressing
op
rs
rt
Memory
Address
PC
+
Word
I-Type
bne $rs,$rt,address # goto {4 x address (0:15)}
π.χ. bne $s0,$s1,L2
5. Pseudodirect addressing
op
Memory
Address
Word
PC
J-Type
j address # goto {4 x address(0:25)}(0:27)-(28:31)(PC)
7/2/2011
cslab@ntua 2010-2011
100
Addressing Modes : Παραδείγματα
Addr. mode
Παράδειγμα
Έννοια
χρήση
Register
add r4,r3
Regs[r4]← Regs[r4]+ Regs[r3]
a value is in register
Immediate
add r4,#3
Regs[r4]← Regs[r4]+3
for constants
Displacement
add r4,100(r1)
Regs[r4]← Regs[r4]+Mem[100+ Regs[r1]]
local variables
Reg. indirect
add r4,(r1)
Regs[r4]← Regs[r4]+Mem[Regs[r1]]
accessing using a pointer
or comp. address
Indexed
add r4,(r1+r2)
Regs[r4]← Regs[r4]+Mem[Regs[r1]+
Regs[r2]]
array addressing (base +offset)
Direct
add r4,(1001)
Regs[r4]← Regs[r4]+Mem[1001]
addr. static data
Mem. Indirect
add r4,@(r3)
Regs[r4]←
Regs[r4]+Mem[Mem[Regs[r3]]]
g[ ]
[
[ g [ ]]]
if R3 keeps the address of
a pointer p, this yields *p
p
Autoincrement
add r4,(r3)+
Regs[r4]← Regs[r4]+Mem[Regs[r3]]
Regs[r3]← Regs[r3]+d
stepping through arrays
within a loop; d defines
size
i off an element
l
Autodecrement
add r4,-(r3)
Regs[r3]← Regs[r3]-d
Regs[r4]← Regs[r4]+Mem[Regs[r3]]
similar as previous
Scaled
add r4,100(r2)[r3]
,
( )[ ]
Regs[r4]←
g [ ] Regs[r4]+
g[ ]
Mem[100+Regs[r2]+Regs[r3]*d]
to index arrays
y
7/2/2011
cslab@ntua 2010-2011
101
© Copyright 2024 Paperzz
