ΕΠΛ221: Οργάνωση Υπολογιστών και Συμβολικός Προγραμματισμός. Κεφ. 2 Εντολές: H γλώσσα μηχανής

Transcript

1 ΕΠΛ221: Οργάνωση Υπολογιστών και Συμβολικός Προγραμματισμός Κεφ. 2 Εντολές: H γλώσσα μηχανής Αρχιτεκτονική Σύνολο Εντολών MIPS (assembly) αναπαράσταση στο υλικό (ΜIPS) μετάφραση από HLL σε LLL Δομές ελέγχου και βασικοί τύποι δεδομένων 1

2 Λειτουργίες του υλικού του υπολογιστή - Κάθε μηχανή πρέπει να είναι ικανή να κάνει αριθμητικές πράξεις. add a, b, c # a= b+c - Κάθε αριθμητική εντολή στη γλώσσα MIPS πρέπει να έχει τρεις μεταβλητές (τελεσταίους). - Για παράδειγμα αν θέλουμε να υπολογίσουμε την έκφραση: a= b+ c+ d+ e add a, b, c add a, a, d add a, a, e # a = b+c # a = a+d = (b+c)+d # a = a+e = ((b+c)+d)+e - 2

3 - Παράδειγμα Δίνεται η ακόλουθη εντολή σε C: f=(g+h) - (i+j) Τι κώδικα θα μπορούσε να παράξει ο μεταγλωττιστής της C; add t0, g, h add t1, i, j sub f, t0, t1 # προσωρινή μεταβλητή t0, περιέχει το g+h # προσωρινή μεταβλητή t1, περιέχει το i+j # f = t0 - t1 = (g+h) - (i+j) Τελεσταίοι του υλικού του υπολογιστή - Στις συμβολικές γλώσσες οι τελεσταίοι (operators) των αριθμητικών εντολών είναι καταχωρητές ή μνήμη. - Η αρχιτεκτονική MIPS έχει 32 ακέραιους καταχωρητές, οι οποίοι συμβολίζονται με $0, $1,..., $31 (32 bits each 64?) Αρχή 2: Το μικρότερο είναι πιο γρήγορο. 3

4 - Η αποτελεσματική χρήση των καταχωρητών είναι το κλειδί στην απόδοση των προγραμμάτων. - Παράδειγμα 3 Έστω η πιο κάτω εντολή στη C: f = ( g + h ) - ( i + j ) ; μεταγλωττιστής της C συσχετίζει τις μεταβλητές f, g, h, i, και j με τους καταχωρητές $16, $17, $18, $19, και $20 αντιστοίχως. add $8, $17, $18 add $9, $19, $20 sub $16, $8, $9 # ο καταχωρητής $8 έχει το αποτέλεσμα g+h # o καταχωρητής $9 έχει το αποτέλεσμα i+j # ο καταχωρητής $16 έχει το αποτέλεσμα # (g+h)-(i+j), την τιμή της μεταβλητής f Οι καταχωρητές $8 και $9 αντιστοιχούν στις μεταβλητές t0 και t1 του προηγούμενου παραδείγματος. 4

5 - Οι αριθμητικές πράξεις στην αρχιτεκτονική MIPS μπορούν να γίνουν μόνο μέσω των καταχωρητών, Αντίθετα με τον ΙΝΤΕL x86 όπου μπορούν να γίνουν και στην μνήμη. add eax,8(ebx) ld c,8(b) CISC add a,a,c RISC - Η μνήμη στην πραγματικότητα είναι ένας μεγάλος, μονοδιάστατος πίνακας και η διεύθυνση ένας δείκτης στον πίνακα. - Οι διευθύνσεις ξεκινούν από το 0. - Για να έχουμε πρόσβαση στο τρίτο στοιχείο του πίνακα θα χρησιμοποιήσουμε διεύθυνση Memory [2], τα δεδομένα του οποίου είναι Memory Address Data

6 - Eντολή φόρτωσης - Η εντολή που μεταφέρει δεδομένα από την μνήμη σε ένα καταχωρητή, ονομάζεται load -πχ lw (load word) διαβάζει 4 bytes. - Παράδειγμα 4: Υποθέστε ότι ο πίνακας Α έχει 100 στοιχεία και ο μεταγλωττιστής έχει συσχετίσει τις μεταβλητές g, h, και i με τους καταχωρητές $17, $18, και $19. Η βάση του πίνακα (διεύθυνση του πρώτου στοιχείου στον πίνακα) δίνεται είναι η διεύθυνση Astart. Μεταφράστε: g = h + A[i]; lw $8, Astart ($19) add $17, $18, $8 # ο προσωρινός καταχωρητής $8 παίρνει το Α[i] # το αποτέλεσμα 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 6

7 Διασύνδεση υλικού/λογισμικού - Ο μεταγλωττιστής είναι υπεύθυνος για την συσχέτιση μεταβλητών και καταχωρητών, και επίσης για την ανάθεση δομών δεδομένων, όπως για παράδειγμα πίνακες, στους χώρους της μνήμης. - Ακολούθως ο μεταγλωττιστής μπορεί να τοποθετήσει την σωστή αρχική διεύθυνση στις εντολές μεταφοράς δεδομένων π.χ. lw. - Ο επεξεργαστής MIPS μπορεί να έχει διεύθυνση για μεταφορά 1Byte(8 bits), 2 Bytes, 4 Bytes (μίας λέξης), ή 8 Bytes. - Στη περίπτωση λέξεων, οι διευθύνσεις διαφέρουν κατά 4 (4 bytes). Processor Memory Address Data Η διευθυνσιοδότηση επηρεάζει επίσης τον δείκτη i για την εκφράση Α[i]. - Για τον σωστό υπολογισμό της διεύθυνσης του παραδείγματος, ο καταχωρητής $19(στον οποίο περιέχεται η τιμή της μεταβλητής i) πρέπει να πολλαπλασιάζεται με 4 (4 x i) και να προστίθεται στο Astart(βάση του πίνακα) για τον υπολογισμό της διεύθυνσης 7

8 -Yπάρχουν δύο τρόποι για αρίθμηση των Bytes σε μία λέξη: με τον πρώτο τρόπο ο μικρότερος αριθμός είναι ο πιο αριστερά και με τον δεύτερο τρόπο είναι ο πιο δεξιά: - Big endian : Byte # Little endian : Byte # bits - Ο επεξεργαστής MIPS εργάζεται και με τούς δύο τρόπους. - Η οικογένεια επεξεργαστών της Intel ακολουθεί το Little Endian F1 F4 X=F1F2F3F4hex F2 F3 F3 F2 X F4 F1 Little Endian Big Endian 8

9 Βασική Αρχή Ορισμού MIPS Συνόλου Εντολών Πολλά χαρακτηριστικά των εντολών της μηχανής MIPS οφείλονται στη κανονικοποίηση, όπως: όλες οι εντολές έχουν το ίδιο μέγεθος, απαιτούνται πάντα τρείς καταχωρητές για τις αριθμητικές εντολές και τα πεδία των καταχωρητών κρατούνται στην ίδια θέση για όλα τα είδη εντολών. Αρχή 1. Η απλότητα στη σχεδίαση οφείλεται στη κανονικοποίηση. 9

10 - Eντολή Αποθήκευσης: Η αντίστροφη εντολή της load (φόρτωσε), είναι η store -πχ sw (φύλαξε μια λέξη). - Παράδειγμα 5- Υποθέστε ότι η μεταβλητή h συσχετίζεται με τον καταχωρητή $18. Υποθέστε επίσης ότι ο καταχωρητής $19 έχει τιμή 4 x i. Δίνεται ο πιο κάτω κώδικας σε C: A[i] = h + A[i]; Ποιος είναι ο αντίστοιχος κώδικας σε γλώσσα MIPS; lw $8, Astart ($19) add $17, $18, $8 sw $17, Astart ($19) # ο καταχωρητής $8 παίρνει προσωρινά την τιμή του Α[i] # ο καταχωρητής $17παίρνει προσωρινά την τιμή του h+a[i] # Το h+a[i] φυλάγεται πίσω στη θέση Α[i] Εάν το Αstart βρίσκεται στο $20 add $21,$20,$19 // $21 προσωρινή lw $8,0($21) add $17,$18,$8 sw $17,0($21) 10

11 Διασύνδεση υλικού / λογισμικού - Τα περισσότερα προγράμματα χρησιμοποιούν περισσότερες τοπικές μεταβλητές σε σχέση με τους καταχωρητές που διαθέτει η μηχανή. - Ο μεταγλωττιστής προσπαθεί να τοποθετήσει τις τοπικές μεταβλητές που χρησιμοποιούνται συχνότερα, στους καταχωρητές, και τις υπόλοιπες (μεταβλητές) στην μνήμη. - Η διαδικασία της τοποθέτησης των λιγότερα χρησιμοποιημένων μεταβλητών στην μνήμη, ονομάζεται register spilling. - Αν, για παράδειγμα, έχουμε περισσότερες από 32 μεταβλητές σε ένα πρόγραμμα. τότε υποχρεωτικά κάποιες θα πρέπει να βρίσκονται στην μνήμη (μιλώντας πάντα για τον ΜΙPS). - Για επίτευξη ψηλής απόδοσης, οι μεταγλωττιστές πρέπει να χρησιμοποιούν αποδοτικά τούς καταχωρητές. - Στον MIPS υπάρχουν εντολές για load word και store word, για 16 bit (half word) - lh/sh και 8bit - lb/sb δεδομένων και load double word και store double word. 11

12 lw $1,4($2) add $1,$1,$3 sw $1,0($2) Processor Registers Memory Address Data (base 10) $ $ $ $ $

13 add $8, $17, $18 Αναπαράσταση εντολών στην μηχανή bits 5 bits 5 bits 5 bits 5 bits 6 bits - Oπως είναι γνωστό, οι εντολές είναι κωδικοποιημένες στο δυαδικό σύστημα, σαν μία ακολουθία από δυαδικά ψηφία. - Το κάθε ένα από αυτά τα κομμάτια της εντολής ονομάζεται πεδίο (field). Toπρώτο και τελευταίο πεδίο (0 & 32) σε συνδυασμό δηλώνουν ότι η πράξη που θα εκτελεστεί είναι η πρόσθεση. Το δεύτερο πεδίο δίνει τον αριθμό του καταχωρητή ($17) που είναι η πηγή του πρώτου τελεσταίου της πρόσθεση. Το τρίτο πεδίο δίνει τον αριθμό του καταχωρητή ($18) που είναι η πηγή του δεύτερου τελεσταίου της πρόσθεσης. Το τέταρτο πεδίο δίνει τον αριθμό του καταχωρητή ($8) που θα δεχτεί το αποτέλεσμα της πρόσθεσης. Το πέμπτο πεδίο δεν χρησιμοποιείται σε αυτή την εντολή και για αυτό παίρνει την τιμή 0. - Αυτή η εντολή προσθέτει τον καταχωρητή (τα περιεχόμενα του) $17 στον καταχωρητή (στα περιεχόμενα του) $18 και τοποθετεί το αποτέλεσμα στον καταχωρητή $8. 13

14 - Όλες οι εντολές στο MIPS έχουν μέγεθος 32 bits, άρα διατηρείται η πρώτη αρχή που θέσαμε. Τα πιο πάνω πεδία έχουν συγκεκριμένα ονόματα: - Η γενική μορφή της εντολής στη μηχανή MIPS με τα αντίστοιχα ονόματα των πεδίων. op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits - Το κάθε πεδίο στην πιο πάνω κωδικοποίηση έχει ώς ακολούθως: 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. 14

15 - Όταν μια εντολή χρειάζεται μεγαλύτερα πεδία από αυτά που δίνονται πιο πάνω παρουσιάζονται προβλήματα. - Για παράδειγμα, στην εντολή lw πρέπει να προσδιορισθούν δύο καταχωρητές και μια διεύθυνση. Αν οι διευθύνσεις χρειάζονταν μόνο 5 bits (=2 5 ή 32 θέσεις μνήμης ) τότε αυτό θα ήταν δυνατό. - Όμως, αυτό το μέγεθος είναι πολύ μικρό για να μπορέσει να χρησιμοποιηθεί για διευθύνσεις δεδομένων. - Οι σχεδιαστές του MIPS αποφάσισαν να κρατήσουν όλες τις εντολές στο ίδιο μήκος -32 bits- > διαφορετικά είδη εντολών θα πρέπει να έχουν διαφορετική μορφή. -H πιο κάτω μορφή ονομάζεται R-type (Register type). op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 15

16 Ένα δεύτερο είδος εντολής ονομάζεται I-type και χρησιμοποιείται από τις εντολές μετακίνησης δεδομένων (π.χ. lw, sw). Tα πεδία αυτής της μορφής είναι: op rs rt address 6 bits 5 bits 5 bits 16 bits Για παράδειγμα για την εντολή: lw $8, Astart ($19) Η τιμή 19 θα τοποθετηθεί στο πεδίο rs Η τιμή 8 θα τοποθετηθεί στο πεδίο rt και η βάση της διεύθυνσης του πίνακα Astart στο πεδίο διευθύνσεων (address). Σημειώστε ότι το πεδίο rt στην εντολή lw δίνει το πεδίο που θα πάρει το αποτέλεσμα. Στο sw το πεδίο rt περιέχει τον καταχωρήτη με την τιμή που θα πάει στην μνήμη 16

17 Πολλές μορφές εντολών προκαλούν πολυπλοκότητα στο υλικό > μπορούμε να μειώσουμε την πολυπλοκότητα κρατώντας τις μορφές των εντολών παρόμοιες. Για παράδειγμα, τα πρώτα τρία πεδία στις μορφές R-type και I-type έχουν τα ίδια ονόματα και το τέταρτο πεδίο στην I-type είναι ίσο με το μήκος των άλλων τριών πεδίων του R-type. Η ομοιομορφία ανάμεσα στους δύο τύπους, αυτό βοηθά στην αποκωδικοποίηση του προγράμματος, χρησιμοποιώντας το ίδιο κύκλωμα. Οι διάφορες μορφές/τύποι των εντολών ξεχωρίζουν από τις τιμές που δίνονται στο πρώτο πεδίο (op). Η κάθε μορφή παίρνει συγκεκριμένες τιμές στο πεδίο op, γι αυτό και παραδοσιακά το πεδίο αυτό ονομάζεται opcode -κωδικός εντολής. RISC VS CISC Debate 17

18 Kωδικοποιήσεις των εντολών που μελετήσαμε μέχρι τώρα Instruction Format op rs rt rd shamt funct address Add 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. address Sw I 43 Reg Reg n.a. n.a. n.a. address Μεγέθη των πεδίων για τις πιο πάνω εντολές: Field op rs rt rd shamt funct address Size 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 16 bits οι εντολές add και sub έχουν το ίδιο op πεδίο. Το πεδίο funct προσδιορίζει ποια αριθμητική πράξη (πρόσθεση ή αφαίρεση) πρέπει να εκτελέσει. 18

19 Παράδειγμα 6- Υποθέστε ότι η μεταβλητή h συσχετίζεται με τον καταχωρητή $18 και επίσης ότι ο καταχωρητής $19 έχει την τιμή 4 x i (όπως στο προηγούμενο παράδειγμα). H εντολή στη C A[i] = h + A[i] ; μεταγλωττίζεται σε: lw $8, Astart ($19) add $8, $18, $8 sw $8, Astart ($19) # ο καταχωρητής $8 παίρνει προσωρινά το Α[i] # ο καταχωρητής $8 παίρνει προσωρινά h+a[i] # Το h+a[i] φυλάγεται πίσω στη θέση Α[i] Ποιός είναι ο κώδικας σε γλώσσα μηχανής (MIPS) για τις πιο πάνω εντολές; 19

20 Υποθέτουμε ότι η βάση του πίνακα (αρχική διεύθυνση) είναι το 1200 στο δεκαδικό (ή στο δυαδικό). Η μορφή των τριών εντολών στο δεκαδικό σύστημα είναι: op rs rt (rd) (shamt) Address OR funct (Astart) Η εντολή lw προσδιορίζεται από τον αριθμό 35 (πεδίο op). H εντολή add προσδιορίζεται από το πρώτο και τελευταίο πεδίο (0 και 32) H εντολή sw προσδιορίζεται από τον αριθμό 43 στο πρώτο πεδίο Η αντίστοιχη δυαδική μορφή των εντολών (τρόπος αναπαράστασης τους σε γλώσσα μηχανής) είναι: Προσέξτε την ομοιότητα της πρώτης και τρίτης εντολής στην δυαδική απεικόνιση. Η μόνη διαφορά τους βρίσκεται στο πρώτο πεδίο, στο τρίτο bit από τα αριστερά. 20

21 H μεγάλη εικόνα: Σήμερα οι υπολογιστές είναι κτισμένοι πάνω σε δύο βασικές αρχές: 1. Οι εντολές απεικονίζονται ως αριθμοί. 2. Τα προγράμματα μπορούν να αποθηκευθούν στη μνήμη για να διαβαστούν, ή να γραφούν, όπως οι αριθμοί. 3. Το ίδιο και τα δεδομένα: μεταβλητές, προσωρινά αποτελέσματα, δομές - Αυτή η αρχή ονομάζεται η έννοια του αποθηκευμένου προγράμματος (stored program concept). John Von Neuman (1946) John Von Neuman, J. Presper Eckert and John William Mauchly - Αποθηκευμένα Προγράμματα --Τα προγράμματα φυλάγονται στη μνήμη σαν κώδικας σε γλώσσα μηχανής. 21

22 Διασύνδεση Υλικού/Λογισμικού Η συμβολική αναπαράσταση των εντολών ονομάζεται συμβολική γλώσσα, και η αντίστοιχη αναπαράσταση με αριθμούς ονομάζεται γλώσσα μηχανής. -Hιεραρχία μετάφρασης για ένα πρόγραμμα από υψηλού επιπέδου γλώσσα μέχρι τη γλώσσα μηχανής. - ένα πρόγραμμα σε C(υψηλού επιπέδου γλώσσα) μεταφράζεται σε συμβολική γλώσσα από τον μεταγλωττιστή C program - ο συμβολομεταφραστής μεταφράζει την συμβολική γλώσσα σε γλώσσα μηχανής. Compiler Assembly language program Assembler - Το πρόγραμμα που τοποθετεί το πρόγραμμα της γλώσσας μηχανής στη μνήμη για εκτέλεση ονομάζεται φορτωτής (loader). Υπάρχουν και άλλα ενδιάμεσα επίπεδα (πχ JVM, assembler-to-assembler) 22 Machine language program Loader Memory

23 Ιδιομορφίες του MIPS και ψευδοεντολές Ο καταχωρητής $0 στη μηχανή MIPS έχει πάντα την τιμή 0. Γι αυτό ο συμβολομεταφραστής της γλώσσας MIPS έχει την πιο κάτω εντολή αν και δεν ανήκει στην αρχιτεκτονική της μηχανής MIPS: move $8, $18 #ο καταχωρητής 8 θα πάρει το περιεχόμενο του #καταχωρητή 18. Ο συμβολομεταφραστής μεταφράζει την πιο πάνω εντολή στην αντίστοιχη εντολή του MIPS που είναι: add $8, $0, $18 # ο καταχωρητής 8 παίρνει το άθροισμα του # καταχωρητή 0 και 18. Η εντολή move δεν υποστηρίζεται από τον MIPS, είναι ψευδοεντολή και συσχετίζεται με την εντολή add. 23

24 Εντολές διακλαδώσειςν/ ανάληψη αποφάσεων Η μηχανή Μ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). 24

25 - Παράδειγμα 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 = j add $16, $17, $18 # f = g + h (αγνοείται αν i= j) L1: sub $16, $16, $19 # f = f - i εκτελείται πάντοτε 25

26 Διασύνδεση υλικού / λογισμικού Οι μεταγλωττιστές συχνά δημιουργούν μεταπηδήσεις και ετικέτες που δεν παρουσιάζονται στις γλώσσες υψηλού επιπέδου. Για παράδειγμα, χρησιμοποιώντας τις μεταβλητές και τους καταχωρητές του πιο πάνω παραδείγματος, ο πιο κάτω κώδικας σε C: if (i= =j) f=g+h; else f=g-h; f = g + h i = j i = = j? i!= j Else : f = g - h μεταγλωττίζεται στον πιο κάτω κώδικα MIPS: Exit : 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 : 26

27 J (jump) εντολή διακλάδωσης χωρίς συνθήκη Σύνταξη: j label Σημασία: μετά την εκτέλεση της εντολής τύπου jump η ροή ελέγχου συνεχίζει στην εντολή με το label Format (j-type): optype Target 6-bit 26-bit 27

28 Παράδειγμα 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+j bne $19, $18, Loop # Πήγαινε στο Loop αν i h 28

29 Διασύνδεση λογισμικού / υλικού 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 4 lw $8, Sstart ($9) # Προσωρινός καταχωρητής $8 = save [i] bne $8, $21, Exit # go to Exit if save [i]!= k add $19, $19, $20 # i=i+j j Loop # goto Loop Exit: 29

30 Ο έλεγχος για ισότητα ή ανισότητα είναι ίσως ο πιο δημοφιλής έλεγχος, αλλά αρκετές φορές, θέλουμε να ελέγξουμε αν μια μεταβλητή, είναι πιο μικρή από μια άλλη μεταβλητή. Η εντολή set on less than (slt), μας επιτρέπει να κάνουμε αυτήν την σύγκριση, π.χ. slt $8, $19, $20 Ο καταχωρητής $8 παίρνει την τιμή 1, αν η τιμή στον καταχωρητή $19 είναι πιο μικρή από την τιμή στον καταχωρητή $20, διαφορετικά ο καταχωρητής $8 παίρνει την τιμή 0. 30

31 Διασύνδεση λογισμικού/υλικού: Στον MIPS, οι εντολές slt, beq, bne, και η τιμή 0 στον καταχωρητή $0 χρησιμοποιούνται για τη δημιουργία όλων των σχετικών ελέγχων. Για παράδειγμα, για να ελέξουμε αν η μεταβλητή στον καταχωρητή $16 είναι πιο μικρή από την τιμή στον καταχωρητή $17, εκτελούμε τις ακόλουθες εντολές: slt $1, $16, $17 # S1=1 if $16 < $17 bne $1, $0, Less # goto Less if $1 $0. Οι εντολές slt και bne εκτελούν την συνθήκη ελέγχου για το μικρότερο. Στην πραγματικότητα ο συμβαλόμεταφραστής του MIPS, μεταφράζει την εντολή ψευδοεντολή blt (branch on less than) στις δύο πιο πάνω εντολές. blt $16,$17,Less - προσοχή στην χρήση του $1 31

32 Ο MIPS δεν υποστηρίζει την εντολή blt, είναι διότι θα προκαλούσε επιπρόσθετη πολυπλοκότητα στη μηχανή, είτε θα μεγάλωνε ο κύκλος μηχανής είτε η εντολή θα χρειαζόταν επιπρόσθετους κύκλους μηχανής για κάθε εντολή. Δύο γρήγορες εντολές είναι πολύ πιο χρήσιμες. To μικρότερο είναι το πιο γρήγορο (ΑΡΧΗ 2). Σημειώστε ότι ο καταχωρητής $1 χρησιμοποιείται από τον συμβολομεταφραστή. Για αυτό το λόγο αποφεύγεται να χρησιμοποιείται από τους μεταγλωττιστές της γλώσσας MIPS. 32

33 Bitwise Λογικοί Τελεστές Shift left << sll R-type Shift right >> srl R-type Bit by bit AND & and,andi R/I-type Bit by bit OR or, ori R/I-type Bit by bit NOT ~ nor R-type sll $t2,$s0,4 # $t2 = $s0 << 4 op rs rt rd shamt func (9<<4) =

34 Unsigned and Signed Τελεστές Unsigned: 0-extend άμεση τιμή από 16 σε 32 bit Signed: sign-extend άμεση τιμή από 16 σε 32 bit Αριθμητικές πράξεις μπορεί να προκαλέσουν exception σε περίπτωση overflow (επιλογή για ορισμό στην αρχιτεκτονική) add $1,$2,$3 addi $1,$2,0xf123 addu $1,$2,$3 addiu $1,$2,0xf123 ori $1,$2,0xf0 andi $1,$2,0xff00 $1 = $2 + 0xfffff123 $1 = $2 + 0x0000f123 $1 = $2 0x000000f0 $1 = $2 & 0x0000ff00 34

35 Άλλα είδη διευθυνσιοδότησης στη μηχανή MIPS Σταθεροί ή Άμεσοι Τελεσταίοι - Πολλές φορές χρησιμοποιούμε σταθερούς αριθμούς σε μια λειτουργία (μιαν εντολή). 1. Για παράδειγμα, όταν αυξάνουμε τον δείκτη να δείχνει στο επόμενο στοιχείο σε ένα πίνακα, ή όταν μετρούμε τις επαναλήψεις σε ένα loop, ή όταν μετατρέπουμε την στοίβα σε ένα φωλιασμένο call. 2. Στην πραγματικότητα, σε δύο προγράμματα που έχουν μελετηθεί: στο μεταγλωττιστή της C, gcc και στο πρόγραμμα για σχεδίαση ηλεκτρονικών κυκλωμάτων spice, περισσότερο από 50% των αριθμητικών λειτουργιών διεξάγεται σε σταθερούς τελεσταίους. 35

36 Η μορφή εντολών Ι-type είναι για Immediate-type εντολές (δηλ. εντολές στις οποίες ένας από τους τελεσταίους τους είναι σταθερά). Το πεδίο του MIPS στο οποίο αποθηκεύεται η σταθερά έχει μέγεθος 16 bits. Η εντολή πρόσθεσης - add η οποία έχει ένα σταθερό τελεσταίο ονομάζεται add immediate ή addi. Για να προσθέσουμε τον αριθμό 4 στον καταχωρητή 29 γράφουμε απλά: addi $29, $29, 4 # $29 = $ Ο κώδικας μηχανής: op rs rt immediate

37 Οι τελεσταίοι άμεσης πρόσβασης/στεθερές (immediate) είναι επίσης πολύ χρήσιμοι για τις συγκρίσεις. Όπως έχουμε τονίσει ο καταχωρητής $0 έχει πάντα την τιμή 0, έτσι μπορούμε να συγκρίνουμε με το μηδέν. Για σύγκριση με άλλες τιμές, μπορούμε να χρησιμοποιήσουμε την εντολή slti (set on less than immediate), Για παράδειγμα στις πιο κάτω εντολές θέλουμε να συγκρίνουμε αν το περιεχόμενο του καταχωρητή 18 είναι μικρότερο από το 10 : slti $8, $18, 10 # $8 = 1 if $18<10 bne $8, $0, Less # goto Less if $18<10 37

38 Αρχή 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:

39 - Ποίος θα είναι ο κώδικας στη συμβολική γλώσσα MIPS για να φορτώσουμε την πιο κάτω 32-bit σταθερά στο καταχωρητή $16: Πρώτα θα φορτώσουμε τα ψηλότερα 16 bits (είναι ο αριθμός 61 στο δεκαδικό), χρησιμοποιώντας την εντολή lui: lui $16, 61 # 61 decimal = in binary, 0x003D Η τιμή στο καταχωρητή 16 θα είναι τελικά: Το επόμενο βήμα είναι να προσθέσουμε τα χαμηλότερα 16 bits, τους οποίους η δεκαδική τιμή είναι 2304: addiu $16, $16, 2304 # 2304 decimal = Αντί addiu; Η τελική τιμή στο καταχωρητή $16 θα είναι η επιθυμητή τιμή, δηλαδή:

40 Διευθυνσιοδότηση με διακλάδωση και άμεσες τίμες - Η πιο απλή διευθυνσιοδότηση στον MIPS είναι η εντολές jump. - Χρησιμοποιείται η τρίτη και τελευταία μορφή εντολών στον ΜIPS, η J-type, - 6 bits για το πεδίο op (λειτουργίας) και τα υπόλοιπα 26 bits είναι για το πεδίο των διευθύνσεων. (PC <= PC 31_28 ::IR 25_0 ::00 Program counter (PC), ή instruction address register: καταχωρητής ο οποίος αποθηκεύει (κρατεί) την διεύθυνση της επόμενης εντολής που θα εκτελεσθεί. j # goto location PC 31_28 :10000x bits 26 bits - Η διακλάδωση υπό συνθήκη - bne $8, $21, Exit # goto Exit if $8 = $ Exit 6 bits 5 bits 5 bits 16 bits 40

41 Αν οι διευθύνσεις ενός προγράμματος έπρεπε να χωράνε σε ένα πεδίο 16 bits, Ένα πρόγραμμα δεν θα μπορούσε να είναι μεγαλύτερο από 2 16 bits. Σχεδόν οι μισές εντολές διακλάδωσης υπό συνθήκη στα προγράμματα gcc και spice πηγαίνουν (μεταπηδούν) σε λιγότερο από 16 εντολές από το σημείο (εντολή) που ελέγχθηκε η συνθήκη. Δεδομένου ότι ο PC περιέχει την διεύθυνση της τρέχουσας εντολής, μπορούμε να έχουμε διακλάδωση μέσα σε 2 16 από την τρέχουσα εντολή χρησιμοποιώντας τον καταχωρητή PC για να προστεθεί η διεύθυνση διακλάδωσης. Σχεδόν όλες οι εντολές load και if χρειάζονται πιο μικρή διεύθυνση από 2 16 bits, επομένως η χρήση του καταχωρητή PC είναι η ιδανική λύση. 41

42 PC-relative addressing. 1. Το υλικό αυξάνει τον καταχωρητή PC στα αρχικά στάδια της εντολής για να δείχνει στην επόμενη εντολή. 2. Επομένως η επόμενη διεύθυνση στη μηχανή MIPS θα είναι στη θέση PC+4 αν η προηγούμενη ήταν στη θέση που δεικνύει ο PC. 42

43 Δίνεται ο πιο κάτω κώδικας σε MIPS που αντιπροσωπεύει ένα while loop σε μια γλώσσα ψηλού επιπέδου: Loop : sll $9, $19, 2 # Προσωρινός καταχωρητής $9 = i x 4 lw $8, Sstart ($9) # Προσωρινός καταχωρητής $8 = save [i] bne $8, $21, Exit # go to Exit if save [i]!= k add $19, $19, $20 # i=i+j j Loop # goto Loop Exit: - Η εντολή bne στην τρίτη γραμμή προσθέτει 8 bytes (2x4) στη διεύθυνση της επόμενης εντολής (80012), προσδιορίζοντας τον προορισμό της διακλάδωσης σε σχέση με αυτή την εντολή αντί να χρησιμοποιήσει ολόκληρη τη διεύθυνση (80020) Η εντολή j (jump) χρησιμοποιεί ολόκληρη την διεύθυνση (20000x4=80000), που ανταποκρίνεται στην ετικέτα Loop 43

44 Διασύνδεση λογισμικού / υλικού Αν και σχεδόν όλες οι διακλαδώσεις υπό συνθήκη είναι σε κοντινές διευθύνσεις, υπάρχει ανάγκη για διακλάδωση και σε μακρινές διευθύνσεις. Για παράδειγμα η εντολή: beq $18, $19, L1 μπορεί να αντικατασταθεί με δύο εντολές, ώς ακολούθως, για να επιτευχθεί η διακλάδωση στη μακρινή διεύθυνση L1: bne $18, $19, L2 j L1 L2: 44

45 Switch και jr -Αρκετές γλώσσες προγραμματισμού έχουν εντολές case ή switch. Για την υποστήριξη τέτοιων εντολών, ο MIPS έχει την εντολή jr (jump register), η οποία εκτελεί μεταπήδηση χωρίς συνθήκη στην διεύθυνση (αντίστοιχη ετικέτα) που είναι αποθηκευμένη στον καταχωρητή. Παράδειγμα 9 Δίνεται ο πιο κάτω κώδικας σε C, o οποίος χρησιμοποιεί την εντολή επιλογής switch για να επιλέξει μια συγκεκριμένη λειτουργία, ανάλογα με την τιμή της μεταβλητής k. Υποθέστε ότι οι μεταβλητές f, g, h, i, j, k συσχετίζονται με τους καταχωρητές από $16 ως $21 και επίσης Ο καταχωρητής $10 περιέχει τον αριθμό 4. Ποιος θα είναι ο αντίστοιχος κώδικας σε MIPS; 45

46 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 +0 L0 +4 L1 +8 L2 +12 L3 - Φορτώνουμε τέσσερις λέξεις στη μνήμη, ξεκινώντας από τη θέση JumpTable - Ο πίνακας έχει οριστεί από τον μεταγλωττιστή. - Κάθε εντολή είναι 4 bytes άρα ξέρουμε τις διευθύνσεις L0, L1, L2, L3. Loop: mult $9, $10, $21 # Temporary reg. $9 =k x4 ή sll $9,$10,2 lw $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 + j j 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 - j Exit: # end of switch statement 46

47 Διευθύνσεις Δεδομένα μεγέθους 32 bits (δυαδική μορφή εντολών) Οι διευθύνσεις των ετικετών στον πίνακα διαφέρουν 8 bytes η μία από την άλλη διότι κάθε ετικέτα αποτελείται από 2 εντολέs των 4 bytes η κάθε μία. L3 : 0XF20018 L2 : 0XF L1 : 0XF L0 : 0XF JumpTable [12] JumpTable [8] JumpTable [4] JumpTable [0] 47

48 Αρχιτεκτονική MIPS Name Example Comments 32 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 to Handle pseudoinstructions and large constants memory Words (2 32 B) Memory[0], Memory[4], Memory[ ] 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. 48

49 Category Instructions Example Meaning Comments Add add $1, $2, $3 $1 = $2 + $3 3 operands; data in register Arithmetic Subtract sub $1, $2, $3 $1 = $2 - $3 3 operands; data in register Add addi $1, $2, 100 $1 = $ Used to add constants Immediate Load word lw $1, 100($2) $1 = Memory[$2+100] Data from memory to register Data Store word sw $1, 100($2) Memory[$2+100] = $1 Data from register to memory Transfer Load upper lui $1, 100 $1 = 100 * 2 16 Loads constants in upper 16 Conditional Branch Uncondition al Jump immediate bits Branch on beq $1, $2, 25 if ($1 == $2) go to Equal test; PC relative branch equal PC Branch on bne $1, $2, 25 if ($1!= $2) go to Not equal test; PC relative not equal PC Set on less slt $1, $2, $3 if ($2<$3) $1 = 1; Compare less than; for beq, than else $1 = 0 bne Set less than slti $1, $2, 100 if ($2<100) $1 = 1; Compare less than constant immediate else $1 = 0 Jump j 2500 go to Jump to target address Jump jr $31 go to $31 For switch, procedure return register Jump and link jal 2500 $31 = PC + 4; go to For procedure call 49

50 Name Format Example Comments Add R add $1, $2, $3 Sub R sub $1, $2, $3 Addo I addi $1, $2, 100 Lw I lw $1, 100($2) Sw I sw $1, 100($2) Lui I lui $1,100 Beq I beq $1, $2, 100 Bne I bne $1, $2, 100 Slt R slt $1, $2, $3 Slti I slti $1, $2, 100 J J j Jr R jr $31 Jal J jal Field size 6 bits Format R 5 bits 5 bits 5 bits 5 bits 6 bits R op rs rt rd Sham t funct All MIPS instructions 32 bits Arithmetic Instruction format Format I I op rs rt Address / immediate Transfer, branch, Imm. Format Format J J op Target address Jump instruction format 50

51 Memory Model MIPS Reserved 0x Text 0x pc Static 0x x $gp Heap 0x Stack 0x7FFF FFFC $sp Ευθύνη μεταγλωτιστή/προγραμματιστή δέσμευση στον κατάλληλο χώρο Text: κώδικας Static: global Stack: local Heap dynamic Registers: local (τυποποίηση 0,1,26,27,28,29,30,31 δεσμευμένα) 51

52 Υποστήριξης διαδικασιών σε επίπεδο υλικού - Μία διαδικασία ή υποπρόγραμμα (subroutine) είναι ένας τρόπος με τον οποίο οι προγραμματιστές χωρίζουν τα προγράμματα τους για να κάνουν πιο εύκολη την κατανόηση του κώδικα και για να επιτρέψουν στον κώδικα να ξαναχρησιμοποιηθεί (reusability). - Μια ομάδα εντολών πρέπει να παρέχει ένα τρόπο μεταφοράς της ροής εκτέλεσης του προγράμματος σε μια διαδικασία και ακολούθως να επιτρέπει την επιστροφή στην επόμενη εντολή (αμέσως μετά από την εντολή που κάλεσε τη διαδικασία). - Οι προγραμματιστές ακόμη πρέπει να έχουν τρόπο για το πέρασμα των παραμέτρων - Η αρχιτεκτονική MIPS υποστηρίζει μίαν εντολή που μεταπηδά σε μία διεύθυνση, και ταυτόχρονα αποθηκεύει τη διεύθυνση της εντολής που ακολουθεί στον καταχωρητή $31: jump - and - link (jal) και έχει ως ακολούθως: jal ProcedureAddress - H εντολή που μεταπηδά στην επιστροφή είναι η jr $31 52

53 π.χ. υψηλού επιπέδου γλώσσα: call procedure1 σε συμβολική γλώσσα: jal procedure1 address Ο μεταγλωττιστής θα δώσει/συσχετίσει την διεύθυνση procedure1 με το όνομα της διαδικασίας procedure1. Το jr $31 αντιστοιχεί στο ret (return) ή end που είναι η τελευταία εντολή που εκτελείται στην διαδικασία. $31 : φυλάγεται η επόμενη διεύθυνση μετά από το call. 53

54 Program counter (PC), ή instruction address register: καταχωρητής ο οποίος αποθηκεύει (κρατεί) την διεύθυνση της επόμενης εντολής που θα εκτελεσθεί. ΚΑΘΕ ΕΝΤΟΛΗ ΕΝΗΜEΡΩΝΕΙ ΤΟΝ PC PC= PC+4 για εντολές που δεν είναι διακλαδώσεις Η εντολή jal ProcedureAddress προσθέτει 4 στο PC, για να δείχνει στην επόμενη εντολή και αποθηκεύει το αθροίσμα στον καταχωρητή $31 και μετά ενημερώνει τον PC να δείχνει στο ProcedureAddress Η εντολή jr $31 απλά αντιγράφει το $31 στο PC $31 ενναλακτικα $ra (return address) 54

55 Στην περίπτωση που έχουμε φωλιασμένα (nested) jal τότε είναι απαραίτητο να φυλαχτεί η αρχική τιμή του $ra πριν να εκτελέσουμε τα jal που ακολουθούν. Ο ιδανικός τρόπος για επίτευξη αυτής της λειτουργίας είναι η χρησιμοποίηση της στοίβας (stack). Χρειάζεται ένας δείκτης που θα δείχνει στην κορυφή της στοίβας, δηλαδή εκεί που η επόμενη εντολή πρέπει να τοποθετήσει τους καταχωρητές της. Η τοποθέτηση δεδομένων στη στοίβα ονομάζεται push, ενώ η μετακίνηση τους από την στοίβα pop. 55

56 - Επιπρόσθετα στη διεύθυνση επιστροφής χρειαζόμαστε μεταφορά των δεδομένων των μεταβλητών ή των παραμέτρων σε μία διαδικασία. 1. Στην αρχιτεκτονική MIPS η μέθοδος αυτή γίνεται με την τοποθέτηση των παραμέτρων στους καταχωρητές $4 έως $7. (σύμβαση) 2. Αν μία διαδικασία χρειάζεται να καλέσει μιαν άλλη διαδικασία, αυτοί οι καταχωρητές μπορούν να φυλαχθούν και να τους επαναφέρομαι στη συνέχεια, χρησιμοποιώντας τη στοίβα. - Γενικώς μία διαδικασία, μπορεί να αλλάξει τους καταχωρητές που χρησιμοποιούνται από την τρέχουσα διαδικασία. Υπάρχουν δύο τυποποιημένες πρακτικές για αυτό: 1. Αποθηκεύει αυτός που καλεί (caller save). Η διαδικασία που καλεί είναι υπεύθυνη για το φύλαγμα και την επαναφορά των καταχωρητών, οι οποίοι πρέπει να φυλαχτούν κατά την διάρκεια της εκτέλεσης της διαδικασίας. Τότε η διαδικασία που καλείται μπορεί να αλλάξει οποιοδήποτε καταχωρητή. 2. Αποθηκεύει αυτός που καλείται (call/callee save). Φυλάει και επαναφέρει αυτός που καλείται. Η διαδικασία που καλείται φυλάει τους καταχωρητές, τους χρησιμοποιεί όπως θέλει και επαναφέρει τους αρχικούς στο τέλος του καλέσματος. 56

57 Ένα γενικό παράδειγμα 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) αποθήκευση στην στοίβα στην αρχή και επαναφορά στο τέλος (για τώρα) 57

58 Θα μετατρέψουμε την διαδικασία 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] = $17 sw $16, 4 ($18) # v[k+1] = $16 (temp) 58

59 Διαφύλαξη καταχωρητών - Αφού θα αλλάξουμε τα περιεχόμενα των καταχωρητών $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) και μετά προσαρμόζουμε την στοίβα στην άλλη κατεύθυνση. 59

60 Saving Registers Swap: addi $29, $29, -12 sw $16, 0($29) sw $17, 4($29) sw $18, 8($29) Procedure body sll $18, $5, 2 add $18, $4, $18 lw $16, 0($18) lw $17, 4($18) sw $17, 0($18) sw $16, 4($18) Restoring Registers lw $16, 0($29) lw $17, 4($29) lw $18, 8($29) addi $29, $29, 12 Procedure Return jr $31 # make room on the stack for 3 reg # save $16 on stack # save $17 on stack # save $18 on stack # 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) # restore $16 from stack # restore $17 from stack # restore $18 fron stack # restore stack pointer # return to calling routine 60

61 Ένα μεγαλύτερο παράδειγμα - Σε αυτή την ενότητα θα δώσουμε ένα πρόγραμμα στη γλώσσα 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. 61

62 Κώδικας για το σώμα της διαδικασίας - Το σώμα της διαδικασίας αποτελείται από δύο φωλιασμένους βρόγχους και ένα κάλεσμα στη 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

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

64 - Άρα η μορφή του πρώτου 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: 64

65 -Oεσωτερικός βρόγχος for ( j = i - 1; j >= 0 && v[j] > v[j+1]; j = j - 1 ) { - Δίνεται αρχική τιμή στη μεταβλητή j του for loop: addi $17, $19, -1 # j = i Η μείωση του 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 4 add $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 >= $24 beq $1, $0, exit2 # go to exit2 if $25 >= $24 65

66 Στο τέλος του βρόγχου γίνεται μεταπήδηση πίσω στον έλεγχο του 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 4 add $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 >= $24 beq $1, $0, exit2 # go to exit2 if $25 >= $ (body of second for loop).... addi $17, $17, -1 # j = j - 1 j for2tst # jump to test of inner loop exit2: 66

67 -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-4 sw $5,0($sp) move $5,$17 jal swap lw $5,0($sp) addi $sp,$sp,4 ή Register Renaming move $20,$5 στην αρχή για να αποφύγουμε πολλές εντολές και πριν την κλήση move $5, $17 # copy parameter $5 into $20 - j 67

68 Διαφύλαξη Καταχωρητών - Το μόνο που έμεινε τώρα είναι η αποθήκευση των καταχωρητών χρησιμοποιώντας την μέθοδο callee save. - Αποθηκεύουμε την διεύθυνση επιστροφής στον καταχωρητή $31, αφού η sort καλεί μια άλλη διαδικασία. - Οι άλλοι καταχωρητές που πρέπει να χρησιμοποιήσουμε είναι: $5, $15, $16, $17, $18, $19, $20, $24 και $25. Άρα θα έχουμε: addi $29, $29, -40 # make room on stack for 10 registers sw $15, 0($29) # save $15 on stack sw $16, 4($29) # save $16 on stack sw $17, 8($29) # save $17 on stack sw $18, 12($29) # save $18 on stack sw $19, 16($29 # save $19 on stack sw $20, 20($29) # save $20 on stack sw $24, 24($29) # save $24 on stack sw $25, 28($29) # save $25 on stack sw $31, 32($29) # save $31 on stack sw $5,36($29) # save $5 on stack 68

69 Saving Registers sort: 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 69

70 Procedure Body Move parameters Outer loop for1st: Inner loop Pass parameters and call for2st: move $20, $5 # copy parameter $5 into $20 add $19, $0, $0 slt $1, $19, $20 beq $1, $0, exit1 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 move $5, $17 jal swap Inner loop addi $17, $17, -1 j for2tst Outer loop exit2: addi $19, $19, 1 j for1tst # i = 0 # reg $1 = 0 if $19 >= $5 (i >= n) # go to exit1 if $19 >= $5 (i >= n) # 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 # first parameter of swap is v # second parameter of swap is j # j = j 1 # jump to test of inner loop # i = i + 1 # jump to test to outer loop 70

71 Restoring Registers exit1: 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 Procedure Return jr $31 # 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 # return to calling routine 71

72 Τυποποίηση 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] saved yes $t[8-9] 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, for operating system 72

73 Τυποποίηση Policy of Use Conventions Οι καταχωρητές που είναι preserved on call όταν μια συνάρτηση μπορεί να αλλάξει την τιμή τους τότε πρέπει να αποθηκεύονται στην αρχή της συνάρτησης και να επιστρέφονται στο τέλος sp και fp εξαίρεση (αφαιρεση στην αρχή /πρόσθεση στο τέλος) Οι άλλοι καταχωρητές όταν μια συνάρτηση καλεί άλλη συνάρτηση και χρειάζεται να διατηρήσει τις τιμές σε προσωρινούς τότε πρέπει να αποθηκεύονται πριν την κλήση της άλλης συνάρτησης και να φορτώνονται μετά την επιστροφή σε leaf συναρτήσεις temporaries για όλες τις μεταβλητές (μόνο αν χρειάζεται saved), αλλιώς temporaries για προσωρινές μεταβλητές saved για τοπικές 73

74 Saving Registers Swap: addi $29, $29, -12 sw $16, 0($29) sw $17, 4($29) sw $18, 8($29) Procedure body sll $18, $5, 2 add $18, $4, $18 lw $16, 0($18) lw $17, 4($18) sw $17, 0($18) sw $16, 4($18) Restoring Registers lw $16, 0($29) lw $17, 4($29) lw $18, 8($29) addi $29, $29, 12 Procedure Return jr $31 # make room on the stack for 3 reg # save $16 on stack # save $17 on stack # save $18 on stack # 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) # restore $16 from stack # restore $17 from stack # restore $18 fron stack # restore stack pointer # return to calling routine 74

75 Swap: Procedure body sll $t0, $a1, 2 add $t0, $a0, $t0 lw $t2, 0($t0) lw $t1, 4($t0) sw $t1, 0($t0) sw $t2, 4($t0) jr $ra # reg $8 = k x 4 # reg $8 = v + (k x 4) # reg $8 has the adress of v[k] # reg $10 (temp) = v[k] # reg $9 = v[k+1] # refers to next element of v # v[k] = reg $9 # v[k+1] = reg $10 (temp) # return to calling routine Leaf: δεν χρειάστηκε αποθήκευση στην στοίβα 75

76 Saving Registers sort: 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 76

77 Procedure Body Move parameters Outer loop for1st: move $s0, $a0 move $s1, $a1 add $s2, $0, $0 ble $s1,$s2,exit1 Inner loop addi $s3, $s2, -1 for2st: blt $s3,$0,exit2 sll $t0, $s3, 2 add $t0, $s0, $t0 lw $t1, 0 ($t0) lw $t2, 4 ($t0) ble $t1,$t2,exit2 Pass move $a0, $s0 parameters move $a1, $s3 and call jal swap Inner loop addi $s3, $s3, -1 j for2tst Outer loop exit2: addi $s2, $s2, 1 j for1tst # copy parameter $a0 into $s0 v (local) # copy parameter $a1 into $s1 n (local) # i = 0 (local) # go to exit1 if (n<= i) # 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] # first parameter of swap is v # second parameter of swap is j # j = j 1 # jump to test of inner loop # i = i + 1 # jump to test to outer loop 77

78 Restoring Registers exit1: Procedure Return lw $s0, 0($sp) lw $s1, 4($sp) lw $s2, 8($sp) lw $s3, 12($sp) lw $ra, 16($sp) addi $sp, $sp, 20 ret # return to calling routine 78

79 Στοίβα: τοπικές, προσωρινές, Κάθε κλήση συνάρτησης δημιουργεί ένα Stack Frame (ή Activation Record) arguments, saved, return Τοπικά δεδομένα Padding (empty) = x8 for double words Return address Saved Registers Παράμετροι address, πίνακες 79

80 int g( int x, int y ) { return (x + y); } g: add $v0,$a0,$a1 jr $ra # result is sum of args # return 80

81 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 epilogue addiu $sp,$sp,128 # pop stack frame # end of epilogue jr $ra # return 81

82 g: # start of prologue addiu $sp,$sp,(-144) # push stack frame sw $s0,0($sp) # save value of $s0 sw $s1,4($sp) # save value of $s1 sw $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 $s0 lw $s1,4($sp) # restore value of $s1 lw $s3,8($sp) # restore value of $s3.. addiu $sp,$sp,144 jr $ra # pop stack frame # end of epilogue # return 82

83 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 prologue addiu $sp,$sp,(-160) # push stack frame sw $ra,28($sp) # save the return address sw $s0,16($sp) # save value of $s0 sw $s1,20($sp) # save value of $s1 sw $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 frame sw $a0,160(sp) # save $a0 (variable x) sw $a1,164(sp) # save $a1 (variable y) # first call to function f lw $a0,164(sp) # arg0 is variable y lw $a1,160(sp) # arg1 is variable x lw $a2,40(sp) # arg2 is a[2] jal f # call f sw $v0,36(sp) # store value of f into a[1] # second call to function f lw $a0,160(sp) # arg0 is variable x lw $a1,164(sp) # arg1 is variable y lw $a2,36(sp) # arg2 is a[1] jal f # call f sw $v0,32(sp) # store value of f into a[0] # load return value of g into $v0 lw $v0,32($sp) # result is a[0] # end of body # start of epilogue lw $s0,16($sp) # restore value of $s0 lw $s1,20($sp) # restore value of $s1 lw $s3,24($sp) # restore value of $s3 lw $ra,28($sp) # restore the return address addiu 83 $sp,$sp,160 # pop stack frame # end of epilogue jr $ra # return

84 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]; } 84 g: # start of prologue addiu $sp,$sp,(-168) # push stack frame sw $ra,32($sp) # save the return address sw $s0,20($sp) # save value of $s0 sw $s1,24($sp) # save value of $s1 sw $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 frame sw $a0,168(sp) # save $a0 (variable x) sw $a1,172(sp) # save $a1 (variable y) # first call to function f lw $a0,172(sp) # arg0 is variable y lw $a1,168(sp) # arg1 is variable x lw $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 f sw $v0,44(sp) # store value of f into a[1] # second call to function f lw $a0,168(sp) # arg0 is variable x lw $a1,172(sp) # arg1 is variable y lw $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 f sw $v0,40(sp) # store value of f into a[0] # load return value of g into $v0 lw $v0,40($sp) # result is a[0] # end of body # start of epilogue lw $s0,20($sp) # restore value of $s0 lw $s1,24($sp) # restore value of $s1 lw $s3,28($sp) # restore value of $s3 lw $ra,32($sp) # restore the return address addiu $sp,$sp,168 # pop stack frame # end of epilogue jr $ra # return

85 Βελτιστοποίηση κώδικα Επαναχρησιμοποίηση αποτελεσμάτων σε καταχωρητες Αριθμητική δεικτών για έλεγχο συνθήκης επανάληψης βρόγχων Exceptions/Interrupts Τύποι ιευθυνσιοδότησης X86 ISA 85

86 g: # start of prologue addiu $sp,$sp,(-168) # push stack frame sw $ra,32($sp) # save the return address sw $s0,20($sp) # save value of $s0 sw $s1,24($sp) # save value of $s1 sw $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 frame sw $a0,168(sp) # save $a0 (variable x) sw $a1,172(sp) # save $a1 (variable y) # first call to function f lw $a0,172(sp) # arg0 is variable y lw $a1,168(sp) # arg1 is variable x lw $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 f sw $v0,44(sp) # store value of f into a[1] # second call to function f lw $a0,168(sp) # arg0 is variable x lw $a1,172(sp) # arg1 is variable y lw $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 prologue addiu $sp,$sp,(-168) # push stack frame sw $ra,32($sp) # save the return address sw $s0,20($sp) # save value of $s0 sw $s1,24($sp) # save value of $s1 sw $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 frame sw $a0,168(sp) # save $a0 (variable x) sw $a1,172(sp) # save $a1 (variable y) # first call to function f mov $a0,$a1 # arg0 is variable y lw $a1,168(sp) # arg1 is variable x lw $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 f sw $v0,44(sp) # store value of f into a[1] # second call to function f lw $a0,168(sp) # arg0 is variable x lw $a1,172(sp) # arg1 is variable y lw $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!