ΕΠΛ221: Οργάνωση Υπολογιστών και Συμβολικός ......1 Ενότητα 3 - Εντολές: Η γλώσσα μηχανής ΕΠΛ221: Οργάνωση

1Ενότητα 3 - Εντολές: Η γλώσσα μηχανής

ΕΠΛ221: Οργάνωση Υπολογιστών και Συμβολικός Προγραμματισμός

Κεφ. 2 Εντολές: H γλώσσα μηχανής– Αρχιτεκτονική Σύνολο Εντολών MIPS

(assembly)– αναπαράσταση στο υλικό (ΜIPS)– μετάφραση από HLL σε LLL

• Δομές ελέγχου και βασικοί τύποι δεδομένων


Λειτουργίες του υλικού του υπολογιστή

- Κάθε μηχανή πρέπει να είναι ικανή να κάνει αριθμητικές πράξεις.

add a, b, c # a= b+c

- Κάθε αριθμητική εντολή στη γλώσσα MIPS πρέπει να έχει τρειςμεταβλητές (τελεσταίους).

- Για παράδειγμα αν θέλουμε να υπολογίσουμε την έκφραση: a = b + c + d + e

add a, b, c # a = b+cadd a, a, d # a = a+d = (b+c)+dadd a, a, e # a = a+e = ((b+c)+d)+e

-


- Παράδειγμα Δίνεται η ακόλουθη εντολή σε C : f=(g+h) - (i+j) Τι κώδικαθα μπορούσε να παράξει ο μεταγλωττιστής της C;

add t0, g, h # προσωρινή μεταβλητή t0, περιέχει το g+hadd t1, i, j # προσωρινή μεταβλητή t1, περιέχει το i+jsub f, t0 , t1 # f = t0 - t1 = (g+h) - (i+j)

Τελεσταίοι του υλικού του υπολογιστή

- Στις συμβολικές γλώσσες οι τελεσταίοι (operators) των αριθμητικώνεντολών είναι καταχωρητές ή μνήμη .

- Η αρχιτεκτονική MIPS έχει 32 ακέραιους καταχωρητές, οι οποίοι συμβολίζονται με $0, $1, ..., $31 (32 bits each – 64?)

Αρχή 2: Το μικρότερο είναι πιο γρήγορο.


- Η αποτελεσματική χρήση των καταχωρητών είναι το κλειδί στηναπόδοση των προγραμμάτων.

- Παράδειγμα 3 Έστω η πιο κάτω εντολή στη C : f = ( g + h ) - ( i + j ) ;μεταγλωττιστής της C συσχετίζει τις μεταβλητές f, g, h, i, και j με τους καταχωρητές $16, $17, $18, $19, και $20 αντιστοίχως.

add $8, $17, $18 # ο καταχωρητής $8 έχει το αποτέλεσμα g+hadd $9, $19, $20 # o καταχωρητής $9 έχει το αποτέλεσμα i+jsub $16, $8, $9 # ο καταχωρητής $16 έχει το αποτέλεσμα

# (g+h)-(i+j), την τιμή της μεταβλητής f

Οι καταχωρητές $8 και $9 αντιστοιχούν στις μεταβλητές t0 και t1 τουπροηγούμενου παραδείγματος.


- Οι αριθμητικές πράξεις στην αρχιτεκτονική MIPS μπορούν να γίνουν μόνομέσω των καταχωρητών,

– Αντίθετα με τον ΙΝΤΕL x86 όπου μπορούν να γίνουν και στην μνήμη. add eax,8(ebx) ld c,8(b)CISC add a,a,c RISC

- Η μνήμη στην πραγματικότητα είναι ένας μεγάλος, μονοδιάστατος πίνακαςκαι η διεύθυνση ένας δείκτης στον πίνακα.

- Οι διευθύνσεις ξεκινούν από το 0. - Για να έχουμε πρόσβαση στο τρίτο στοιχείο του πίνακα θαχρησιμοποιήσουμε διεύθυνση Memory [2], τα δεδομένα του οποίου είναι1000. Memory

Address Data

0 100

1 10

2 1000

... ...


- Eντολή φόρτωσης - Η εντολή που μεταφέρει δεδομένα από την μνήμη σε ένακαταχωρητή, ονομάζεται load -πχ lw (load word) διαβάζει 4 bytes.

- Παράδειγμα 4: Υποθέστε ότι ο πίνακας Α έχει 100 στοιχεία και ομεταγλωττιστής έχει συσχετίσει τις μεταβλητές g, h, και i με τουςκαταχωρητές $17, $18, και $19. Η βάση του πίνακα (διεύθυνση του πρώτουστοιχείου στον πίνακα) δίνεται είναι η διεύθυνση Astart. Μεταφράστε:

g = h + A[i];

lw $8, Astart ($19) # ο προσωρινός καταχωρητής $8 παίρνει το Α[i]add $17, $18, $8 # το αποτέλεσμα h + A[i] κρατείται στον

# καταχωρητή $17, ο καταχωρητής $17 κρατάει# την τιμή της μεταβλητής g

- H εντολή lw προσθέτει στην βάση της διεύθυνσης του πίνακα Α (Astart) τονδείκτη i που βρίσκεται στον καταχωριτή $19, για να υπολογίσει τηνδιεύθυνση του στοιχείου Α[i].

- Ο καταχωρητής που κρατεί την τιμή του δείκτη του πίνακα ονομάζεταικαταχωρητής δείκτη (index register). Εάν το Αstart βρίσκεται στο $20

add $21,$20,$19 // $21 προσωρινήlw $8,0($21)add $17,$18,$8


Διασύνδεση υλικού/λογισμικού- Ο μεταγλωττιστής είναι υπεύθυνος για την συσχέτιση μεταβλητών καικαταχωρητών, και επίσης για την ανάθεση δομών δεδομένων, όπως γιαπαράδειγμα πίνακες, στους χώρους της μνήμης.

-Ακολούθως ο μεταγλωττιστής μπορεί να τοποθετήσει την σωστή αρχικήδιεύθυνση στις εντολές μεταφοράς δεδομένων π.χ. lw.

- Ο επεξεργαστής MIPS μπορεί να έχει διεύθυνση για μεταφορά 1 Byte (8bits), 2 Bytes, 4 Bytes (μίας λέξης), ή 8 Bytes.

- Στη περίπτωση λέξεων, οι διευθύνσεις διαφέρουν κατά 4 (4 bytes).

Processor MemoryAddress Data0 1004 108 100012 1… …

- Η διευθυνσιοδότηση επηρεάζει επίσης τονδείκτη i για την εκφράση Α[i].

- Για τον σωστό υπολογισμό της διεύθυνσηςτου παραδείγματος, ο καταχωρητής $19(στονοποίο περιέχεται η τιμή της μεταβλητής i )πρέπει να πολλαπλασιάζεται με 4 (4 x i) καινα προστίθεται στο Astart(βάση του πίνακα)για τον υπολογισμό της διεύθυνσης


-Yπάρχουν δύο τρόποι για αρίθμηση των Bytes σε μία λέξη: με τον πρώτοτρόπο ο μικρότερος αριθμός είναι ο πιο αριστερά και με τον δεύτερο τρόποείναι ο πιο δεξιά: - Big endian : Byte # 0 1 2 3- Little endian : Byte # 3 2 1 0

- Ο επεξεργαστής MIPS εργάζεται και με τούς δύο τρόπους.

- Η οικογένεια επεξεργαστών της Intelακολουθεί το Little Endian.

X=F1F2F3F4hex

20 000

20 001

20 002

20 003

20 004

F4 F1

F3

F2

F1 F4

F3

F2

Little Endian Big Endian

X

8 bits

Βασική Αρχή Ορισμού MIPS Συνόλου Εντολών

Πολλά χαρακτηριστικά των εντολών της μηχανής MIPS οφείλονται στη κανονικοποίηση, όπως:

– όλες οι εντολές έχουν το ίδιο μέγεθος,– απαιτούνται πάντα τρείς καταχωρητές για τις αριθμητικές εντολές και τα

πεδία των καταχωρητών κρατούνται στην ίδια θέση για όλα τα είδη εντολών.

Αρχή 1. Η απλότητα στη σχεδίαση οφείλεται στη κανονικοποίηση.



- Eντολή Αποθήκευσης: Η αντίστροφη εντολή της load (φόρτωσε),είναι η store -πχ sw (φύλαξε μια λέξη).

- Παράδειγμα 5- Υποθέστε ότι η μεταβλητή h συσχετίζεται με τονκαταχωρητή $18. Υποθέστε επίσης ότι ο καταχωρητής $19 έχει τιμή 4 x i.Δίνεται ο πιο κάτω κώδικας σε C : A[i] = h + A[i]; Ποιος είναι ο αντίστοιχοςκώδικας σε γλώσσα MIPS;

lw $8, Astart ($19) # ο καταχωρητής $8 παίρνει προσωρινά την τιμή του Α[i]add $17, $18 , $8 # ο καταχωρητής $17παίρνει προσωρινά την τιμή του h+A[i]sw $17, Astart ($19) # Το h+A[i] φυλάγεται πίσω στη θέση Α[i]

Εάν το Αstart βρίσκεται στο $20

add $21,$20,$19 // $21 προσωρινήlw $8,0($21)add $17,$18,$8sw $17,0($21)


Διασύνδεση υλικού / λογισμικού

- Τα περισσότερα προγράμματα χρησιμοποιούν περισσότερες τοπικές μεταβλητές σεσχέση με τους καταχωρητές που διαθέτει η μηχανή.

- Ο μεταγλωττιστής προσπαθεί να τοποθετήσει τις τοπικές μεταβλητές πουχρησιμοποιούνται συχνότερα, στους καταχωρητές, και τις υπόλοιπες(μεταβλητές) στην μνήμη.

- Η διαδικασία της τοποθέτησης των λιγότερα χρησιμοποιημένων μεταβλητώνστην μνήμη, ονομάζεται register spilling.

-Αν, για παράδειγμα, έχουμε περισσότερες από 32 μεταβλητές σε έναπρόγραμμα. τότε υποχρεωτικά κάποιες θα πρέπει να βρίσκονται στηνμνήμη (μιλώντας πάντα για τον ΜΙPS).

- Για επίτευξη ψηλής απόδοσης, οι μεταγλωττιστές πρέπει ναχρησιμοποιούν αποδοτικά τούς καταχωρητές.

- Στον MIPS υπάρχουν εντολές για load word και store word, για 16 bit (halfword) - lh/sh και 8bit - lb/sb δεδομένων και load double word και store double word.


Processor Registers

MemoryAddress

Data (base 10)

$0 0 0 1003$1 1234 4 10$2 8 8 1000$3 23 12 1$4 512000 … …

lw $1,4($2)add $1,$1,$3sw $1,0($2)


Αναπαράσταση εντολών στην μηχανή

-‘Oπως είναι γνωστό, οι εντολές είναι κωδικοποιημένες στο δυαδικόσύστημα, σαν μία ακολουθία από δυαδικά ψηφία.

- Το κάθε ένα από αυτά τα κομμάτια της εντολής ονομάζεται πεδίο (field).– To πρώτο και τελευταίο πεδίο (0 & 32) σε συνδυασμό δηλώνουν ότι η

πράξη που θα εκτελεστεί είναι η πρόσθεση. – Το δεύτερο πεδίο δίνει τον αριθμό του καταχωρητή ($17) που είναι η πηγή

του πρώτου τελεσταίου της πρόσθεση. – Το τρίτο πεδίο δίνει τον αριθμό του καταχωρητή ($18) που είναι η πηγή του

δεύτερου τελεσταίου της πρόσθεσης. – Το τέταρτο πεδίο δίνει τον αριθμό του καταχωρητή ($8) που θα δεχτεί το

αποτέλεσμα της πρόσθεσης. – Το πέμπτο πεδίο δεν χρησιμοποιείται σε αυτή την εντολή και για αυτό

παίρνει την τιμή 0. -Αυτή η εντολή προσθέτει τον καταχωρητή (τα περιεχόμενα του) $17 στονκαταχωρητή (στα περιεχόμενα του) $18 και τοποθετεί το αποτέλεσμα στονκαταχωρητή $8.

0 17 18 8 0 32

000000 10001 10010 01000 00000 100000

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

add $8, $17, $18


- Όλες οι εντολές στο MIPS έχουν μέγεθος 32 bits, άρα διατηρείται η πρώτηαρχή που θέσαμε. Τα πιο πάνω πεδία έχουν συγκεκριμένα ονόματα:

- Η γενική μορφή της εντολής στη μηχανή MIPS με τα αντίστοιχαονόματα των πεδίων.

- Το κάθε πεδίο στην πιο πάνω κωδικοποίηση έχει ώς ακολούθως:

op: η λειτουργία της εντολής (operation of the instruction)rs: ο πρώτος καταχωρητής εισόδου (the first register, source operand)rt: ο δεύτερος καταχωρητής εισόδου (the second register, source operand) rd: o καταχωρητής που θα πάρει το αποτέλεσμα (the register destination

operand)shamt: ποσότητα μετακίνησης funct: συνάρτηση (function). Αυτό το πεδίο αποτελεί διαφοροποίηση της

εντολής από το πεδίο op.

op rs rt rd shamt funct6 bits 5 bits 5 bits 5 bits 5 bits 6 bits


- Όταν μια εντολή χρειάζεται μεγαλύτερα πεδία από αυτά που δίνονται πιοπάνω παρουσιάζονται προβλήματα.

- Για παράδειγμα, στην εντολή lw πρέπει να προσδιορισθούν δύοκαταχωρητές και μια διεύθυνση. Αν οι διευθύνσεις χρειάζονταν μόνο 5 bits(=25 ή 32 θέσεις μνήμης ) τότε αυτό θα ήταν δυνατό.

- Όμως, αυτό το μέγεθος είναι πολύ μικρό για να μπορέσει να χρησιμοποιηθείγια διευθύνσεις δεδομένων.

- Οι σχεδιαστές του MIPS αποφάσισαν να κρατήσουν όλες τις εντολές στοίδιο μήκος -32 bits-

> διαφορετικά είδη εντολών θα πρέπει να έχουν διαφορετική μορφή.

- H πιο κάτω μορφή ονομάζεται R-type (Register type).

op rs rt rd shamt funct6 bits 5 bits 5 bits 5 bits 5 bits 6 bits


• Ένα δεύτερο είδος εντολής ονομάζεται I-type και χρησιμοποιείται από τις εντολές μετακίνησης δεδομένων (π.χ. lw, sw).

• Tα πεδία αυτής της μορφής είναι:

• Για παράδειγμα για την εντολή: lw $8, Astart ($19)– Η τιμή 19 θα τοποθετηθεί στο πεδίο rs– Η τιμή 8 θα τοποθετηθεί στο πεδίο rt– και η βάση της διεύθυνσης του πίνακα Astart στο πεδίο

διευθύνσεων (address). – Σημειώστε ότι το πεδίο rt στην εντολή lw δίνει το πεδίο που θα

πάρει το αποτέλεσμα. – Στο sw το πεδίο rt περιέχει τον καταχωρήτη με την τιμή που θα

πάει στην μνήμη

op rs rt address

6 bits 5 bits 5 bits 16 bits


• Πολλές μορφές εντολών προκαλούν πολυπλοκότητα στο υλικό> μπορούμε να μειώσουμε την πολυπλοκότητα κρατώντας τις μορφές των εντολών παρόμοιες.

• Για παράδειγμα, τα πρώτα τρία πεδία στις μορφές R-type και I-typeέχουν τα ίδια ονόματα και το τέταρτο πεδίο στην I-type είναι ίσο με το μήκος των άλλων τριών πεδίων του R-type.

• Η ομοιομορφία ανάμεσα στους δύο τύπους, αυτό βοηθά στηναποκωδικοποίηση του προγράμματος, χρησιμοποιώντας το ίδιο κύκλωμα.

• Οι διάφορες μορφές/τύποι των εντολών ξεχωρίζουν από τις τιμές πουδίνονται στο πρώτο πεδίο (op).

• Η κάθε μορφή παίρνει συγκεκριμένες τιμές στο πεδίο op, γι’ αυτό καιπαραδοσιακά το πεδίο αυτό ονομάζεται opcode -κωδικός εντολής.

RISC VS CISC Debate


Kωδικοποιήσεις των εντολών που μελετήσαμε μέχρι τώρα

• Μεγέθη των πεδίων για τις πιο πάνω εντολές:

οι εντολές add και sub έχουν το ίδιο op πεδίο. Το πεδίο funct προσδιορίζει ποια αριθμητική πράξη (πρόσθεση ή αφαίρεση) πρέπει να εκτελέσει.

Instruction Format op rs rt rd shamt funct addressAdd R 0 Reg Reg Reg 0 32 n.a.Sub R 0 Reg Reg Reg 0 34 n.a.

Lw I 35 Reg Reg n.a. n.a. n.a. addressSw I 43 Reg Reg n.a. n.a. n.a. address

Field op rs rt rd shamt funct addressSize 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 16 bits


Παράδειγμα 6- Υποθέστε ότι η μεταβλητή h συσχετίζεται με τον καταχωρητή$18 και επίσης ότι ο καταχωρητής $19 έχει την τιμή 4 x i (όπως στοπροηγούμενο παράδειγμα). H εντολή στη C A[i] = h + A[i] ;

μεταγλωττίζεται σε:

lw $8, Astart ($19) # ο καταχωρητής $8 παίρνει προσωρινά το Α[i]add $8, $18 , $8 # ο καταχωρητής $8 παίρνει προσωρινά h+A[i]sw $8, Astart ($19) # Το h+A[i] φυλάγεται πίσω στη θέση Α[i]

Ποιός είναι ο κώδικας σε γλώσσα μηχανής (MIPS) για τις πιο πάνω εντολές;


Υποθέτουμε ότι η βάση του πίνακα (αρχική διεύθυνση) είναι το 1200 στοδεκαδικό (ή 0000 0100 1011 0000 στο δυαδικό). Η μορφή των τριών εντολώνστο δεκαδικό σύστημα είναι:

• Η εντολή lw προσδιορίζεται από τον αριθμό 35 (πεδίο op). • H εντολή add προσδιορίζεται από το πρώτο και τελευταίο πεδίο (0 και 32)• H εντολή sw προσδιορίζεται από τον αριθμό 43 στο πρώτο πεδίο• Η αντίστοιχη δυαδική μορφή των εντολών (τρόπος αναπαράστασης τους σε

γλώσσα μηχανής) είναι:

• Προσέξτε την ομοιότητα της πρώτης και τρίτης εντολής στην δυαδική απεικόνιση. – Η μόνη διαφορά τους βρίσκεται στο πρώτο πεδίο, στο τρίτο bit από τα αριστερά.

op rs rt (rd) (shamt) AddressOR funct

35 19 8 1200(Astart)0 18 8 8 0 3243 19 8 1200

100011 10011 01000 0000 0100 1011 0000000000 10010 01000 01000 00000 100000101011 10011 01000 0000 0100 1011 0000


H μεγάλη εικόνα:

• Σήμερα οι υπολογιστές είναι κτισμένοι πάνω σε δύο βασικές αρχές:

1. Οι εντολές απεικονίζονται ως αριθμοί.2. Τα προγράμματα μπορούν να αποθηκευθούν στη μνήμη για να

διαβαστούν, ή να γραφούν, όπως οι αριθμοί. 3. Το ίδιο και τα δεδομένα: μεταβλητές, προσωρινά

αποτελέσματα, δομές

-Αυτή η αρχή ονομάζεται “η έννοια του αποθηκευμένου προγράμματος” (stored program concept). John Von Neuman (1946)John Von Neuman, J. Presper Eckert and John William Mauchly

-Αποθηκευμένα Προγράμματα --Τα προγράμματα φυλάγονται στη μνήμη σαν κώδικας σε γλώσσα μηχανής.


Διασύνδεση Υλικού/Λογισμικού

Η συμβολική αναπαράσταση των εντολών ονομάζεται συμβολική γλώσσα, καιη αντίστοιχη αναπαράσταση με αριθμούς ονομάζεται γλώσσα μηχανής.

- H ιεραρχία μετάφρασης για ένα πρόγραμμα από υψηλού επιπέδου γλώσσαμέχρι τη γλώσσα μηχανής.

- ένα πρόγραμμα σε C (υψηλού επιπέδου γλώσσα) μεταφράζεται σε συμβολική γλώσσα από τον μεταγλωττιστή

- ο συμβολομεταφραστής μεταφράζει την συμβολική γλώσσα σε γλώσσα μηχανής.

- Το πρόγραμμα που τοποθετεί το πρόγραμμα της γλώσσας μηχανής στη μνήμη για εκτέλεση ονομάζεται φορτωτής (loader).

C program

Assembly language program

Machine language program

Memory

Compiler

Assembler

Loader

Υπάρχουν και άλλα ενδιάμεσα επίπεδα (πχ JVM, assembler-to-assembler)


Ιδιομορφίες του MIPS και ψευδοεντολές

• Ο καταχωρητής $0 στη μηχανή MIPS έχει πάντα την τιμή 0.• Γι’ αυτό ο συμβολομεταφραστής της γλώσσας MIPS έχει την πιο κάτω

εντολή αν και δεν ανήκει στην αρχιτεκτονική της μηχανής MIPS:

move $8, $18 #ο καταχωρητής 8 θα πάρει το περιεχόμενο του #καταχωρητή 18.

• Ο συμβολομεταφραστής μεταφράζει την πιο πάνω εντολή στην αντίστοιχη εντολή του MIPS που είναι:

add $8, $0, $18 # ο καταχωρητής 8 παίρνει το άθροισμα του # καταχωρητή 0 και 18.

• Η εντολή move δεν υποστηρίζεται από τον MIPS, είναι ψευδοεντολή και συσχετίζεται με την εντολή add.


Εντολές διακλαδώσειςν/ ανάληψη αποφάσεων

• Η μηχανή ΜIPS υποστηρίζει δύο εντολές για λήψη αποφάσεων, παρόμοιες με το if και το goto,

beq register1, register2, L1

• Η πιο πάνω εντολή (branch equal) μεταφέρει την εκτέλεση του προγράμματος στην εντολή που έχει ετικέτα (label) L1 αν τα δεδομένα του register1 ισούνται με τα δεδομένα του register2.

• Η επόμενη εντολή για ανάληψη αποφάσεων είναι:

bne register1, register2, L1

• Η πιο πάνω εντολή πηγαίνει στην εντολή που έχει ετικέτα L1 αν τα δεδομένα του register1 και register2 δεν ισούνται (branch not equal).

• Αυτές οι δύο εντολές ονομάζονται διακλαδώσεις υπό συνθήκη (conditional branches).


- Παράδειγμα 7: Δίνεται ο ακόλουθος κώδικας σε γλώσσα C :if ( i = = j ) goto L1; Ή if (i!=j)f = g + h; f = g + h;

L1: f = f - i; f = f – i;

Οι μεταβλητές f, g, h, i και j είναι τοποθετημένες στους καταχωρητές $16 έως $20.

beq $19, $20, L1 # go to L1 αν i = jadd $16, $17, $18 # f = g + h (αγνοείται αν i = j)

L1: sub $16, $16, $19 # f = f - i εκτελείται πάντοτε


Διασύνδεση υλικού / λογισμικού

Οι μεταγλωττιστές συχνά δημιουργούν μεταπηδήσεις και ετικέτες που δεν παρουσιάζονται στις γλώσσες υψηλού επιπέδου. Για παράδειγμα,χρησιμοποιώντας τις μεταβλητές και τους καταχωρητές του πιο πάνωπαραδείγματος, ο πιο κάτω κώδικας σε C:

if (i= =j)f=g+h;

else f=g-h;

μεταγλωττίζεται στον πιο κάτω κώδικα MIPS:

bne $19, $20, Else # αν i ≠ j goto Else add $16, $17, $18 # f = g + h ( αγνοείται αν i ≠ j )j Next # go to Next

Else : sub $16, $17, $18 # f = g - h ( αγνοείται αν i = j )Next :

f = g + h f = g - h

i = = j ?

Exit :

i = j i != j

Else :

J (jump) εντολή διακλάδωσης χωρίς συνθήκη

Σύνταξη: j label

Σημασία: μετά την εκτέλεση της εντολής τύπου jump η ροή ελέγχου συνεχίζει στην εντολή με το label

Format (j-type):


optype Target6-bit 26-bit


Παράδειγμα 8: Δίνεται ο ακόλουθος βρόγχος σε C :

Loop : g = g + A[i] do g = g + A[i];i = i + j; i = i + j;

if (i != h) goto Loop; while(i!=h);

- Υποθέστε ότι - ο πίνακας Α έχει 100 στοιχεία words (32 bit=word = 4 bytes ) - μεταγλωττιστής συσχετίζει τις μεταβλητές g, h, i, και j με τους καταχωρητές

$17, $18, $19 και $20. - Επίσης ο πίνακας Α ξεκινά στο Astart που την τιμή του το περιέχει ο $21. - Ο δείκτης του πίνακα i, πρέπει να πολλαπλασιάζεται επί 4 και το 4 βρίσκεταιστον καταχωρητή $10.

Loop : mul $9, $19, $10 # Προσωρινός καταχωρητής $9 = i x 4, add $11,$9,$21 # υπολογισμός δείκτη lw $8, 0 ($11) # Προσωρινός καταχωρητής $8 = A[i]add $17, $17, $8 # g=g+A[i]add $19, $19, $20 # i = i+jbne $19, $18, Loop # Πήγαινε στο Loop αν i ≠ h


Διασύνδεση λογισμικού / υλικού

• Oι προγραμματιστές συνήθως δεν γράφουν loops με gotos. • Εναπόκειται στον μεταγλωττιστή να μεταφράσει τα loops, σε γλώσσα

μηχανής. Ο κώδικας σε C:

while (save [i] == k)i = i + j;

μεταφράζεται στον πιο κάτω κώδικα MIPS, δεδομένου ότι • i, j και k, αντιστοιχούν στους καταχωρητές $19, $20 και $21, επίσης • ο πίνακας save ξεκινά στο Sstart και ο καταχωρητής $10 περιέχει το 4.

Loop: mul $9, $19, $10 # Προσωρινός καταχωρητής $9 = i x 4lw $8, Sstart ($9) # Προσωρινός καταχωρητής $8 = save [i]bne $8, $21, Exit # go to Exit if save [i] != kadd $19, $19, $20 # i=i+jj Loop # goto Loop

Exit:


• Ο έλεγχος για ισότητα ή ανισότητα είναι ίσως ο πιο δημοφιλής έλεγχος, αλλά αρκετές φορές, θέλουμε να ελέγξουμε αν μια μεταβλητή, είναι πιο μικρή από μια άλλη μεταβλητή.

• Η εντολή set on less than (slt), μας επιτρέπει να κάνουμε αυτήν την

σύγκριση, π.χ.– slt $8, $19, $20

• Ο καταχωρητής $8 παίρνει την τιμή 1, αν η τιμή στον καταχωρητή $19 είναι πιο μικρή από την τιμή στον καταχωρητή $20, διαφορετικά ο καταχωρητής $8 παίρνει την τιμή 0.


Διασύνδεση λογισμικού/υλικού:

• Στον MIPS, οι εντολές slt, beq, bne, και η τιμή 0 στον καταχωρητή $0 χρησιμοποιούνται για τη δημιουργία όλων των σχετικών ελέγχων.

• Για παράδειγμα, για να ελέξουμε αν η μεταβλητή στον καταχωρητή $16 είναι πιο μικρή από την τιμή στον καταχωρητή $17, εκτελούμε τις ακόλουθες εντολές:

slt $1, $16, $17 # S1=1 if $16 < $17bne $1, $0, Less # goto Less if $1 ≠ $0.

• Οι εντολές slt και bne εκτελούν την συνθήκη ελέγχου για το μικρότερο.

• Στην πραγματικότητα ο συμβαλόμεταφραστής του MIPS, μεταφράζει την εντολή ψευδοεντολή blt (branch on less than)στις δύο πιο πάνω εντολές.

• blt $16,$17,Less - προσοχή στην χρήση του $1


• Ο MIPS δεν υποστηρίζει την εντολή blt, είναι διότι θα προκαλούσε επιπρόσθετη πολυπλοκότητα στη μηχανή,

– είτε θα μεγάλωνε ο κύκλος μηχανής – είτε η εντολή θα χρειαζόταν επιπρόσθετους κύκλους

μηχανής για κάθε εντολή. – Δύο γρήγορες εντολές είναι πολύ πιο χρήσιμες. To

μικρότερο είναι το πιο γρήγορο (ΑΡΧΗ 2).

Σημειώστε ότι ο καταχωρητής $1 χρησιμοποιείται από τονσυμβολομεταφραστή. Για αυτό το λόγο αποφεύγεται ναχρησιμοποιείται από τους μεταγλωττιστές της γλώσσας MIPS.


Bitwise Λογικοί Τελεστές

Shift left << sll R-typeShift right >> srl R-typeBit by bit AND & and,andi R/I-typeBit by bit OR | or, ori R/I-typeBit by bit NOT ~ nor R-type

sll $t2,$s0,4 # $t2 = $s0 << 4op rs rt rd shamt func0 0 16 10 4 0

0000 0000 0000 0000 0000 0000 0000 10012 90000 0000 0000 0000 0000 0000 1001 00002 (9<<4) = 144


Unsigned and Signed Τελεστές• Unsigned: 0-extend άμεση τιμή από 16 σε 32 bit• Signed: sign-extend άμεση τιμή από 16 σε 32 bit • Αριθμητικές πράξεις μπορεί να προκαλέσουν

exception σε περίπτωση overflow (επιλογή για ορισμό στην αρχιτεκτονική)

add $1,$2,$3addi $1,$2,0xf123 $1 = $2 + 0xfffff123addu $1,$2,$3 addiu $1,$2,0xf123 $1 = $2 + 0x0000f123ori $1,$2,0xf0 $1 = $2 | 0x000000f0andi $1,$2,0xff00 $1 = $2 & 0x0000ff00


Άλλα είδη διευθυνσιοδότησης στη μηχανή MIPS

Σταθεροί ή Άμεσοι Τελεσταίοι

- Πολλές φορές χρησιμοποιούμε σταθερούς αριθμούς σε μια λειτουργία (μιανεντολή). 1. Για παράδειγμα, όταν αυξάνουμε τον δείκτη να δείχνει στο επόμενοστοιχείο σε ένα πίνακα, ή όταν μετρούμε τις επαναλήψεις σε ένα loop, ήόταν μετατρέπουμε την στοίβα σε ένα φωλιασμένο call.

2. Στην πραγματικότητα, σε δύο προγράμματα που έχουν μελετηθεί: στομεταγλωττιστή της C, gcc και στο πρόγραμμα για σχεδίαση ηλεκτρονικώνκυκλωμάτων spice, περισσότερο από 50% των αριθμητικών λειτουργιώνδιεξάγεται σε σταθερούς τελεσταίους.


• Η μορφή εντολών Ι-type είναι για Immediate-type εντολές (δηλ. εντολές στις οποίες ένας από τους τελεσταίους τους είναι σταθερά). Το πεδίο του MIPS στο οποίο αποθηκεύεται η σταθερά έχει μέγεθος 16 bits.

• Η εντολή πρόσθεσης - add η οποία έχει ένα σταθερό τελεσταίο ονομάζεται add immediate ή addi. Για να προσθέσουμε τον αριθμό 4 στον καταχωρητή 29 γράφουμε απλά:

addi $29, $29, 4 # $29 = $29 + 4

Ο κώδικας μηχανής:op rs rt immediate8 29 29 4

001000 11101 11101 0000 0000 0000 0100


• Οι τελεσταίοι άμεσης πρόσβασης/στεθερές (immediate) είναι επίσης πολύ χρήσιμοι για τις συγκρίσεις.

• Όπως έχουμε τονίσει ο καταχωρητής $0 έχει πάντα την τιμή 0, έτσι μπορούμε να συγκρίνουμε με το μηδέν.

• Για σύγκριση με άλλες τιμές, μπορούμε να χρησιμοποιήσουμε την εντολή slti (set on less than immediate),

• Για παράδειγμα στις πιο κάτω εντολές θέλουμε νασυγκρίνουμε αν το περιεχόμενο του καταχωρητή 18 είναιμικρότερο από το 10 :

slti $8, $18, 10 # $8 = 1 if $18<10bne $8, $0, Less # goto Less if $18<10


Αρχή 4: Σχεδίασε τις πιο συχνές περιπτώσεις έτσι ώστε να εκτελούνταιπιό γρήγορα (Make the common cases fast).

• Η χρήση σταθερών τελεσταίων είναι πολύ συχνή.• Αν και οι περισσότερες σταθερές χωράνε στο πεδίο των 16bits, μερικές

φορές μπορεί να έχουμε και πιο μεγάλες σταθερές. • Η εντολή του MIPS load upper immediate (lui), μεταφέρει τα 16 bits

της σταθερά στα πιο ψηλά 16 bits του καταχωρητή, αφήνοντας τα χαμηλότερα 16 bits να προσδιορισθούν από μία άλλη εντολή, όπως φαίνεται στο Σχήμα 3.9α.

• Ο κώδικας σε γλώσσα μηχανής για την εντολή lui $8, 255 :

Τα περιεχόμενα του καταχωρητή 8 μετά από την εκτέλεση της εντολής lui:

001111 00000 01000 0000 0000 1111 1111

0000 0000 1111 1111 0000 0000 0000 0000


- Ποίος θα είναι ο κώδικας στη συμβολική γλώσσα MIPS για να φορτώσουμε την πιο κάτω 32-bit σταθερά στο καταχωρητή $16:

0000 0000 0011 1101 0000 1001 0000 0000

- Πρώτα θα φορτώσουμε τα ψηλότερα 16 bits (είναι ο αριθμός 61 στοδεκαδικό), χρησιμοποιώντας την εντολή lui:

lui $16, 61 # 61 decimal = 0000 0000 0011 1101 in binary, 0x003D

Η τιμή στο καταχωρητή 16 θα είναι τελικά:0000 0000 0011 1101 0000 0000 0000 0000

Το επόμενο βήμα είναι να προσθέσουμε τα χαμηλότερα 16 bits, τους οποίους η δεκαδική τιμή είναι 2304:

addiu $16, $16, 2304 # 2304 decimal = 0000 1001 0000 0000

Αντί addiu;

Η τελική τιμή στο καταχωρητή $16 θα είναι η επιθυμητή τιμή, δηλαδή:0000 0000 0011 1101 0000 1001 0000 0000


Διευθυνσιοδότηση με διακλάδωση και άμεσες τίμες

- Η πιο απλή διευθυνσιοδότηση στον MIPS είναι η εντολές jump. - Χρησιμοποιείται η τρίτη και τελευταία μορφή εντολών στον ΜIPS, η J-type, - 6 bits για το πεδίο op (λειτουργίας) και τα υπόλοιπα 26 bits είναι για το πεδίοτων διευθύνσεων. (PC <= PC31_28::IR25_0::00

Program counter (PC), ή instruction address register: καταχωρητής ο οποίος αποθηκεύει (κρατεί) την διεύθυνση της επόμενης εντολής που θα εκτελεσθεί.

j 10000 # goto location PC31_28 :10000x4

- Η διακλάδωση υπό συνθήκη- bne $8, $21, Exit # goto Exit if $8 = $21

2 100006 bits 26 bits

5 8 21 Exit6 bits 5 bits 5 bits 16 bits


• Αν οι διευθύνσεις ενός προγράμματος έπρεπε να χωράνε σε ένα πεδίο 16 bits,

– Ένα πρόγραμμα δεν θα μπορούσε να είναι μεγαλύτερο από 216 bits.

• Σχεδόν οι μισές εντολές διακλάδωσης υπό συνθήκη στα προγράμματα gcc και spice πηγαίνουν (μεταπηδούν) σε λιγότερο από 16 εντολές από το σημείο (εντολή) που ελέγχθηκε η συνθήκη.

• Δεδομένου ότι ο PC περιέχει την διεύθυνση της τρέχουσας εντολής, μπορούμε να έχουμε διακλάδωση μέσα σε 216 από την τρέχουσα εντολή χρησιμοποιώντας τον καταχωρητή PCγια να προστεθεί η διεύθυνση διακλάδωσης.

• Σχεδόν όλες οι εντολές load και if χρειάζονται πιο μικρή διεύθυνση από 216 bits, επομένως η χρήση του καταχωρητή PC είναι η ιδανική λύση.


PC-relative addressing.1. Το υλικό αυξάνει τον καταχωρητή PC στα αρχικά στάδια

της εντολής για να δείχνει στην επόμενη εντολή. 2. Επομένως η επόμενη διεύθυνση στη μηχανή MIPS θα είναι

στη θέση PC+4 αν η προηγούμενη ήταν στη θέση που δεικνύει ο PC.


Δίνεται ο πιο κάτω κώδικας σε MIPS που αντιπροσωπεύει ένα while loop σεμια γλώσσα ψηλού επιπέδου:

Loop : sll $9, $19, 2 # Προσωρινός καταχωρητής $9 = i x 4lw $8, Sstart ($9) # Προσωρινός καταχωρητής $8 = save [i]bne $8, $21, Exit # go to Exit if save [i] != kadd $19, $19, $20 # i=i+jj Loop # goto Loop

Exit:

80000 0 19 9 0 2 080004 35 9 8 100080008 5 8 21 280012 0 19 20 19 0 3280016 2 2000080020 …

- Η εντολή bne στην τρίτη γραμμήπροσθέτει 8 bytes (2x4) στη διεύθυνση τηςεπόμενης εντολής (80012), προσδιορίζονταςτον προορισμό της διακλάδωσης σε σχέσημε αυτή την εντολή αντί να χρησιμοποιήσειολόκληρη τη διεύθυνση (80020).

- Η εντολή j (jump) χρησιμοποιεί ολόκληρητην διεύθυνση (20000x4=80000), που ανταποκρίνεται στην ετικέτα Loop


Διασύνδεση λογισμικού / υλικού

• Αν και σχεδόν όλες οι διακλαδώσεις υπό συνθήκη είναι σε κοντινές διευθύνσεις, υπάρχει ανάγκη για διακλάδωση και σε μακρινές διευθύνσεις.

– Για παράδειγμα η εντολή:

beq $18, $19, L1μπορεί να αντικατασταθεί με δύο εντολές, ώς ακολούθως, για να επιτευχθεί ηδιακλάδωση στη μακρινή διεύθυνση L1:

bne $18, $19, L2j L1

L2:


Switch και jr

• -Αρκετές γλώσσες προγραμματισμού έχουν εντολές case ή switch. Για την υποστήριξη τέτοιων εντολών, ο MIPS έχει την εντολή jr (jump register), η οποία εκτελεί μεταπήδηση χωρίς συνθήκη στην διεύθυνση (αντίστοιχη ετικέτα) που είναι αποθηκευμένη στον καταχωρητή.

Παράδειγμα 9• Δίνεται ο πιο κάτω κώδικας σε C, o οποίος χρησιμοποιεί την

εντολή επιλογής switch για να επιλέξει μια συγκεκριμένη λειτουργία, ανάλογα με την τιμή της μεταβλητής k.

• Υποθέστε ότι οι μεταβλητές f, g, h, i, j, k συσχετίζονται με τους καταχωρητές από $16 ως $21 και επίσης

• Ο καταχωρητής $10 περιέχει τον αριθμό 4.

Ποιος θα είναι ο αντίστοιχος κώδικας σε MIPS;


switch (k) case 0: f = i + j; break; /* k = 0 */

case 1: f = g + h; break; /* k =1 */case 2: f = g - h; break; /* k =2 */case 3: f = i - j; break; /* k = 3 */

- Φορτώνουμε τέσσερις λέξεις στη μνήμη, ξεκινώντας από τη θέση JumpTable- Ο πίνακας έχει οριστεί από τον μεταγλωττιστή. - Κάθε εντολή είναι 4 bytes άρα ξέρουμε τις διευθύνσεις L0, L1, L2, L3.

Loop: mult $9, $10, $21 # Temporary reg. $9 =k x4 ή sll $9,$10,2lw $8, JumpTable($9) # Temporary register $8 = JumpTable[k]jr $8 # Jump based on register $8

L0: add $16, $19, $20 # k = 0 so f gets i + jj Exit # end of this case so goto Exit

L1: add $16, $17, $18 # k = 1 so f gets g + h j Exit # end of this case so goto Exit

L2: sub $16, $17, $18 # k = 2 so f gets g - h j Exit # end of this case so goto Exit

L3: sub $16, $19, $20 # k = 3 so f gets i - jExit: # end of switch statement

JumpTable +0 L0+4 L1+8 L2+12 L3


Διευθύνσεις Δεδομένα μεγέθους 32 bits (δυαδική μορφή εντολών)

Οι διευθύνσεις των ετικετών στον πίνακα διαφέρουν 8 bytes η μία από τηνάλλη διότι κάθε ετικέτα αποτελείται από 2 εντολέs των 4 bytes η κάθε μία.

JumpTable [12]

JumpTable [8]

JumpTable [4]

JumpTable [0]L0 : 0XF20 000

L1 : 0XF20 008

L2 : 0XF20 010

L3 : 0XF20018


Αρχιτεκτονική MIPS

Name Example Comments32 registers $0, $1, $2, . . . ., $31 Fast location for data. In MIPS, data must

be in registers to perform arithmetic.

MIPS register $0 always equals 0.

Register $1 is reserved for the assembler toHandle pseudoinstructions and largeconstants.

230 memory Words (232B)

Memory[0],Memory[4],Memory[4292967292]

Accessed only by data transfer instructions. MIPS uses byte addresses. Sequential words differ by 4. Memory holds data structures, such as arrays, and spilled registers, such as those saved on procedure calls.


Category Instructions Example Meaning Comments

Arithmetic

Add add $1, $2, $3 $1 = $2 + $3 3 operands; data in registerSubtract sub $1, $2, $3 $1 = $2 - $3 3 operands; data in registerAddImmediate

addi $1, $2, 100 $1 = $2 + 100 Used to add constants

Data Transfer

Load word lw $1, 100($2) $1 = Memory[$2+100] Data from memory to registerStore word sw $1, 100($2) Memory[$2+100] = $1 Data from register to memoryLoad upper immediate

lui $1, 100 $1 = 100 * 216 Loads constants in upper 16 bits

Conditional Branch

Branch on equal

beq $1, $2, 25 if ($1 == $2) go toPC + 4 + 100

Equal test; PC relative branch

Branch on not equal

bne $1, $2, 25 if ($1 != $2) go toPC + 4 + 100

Not equal test; PC relative

Set on less than

slt $1, $2, $3 if ($2<$3) $1 = 1;else $1 = 0

Compare less than; for beq, bne

Set less than immediate

slti $1, $2, 100 if ($2<100) $1 = 1;else $1 = 0

Compare less than constant

Unconditional Jump

Jump j 2500 go to 10000 Jump to target addressJump register

jr $31 go to $31 For switch, procedure return

Jump and link jal 2500 $31 = PC + 4; go to 10000 For procedure call


Name Format Example CommentsAdd R 0 2 3 1 0 32 add $1, $2, $3Sub R 0 2 3 1 0 34 sub $1, $2, $3Addo I 8 2 1 100 addi $1, $2, 100Lw I 35 2 1 100 lw $1, 100($2)Sw I 43 2 1 100 sw $1, 100($2)Lui I 15 0 1 100 lui $1,100Beq I 4 1 2 25 beq $1, $2, 100Bne I 5 1 2 25 bne $1, $2, 100Slt R 0 2 3 1 0 42 slt $1, $2, $3Slti I 10 2 1 100 slti $1, $2, 100J J 2 2500 j 10000Jr R 0 31 0 0 0 8 jr $31Jal J 3 2500 jal 10000Field size 6

bits5 bits

5 bits

5 bits 5 bits 6 bits

All MIPS instructions32 bits

Format R

R op rs rt rd Shamt

funct Arithmetic Instruction format

Format I I op rs rt Address / immediate Transfer, branch,Imm. Format

Format J J op Target address Jump instructionformat


Reserved 0x0000 0000Text 0x0040 0000 pcStatic 0x1000 0000

0x1000 8000 $gpHeap 0x1000 8004Stack 0x7FFF FFFC $sp

Ευθύνη μεταγλωτιστή/προγραμματιστή δέσμευση στον κατάλληλο χώρο

Text: κώδικαςStatic: globalStack: localHeap dynamic

Registers: local (τυποποίηση 0,1,26,27,28,29,30,31 δεσμευμένα)

Memory Model MIPS


Υποστήριξης διαδικασιών σε επίπεδο υλικού

- Μία διαδικασία ή υποπρόγραμμα (subroutine) είναι ένας τρόπος με τονοποίο οι προγραμματιστές χωρίζουν τα προγράμματα τους για να κάνουν πιοεύκολη την κατανόηση του κώδικα και για να επιτρέψουν στον κώδικα ναξαναχρησιμοποιηθεί (reusability).

- Μια ομάδα εντολών πρέπει να παρέχει ένα τρόπο μεταφοράς της ροήςεκτέλεσης του προγράμματος σε μια διαδικασία και ακολούθως να επιτρέπειτην επιστροφή στην επόμενη εντολή (αμέσως μετά από την εντολή πουκάλεσε τη διαδικασία).

- Οι προγραμματιστές ακόμη πρέπει να έχουν τρόπο για το πέρασμα τωνπαραμέτρων

- Η αρχιτεκτονική MIPS υποστηρίζει μίαν εντολή που μεταπηδά σε μίαδιεύθυνση, και ταυτόχρονα αποθηκεύει τη διεύθυνση της εντολής πουακολουθεί στον καταχωρητή $31: jump - and - link (jal) και έχει ωςακολούθως:

jal ProcedureAddress

- H εντολή που μεταπηδά στην επιστροφή είναι η jr $31


π.χ. • υψηλού επιπέδου γλώσσα:

– call procedure1• σε συμβολική γλώσσα:

– jal procedure1 address• Ο μεταγλωττιστής θα δώσει/συσχετίσει την διεύθυνση procedure1 με το όνομα της διαδικασίας procedure1.

• Το jr $31 αντιστοιχεί στο ret (return) ή end που είναι η τελευταία εντολή που εκτελείται στην διαδικασία.

• $31 : φυλάγεται η επόμενη διεύθυνση μετά από το call.


• Program counter (PC), ή instruction address register: καταχωρητής ο οποίος αποθηκεύει (κρατεί) την διεύθυνση της επόμενης εντολής που θα εκτελεσθεί.

ΚΑΘΕ ΕΝΤΟΛΗ ΕΝΗΜEΡΩΝΕΙ ΤΟΝ PCPC= PC+4 για εντολές που δεν είναι διακλαδώσεις

• Η εντολή jal ProcedureAddress προσθέτει 4 στο PC, για να δείχνει στην επόμενη εντολή και αποθηκεύει το αθροίσμα στον καταχωρητή$31 και μετά ενημερώνει τον PC να δείχνει στο ProcedureAddress

• Η εντολή jr $31 απλά αντιγράφει το $31 στο PC• $31 ενναλακτικα $ra (return address)


• Στην περίπτωση που έχουμε φωλιασμένα (nested) jal τότε είναι απαραίτητο να φυλαχτεί η αρχική τιμή του $ra πριν να εκτελέσουμε τα jal που ακολουθούν.

– Ο ιδανικός τρόπος για επίτευξη αυτής της λειτουργίας είναι η χρησιμοποίηση της στοίβας (stack).

• Χρειάζεται ένας δείκτης που θα δείχνει στην κορυφή της στοίβας, δηλαδή εκεί που η επόμενη εντολή πρέπει να τοποθετήσει τους καταχωρητές της.

• Η τοποθέτηση δεδομένων στη στοίβα ονομάζεται push, ενώ η μετακίνηση τους από την στοίβα pop.


- Επιπρόσθετα στη διεύθυνση επιστροφής χρειαζόμαστε μεταφορά τωνδεδομένων των μεταβλητών ή των παραμέτρων σε μία διαδικασία.

1. Στην αρχιτεκτονική MIPS η μέθοδος αυτή γίνεται με την τοποθέτησητων παραμέτρων στους καταχωρητές $4 έως $7. (σύμβαση)

2. Αν μία διαδικασία χρειάζεται να καλέσει μιαν άλλη διαδικασία, αυτοί οικαταχωρητές μπορούν να φυλαχθούν και να τους επαναφέρομαι στη συνέχεια,χρησιμοποιώντας τη στοίβα.

- Γενικώς μία διαδικασία, μπορεί να αλλάξει τους καταχωρητές πουχρησιμοποιούνται από την τρέχουσα διαδικασία. Υπάρχουν δύοτυποποιημένες πρακτικές για αυτό:

1. Αποθηκεύει αυτός που καλεί (caller save). Η διαδικασία που καλεί είναι υπεύθυνη για το φύλαγμα και την επαναφορά των καταχωρητών, οιοποίοι πρέπει να φυλαχτούν κατά την διάρκεια της εκτέλεσης τηςδιαδικασίας. Τότε η διαδικασία που καλείται μπορεί να αλλάξειοποιοδήποτε καταχωρητή.

2. Αποθηκεύει αυτός που καλείται (call/callee save). Φυλάει και επαναφέρειαυτός που καλείται. Η διαδικασία που καλείται φυλάει τους καταχωρητές,τους χρησιμοποιεί όπως θέλει και επαναφέρει τους αρχικούς στο τέλοςτου καλέσματος.


Ένα γενικό παράδειγμα

swap ( int v[ ], int k ) int temp;

temp = v[k] ;v[k] = v[k+1] ;v[k+1] = temp ;

Η διαδικασία swap, η οποία ανταλλάζει δύο διαδοχικές θέσεις στη μνήμη, στηγλώσσα C.

- Όταν μεταφράζουμε κάποια διαδικασία από C σε συμβολική γλώσσαακολουθούμε τρία γενικά βήματα:1. Προσδιορισμός των καταχωρητών που θα χρησιμοποιηθούν για τιςμεταβλητές του προγράμματος.

2. Παραγωγή κώδικα για το κύριο σώμα της διαδικασίας. 3. Διαφύλαξη καταχωρητών κατά τις κλήσεις διαδικασιών (across the

procedure invocation) – αποθήκευση στην στοίβα στην αρχή και επαναφορά στο τέλος (για τώρα)


Θα μετατρέψουμε την διαδικασία swap σε συμβολική γλώσσα ακολουθώνταςτα πιο πάνω βήματα.

Προσδιορισμός των καταχωρητών:- Η διαδικασία swap έχει δύο μεταβλητές , την v και k οι οποίεςσυσχετίζονται με τους καταχωρητές $4 και $5. Η μεταβλητή temp βρίσκεταιστο καταχωρητή $16.

- Το κύριο μέρος της διαδικασίας είναι:temp = v[k] ;v[k] = v[k+1] ;v[k+1] = temp ;

Μπορεί να μεταφραστεί στο πιο κάτω πρόγραμμα σε MIPS:

sll $18, $5, 2 # $18 = k * 4 add $18, $4, $18 # $18 = v + (k * 4) ; $18 has the address of v[k]lw $16, 0 ($18) # $16 (temp) = v[k]lw $17, 4 ($18) # $17 = v[k+1] sw $17, 0 ($18) # v[k] = $17sw $16, 4 ($18) # v[k+1] = $16 (temp)


Διαφύλαξη καταχωρητών

-Αφού θα αλλάξουμε τα περιεχόμενα των καταχωρητών $16, $17 και $18πρέπει πρώτα να αποθηκεύσουμε τις αρχικές τους τιμές στη στοίβα.

- Ο καταχωρητής $29 περιέχει τον δείκτη στοίβας (stack pointer) και θαπρέπει να τον προσαρμόσουμε στα 12 bytes (3 x 4) πριν αποθηκεύσουμε τιςτρεις λέξεις:

addi $29, $29, -12

H προσαρμογή είναι αρνητική επειδή η στοίβα στο MIPS μεγαλώνει από τιςψηλότερες διευθύνσεις στις χαμηλότερες. Τώρα μπορούμε να αποθηκεύσουμετις παλιές τιμές:

sw $16, 0($29) # save $16 on stack sw $17, 4($29) # save $17 on stack sw $18, 8($29) # save $18 on stack

Στο τέλος της διαδικασίας απλά αποκαθιστούμε τους καταχωρητές μέσωτριών φορτώσεων (lw) και μετά προσαρμόζουμε την στοίβα στην άλληκατεύθυνση.


Saving RegistersSwap: addi $29, $29, -12

sw $16, 0($29)sw $17, 4($29)sw $18, 8($29)

# make room on the stack for 3 reg# save $16 on stack# save $17 on stack# save $18 on stack

Procedure bodysll $18, $5, 2add $18, $4, $18

lw $16, 0($18)lw $17, 4($18)

sw $17, 0($18)sw $16, 4($18)

# reg $18 = k x 4# reg $18 = v + (k x 4)# reg $18 has the adress of v[k]# reg $16 (temp) = v[k]# reg $17 = v[k+1]# refers to next element of v# v[k] = reg $17# v[k+1] = reg $16 (temp)

Restoring Registerslw $16, 0($29)lw $17, 4($29)lw $18, 8($29)addi $29, $29, 12

# restore $16 from stack# restore $17 from stack# restore $18 fron stack# restore stack pointer

Procedure Returnjr $31 # return to calling routine


Ένα μεγαλύτερο παράδειγμα

- Σε αυτή την ενότητα θα δώσουμε ένα πρόγραμμα στη γλώσσα MIPS πουταξινομεί ένα πίνακα από n ακεραίους χρησιμοποιώντας την διαδικασίαswap.

sort ( int v[ ], int n ) int i, j;

for ( i = 0; i < n; i = i + 1 ) for ( j = i -1; j >=0 && v[j] >v[j+1]; j =j - 1 )

swap ( v, j );

Προσδιορισμός Καταχωρητών

- Οι δύο παράμετροι της διαδικασία Sort είναι οι v και n, που βρίσκονταιστους καταχωρητές $4 και $5.

- Στον καταχωρητή $19 βρίσκεται το i και στον καταχωρητή $17 βρίσκεται το j.


Κώδικας για το σώμα της διαδικασίας

- Το σώμα της διαδικασίας αποτελείται από δύο φωλιασμένους βρόγχους καιένα κάλεσμα στη swap που περιέχει τις παραμέτρους.

- Ο εξωτερικός βρόγχος: Το πρώτο βήμα μετάφρασης γίνεται στον πρώτοβρόγχο

for ( i = 0; i < n; i = i + 1 )

- Το for loop στη γλώσσα C αποτελείται απο τρία μέρη: - αρχική τιμή η μεταβλητή (μετρητής) του βρόγχου, - έλεγχος συνθήκης βρόγχου και- αύξηση/μείωση του μετρητή.

- Χρειάζεται μια εντολή στον MIPS για να δοθεί αρχική τιμή μηδέν στο i. add $19, $0, $0 # i = 0

- Επίσης χρειάζεται μια εντολή για το τελευταίο μέρος του for: addi $19, $19, 1 # i = i + 1


- Χρειάζονται δύο εντολές για το δεύτερο μέρος του βρόγχου, όπου γίνεται οέλεγχος, δηλαδή είναι η συνθήκη εξόδου από τον βρόγχο.

for1tst : slt $1, $19, $5 # reg $1 = 0 if $19 >= $5 (i >= n) beq $1, $0, exit1 # go to exit1 if $19 >= $5 (i >= n)

- Η τελευταία εντολή του βρόγχου απλά μεταπηδά πίσω στον έλεγχο τουβρόγχου.

j for1tst # jump to test of outer loop


-Άρα η μορφή του πρώτου for loop θα είναι:add $19, $0, $0 # i = 0

for1tst : slt $1, $19, $5 # reg $1 = 0 if $19 >= $5 (i >= n) beq $1, $0, exit1 # go to exit1 if $19 >= $5 (i >= n)

. . . (body of the first for loop)

. . .addi $19, $19, 1 # i = i + 1 j for1tst # jump to test of outer loop

exit1:


- O εσωτερικός βρόγχοςfor ( j = i - 1; j >= 0 && v[j] > v[j+1]; j = j - 1 )

-Δίνεται αρχική τιμή στη μεταβλητή j του for loop:addi $17, $19, -1 # j = i - 1

- Η μείωση του j στο βρόγχο δίνεται από την εντολή:addi $17, $17, -1 # j = j – 1

Ο έλεγχος του βρόγχου σε αυτή την περίπτωση αποτελείται από δύο συνθήκεςπου δίνονται από τις εντολές:

for2tst: stl $1, $17, $0 # reg $1 = 1 if $17 < 0 (j < 0)bne $1, $0, exit2 # go to exit2 if $17 < 0 (j < 0)sll $15, $17, 2 # reg $15 = j x 4add $16, $4, $15 # reg $16 = v + (j x 4)lw $24, 0 ($16) # reg $24 = v[j]lw $25, 4 ($16) # reg $25 = v[j+1]slt $1, $25, $24 # reg $1 = 0 if $25 >= $24beq $1, $0, exit2 # go to exit2 if $25 >= $24


Στο τέλος του βρόγχου γίνεται μεταπήδηση πίσω στον έλεγχο του for loop:j for2tst # jump to test of inner loop

Η μορφή του δεύτερου for loop θα είναι:addi $17, $19, -1 # j = i - 1

for2tst: stl $1, $17, $0 # reg $1 = 1 if $17 < 0 (j < 0)bne $1, $0, exit2 # go to exit2 if $17 < 0 (j < 0)sll $15, $17, 2 # reg $15 = j x 4add $16, $4, $15 # reg $16 = v + (j x 4)lw $24, 0 ($16) # reg $24 = v[j]lw $25, 4 ($16) # reg $25 = v[j+1]slt $1, $25, $24 # reg $1 = 0 if $25 >= $24beq $1, $0, exit2 # go to exit2 if $25 >= $24

. . . .(body of second for loop). . . .

addi $17, $17, -1 # j = j - 1j for2tst # jump to test of inner loop

exit2:


- To κάλεσμα της διαδικασίας- Το επόμενο βήμα είναι το σώμα του δεύτερου for loop:

swap (v, j);- To κάλεσμα της swap μπορεί να γίνει πολύ εύκολα:

jal swap- Πέρασμα παραμέτρων

- Το πρόγραμμα sort χρειάζεται τις τιμές στους καταχωρητές $4 και $5,αλλά και η διαδικασία swap χρειάζεται να έχει τις παραμέτρους της στουςίδιους καταχωρητές.

- Μια λύση είναι να αντιγράψουμε τις παραμέτρους του sort σε κάποιουςάλλους καταχωρητές ή στην στοίβα

$4 – περιέχει αύτο που θέλουμε το v$5 – περιχέχει το n; $5 στο stack και j στο $5

addi sp,sp-4sw $5,0($sp)move $5,$17jal swaplw $5,0($sp)addi $sp,$sp,4

ήRegister Renamingmove $20,$5 στην αρχή για να αποφύγουμε πολλές εντολές

και πριν την κλήσηmove $5, $17 # copy parameter $5 into $20 - j


Διαφύλαξη Καταχωρητών

- Το μόνο που έμεινε τώρα είναι η αποθήκευση των καταχωρητώνχρησιμοποιώντας την μέθοδο callee save.

-Αποθηκεύουμε την διεύθυνση επιστροφής στον καταχωρητή $31, αφού ηsort καλεί μια άλλη διαδικασία.

- Οι άλλοι καταχωρητές που πρέπει να χρησιμοποιήσουμε είναι: $5, $15, $16,$17, $18, $19, $20, $24 και $25. Άρα θα έχουμε:

addi $29, $29, -40 # make room on stack for 10 registerssw $15, 0($29) # save $15 on stack sw $16, 4($29) # save $16 on stacksw $17, 8($29) # save $17 on stacksw $18, 12($29) # save $18 on stacksw $19, 16($29 # save $19 on stacksw $20, 20($29) # save $20 on stacksw $24, 24($29) # save $24 on stacksw $25, 28($29) # save $25 on stacksw $31, 32($29) # save $31 on stacksw $5,36($29) # save $5 on stack


Saving Registerssort: addi $29, $29, -40

sw $15, 0($29)sw $16, 4($29)sw $17, 8($29)sw $18, 12($29) sw $19, 16($29)sw $20, 20($29)sw $24, 24($29)sw $25, 28($29)sw $31, 32($29)sw $5,36($29)

# make room on stack for 9 registers# save $15 on stack# save $16 on stack# save $17 on stack# save $18 on stack# save $19 on stack# save $20 on stack# save $24 on stack# save $25 on stack# save $31 on stack# save $5 on stack


Procedure BodyMove parameters

move $20, $5 # copy parameter $5 into $20

Outer loopfor1st:

add $19, $0, $0 slt $1, $19, $20 beq $1, $0, exit1

# i = 0 # reg $1 = 0 if $19 >= $5 (i >= n) # go to exit1 if $19 >= $5 (i >= n)

Inner loopfor2st:

addi $17, $19, -1 stli $1, $17, 0 bne $1, $0, exit2 sll $15, $17, 2 add $16, $4, $15 lw $24, 0 ($16) lw $25, 4 ($16) slt $1, $25, $24 beq $1, $0, exit2

# j = i – 1# reg $1 = 1 if $17 < 0 (j < 0) # go to exit2 if $17 < 0 (j < 0) # reg $15 = j x 4 # reg $16 = v + (j x 4) # reg $24 = v[j] # reg $25 = v[j+1] # reg $1 = 0 if $25 >= $24 # go to exit2 if $25 >= $24

Pass parameters and call

move $5, $17 jal swap

# first parameter of swap is v # second parameter of swap is j

Inner loop addi $17, $17, -1 j for2tst

# j = j – 1 # jump to test of inner loop

Outer loop exit2: addi $19, $19, 1 j for1tst

# i = i + 1 # jump to test to outer loop


Restoring Registersexit1: lw $15, 0($29)

lw $16, 4($29)lw $17, 8($29)lw $18, 12($29) lw $19, 16($29)lw $20, 20($29)lw $24, 24($29)lw $25, 28($29)lw $31, 32($29)lw $5,36($29)addi $29, $29, 40

# restore $15 from stack# restore $16 from stack# restore $17 from stack# restore $18 from stack# restore $19 from stack# restore $20 from stack# restore $24 from stack# restore $25 from stack# restore $31 from stack# restore $5 from stack# restore stack pointer



ΤυποποίησηPolicy of Use Conventions

Register number Usage Preserved on call?$zero 0 the constant value 0 n.a. $v[0-1] 2-3 values for results and expression evaluation no $a[0-3] 4-7 arguments no$t[0-7] 8-15 temporaries no $s[0-7] 16-23 saved yes$t[8-9] 24-25 more temporaries no$gp 28 global pointer yes$sp 29 stack pointer yes$fp 30 frame pointer yes$ra 31 return address yes

Register 1 ($at) reserved for assembler, 26-27 for operating system


ΤυποποίησηPolicy of Use Conventions

•Οι καταχωρητές που είναι preserved on call όταν μια συνάρτηση μπορεί να αλλάξει την τιμή τους τότε πρέπει να αποθηκεύονται στην αρχή της συνάρτησης και να επιστρέφονται στο τέλοςsp και fp εξαίρεση (αφαιρεση στην αρχή /πρόσθεση στο τέλος)

•Οι άλλοι καταχωρητέςόταν μια συνάρτηση καλεί άλλη συνάρτηση και χρειάζεται να διατηρήσει τις τιμές σε προσωρινούς τότε πρέπει να αποθηκεύονται πριν την κλήση της άλλης συνάρτησης και να φορτώνονται μετά την επιστροφή

σε leaf συναρτήσεις temporaries για όλες τις μεταβλητές (μόνο αν χρειάζεται saved), αλλιώςtemporaries για προσωρινές μεταβλητέςsaved για τοπικές


Saving RegistersSwap: addi $29, $29, -12

sw $16, 0($29)sw $17, 4($29)sw $18, 8($29)

# make room on the stack for 3 reg# save $16 on stack# save $17 on stack# save $18 on stack

Procedure bodysll $18, $5, 2add $18, $4, $18

lw $16, 0($18)lw $17, 4($18)

sw $17, 0($18)sw $16, 4($18)


Restoring Registerslw $16, 0($29)lw $17, 4($29)lw $18, 8($29)addi $29, $29, 12

# restore $16 from stack# restore $17 from stack# restore $18 fron stack# restore stack pointer



Swap:Procedure body

sll $t0, $a1, 2add $t0, $a0, $t0

lw $t2, 0($t0)lw $t1, 4($t0)

sw $t1, 0($t0)sw $t2, 4($t0)


jr $ra # return to calling routine

Leaf: δεν χρειάστηκε αποθήκευση στην στοίβα


Saving Registerssort: addi $sp, $sp, -20

sw $s0, 0($sp)sw $s1, 4($sp)sw $s2, 8($sp) sw $s3, 12($sp)sw $ra, 16($sp)

# make room on stack for 5 registers


Procedure BodyMove parameters

move $s0, $a0 move $s1, $a1

# copy parameter $a0 into $s0 – v (local) # copy parameter $a1 into $s1 – n (local)

Outer loopfor1st:

add $s2, $0, $0 ble $s1,$s2,exit1

# i = 0 (local) # go to exit1 if (n<= i)

Inner loopfor2st:

addi $s3, $s2, -1 blt $s3,$0,exit2sll $t0, $s3, 2 add $t0, $s0, $t0 lw $t1, 0 ($t0) lw $t2, 4 ($t0) ble $t1,$t2,exit2

# j = i – 1 (local)# go to exit2 if (j < 0) # temp0 = j x 4 # temp0 = v + (j x 4) # temp1 = v[j] # temp2 = v[j+1] # go to exit2 if v[j+1] >= v[j]

Pass parameters and call

move $a0 , $s0 move $a1, $s3 jal swap

# first parameter of swap is v # second parameter of swap is j

Inner loop addi $s3, $s3, -1 j for2tst

# j = j – 1 # jump to test of inner loop

Outer loop exit2: addi $s2, $s2, 1 j for1tst

# i = i + 1 # jump to test to outer loop


Restoring Registersexit1: lw $s0, 0($sp)

lw $s1, 4($sp)lw $s2, 8($sp) lw $s3, 12($sp)lw $ra, 16($sp)addi $sp, $sp, 20

Procedure Returnret # return to calling routine


Στοίβα: τοπικές, προσωρινές, arguments, saved, return

address, πίνακες…Κάθε κλήση συνάρτησης δημιουργεί ένα Stack Frame (ή Activation Record)

• Τοπικά δεδομένα• Padding (empty) = x8 for

double words• Return address• Saved Registers• Παράμετροι

int g( int x, int y ) return (x + y);

g: add $v0,$a0,$a1 # result is sum of argsjr $ra # return


int g( int x, int y ) int a[32]; ... (calculate using x, y, a); return a[0]; g: # start of prologue

addiu $sp,$sp,(-128) # push stack frame# end of prologue. . . # calculate using $a0, $a1 and a

# array a is stored at addresses# 0($sp) to 124($sp)

lw $v0,0($sp) # result is a[0]# start of epilogueaddiu $sp,$sp,128 # pop stack frame# end of epiloguejr $ra # return


g: # start of prologueaddiu $sp,$sp,(-144) # push stack framesw $s0,0($sp) # save value of $s0sw $s1,4($sp) # save value of $s1sw $s3,8($sp) # save value of $s3

# end of prologue# start of body

. . . # calculate using $a0, $a1 and a# array a is stored at addresses# 16($sp) to 140($sp)

lw $v0,16($sp) # result is a[0]# end of body# start of epilogue

lw $s0,0($sp) # restore value of $s0lw $s1,4($sp) # restore value of $s1lw $s3,8($sp) # restore value of $s3..

addiu $sp,$sp,144 # pop stack frame# end of epilogue

jr $ra # return


int g( int x, int y ) int a[32];... (calculate using x, y, a);a[1] = f(y,x,a[2]);a[0] = f(x,y,a[1]);

return a[0];


g:# start of prologueaddiu $sp,$sp,(-160) # push stack framesw $ra,28($sp) # save the return addresssw $s0,16($sp) # save value of $s0sw $s1,20($sp) # save value of $s1sw $s3,24($sp) # save value of $s3# end of prologue# start of body. . . # calculate using $a0, $a1 and a# array a is stored at addresses# 32($sp) to 156($sp)# save $a0 and $a1 in caller’s stack framesw $a0,160(sp) # save $a0 (variable x)sw $a1,164(sp) # save $a1 (variable y)# first call to function flw $a0,164(sp) # arg0 is variable ylw $a1,160(sp) # arg1 is variable xlw $a2,40(sp) # arg2 is a[2]jal f # call fsw $v0,36(sp) # store value of f into a[1]# second call to function flw $a0,160(sp) # arg0 is variable xlw $a1,164(sp) # arg1 is variable ylw $a2,36(sp) # arg2 is a[1]jal f # call fsw $v0,32(sp) # store value of f into a[0]# load return value of g into $v0lw $v0,32($sp) # result is a[0]# end of body# start of epiloguelw $s0,16($sp) # restore value of $s0lw $s1,20($sp) # restore value of $s1lw $s3,24($sp) # restore value of $s3lw $ra,28($sp) # restore the return addressaddiu $sp,$sp,160 # pop stack frame# end of epiloguejr $ra # return

int g( int x, int y ) int a[32];... (calculate using x, y, a);a[1] = f(y,x,a[2],a[3],a[4]);a[0] = f(x,y,a[1],a[2],a[3]);return a[0];


g:# start of prologueaddiu $sp,$sp,(-168) # push stack framesw $ra,32($sp) # save the return addresssw $s0,20($sp) # save value of $s0sw $s1,24($sp) # save value of $s1sw $s3,28($sp) # save value of $s3# end of prologue# start of body. . . # calculate using $a0, $a1 and a# array a is stored at addresses# 40($sp) to 164($sp)# save $a0 and $a1 in caller’s stack framesw $a0,168(sp) # save $a0 (variable x)sw $a1,172(sp) # save $a1 (variable y)# first call to function flw $a0,172(sp) # arg0 is variable ylw $a1,168(sp) # arg1 is variable xlw $a2,48(sp) # arg2 is a[2]lw $a3,52(sp) # arg3 is a[3]lw $t0,56(sp) # arg4 is a[4]sw $t0,16(sp) # BUT it is passed on the stack!jal f # call fsw $v0,44(sp) # store value of f into a[1]# second call to function flw $a0,168(sp) # arg0 is variable xlw $a1,172(sp) # arg1 is variable ylw $a2,44(sp) # arg2 is a[1]lw $a3,48(sp) # arg3 is a[2]lw $t0,52(sp) # arg4 is a[3]sw $t0,16(sp) # BUT it is passed on the stack!

jal f # call fsw $v0,40(sp) # store value of f into a[0]# load return value of g into $v0lw $v0,40($sp) # result is a[0]# end of body# start of epiloguelw $s0,20($sp) # restore value of $s0lw $s1,24($sp) # restore value of $s1lw $s3,28($sp) # restore value of $s3lw $ra,32($sp) # restore the return addressaddiu $sp,$sp,168 # pop stack frame# end of epiloguejr $ra # return

• Βελτιστοποίηση κώδικα• Επαναχρησιμοποίηση αποτελεσμάτων σε

καταχωρητες• Αριθμητική δεικτών για έλεγχο συνθήκης

επανάληψης βρόγχων• Exceptions/Interrupts• Τύποι ∆ιευθυνσιοδότησης• X86 ISA


g:# start of prologueaddiu $sp,$sp,(-168) # push stack framesw $ra,32($sp) # save the return addresssw $s0,20($sp) # save value of $s0sw $s1,24($sp) # save value of $s1sw $s3,28($sp) # save value of $s3# end of prologue# start of body. . . # calculate using $a0, $a1 and a# array a is stored at addresses# 40($sp) to 164($sp)# save $a0 and $a1 in caller’s stack framesw $a0,168(sp) # save $a0 (variable x)sw $a1,172(sp) # save $a1 (variable y)# first call to function fmov $a0,$a1 # arg0 is variable ylw $a1,168(sp) # arg1 is variable xlw $a2,48(sp) # arg2 is a[2]lw $a3,52(sp) # arg3 is a[3]lw $t0,56(sp) # arg4 is a[4]sw $t0,16(sp) # BUT it is passed on the stack!jal f # call fsw $v0,44(sp) # store value of f into a[1]# second call to function flw $a0,168(sp) # arg0 is variable xlw $a1,172(sp) # arg1 is variable ylw $a2,44(sp) # arg2 is a[1]lw $a3,48(sp) # arg3 is a[2]lw $t0,52(sp) # arg4 is a[3]sw $t0,16(sp) # BUT it is passed on the stack!

g:# start of prologueaddiu $sp,$sp,(-168) # push stack framesw $ra,32($sp) # save the return addresssw $s0,20($sp) # save value of $s0sw $s1,24($sp) # save value of $s1sw $s3,28($sp) # save value of $s3# end of prologue# start of body. . . # calculate using $a0, $a1 and a# array a is stored at addresses# 40($sp) to 164($sp)# save $a0 and $a1 in caller’s stack framesw $a0,168(sp) # save $a0 (variable x)sw $a1,172(sp) # save $a1 (variable y)# first call to function flw $a0,172(sp) # arg0 is variable ylw $a1,168(sp) # arg1 is variable xlw $a2,48(sp) # arg2 is a[2]lw $a3,52(sp) # arg3 is a[3]lw $t0,56(sp) # arg4 is a[4]sw $t0,16(sp) # BUT it is passed on the stack!jal f # call fsw $v0,44(sp) # store value of f into a[1]# second call to function flw $a0,168(sp) # arg0 is variable xlw $a1,172(sp) # arg1 is variable ylw $a2,44(sp) # arg2 is a[1]lw $a3,48(sp) # arg3 is a[2]lw $t0,52(sp) # arg4 is a[3]sw $t0,16(sp) # BUT it is passed on the stack!

jal f # call fsw $v0,40(sp) # store value of f into a[0]# load return value of g into $v0lw $v0,40($sp) # result is a[0]# end of body# start of epiloguelw $s0,20($sp) # restore value of $s0lw $s1,24($sp) # restore value of $s1lw $s3,28($sp) # restore value of $s3lw $ra,32($sp) # restore the return addressaddiu $sp,$sp,168 # pop stack framejr $ra # return

jal f # call fsw $v0,40(sp) # store value of f into a[0]# load return value of g into $v0lw $v0,40($sp) # result is a[0]# end of body# start of epiloguelw $s0,20($sp) # restore value of $s0lw $s1,24($sp) # restore value of $s1lw $s3,28($sp) # restore value of $s3lw $ra,32($sp) # restore the return addressaddiu $sp,$sp,168 # pop stack framejr $ra # return


Πίνακες σε αντιπαράθεση με τους δείκτες

-Δίνονται δύο διαδικασίες στη γλώσσα C, οι οποίες αντικαθιστούν(καθαρίζουν) μια ακολουθία από λέξεις με μηδενικά. Το ένα είναιυλοποιημένο με πίνακες και το άλλο είναι υλοποιημένο με δείκτες.

clear1 (int array[ ], int size) int i ;for (i = 0; i < size; i =i + 1)

array[i] = 0;

clear2 (int *array, int size) int *p;for (p = &array[0]; p < & array[size]; p = p + 1)

*p = 0;

- clear1: Υποθέτουμε ότι οι δύο παράμετροι array και size βρίσκονται στουςκαταχωρητές $a0 και $a1, αντίστοιχα. Η μεταβλητή i βρίσκεται στοκαταχωρητή $t0 KAI πως πάντοτε το size>0


O κώδικας της διαδικασίας clear1 στη γλώσσα MIPS είναι:

move $t0, $zero # i = 0loop1: sll $t1, $t0, 2 # temp = i x 4

add $t1, $a0, $t1 # temp = address of array[i]sw $0, 0($t1) # array[i] = 0addi $t0, $t0, 1 # i = i + 1blt $t0,$a1,loop1 # if (i<size) repeat


KΑΛΥΤΕΡΟΣ κώδικας της διαδικασίας clear1 στη γλώσσα MIPS είναι:

move $t0, $zero # i = 0sll $t2,$a1,2 # size*4

loop1: add $t1, $a0, $t0 # temp = address of array[i]sw $0, 0($t1) # array[i] = 0addi $t0, $t0, 4 # i = i + 4blt $t0,$t2,loop1 # if (i<size) repeat


AKOMH KΑΛΥΤΕΡΟΣ κώδικας της διαδικασίας clear2 στη γλώσσαMIPS είναι:

move $t0, $a0 # p= &array[0]sll $t1,$a1,2 # size*4add $t1,$t1,$t0 # base+size*4

loop1: sw $0, 0($t0) # array[i] = 0addi $t0, $t0, 4 # p = p + 4blt $t0,$t1,loop1 # if (p<&array[size]) repeat


Exceptions και Interrupts

• Exceptions:προκαλούνται από λάθη/εξαιρετικά γεγονότα κατά την εκτέλεση εντολών

• Interrupts: προκαλούνται από μονάδες Ε/Ε(I/O), debugging breakpoints

• Αντιμετωπίζονται με exception handlers– Μικρές ρουτίνες

• ΜΙPS χρήση coprocessor registers για αντιμετώπιση interrupts και exceptions

Exception Causing Instructions

# divide by zero -- breakpointdiv $t0, $t0, $zero

# arithmetic overflowli $t1, 0x7fffffffaddi $t1, $t1, 1

# non-existent memory address -- bus errorsw $t2, 124($zero)

# non-aligned address -- address errorsw $t2, 125($sp)


Interrupts from external devices

• User pressed a key on console• Console ready to display another

character• Hardware timer expired• Disk read complete (πχ DMA)• Memory error (με ECC RAM)



Coprocessor Registers

• Πρόσβαση με χρήση των εντολών mfc0 και mtc0• Μετά από ένα exception το EPC περιέχει την διεύθυνση της προβληματική εντολής


Status και Cause Registers

• Για διακρίβωση τι προκαλεί ένα interrupt/exception• Για καθορισμό των επιτρεπόμενων interrupts και

exceptions (επίσης προτεραιότητα)

STATUS

CAUSE


Tι προκαλεί exceptions και ο κωδικός του στο Cause register

• Μετά από exception η εκτέλεση συνεχίζει στην διεύθυνση 0x80000180 (kernel address space)


Tι συμβαίνει μετά…

• Το exception handler αναγνωρίζει τι προκάλεσε το exception ή interrupt και εκτελεί ανάλογο routine (service) ή τερματίζοντας την διεργασία που το προκάλεσε, π.χ.:– εκτέλεση μη αρχιτεκτονικής εντολής (kill)– Page fault (service για να φέρουμε δεδομένα από τον δίσκο)

– Αγνοεί το exception


beqz $a0,$0,done

# κώδικας που διαχειρίζεται τις διάφορες περιπτώσεις

Τύποι ∆ιευθυνσιοδότησης



1. Register addressing, όπου ο τελεσταίος είναι καταχωρητής.2. Base or displacement addressing, όπου ο τελεσταίος είναι τοποθετημένος στηνμνήμη, του οποίου η διεύθυνση είναι το άθροισμα του καταχωρητή και τηςδιεύθυνσης της εντολής.

3. Immediate addressing, όπου ο τελεσταίος είναι μία σταθερά μέσα στην εντολή .4. PC-relative addressing, όπου η διεύθυνση είναι το άθροισμα του καταχωρητή PCκαι της σταθεράς μέσα στην εντολή.

1. Register Addressing (add, sub, κ.α.)

2. Base Addressing (lw,sw, κ.α.)

op rs rt rd … funct↓

register

op rs rt address↓

register

Memory


3. Immediate Addressing (addi, subi, κ.α.)

4. PC - Relative Addressing (bne, κ.α.)

5. Direct Addressing Mode (jump)

op rs rt immediate

op rs rt address

PC

Memory

op address

PC


Design alternative:

– provide more powerful operations (CISC)

– goal is to reduce number of instructions executed

– danger is a slower cycle time and/or a higher CPI

Let’s look (briefly) at Intel Architecture (IA) x86

Alternative Architectures



x86 OverviewComplexity:

– Instructions from 1 to 17 bytes long– one operand must act as both a source and destination– one operand can come from memory– complex addressing modes

e.g., “base or scaled index with 8 or 32 bit displacement”


x86-32 Registers and Data Addressing

Registers in the x86-32-bit subset that originated with 80386

GPR 0

GPR 1

GPR 2

GPR 3

GPR 4

GPR 5

GPR 6

GPR 7

Code segment pointer

Stack segment pointer (top of stack)

Data segment pointer 0




Instruction pointer (PC)

Condition codes

Use031

Name

EAX

ECX

EDX

EBX

ESP

EBP

ESI

EDI

CS

SS

DS

ES

FS

GS

EIP

EFLAGS


x86 instruction FormatsTypical formats: (notice the different lengths)

a. JE EIP + displacement

b. CALL

c. MOV EBX, [EDI + 45]

d. PUSH ESI

e. ADD EAX, #6765

f. TEST EDX, #42

ImmediatePostbyteTEST

ADD

PUSH

MOV

CALL

JE

w

w ImmediateReg

Reg

wd Displacementr/mPostbyte

Offset

DisplacementCondi-tion

4 4 8

8 32

6 81 1 8

5 3

4 323 1

7 321 8


x86 Register RestrictionsRegisters are not “general purpose” – note the restrictions below


x86 Typical Instructions

Four major types of integer instructions:– Data movement including move, push, pop– Arithmetic and logical (destination register or memory)– Control flow (use of condition codes / flags )– String instructions, including string move and string compare


ΕΝΤΟΛΕΣ ΣΕ ΆΛΛΕΣ ΑΣΕ

Αυτόματη Αύξηση και Αυτόματη Μείωση

lw $8, Sstart ($19) # register $8 gets S[$19]addi $19, $19, 4 # $19 = $19 + 4

Οι πιο πάνω εντολές θα μπορούσαν να αντικατασταθούν με την πιο κάτωυποθετική εντολή:

lw+ $8, Sstart ($19) # register $8 = S[$19] ; $19 = $19 + 4

Τελεσταίοι εντολών βασισμένοι στη μνήμη

lw $8, Astart ($19) # Temporary register $8 gets A [$19]add $16, $16, $8 # $16 = $17 + A [I]

Το πιο πάνω ζεύγος εντολών θα μπορούσε να αντικατασταθεί με την πιο κάτωυποθετική εντολή:

addm $16, $16, Astart ($19) #$16 = $16 + Memory [$19 + Astart]


RISC vs CISC

• MIPS – RISC ISA– ίδιο μέγεθος εντολών– Δεν υποστηρίζει πράξεις με τελεστές στην μνήμη

• IA32 (x86) – CISC ISA• Μετάφραση στο υλικο από CISC σε RISC

• Alignment:• sw/lw σε διευθύνσεις που είναι πολλαπλάσια του 4• sd/ld σε διευθύνσεις που είναι πολλαπλάσια του 8

• Καταχωρητές και εντολές κινητής υποδιαστολής• Strings• Μονάδες Εισόδου/Εξόδου (Ι/Ο)

• DMA: direct memory access• Memory mapped I/O: διευθύνσεις μνήμης

αναπαριστούν Ε/Ε 112

Ενότητα 3 - Εντολές: Η γλώσσα μηχανής

Είσοδος

# spin until bit is set, when set read valueli $t0, 0xffff0000

rd poll:lw $v0, 0($t0)andi $v0, $v0, 0x01beq $v0, $zero, rd polllw $v0, 4($t0)


Έξοδος


# character in $a0, spin until device readyli $t0, 0xffff0008

wr poll:lw $v0, 0($t0)andi $v0, $v0, 0x01beq $v0, $zero, wr pollsw $a0, 4($t0)


Interrupts vs Polling

Poll:1. you need to spin wait until something

happens or timeoutInterrupt: 1. processor gets interrupted when device

interrupt bit enabled. 2. Code of interrupt is communicated to the

processor


Documents

ΕΠΛ221: Οργάνωση Υπολογιστών και Συμβολικός ......1 Ενότητα 3 - Εντολές: Η γλώσσα μηχανής ΕΠΛ221: Οργάνωση