Le istruzioni: il linguaggio dei calcolatori. Luigi Palopoli

Transcript

1 Le istruzioni: il linguaggio dei calcolatori Luigi Palopoli

2 Insieme delle Istruzioni Per impartire istruzioni al computer bisogna parlare il suo linguaggio Il linguaggio si compone di un vocabolario di istruzioni detto instruction set (IS) I vari tipi di processore hanno ciascuno il proprio IS. Tuttavia le differenze non sono eccessive Un utile esempio e quello delle inflessioni regionali di un unica radice linguistica

3 Instruction Set Come osservato da Von Nueman le istruzioni: certi [insiemi di istruzioni] che in linea di principio siprestano a controllare l Hardware Egli stesso osservava che le considerazioni davvero decisive sono di natura pratica: semplicita dei dispositivi richiesti chiarezza delle applicazioni velocita di esecuzionei Queste considerazioni scritte nel 1947 sono straordinariamente valide anche oggi

4 In queste lezioni Questa serie di lezioni vuole mostrare degli IS (in modo da vedere in seguito la realizzazione) Studieremo il concettodi programma memorizzato: Studieremo tre IS: MIPS INTEL ARM (cenni) Istruzioni e dati sono memorizzati come numeri

5 Perche il MIPS Il motivo per cui mostreremo e faremo esercizi con INTEL e abbastanza chiaro (qualche milione di PC sono basati su Intel o Intel compatibili) L architettura MIPS e invece un architettura RISC (in verita non diffusissima) Tuttavia E molto simile ad altre architetture RISC diffusissime (esempio ARM) L architettura INTEL fa una traduzione on the fly del proprio IS che viene tradotta internamente in un linguaggio RISC

6 Incominciamo.. Inzieremo dall IS MIPS A cominciare da Von Neuman si diceva che all interno di un IS: Devono necessariamente essere previste istruzioni per il calcolo delle operazioni aritmetiche fondamentali

7 Operazioni artimetiche E dunque naturale che l architettura MIPS supportile operazioni aritmetiche Per progettare un IS come quello del MIPS terremo conto di vari principi ispiratori Principio di Progettazione n. 1: La semplicita favorisce la regolarita

8 Istruzioni aritmetiche Il modo piu semplice di immaginare una istruzione aritmetica e a tre operandi: a = b + c Quindi l architettura del MIPS prevede soltanto istruzioni aritmetiche a tre operandi add a, b, c

9 Istruzioni piu complesse Istruzioni piu complesse si ottengono a partire dalla combinazione di istruzioni semplici. Es. a = b + c; d = a e; Diventa add a, b, c sub d, a, e

10 Esempio Neilinguaggi ad alto livello possiamoscrivere espressioni complesse a piacimento: f = (g+h) (i+j); Quando si traduce a basso livello bisogna per forza usare sequenzedi istruzioni elementari

11 Esempio Ad esempio la nostra espressione verra tradotta come mostrato di seguito add t0, g, h; #la variabile temp. # t0 = g + h add t1, i, j; #la variabile temp. # t1 = i + j sub f, t0, t1; # f = t0 t1

12 Un po di commenti Nell assembler MIPS i commenti iniziano con # e continuano fino alla fine della linea l operando destinatario dell operazione e sempre il primo Questo non vale per tutti gli assemblatori. Ad esempio se si usa gcc come assemblatore questo segue la sintassi AT&T per la quale: I commenti si fanno a la C /* commento */ L operando destinatario dell operazione e messo in fondo

13 Operandi Fino ad ora abbiamo usato gli operandi piuttosto allegramente (come se fossero normali variabili di un linguaggio ad alto livello) In realta nel MIPS gli operandi di operazioni aritmetiche sono vincolati ad essere registri Un registro e una particolarelocazionedi memoria che e interna al processore e quindi puo essere reperita in maniera velocissima (un ciclo di clock)

14 Registri del MIPS Il MIPS contiene 32 registri a 32 bit (64 nel caso di MIPS 64) Il vincolo di operare solo tra registri semplifica di molto il progetto dell hardware Ma perche solo 32 registri? Principio di Progettazione n. 2: minori sono le dimensioni, maggiore la velocita Avere molti registri obbligherebbe I segnali a spostarsi su distanze piu lunghe all interno del processore Quindi per effettuare uno spostamento all interno di un ciclo di clock saremmo costretti a rallentare il clock

15 Esempio (Ripreso) Torniamo al nostro esempio: f = (g+h) (i+j); Il codice con I registri diviene: add $t0, $s1, $s2; #Il registro temporaneo # t0 viene settato = # regist. s1+s2 add $t1, $s3, $s4; sub $s0, $t0, t1; # f = t1 t0

16 Osservazioni Nell assembler MIPS per indicare che un operando e un registro lo si fa precedere da $ Come abbiamo detto le operazioni aritmetiche e logiche si effettuano solo tra registri Il problema e che I registri non bastano Ci occorrono istruzioni di trasferimento che prelevino locazioni di memoria e li mettano nei registri (load) salvino il contenuto dei registri in memoria

17 La memoria La memoria e una sequenza di bit organizzati in gruppi di 8 (byte). Ciascun byte e associato ad un indirizzo lineare progressivo tramite il quale e possibile prelevarlo

18 Word Per quanto la maggior parte delle architetture permettano l accesso a ciascun byte la maggior parte delle volte si trasferiscano parole di dimensioni uguali ai registri Vincolo di allineamento: e possibile accedere solo a parole poste a indirizzi multipli dell ampiezza della parola

19 Trasferimento Per caricare una word (o un byte) devo specificarne l indirizzo Nell assembler MIPS l indirizzo si specifica tramite una base (in un registro) e uno spiazzamento o offset (costante) Come vedremo in altre architetture (esempio INTEL) c e molta piu flessibilita nello specificare l indirizzo

20 Load Il caricamento di una parola contenuta in indirizzo in un registro avviene tramite la seguente istruzione: lw $t0, 4($s3) Si sta operando su una parola Registro in cui si vuole caricare Spiazzamento Base L effetto di questa istruzione e di caricare in t0 la word all indirizzo dato da s3 + 4

21 Esempio Supponiamo divolere effettuarel istruzione A[12] = h + A[8] La traduzione in assembly MIPS lw $t0, 32($s3); # La parola 8 comincia #all indirizzo 32 e il #puntatore A e in s3 add $t0, $s2, $t0; #h e in s2 sw $t0, 48($s3); # memorizzo il contenuto del # registro temp. in A[12]

22 Register Spilling Tipicamente I programmi contengono piu variabili che registri :=) Quello che si fa e caricare le variabili in uso in un dato momento nei registri e scaricare quelle che non si usano piu in quel momento Questa operazione e chiamata register spilling ed e eseguita dal compilatore che stimail working set ed inserisce nel codice I carichi/scarichi appropriati Nell esempio precedente,magari l indirizzo di A serve ancora in s3 nelle istruzioni successive mentre forse h si puo scaricare da s2

23 Operandi immediati o costanti Molto spessonelleoperazioni aritmetiche almeno uno dei due operandi e costante Un possibile approccio puo essere di memorizzare la costante in un qualche indirizzo Esempio: f = f + 4; lw $t0, IndCost4($s1);# la costante 4 #e all indirizzo s1 + IndCost4 add $s3, $s3, $t0;

24 Operandi Immediati La soluzione cheabbiamo visto e piuttosto inefficiente Principio di Progettazione n. 3: rendi piu veloci possibile le operazioni comuni Per questo motivo esistono istruzioni che permettono di operare con costani f = f + 4; addi $s3, $s3, 4 Immediate

25 La costante 0 Esistono alcune costanti che possono essere di grande utilita per semplificare alcune operazioni Ad esempio per spostare un registro in un altro posso renderlo destinatorio della somma del sorgente con 0 Per questo motivo il MIPS dedica un registro $zero a contenere la costante0

26 Numeri Prima di parlare del modo in cui le istruzioni sono codificate attraverso numeri (rappresentate) ricordiamo: Nei calcolatori l unita base di informazione e il bit Un gruppo di 4 bit puo essere associato ad un numerofino a 16 che rappresenta una cifra nella notazione esadecimale Quindi un byte viene rappresentato da due cifre esadecimali (ciascuna corrispondente a 4 bit) Ad esempio D

27 Cifre esadecimali

28 Little e big endian Quando si memorizza una parola di quattro byte (o di 8) in una sequenza di byte posti a indirizzi progressivi va capito dove va il byte piu significativo e quello meno significativo. Esempio (esadecimale) 0XEA01BD1C Byte piu significativo Byte meno significativo

29 Little e big endian Little endian (ArchitettureMotorola, Protocolli Internet) EA01BD1C Big Endian (Intel) Addr 3 EA Addr 2 01 Addr 1 BD Addr 0 1C EA01BD1C Addr 3 Addr 2 Addr 1 Addr 0 1C BD 01 EA

30 Rappresentazione delle istruzioni Come I dati, anche un programma deve essere memorizzato in forma numerica Questo vuol dire che le istruzione che abbiamo introdotto simbolicamente (assembly) devono essere convertite in dei numeri (codice macchina) Cominciamo con un esempio

31 Esempio Consideriamo l istruzione add $t0, $s1, $s2 Per rappresentarla tramite un codice numerico univoco ci occorre: Un codice numerico che ci dica che si tratta di un add Altri codici numerici che ci dicano quali sono gli operandi il tutto in 32 bit

32 Risultato Il risultato rappresentato in decimale e il seguente: 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit (0) (17) (18) (8) (0) (32) I primi e gli ultimi bit codificano l istruzione Primo operando Secondo operando Risultato I registri sono numerati (es. s1 = 17, s2 = 18) e quindi possono essere specificati come operandi all interno del codice dell istruzione

33 Campi delle istruzioni MIPS In generale, e utile dare un nome ai vari campi relative al codice macchina di un istruzione 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit OP rs rt rd shamt funct op: codice operativo dell istruzione rs: primo operando sorgente rt: secondo operando sorgente rd: operando destinazione shamt: shift amount (lo vedremo per alcune istuzioni) funct: definisce la funzionalita specifica dell istruzione (insieme a op). Ad esempio la sottrazione e un particolare tipo di addizione

34 Tradeoff Principio di Progettazione n. 4: un buon progetto richiede buonicompromessi Nel nostro caso il buon compromesso e di far stare le istruzioni in 32 bit Ci costa limite al numero di istruzioni limiteal numerodiregistri limite alle modalita di indirizzamento ma ci permette di guadagnare molto in efficienza

35 Istruzioni Immediate Abbiamo visto che ci sonoistruzioni di caricamento/salvataggio e somma con costanti che non possono ovviamente stare nelformato cheabbiamo visto (dettor, da registro) Per questo motivo esiste anche un formato per l indirizzamento immediato (detto I)

36 Istruzioni Immediate Il formato e il seguente 6 bit 5 bit 5 bit 16 bit OP rs rt costante o indirizzo Ad esempio: lw $t0, 32($s3) $s3 $t0

37 Esempio Supponiamo di vole tradurre in linguaggio macchinale seguentiistruzioni: A[300] = h + A[300]; La traduzione e la seguente: lw $t0, 1200($t1) add $t0, $s2, $t0 sw $t0, 1200($t1)

38 in codice macchina. Cominciamo con il guardare i codici decimali: Istruzione op rs rt rd Ind/Shamt Funct lw $t0, 1200($t1) add $t0, $s2, $t sw $t0, 1200($t1) In binario op rs rt rd Ind/Shamt Funct

39 Riassumendo Ciascuna istruzione viene espressa come un numero di 32bit Un programma consistedunque in una sequenza di numeri Tale sequenzaviene scrittain locaziomi consecuitve di RAM In momenti diversi, nella stessa RAM, possiamo rappresentare programmi diversi

40 Codici delle istruzioni viste fino ad ora

41 Elenco (quasi completo) delle istruzioni MIPS

42 Elenco (quasi completo) delle istruzioni MIPS

43 Operazioni Logiche I primi calcolatori operavano solo su parole intere Molto presto si manifesto la necessita di operare su porzioni di parole o addirittura sul singolo bit Il MIPS fornisce alcune istruzioni che permettono di fare questo in maniera semplificata (rispetto ad altre architetture) ma efficace

44 Shift logico La prima operazione che andiamo a vedere e il cosidetto shift logico a sinistra L idea e di inserire degli zeri nella posizione meno significativa e traslare tutto a sinistra perdendoi bit piu significativi Esempio consideriamo: eseguiamo: s0 = sll $t2, $s0, L effetto e di memorizzare in t2 144 (da 9 inizialmente presente in s0)

45 Il codice operativo Il codice operativo dell istruzione: e : sll $t2, $s0, 4 op rs rt rd Ind/Shamt Funct Da qui si comprende l utilita del campo shift amount

46 Effetto collaterale Un effetto collaterale di questa istruzione e moltiplicare il numero operandoper 2^I, dove I e il numero di elementi di cui si fa lo shift Questo funziona sempre? Esempio: s0 = Cosa succede se noi effettuiamo: Otteniamo: sll $t2, $s0, 1 t2 = (dec. 8) (dec ) Il problema e semplicementeche il numero non e rappresentabile.

47 Un caso diverso Se invece prendiamo: s0 = (dec.-2) Se effettuiamo: Otteniamo: sll $t2, $s0, 1 s0 = (dec.-4) Se rimaniamo nel range di rappresentabilita la moltiplicazioneper potenzedi 2 tramite shift funziona bene.

48 Shift a destra Analogamente allo shift logico a sinistra si puo avereuno shift logico a destra Esempio: s0 = Se effettuiamo: srl $t2, $s0,

49 Effetti collaterali Generalizzandoil ragionamento che abbiamo fatto prima, ci verrebbe di dire che lo shift a destra di I unita corrisponde a dividereper 2^I E corretto? Nell esempio fatto prima facendo lo shift a destra di 1 sul numero 9 abbiamoottenuto4 (che e il risultatodella divisioneintera) Consideriamoun altro esempio: s0 = (dec.-4) srl $t2, $s0, 1 Quello che si ottiene e un numero positivo e questo nonostanteil risultato dell operazionesia perfettamenterappresentabile:=(

50 Shift aritmetico Per risolvereil problema evidenziato si risolvecon lo shift aritmetico a destra. In sostanza quello che si inserisce a destra non sono bit ugualia 0 ma uguali al bit di segno Nel nostro esempio s0 = sra $t2, $s0, Risultato (corretto):

51 Shift aritmetico Notare che lo shift aritmetico non ha nessun senso fatto a sinistra In quel caso o il risultato e rappresentabile e lo shift logico funziona come artimetico o non lo e e non c e molto che si possa fare. Altre architetture offrono entrambi I tipi di shift MIPS essendo RISC fornisce solo l essenziale :=)

52 Altre operazioni logiche Il MIPS offrein aggiunta a quelle viste altre operazioni logiche Alcune di queste sono elencate di sotto:

53 AND bit a bit Le operazioni logiche operano su ciascun bit Esempio: t1 = t2 = Risultato: and $t0, $t1, $t2 t0 = L operazione and forza alcuni bit a 0 usando come operando una maschera (I cui bit corrispondenti a quellichesivoglionoannullare siano0)

54 OR bit a bit Analogamente e possibile settare a 1 alcuni bit facendo or con un operando che abbia 1 nella posizione corrispondente(maschera) Esempio: Supponiamo di volere impostare a 1 i 4 bit piu significativi di una word contenuta in s0. addi $t0,$zero,0x000f sll $t0, $t0,28 or $s0, $s0, $t0

55 Rotazione Esempio: Supponiamo di volere girare i quattro bit piu significative di una word sui suoi bit meno significativi

56 Esempio Primo passo s0 = srl $t0, $s0, 28 t0 = Second passo s0 = sll $s0, $s0, 4 s0 =

57 Esempio Terzo passo s0 = or $s0, $s0, $to s0 =

58 Il nor Supponiamo: t1 = t2 = nor$t0, $t1, $t2 Risultato: t0 =

59 Lo strano caso del not Il not normalmente e un operatore unario Per i progettisti MIPS tutte le operazioni artimetiche hanno tre operandi di tipo registro Per questo motivo si e deciso di non fornire il not ma il nor Il not si ottiene dal nor molto facilmente nor $s0, $s0, $zero #equivale a not s0

60 Or esclusivo Oltre che AND, OR, NOR abbiamo anche un supporto per l OR esclusivo (XOR) Ricordiamo che l OR esclusivo produce 1 se e solo se I due bit operandi sono uno e zero (e zero negli altri casi). t1 = t2 = Risultato: xor$t0, $t1, $t2 t0 =

61 Esempio Cosa succede se facciamo? xor $t0, $t0, $t0 Il risultato e quello di annullare il valore di t0 E una maniera molto veloce ed efficiente per annullare un registro Ricordare A XOR B = (A AND NOT(B)) OR (NOT(A) AND B)

62 Istruzioni per prendere decisioni Una delle caratteristiche fondamentali dei calcolatori (che li distinguono dalle calcolatrici) e la possibilita di alterare il flusso di programma al verificarsi di certe condizioni costrutto if nelle varie forme Il linguaggio macchina delle varie architetture supporta questa possibilita fornendo istruzioni di salto condizionali Tipicamente questo avviene sulla base del valore di un registro di flag di stato Nel caso le condizioni per il salto sono esplicite nell istuzione di salto

63 Salto su condizioni Le due istruzioni di salto condizionale sono: beq reg1, reg2, L1 bne reg1, reg2, L1 Se il registro reg1 e uguale al registro reg2 effettua un salto all istruzione con etichetta L! Se il registro reg1 e diverso dal registro reg2 effettua un salto all istruzione con etichetta L!

64 Costrutto if Supponiamo di avere il seguente codice C. Come viene tradotto? if (i == j) f = g + h; else f = g h;

65 Costrutto if Traduzione costrutto if precedente: bne $s3, $s4, ELSE #Salta a ELSE se s3 div. da s4 add $s0, $s1, $s2 #f = g + h j ESCI # Salto incond. a ESCI ELSE: sub $s0, $s1, $s2 # f = g - h ESCI: Alcune osservazioni Le label vengono alla fine tradotte in indirizzi Per fortuna questo lavoro noioso e opera del compilatore

66 Cicli La struttura che abbiamo presentato puo essere usata anche per realizzare dei cicli Consideriamo l esempio: Traduzione: while (salva[i] == k) i += 1; Ciclo: sll $t1, $s2, 2 #Registro temp. t1 = 4*I add $t1, $t1, $s6 #Ind di salva[i] in t1 lw $t0, 0($t1) #salva[i] in t0 bne $t0, $s5, Esci #Esci se raggiunto limite addi $s2, $s2, 1 #i = i+1 j Ciclo Esci:.

67 Commenti Le sequenze di istruzioni di salto condizionato (conditional branch) sono cosi importanti che viene dato loro un nome: blocchi di base Blocco di base: seq. di istruzioni che non contiene istuziomi di salto (con l eccezione dell ultima) ne etichette di destinazione (con l eccezione dela prima) Una delle prime fasi della compilazione e di individuare I blocchi base Tutti I cicli in linguaggio ad alto livello vengono implementati co blocchi di base.

68 Altri confronti Oltre al salto su operandi uguali o diversi, e utile avere un salto anche su operandi minori/maggiorio minori uguali Il modo di fare del MIPS e tramite istruzioni che settano il valore di registri flag La prima di queste e setta se minore o uguale slt $t0, $s3, $s4 #t0 = 1 se s3 < s4 Di questa istruzione esiste anche una variante immediata: slti $t0, $s3, 10 #t0 = 1 se s3 < 10 I compilatorimips ottengono I salti su condizioni di tipo minore o uguale combinando SLT con BEQ, o BNE e usando la costante 0 per fare I test

69 Esempio Consideriamo il codice Traduzione if (i < j) f = g + h; else f = g h; slt $t0, $s3, $s4 #setta t0 se se i < j beq $t0, $zero, ELSE #Salta a ELSE se s3 div. da s4 add $s0, $s1, $s2 #f = g + h j ESCI # Salto incond. a ESCI ELSE: sub $s0, $s1, $s2 # f = g - h ESCI:

70 Signed e unsigned L esito del confronto e ovviamente diverso se si tiene conto del segno oppure no. Per questo motivo troviamo due versioni di SLT (SLTU, SLTUI) cheoperano suinteri senza segno

71 Esempio Si supponga che s0 = s1 = Cosa produce? slt $t0, $s0, $s1 E cosa t0 = 1 sltu $t0, $s0, $s1 t0 = 0

72 Un piccolo trucco Supponiamo di volere controllare se un indice (s1) e fuori dal limite di un array ([0, t2]) Ce la possiamo cavare con un solo confronto Perche? sltu $t0, $s1, $t2 beq $t0, $zero, FuoriLimite Se s1 e maggiore di t2, ovviamente avremo 0 in t2 Ma anche se s1 e negativo, interpretato come unsigned, sara maggiore di t2 (che ha il bit piu significativo a 0)

73 Il costrutto case/switch Una possibilita e quella di effettuare una sequenzain cascatadiif-then-else In realta esiste una tecnica diversa Memorizzare i vari indirizzi dove eseguire il codice in una tabella (una sequenza di word) Caricare in un registro l indirizzo cui si deve saltare fare un salto all indirizzo puntatodal registro (jr)

74 Il costrutto case/switch Esempio: switch(a) { case 1: <code 1>; case 2: <code 2>;.. }; Tabella dove memorizzo gli indirizzi dei codici sll $t0, $a0, 2 #moltiplica per 4 lw $t0, TABLE($t0) jr $t0 Salto all indiriizzo nel registro

75 Procedure L utilita di un compute sarebbe molto limitata se non si potessero chiamare procedure (o funzioni) Possiamo pensare a una procedure come a una spia che fa del lavoro per noi senza che noi vogliamo sapere come lo fa La cosa importante e di mettersi d accordo su un protocollo

76 Protocollo 1. metter i parametri in un posto noto 2. trasferire il controllo alla procedura 1. Acquisire le risorse necessarie 2. Eseguire il compito 3. metterei valori di ritorno in posti noti 4. Restituire il controllo al chiamante 3. Prendersi il valore di ritorno e cancellare le traccie

77 Protocollo Il modo in cui questo protocollo viene messo in pratica dipende dall architettura e dalle convenzioni di chiamata del compilatore Ci limitiamo a pochi cenni per il MIPS

78 Protocollo di chiamata MIPS L idea di base e di cercare di laddove possibile i registri, perche sono il meccanismo piu veloce per effettuare il passaggio dei parametri Convenzione per il MIPS $a0,..$a3: usati per i parametri in ingresso $v0, $v1 : valori di ritorno $ra : indirizzo di ritorno per tornare al punto di partenza

79 Protocollo di chiamata MIPS Oltre ai registri, l hardware MIPS mette a disposizione l istruzione di jump and link (JAL) che effettua il salto e contemporaneamente memorizzain ra l indirizzo di ritorno L indirizzo che viene salvato in ra e il PC (program counter) incrementatodi 4 (istruzionesucessiva alla jal) Alla fine della procedura sara sufficiente fare un salto jr $ra

80 e se i registri non bastano? In certi casi I registri non bastano perche ho piu parametri di quanti ne possano contenere I registri In tal caso si una lo stack, una struttura dati gestita con disciplina FIFO in cui e possibile mettere a partire da una posizione nota alla procedura (puntata dal registro fp) I parametri in piu Lo stack si puo usare anche mettere variabili locali (tramite un operazione di push) e salvare registri che occorrera ripristinare in seguito Alla fine della procedura si puo ripulire lo stack (operazione pop) riportandolo alla situazione precedente

81 Esempio Consideriamo la procedura in C: int esempio_foglia(int g, int h, int i, int j) { int f; } f = (g+h) (i+j); return f; Cerchiamo di capire come verrebbe tradotta

82 Prologo Per prima cosa il compilatore sceglie un etichetta associata all indirizzo di entrata della procedura (esempio_foglia) In fase di collegamento (linking) l etichetta sara collegata a un indirizzo La prima operazione e quella di salvare in memoria tutti I registri che la procedura usa in modo da poterli ripristinare in seguito Tale fase e chiamata prologo e potrebbe richiedere di allocare nello stack anche spazio per le variabili locali (se i registri non bastano).

83 Uso dei Registri Parametri in input - g = $a0; h=$a1; i=$a2: j=$a3 Variabile locale f: $s0 Usiamo a titolo di esempio anche I registri $t0 e $t1 (cosa che nessun compilatore farebbe) Supponiamo, sempre a titolo di esempio, di dover salvere $s0, $t1 e $t0

84 Prologo La procedura us I registri s0, t0, t1; Il registro SP punta alla testa dello stack (che si evolve verso il basso) Il codice del prologo e il seguente: Decrementiamo sp di 12, per far posto a 3 word esempio_foglia: addi $sp, $sp, -12; sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) Salvataggio di t1 in sp+8 Salvataggio di s0 in sp+0

85 Esecuzione della procedura Dopo il prologo, l esecuzione della procedura: In t0 mettiamo g+h add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 In t1 mettiamo i+j In s0 (g+h)-(i+j)

86 Epilogo Dopo aver eseguito la procedura, si ripristinano i registri usati e si setta il valore di ritorno Trasferiamo s0 in v0 (valore di ritorno) add $v0, $s0, $zer0 lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) addi $sp, $sp, 12 jr $ra Salto al punto da dove sono arrivato Ripristino I registri prelevando i valori esattamente da dove li avevomessi Ripristino lo stack (tutto cio che e sotto sp non e significativo)

87 Evoluzione dello stack Stack prima della chiamata Stack durante l esecuzione della procedura Stack dopo la chiamata

88 Un bagno di realta Nessun compilatore farebbe mai questo Infatti I registri temporanei *non* devono essere salvaguardati L uso di $s0 era non necessario (potevamo lavorare direttamentesu $t0 e $v0)

89 Ulteriori complicazioni In realta le cose possono complicarsi per via di Variabili locali Procedure annidate Questo si risolve usando sempre lo stack e allocandovi dentro variabili locali e valori del registro ra Vediamo un esempio

90 Procedure ricorsiva Consideriamo il seguente esempio int fact(int n) { if (n < 1) return 1; else return n*fact(n-1); } Qui (ma sarebbe lo stessocon una qualsiasi funzione che chiama un altra funzione) abbiamo due problemi: sovrascrittura di $ra che mi renderebbe impossibileil ritorno una volta finita la chiamata innestata. Sovrascrittura di $a0 usato per il registro n

91 Procedure ricorsiva Soluzione: salvaguardare il registro $ra, a0 Vediamo la soluzione Primo step: creiamo spazio nello stack e salviamo ra e a0 Fact: addi $sp, $sp, -8 #Ci serve spazio per due oggetti sw $ra, 4($sp) #Salviamo ra sw $a0, 0($sp) #Salviamo a0 Secondo step, testiamo se n <1 (ritornando 1 in caso affermativo): slti $t0, $a0, 1 #t0 settato a 1 se n < 1 beq $t0, $zero, L1 #Se n > 1 saltiamo a L1

92 Procedure ricorsiva Se n < 1 chiudiamo la procedura addi $v0, $zero, 1 #metodo del MIP per mettere in v0 1 addi $sp, $sp, 8 #Ripuliamo lo stack jr $ra #Ritorniamo all indirizzo di ritorno nota che non ripristiniamo ra e a0 (come si farebbe normalmente, perchè non li abbiamo cambiati) Se n > 1 decrementiamo n e richiamiamo fact L1: addi $a0, $a0, -1 #decrementiamo n jal fact #chiamiamo fact(n-1)

93 Procedure ricorsiva A questo punto ripristiniamo a0 e ra e ripuliamo lo stack lw $a0, 0($sp) #Ripristino a0 lw $ra, 4($sp) #Ripristino ra addi $sp, $sp, 8 #ripulisco stack Non ci resta che moltiplicare fact(n-1), che è in v0, per n e ritornare mul $v0, $a0, $v0 jr $ra

94 Storage class Le variabili in C sono in genere associate a locazioni di memoria Si caratterizzano per Tipo (int, char, float) Storage class Il C ha due possibili storage class Automatic (variabili locali che hanno un ciclo di vita collegata alla funzione) Static sopravvivono alle chiamate di procedura. Sono essenzialmente variabili globali o definite dentro funzioni come static Le variabili statiche sono memorizzate in una zona di memoria (nel MIPS accessibile attraverso il registro global pointer, $GP)

95 Variabili locali L ultimo problema è costituito dalle variabili locali Quando sono poche, si riescono a usare registri Quando sono tante (ad esempio struct complesse o array) non ci sono abbastanza registri Quello che sifa è allocare le variabili locali nello stack

96 Record di attivazione Il segmento di stack che contiene registri salvati e variabili locali relative a una funzione viene chimata record di attivazione (o stack frame) Le variabili locali vengono individuate tramite un offset a partire da un puntatore Il puntatore $sp è alle volte scomodo come base perchè cambia durante l esecuzione della funzione Il registro $fp (frame pointer) viene sempre mantenuto costante durante la funzione e può essere usato come base.

97 Evoluzione dello stack $fp $fp $sp $fp Saved arguments registers $sp Saved return address $sp Saved registers Saved registers Prima della chaimata Durante la chiamata Dopo la chiamata

98 Dati dinamici In aggiunta a variabili globali e variabili locali abbiamo anche le variabili dinamiche (quelle che vengono allocata con malloc/free, new/delete) Il MIPS adotta il seguente schema di memoria $sp stack Lo stack procede per indirizzi decrescenti $gp $pc Dynamic data Static Data Text Resrved Lo heapprocede per indirizzi crescenti

99 Convenzioni sui registi In base alle convenzioni, l uso dei registri è nella sequente tabella Nome Numero Uso Preservare $zero 0 Valore costante 0 n.a. $v0 - $v1 2-3 Valori di ritorno per chiamate di funzioni e valuazione di espressioni $a0-$a3 4-7 Argomenti No $t0-$t Temporanei No $s0 - $s Salvati Si $t8-$t Ulteriori temporanei No $gp 28 Puntatore ai globali Si $sp 29 Puntatore allo stack Si $fp 30 Frame pointer Si $ra 31 Return Address si No

100 Elaborazione Per quantole ricorsioni siano eleganti spesso sono causa di varie inefficienze Never hire a programmer who solve the factorial with a recursion Consideriamo la seguentefunzione int sum(int n) { if (n > 0) return sum(n-1) + n; else return n; }

101 Elaborazione Consideriamo la chiamata sum (2) Sum (2) n = 2 Sum (1) 2+sum(1) Il valore di ritorno viene costruito Tornando su per la catena di chiamate. Ogni frame di attivazione deve essere Preservato per produrre il risutlato corretto. 0 n = 1 Sum (0) 1+sum(0) n = 0

102 Elaborazione Consideriamo ora il codicecosìmodicato int sum(int n, int acc) { if (n > 0) return sum(n-1, acc+n); else return acc; } Stavolta la chiamata ricorsiva è l ultima cosa che la funzione fa (si limita a ritornare). Questa ricorsione viene detta di coda ritorniamo al nostro esempi sum(2,0).

103 Codice La proceduraricorsiva vienecompilata come segue segue: sum: move $v0, $a1 #metti $a1 in $v0 blez $a0, $L5 #se $a0 < 0, salta a L5 addiu $sp, $sp, -32 #Prologo> crea spazio nello stack sw $ra, (28)$sp #Prologo, salve ra addu $a1, $a1, $a0 #Somma a0 ad a1 (acc=acc+n) addiu $a0, $a0, -1 #Decrementa a0 (n=n-1) jal sum #Chiamata ricorsiva (modifica ra) lw $ra, 28($sp) #ripristina ra addiu $sp, $sp, 32 #rimette a posto lo stack $L5: j $ra

104 Elaborazione Consideriamo la chiamata sum (2) 3 3 Sum (2,0) n = 2, acc=0 Sum (1) Sum(1,2) In questo caso lungo i rami di ritorno non faccio che restituire 3. Conservare i dati nel frame di attivazione è inutile. Posso usare un unico frame di attivazione e svolgere La ricorsione in iterazione. 3 n = 1, acc= 2 Sum (0) Sum(0, 3) n = 0, acc= 3

105 Ottimizzazione Alcuni compilatori sanno riconoscere la ricorsione di coda: Il chiamante ritorna subito dopo la jal $v0 e gli altri registri non cambiano Il chiamato potrebbe direttamente ritornare al $ra del chiamante In altre parole il chiamante salva $ra e lo recupera per nulla Torniamo al nostro esempiodella somma

106 Ottimizzazione Quello che potremmo fare guardando al codice e molto semplicemente osservare che possiamo sostituire la jal con un jump j, con grandi semplificazioni sum: move $v0, $a1 #metti $a1 in $v0 blez $a0, $L5 #se $a0 < 0, salta a L5 addiu $sp, $sp, -32 #Prologo> crea spazio nello stack sw $ra, (28)$sp #Prologo, salve ra addu $a1, $a1, $a0 #Somma a0 ad a1 (acc=acc+n) addiu $a0, $a0, -1 #Decrementa a0 (n=n-1) jal sum #Chiamata ricorsiva (modifica ra) lw $ra, 28($sp) #ripristina ra addiu $sp, $sp, 32 #rimette a posto lo stack $L5: j $ra

107 Ottimizzazione Il codice risultante e piu corto e anche piu efficiente Il gcc fa questo con O2 sum: move $v0, $a1 #metti $a1 in $v0 blez $a0, $L5 #se $a0 < 0, salta a L5 addu $a1, $a1, $a0 #Somma a0 ad a1 (acc=acc+n) addiu $a0, $a0, -1 #Decrementa a0 (n=n-1) j sum #Chiamata ricorsiva (modifica ra) $L5: j $ra