Fetch Decode Execute Program Counter controllare esegue prossima

Transcript

1 Stored Program Istruzioni sono stringhe di bit Programmi: sequenze di istruzioni Programmi (come i dati) memorizzati in memoria La CPU legge le istruzioni dalla memoria (come i dati) Ciclo macchina (ciclo Fetch Decode Execute) La CPU legge (fetch) l istruzione corrente (indirizzata da un registro Program Counter = PC), e la pone in un registro speciale interno La CPU usa i bit dell istruzione per "controllare" le azioni da svolgere, e su questa base esegue l istruzione CPU determina la prossima istruzione e ripete il ciclo

2 Operandi e memoria I dati devono essere prelevati dalla memoria prima che le operazioni possano utilizzarli Load word lw $t0, indirizzo-di-memoria Processore Registro Memoria I dati devono essere immagazzinati in memoria quando necessario Store word sw $t0, indirizzo-di-memoria Processore Registro Memoria

3 Operandi e memoria Il compilatore organizza i dati del programma nella memoria Conosce la locazione in memoria di ogni variabile del programma Per ogni istruzione di load/store genera l opportuno indirizzo di memoria int a int b int c int d[10] indirizzo base

4 Operandi immediati Una istruzione potrebbe richiedere una costante come input Un istruzione immediata usa una costante numerica come uno degli input (al posto di un operando registro) addi $s0, $zero, 1000 # l indirizzo base del programma è 1000 immediate # ed è memorizzato in $s0 # $zero è un registro speciale # contenente sempre 0 addi $s1, $s0, 0 addi $s2, $s0, 4 addi $s3, $s0, 8 addi $s4, $s0, 12 # indirizzo della variabile a # indirizzo della variabile b # indirizzo della variabile c # indirizzo della variabile d[0]

5 Indirizzamento della memoria Siccome la dimensione minima di una cella di memoria si 1 byte, l indirizzamento di memoria è al byte (indirizzamento al byte) Nel MIPS (e in molte altre architetture) è obbligatorio che le parole di memoria abbiano indirizzi multipli di 4 (vincolo di allineamento) Codice C: d[3] = d[2] + a Assembler: lw $t0, 8($s4) # d[2] è caricato in $t0 offset lw $t1, 0($s1) # a è caricato in $t1 add $t0, $t0, $t1 # la somma è in $t0 sw $t0, 12($s4) # $t0 è scaricato in d[3]

6 Istruzioni Aritmetico/Logiche Le istruzioni aritmetiche del MIPS permettono solo operazioni elementari (add, sub, mult, div) tra coppie di operandi a 32 bit Le istruzioni logiche (and, or) sono bit a bit Tutte le istruzioni hanno 3 operandi L ordine degli operandi è fisso L operando destinazione in prima posizione Esempio Codice C: A = B + C Codice Assembler: add $t0, $s1, $s2 Il compilatore associa le variabili ai registri

7 Codifica in formato R-Type esempio add $t0, $s1, $s2 semantica $t0 = $s1 + $s2 codifica op rs rt rd shamt funct op: operazione base dell istruzione rs: registro del primo operando rt: registro del secondo operando rd: registro destinazione, che contiene il risultato dell operazione shamt: utilizzato per istruzioni di shift; posto a zero per le altre istruzioni funct: seleziona la specifica variante dell operazione base definita nel campo op

8 Istruzioni di trasferimento dati Leggere dalla memoria su registro: lw (load word) Scrivere da registro alla memoria: sw (store word) Esempio: Codice C: A[8] += h A è un array di numeri interi Codice Assembler: lw $15, 32($4) add $15, $5, $15 sw $15, 32($4) Indirizzo di memoria &A[8] $ displacement Nota: sw ha la destinazione come ultimo operando Nota: le istruzioni aritmetiche operano su registri, non su celle di memoria.

9 Codifica in formato I-Type esempio lw $t0, 32($s3) semantica $t0 = memory[$s3] + 32 codifica op rs rt 16-bit constant rs: registro della locazione di memoria rt: registro destinazione 16-bit constant: operando immediato (displacement) Questo formato codifica anche operazioni aritmetico-logiche con valori immediati, i.e., costanti: addi $t0, $s1, 8

10 Operazioni Logiche esempio sll $t2, $s0, 4 semantica $t2 = $s0 << 4 codifica rt rd shamt 0

11 Istruzioni di controllo del flusso Il flusso di esecuzione è normalmente sequenziale Le istruzioni di controllo cambiano la prossima istruzione da eseguire Istruzioni di salto condizionato branch if equal beq $s4, $s5, LABEL branch if not equal bne $s6, $s5, LABEL Esempio if (i == j) i = i + j;... bne $s4, $s5, LABEL add $s4, $s4, $s5 LABEL:... Formato I-Type (operando immediato relativo a PC)

12 Istruzioni di controllo del flusso Salto non condizionato Esempio j LABEL if (i!= j) h = i + j; else h = i j;... beq $s4, $s5, ELSE add $3, $4, $5 j EXIT ELSE: sub $3, $4, $5 EXIT:... Formato J-Type op 26-bit constant

13 Istruzioni di controllo del flusso Come facciamo a esprimere Salta se minore o uguale di? In MIPS c è un istruzione aritmetica, set-on-less-than Istruzione Significato slt $t1, $s4, $s5 if ($s4 < $s5) $t1 = 1; else $t1 = 0; Formato R-Type / I-Type (versione immediata)

14 Esempio: Ciclo Tradurre il seguente codice C in codice assembly: while (save[i] == k) i += 1; i e j sono, rispettivamente, in $s3 e $s5 and la base dell array save è in $s6 Loop: sll $t1, $s3, 2 # Moltiplico i per 4 add $t1, $t1, $s6 # Calcolo l indirizzo di save[i] lw $t0, 0($t1) # Carico save[i] in $t0 bne $t0, $s5, Exit # Condizione di uscita dal ciclo addi $s3, $s3, 1 # Corpo del ciclo j Loop # Ricomincio Exit:

15 Procedure Per eseguire una procedura (detta callee, chiamato), un programma (detto caller, chiamante) deve eseguire 6 passi: 1. mettere i parametri in un luogo accessibile alla procedura 2. trasferire il controllo alla procedura 3. acquisire le risorse necessarie per l esecuzione della procedura 4. eseguire il compito richiesto 5. mettere il risultato in un luogo accessibile al chiamante 6. restituire il controllo al chiamante

16 Registri MIPS I 32 registri MIPS sono partizionati come segue: Reg 0 : $zero memorizza sempre la costante 0 Regs 2-3 : $v0, $v1 valori di ritorno di una procedura Regs 4-7 : $a0-$a3 valori di ingresso di una procedura Regs 8-15 : $t0-$t7 registri temporanei Regs : $s0-$s7 registri variabili Regs : $t8-$t9 altri registri temporanei Reg 28 : $gp global pointer Reg 29 : $sp stack pointer Reg 30 : $fp frame pointer Reg 31 : $ra return address

17 Jump-and-Link Un registro speciale contiene l indirizzo dell istruzione correntemente eseguita questo registro è il program counter (PC) L invocazione della procedura è eseguita invocando l istruzione jump-andlink (jal) Il valore corrente di PC (in realtà PC+4) è salvato nel registro $ra Si salta all indirizzo iniziale della procedura specificato come parametro dell istruzione jal Poiché jal potrebbe sovrascrivere un valore pre-esistente di $ra, questo deve essere salvato in memoria prima di invocare l istruzione jal Tramite l istruzione jump-register $ra si ripristina il flusso di controllo del chiamante al termine della procedura Cosa succede se i registri $a0-$a3 e $v0, $v1 non sono sufficienti?

18 Stack Bisogna copiare il contenuto dei registri in memoria La struttura dati utilizzati è lo stack (pila), una coda di tipo LIFO (lastin first-out) utilizzata per salvare il contenuto dei registri Per ragioni storiche, lo stack cresce verso indirizzi di memoria bassi L indirizzo dell elemento dello stack allocato più di recente è memorizzato nello stack pointer ($sp) Inserendo dati nello stack (push), il valore di $sp diminuisce Estraendo dati dallo stack (pop), il valore di $sp aumenta Per convenzione, il contenuto dei registri $s0-$s7 deve essere salvato sullo stack prima dell invocazione di una procedura

19 Gestione dei dati dello stack Una nuova procedura deve creare spazio per tutte le sue variabili sullo stack Prima di eseguire la jal, il chiamante deve salvare i valori necessari dei registri $s0-$s7, $a0-$a3 e $ra nel suo stack Gli argomenti sono copiati in $a0-$a3 e l istruzione jal è eseguita Il chiamato può creare il suo spazio stack, aggiornando il valore di $sp Al termine dell invocazione, il chiamato copia il valore di ritorno in $v0 e libera lo stack se lo ha occupato Il chiamante può recuperare dallo stack i suoi valori precedentemente salvati ($s0-$s7, $a0-$a3 e $ra)

20 Esempio int leaf_example (int g, int h, int i, int j) { int f; f = (g + h) (i + j); return f; } indirizzi alti $sp Memoria leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra indirizzi bassi

21 Nuovi dati delle procedure

22 Codici ASCII load byte: lb $t0, 0($sp) store byte: sb $t0, 0($sp)

23 Esempio void strcpy(char x[], char y[]) { int i; i=0; while ((x[i] = y[i])!= `\0 ) i += 1; } strcpy: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra

24 Grandi costanti Le istruzioni immediate possono specificare solo costanti su 16 bit L istruzione lui è usata per copiare costanti a 16 bit nei 16 bit più significativi di un registro Combinando questa istruzione con un ori (OR immediato) possiamo copiare costanti a 32 bit

25 Grandi costanti Le istruzioni immediate possono specificare solo costanti su 16 bit L istruzione lui è usata per copiare costanti a 16 bit nei 16 bit più significativi di un registro Combinando questa istruzione con un ori (OR immediato) possiamo copiare costanti a 32 bit Nei salti condizionati (beq, bne) l indirizzo di salto (nuovo valore di PC) è una costante a 16 bit, relativa al valore corrente di PC Nel salto (j) l indirizzo di salto è una costante a 26 bit, di valore assoluto Se necessario, possiamo usare il contenuto di un altro registro come base

26 Metodi di indirizzamento del MIPS 1. Indirizzamento immediato: l operando è una costante contenuta nell istruzione 2. Indirizzamento tramite registro: l operando è in un registro 3. Indirizzamento tramite base e spiazzamento: l operando è in una cella di memoria individuata sommando il contenuto di un registro con una costante contenuta nell istruzione 4. Indirizzamento relativo a PC: l indirizzo di salto è ottenuto sommando il contenuto di PC con una costante contenuta nell istruzione 5. Indirizzamento pseudodiretto: l indirizzo di salto è ottenuto concatenando i 26 bit nell istruzione con i 4 bit più significativi di PC