Architettura degli elaboratori

(1)

Università degli Studi dell’Insubria Dipartimento di Scienze Teoriche e Applicate

Architettura degli elaboratori

Il livello Instruction Set Architecture

Marco Tarini

Dipartimento di Scienze Teoriche e Applicate [email protected]

Esecuzione diretta (hardware)

Architettura degli elaboratori

I livelli

Livello 0 Logica digitale Livello 2 Instruction Set

Interpretazione (microprogramma) o esecuzione diretta (hardware)

Livello 5 Linguaggi Applicativi

Traduzione (compilatore)

Livello 3 Sistema operativo

Interpretazione parziale

(sistema operativo)

Livello 4 Linguaggio Assembly

Traduzione (assemblatore)

Livello 1 Architettura

(2)

Livelli di astrazione

Ciascun livello consiste di:

Un’interfaccia

cos’è visibile dall’esterno usata dal livello superiore Un’implementazione

come lavora internamente

usa l’interfaccia del livello inferiore

Il livello ISA

Architettura degli elaboratori - 3 -

Livello 0 Logica digitale

Livello 1 Architettura

Livello 0.5 Blocchi Funzionali

Livelli intermedi:

Livelli di astrazione

Esempio:

livello dei Blocchi Funzionali

Il livello ISA

A B

Y

S

MUX

A

B

S

NAND NAND

NAND

Y Interfaccia Implementazione

(3)

ISA: Instruction Set Architecture

Il livello visto dal programmatore assembly o dal compilatore.

Comprende:

Instruction Set

(quali operazioni possono essere eseguite?) Instruction Format

(come sono fatte le istruzioni?) Data storage

(dove sono posizionati i dati?) Addressing Modes

(come si accede ai dati?) Exceptional Conditions

(come vengono gestiti i casi eccezionali?)

Una corretta comprensione dell’ISA è importante non solo per i progettisti di compilatori e di sistemi operativi, ma anche per i programmatori.

Il livello ISA

Il set di istruzioni: un’interfaccia critica

Il livello ISA

instruction set software

hardware

(4)

Il set di istruzioni: un’interfaccia critica

È un difficile compromesso fra:

massimizzare le prestazioni massimizzare la semplicità di uso minimizzare i costi di produzione minimizzare i tempi di progettazione

Definisce la sintassi e la semantica del linguaggio

Il livello ISA

Criteri di definizione di un IS

Esiste un’infinità di insiemi di istruzioni equivalenti

che permettono di scrivere codice per eseguire… qualsiasi cosa*

La scelta di un insieme delle istruzioni prende in considerazione:

la semplicità della realizzazione cioè dell’HW richiesto

l‘espressività e la semplicità di uso la potenza delle istruzioni la facile programmabilità l'efficienza

velocità di esecuzione cioè: (vel di ogni istruzione)

x (quante se ne rendono necessarie)

* …purché sia computabile, e non richieda troppe risorse.

Vedi corsi di informatica teorica!

Il livello ISA

filosofia RISC:

favorire questo filosofia CISC:

favorire questo

(5)

Criteri di definizione di un IS

Oltre a questi criteri obiettivi, molte altre forze più capricciose

hanno plasmato gli Istruction Sets oggi usati La loro storia

(soprattutto il bisogno di back compatibility) (non tutte le scelte sono logiche a posteriori) Fattori economici / legali

Considerazioni tecniche pertinenti al contesto del loro sviluppo

Il livello ISA

Alcuni Istruction Set popolari oggi

MIPS ARM

X86 X64

Il livello ISA

filosofia RISC

filosofia CISC

per i curiosi: cercare sulla Wikipedia…

(6)

Organizzazione della macchina

L’organizzazione della macchina è la vista del computer del progettista logico. Comprende:

Funzionalità e prestazioni delle unità funzionali (registri, ALU, ecc.) Modalità di connessione delle unità funzionali

Come l’informazione viene comunicata tra i componenti Controllo dei trasferimenti di informazioni

Coordinamento delle unità funzionali per la realizzazione dell’ISA.

Tipicamente l’organizzazione è concepita per supportare un dato set di istruzioni.

Tuttavia, per progettare un buon insieme di istruzioni è importante capire come potrebbe essere implementata l’architettura.

Il livello ISA

Il codice da un livello all’altro

Il livello ISA

lw R15, 0(R2) lw R16, 4(R2) sw R16, 0(R2) sw R15, 4(R2) High Level Language

Program

Assembly Language Program

Machine Language Program

Control Signal Specification

temp = v[k];

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

v[k+1] = temp;

0000 1001 1100 0110 1010 1111 0101 1000 1010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111

ALUOP[0:3] <= InstReg[9:11] & MASK

… compiler

assembler

machine interpretation

(7)

Programmi in Linguaggio macchina (programmi binari)

Un programma (software) scritto in linguaggio macchina (di uno specifico Instruction Set, per uno specifico SO)

Consiste in : DATI

tenuti in un blocco di memoria ISTRUZIONI

tenuti in un altro blocco di memoria

per convenzione, si usano due aree di memoria diverse, dedicate a ciascuna di queste due cose

Le istruzioni sono:

quelle dell’Instruction Set

o invocazioni di funzioni del Sistema Operativo («system calls») (funzioni nel «kernel» di quel SO, per es per aprire un file)

Il livello ISA

Programmi in Linguaggio macchina (programmi binari)

Quindi un Programma Binario è specificoper un Instruction Set e un Sist Op (cioè per una «platform»)

gira solo su una macchina con un architettura che implementa quell’Instruction Set e fornito di quel SO

Alcuni dettagli pratici dei binari più comuni:

Programmi per Win64:

Instruction Set x64, e SO Windows Programmi per Win32:

Instruction Set x86, e SO Windows

ma sono eseguibili anche da architetture x64, perché è back-compatible (seppur con una efficienza leggermente minore,

perché non si sfrutta la maggiore potenza dell’x64). Nota: non viceversa.

Programmi per MacOS:

possono contenere versioni del binario per due Instruction Set: x64 e x86 in modo da essere eseguiti in modo ottimale su entrambe le architetture Programmi per Linux

Il sorgente (in linguaggio ad alto livello) è indipendente dalla piattaforma (è

«cross-platform») perché può invece essere compilato per piattaforme diverse

Il livello ISA

(8)

Eseguire programmi binari

Caricare il programma (DATI + ISTRUZIONI) in memoria Settare il PC alla prima istruzione

(quale sia, è determinato dal programma stesso) Start!

Sarebbe assurdamente difficile scrivere programmi binari direttamente Saliamo di due livelli, e scriviamoli in un linguaggio leggermente più ad alto livello: Assembly

Il livello ISA

Instruction Set MIPS:

piccolo prontuario

(9)

Considerazioni chiave sull’architettura dei computer

Coordinazione tra diversi livelli di astrazione Soggetti a un insieme di forze in rapida evoluzione Progetto, misura e valutazione

Il livello ISA

I/O system Instr. Set Proc.

Compiler

Operating System Application

Digital Design Circuit Design

Instruction Set Architecture Firmware

Datapath & Control

Layout

Software

Hardware

MIPS R3000 Instruction Set Architecture

Categorie di istruzioni:

Computazioni (per la ALU) Integer o Floating Point Logiche or matematiche Load / Store (memoria) Jump / Branch

Speciali

Il livello ISA

R0 - R31

PC HI LO

OP OP OP

rs rt rd sa funct

rs rt immediate

jump target Tre formati di istruzioni: tutti da 32 bit

Registri

tipo R tipo I tipo J

(10)

Architettura MIPS - Registri

32 x 32-bit registri generici

MIPS Instruction Set Architecture

r0r1

°°

°r31

PCLO HI

f0f1

°°

°f31 32 x 32-bit registri floating point

Registri speciali

00000000 00000000 00000000 00000000

sempre 0

32 bit

Modello della memoria di MIPS

I programmi ipotizzano di avere 2³²byte di memoria La memoria è indirizzabile a livello di byte

Parole di 32 bit = 4 byte

Le parole si trovano ad indirizzi multipli di 4

Ricordare sempre: la memoria include sia i dati che le istruzioni

00...0000 00...0100 00...1000

11...1000

32 bit

1 byte

(11)

I campi delle istruzioni MIPS

campo significato

op Codice dell’istruzione (opcode)

rs Quale registro che fa da primo operando

rt Quale registro fa da secondo operando (R-type) o da risultato (I-type) rd Quale registro fa da risultato (c’e’ solo nelle R-type)

shamt Shift amount: di quanto shiftare il risultato (in alcune op) funct Function code – variante dell’istruzione

imm Immediate value (16 bit): il valore del secondo operando

Tutte le istruzioni MIPS hanno lunghezza fissa (32 bit)

6 bits 5 bits

5 bits 5 bits

5 bits 6 bits

R-type

I-type

_op _rs _rt

op rs rt rd shamt funct

J-type

_op

imm address

Modi di indirizzamento MIPS / Formato delle istruzioni

Gli operandi sono tutti registri come in add $s1, $s2, $s3

Modalità di indirizzamento Register (direct) Op e funct indicano l’operazione da eseguire Shamt indica l’entità dello shift del risultato

R-type

op rs rt rd shamt funct

(12)

Modi di indirizzamento MIPS / Formato delle istruzioni

Se Op indica una operazione matematica / logica

Gli operandi dell’operazione sono il registro rs e il valore immediato Il risultato viene memorizzato nel registro rt

Il valore immediato (16 bit) viene esteso a 32 bit

con modalità diverse a seconda dell’op, come sappiamo.

Se Op indica un salto condizionato (un «branch»):

I due registri rs e rt sono usati per decidere SE saltare (con criterio dipende da Op, es «se sono uguali fra loro») Se si salta, a PC viene sommato Imm (esteso in segno) x4 (quindi si salta di max 32K istruzioni in avanti o in indietro)

I-type

op rs rt imm

Modi di indirizzamento MIPS / Formato delle istruzioni

Istruzioni di salto incondizionato (si salta sempre) Address (26 bit) indica dove saltare:

Vecchio PC:

Nuovo PC:

J-type

_op _address

X….X

XXXX 00

address

XXXX 00

primi 4 bit inalterati

(13)

MIPS: parole

(la struttura fondamentale!)

una parola (32 bit, 4 bytes, 1 word) può essere contenuta : in uno qualsiasi dei registri

in 4 byte consecutivi di memoria centrale

(spesso, allineati: il loro indirizzo base 2 termina con 00, 01, 10, 11) (in che ordine sono? Vedi endianness!)

e può rappresentare : un dato

(in virgola mobile, o in CP2, o naturale) una istruzione(MIPS!)

un indirizzodi memoria (fra i dato, o fra le istruzioni)

Il livello ISA

NB: Una parola (in mem o un reg) non «sa» cosa rappresenta.

È il programmatore che lo deve sapere e la deve usare di conseguenza.

MIPS: mezze parole (assai meno usate)

Una mezza parola (half-word: 16 bit, 2 bytes) può essere contenuta In 2 byte consecutivi di memoria

(tipicamente …00e …01, cioè allineatamente) Nella seconda metà di un’istruzione

(di tipo I: è il suo campo imm16) In un registro

(la parola sta tutta nella seconda metà del registro.

Nella prima metà, si estende: tutti 0

o, nel caso di CP2: se numero negativo, tutti 1, se pos tutti 0) E può rappresentare

Un dato a 16 bit (CP2 o binario senza segno)

Il livello ISA

(14)

MIPS: i bytes

Un byte(8 bit) può essere contenuto In una sola casella di memoria

(indicizzata da 32 bit qualsiasi – «indirizzamento al byte») In un registro

(nei sui ultimi 8 bit. Nei primi 24, ci saranno tutti 0 o, nel caso di CP2 di un numero negativo, tutti 1) E può rappresentare

Un dato a 8 bit

(CP2: da -128 a +127; o binario: 0..255) Un carattere, per es di una stringa (attraverso tabella ASCII)

Etc (es il canale «rosso» di un pixel) Quindi un word può essere anche interpretato come 4 lettere consecutive in una stringa

Una stringa: una sequenza di bytes (spesso, terminata dal byte 0x00)

Il livello ISA

Di nuovo:

l’interpretazione di un dato non sta da nessuna parte se non nella mente del programmatore Assembly umano o del compilatore

MIPS si basa sulle words

Scrivere su un registro attraverso computazioni:

Si scrivono tutti i 32 bits del registro (sovrascrivendo tutti i bit precedenti) Tutte le operazioni (logiche o matematiche)

sono sempre fra parole di 32 bit, con risultato a 32 bits (non ci sono op che scrivono solo su una parte di un registro) (ci sono op che scrivono due registri insieme: HI e LO) Scrivere su un registro attraverso letture da memoria:

Si scrivono tutti i 32 bits del registro (sovrascrivendo tutti i bit precedenti) Se si è letto meno di una parola (un half-word o un byte),

il dato letto viene esteso (con 0 o talvolta 1, come visto)

Scrivere su memoria

Si possono scrivere 4 byte, oppure anche solo 2 oppure 1 L’indirizzo si riferisce al primo byte scritto.

Se 4 (o 2), di solito allineati : questo indirizzo per 00 (o per 0) (in molte implementazini HW è molto più efficiente se lo sono)

Il livello ISA

(15)

Registro 0: valore 0

il registro 0 contiene sempre il valore 0 000….0 :

significa 0 sia intepretato in CP2, sia interpetato come binario, sia interpretato in virgola mobile

anche se tentiamo di scrivere sul registro 0, il suo valore non cambia

Il livello ISA

Riassumendo: caratteristiche dell’ISA MIPS

Dimensione fissa a 32 bit (3 formati)

31 registri da 32 bit (R0 contiene zero) e 32 registri FP (e HI LO) Istruzioni aritmetiche a tre indirizzi (registri)

Unica modalità d’indirizzamento per: base+spiazzamento Istruzioni di salto condizionato semplici

Confronto di un registro con zero, confronto di uguaglianza e disuguaglianza tra due registri

(16)

Architetture degli elaboratori:

Assembly (del MIPS):

piccolo prontuario

Marco Tarini

Dipartimento di Scienze Teoriche e Applicate [email protected]

Linguaggio Assembly

Linguaggio molto aderente ad un Instruction Set, Specifico per un Instruction Set

Rapporto (quasi) 1:1 fra comandi Assembly e istruzioni binarie Pensato per essere più facile da leggere o scrivere

per noi esseri umani, rispetto al linguaggio macchina:

Assembler:

programma che effettua la traduzione.

Fa per noi molti lavoretti che sarebbero tediosi ma banali, come:

tradurre le operazioni in OP codes (di sei bit)

tradurre in base 2 (o in CP2) gli indici dei registri e gli immediate calcolare gli offset delle destinazioni dei salti

tenere traccia degli indirizzi a cui sono merizzati dati ed istruzioni altro, come vedremo

Il livello ISA

add $13, $4, $3 VS 000010010001101000110000011000

(17)

Istruzione in Assembly

In Assembly, l’ordine degli operandi è comodamente fisso:

a differenza del MIPS binario, in cui varia fra le istruzioni R e I il PRIMO paramtero rappresenta sempre il risultato

il registro che viene scritto (se l’op prevede di scrivere un reg)

$13 in questo esempio

Seguono gli operandi (che siano registri o immediate)

Il livello ISA

add $13, $4, $3

codice mnemonico dell’istruzione (corrisponde al campo OP e FUNCT)

Registri su cui si opera (corrispondono ai campi Rt, Rs e Rd)

le virgole sono opzionali

addi $13, $4, 162

«i» sta per immediate

L’immediato (il campo imm16)

Commenti e indentazione

In Assembly, spazi, tab e accapo vengono ignorati (posso indentare il programma come voglio)

Per rendere il codice più comprensibile in Assembly posso aggiungere dei commenti

Verranno semplicemente ignorati dal compilatore

Sintassi: i commenti vanno dal carattere # alla fine della linea

(sono questi due semplici ma cruciali elementi che rendono l’Assembly molto più comprensibile del linguaggio macchina)

Il livello ISA

# commento

add $13, $4, $3 # questo fa $13 <- $4 + $3

(18)

Traduzione delle istruzioni

da Assembly a linguaggio macchina

Esempio, l’istruzione MIPS add $8, $17, $18è tradotta così:

add op = 0 = 000000₂ shamt = 0 = 000000₂ funct = 32 = 100000₂

$8 rd = 8 = 01000₂

$17 rs = 17 = 10001₂

$18 rt = 18 = 10010₂

00000 100000 funct shamt

01000 rd 10010

rt 10001

rs 000000

op

Istruzioni assembly MIPS per operazioni aritmetiche

Nome completo Esempio Significato Commenti .

add add $1,$2,$3 $1 = $2 + $3 3 operandi;

subtract sub $1,$2,$3 $1 = $2 – $3 3 operandi;

add immediate addi $1,$2,100 $1 = $2 + 100 + costante;

add unsigned addu $1,$2,$3 $1 = $2 + $3 3 operandi;

subtract unsignedsubu $1,$2,$3 $1 = $2 – $3 3 operandi;

add imm. unsign.addiu $1,$2,100 $1 = $2 + 100 + costante;

multiply mult $2,$3 Hi, Lo = $2 x $3 prodotto con segno da 64-bit multiply unsignedmultu $2,$3 Hi, Lo = $2 x $3 prodotto senza segno da 64-bit divide div $2,$3 Lo = $2 ÷ $3, Lo = quoziente, Hi = resto

Hi = $2 mod $3

divide unsigned divu $2,$3 Lo = $2 ÷ $3, Quoziente e resto senza segno Hi = $2 mod $3

Move from Hi mfhi $1 $1 = Hi Copia Hi

Move from Lo mflo $1 $1 = Lo Copia Lo

(19)

Operazioni aritmetiche «con la U»

La «u» nei comandi artimetici (come addu) sta per «unsigned», ma il nome è fuorviante (ricorda:

la somma di numeri in CP2, e la somma in binario senza segno sono la stessa operazione, cambia solo la gestione dell’overflow) La vera differenza:

il comando senza la «u» può generare eccezione di overflow il comando con la «u» semplicemente ignora l’overflow

In conclusione, si può verificare overflow solo in alcune istruzioni aritmetiche:

add, sub, addi

nelle altre op matematiche, non si verifica o viene ignorato.

nelle op logiche, non si verifica mai

Il livello ISA

Moltiplicazione / divisione

Moltiplicazione / divisione:

(mult e div)

scrivono su una coppia di registri speciali:

Hi e Lo

(non fanno parte dei 32 registri) Ricorda: moltiplicando due numeri da n bit ottengo un numero da 2n bit.

Il valore di Hi e Lo si travasa in normali registri con:

mfhi rd mflo rd

Registers

LO Mult/Div

Unit

HI

(20)

Istruzioni Esempio Significato Commento

and and $1,$2,$3 $1 = $2 & $3 3 operandi 3 reg.; AND logico or or $1,$2,$3 $1 = $2 | $3 3 operandi 3 reg.; OR logico xor xor $1,$2,$3 $1 = $2 $3 3 operandi 3 reg.; XOR logico nor nor $1,$2,$3 $1 = ~($2 |$3) 3 operandi 3 reg.; NOR logico and immediate andi $1,$2,10 $1 = $2 & 10 AND logico tra reg. e costante or immediate ori $1,$2,10 $1 = $2 | 10 OR logico tra reg. e costante xor immediate xori $1, $2,10 $1 = $2  10 XOR logico tra reg. e costante shift left logical sll $1,$2,10 $1 = $2 << 10 Shift a sinistra di una costante shift right logical srl $1,$2,10 $1 = $2 >> 10 Shift a destra di una costante shift right arithm. sra $1,$2,10 $1 = $2 >> 10 Shift a destra (con est. in segno) shift left logical sllv $1,$2,$3 $1 = $2 << $3 Shift a sinistra di una variabile shift right logical srlv $1,$2,$3 $1 = $2 >> $3 Shift a destra di una variabile shift right arithm. srav $1,$2,$3 $1 = $2 >> $3 Shift a destra di una variabile

(con est. in segno)

Istruzioni assembly MIPS per operazioni logiche

Istruzioni assembly MIPS

per operazioni aritmetiche e logiche

Il risultato dell’op viene sempre memorizzato nel primo registro indicato Eccezione: mult e div, che scrivono invece due apposite registri speciali HI e LOW

I due operandi dell’op sono:

nelle versioni non immediate

(e negli shift con variabile): i due registri indicati nelle versioni immediate:

(e negli shift senza variabile): un registro dato e un valore dato Il valore nelle istruzioni con immediate:

E’ memorizzato nel campo imm16 di una istruzione I (di16 bit!) E’ in CP2 nelle op aritmetiche (e quindi viene esteso in segno).

Val max = ?. Val min = ?.

Senza segno nelle op logiche (ed quindi viene esteso con 0) Val max = ?. Val min = ?.

(21)

Istruzioni assembly MIPS per operazioni logiche

Le op logiche lavorano bit a bit

Lo shift a sinistra fa apparire 0 da destra Corrisponde a dividere per 2^n Due versioni dello shift a destra:

Far apparire 0 a sinistra (vers logica)

Far apparire a sinistra il bit più significativo (vers aritmetica) Corrisponde a moltiplicare per 2^n

(nella versione aritmetica: questo vale per i numeri in CP2)

Lo shift di una costante, il valore di cui si shifta è memorizzato, in linguaggio macchina, nell’apposito campo da 5 bit delle istruzioni R

(quindi vale da 0 a 31… ma i più non serve mai!)

Il livello ISA

Estensione in segno / con zero (ripasso)

L’estensione in segno è utilizzata per gli immediati con segno (ad es. in addi) e i valori con segno dalla memoria (lb).

Per estendere in segno un numero di n bit a n+m bit, bisogna copiare il bit di segno (il MSB) m volte.

Per esempio, con n = 4 e m = 4:

1011 = -4 0101 = 5

11111011 = -4 00000101 = 5

L’estensione con zeri è usata per le operazioni logiche (ad es. ori), e valori senza segno da memoria (lbu)

Per estendere con zeri un numero da n bit a n+m bit, basta inserire m zeri.

Per esempio, con n = 4 e m = 4:

1101 = 13 0101 = 5

00001101 = 13 00000101 = 5

(22)

Istruzioni assembly MIPS

per trasferire registri da/a la memoria

Istruzione Commento

sw $3, 500($4) Storeword sh $3, 502($2) Storehalf sb $2, 41($3) Storebyte

lw $1, 30($2) Loadword lh $1, 40($3) Loadhalfword

lhu $1, 40($3) Loadhalfword unsigned lb $1, 40($3) Loadbyte

lbu $1, 40($3) Loadbyte unsigned lui $1, 40($3) LoadUpper Immediate

(16 bits shifted left by 16)

da registro a mem (store)

da mem a registro (load)

Istruzioni assembly MIPS

per trasferire registri da/a la memoria

L’indirizzo a cui si legge o scrive

è quello contenuto nel registro indicato fra parentesi,

incrementato del valore eventualmente indicato prima della parentesi esempi:

($16)

usare l’inidirizzo contenuto nel registro 16 500($4)

usare l’indirizzo contenuto nel registro 4,

incrementato di 500 byte (cioè di 500/4 = 125 word) -4($16)

usare l’inidirizzo contenuto nel registro 16, decrementato di 4

Il livello ISA

(23)

Istruzioni assembly MIPS

per trasferire registri da/a la memoria

Store:

si leggono 1, 2 o 4 byte dal registro indicato nel 1mo parametro (4 se word. 2 se half. 1 se byte. Se 1 o 2: i meno significativi) li si scrivono in 1, 2, o 4 byte consecutivi in memoria

Load:

caso word: si leggono 4 byte dalla memoria

caso short/byte unsigned: si leggono 2/1 byte e si estendono con 0 caso short/byte: si leggono 2/1 byte e si estendono in segno caso lui: si leggono 2 byte e si shiftano a sinistra di 16 bit

in tutti i casi: si scrivono tutti i 4 byte risultanti nel registro indicato

Il livello ISA

Istruzioni assembly MIPS per branch (salti condizionali)

Con confronto fra due registri

beq rs, rt, dest equal, if R[rs] == R[rt] then jump to dest bne rs, rt, dest not equal,

Con confronto fra un registro e zero

blez rs, dest less-or-equal zero, if R[rs] <= 0 then jump bgtz rs, dest greater-then zero >

bgez rs, dest greater-or-equal zero >=

bgezalrs, dest come sopra «…and link» (vedi poi) bltz rs, dest less-than zero <

bltzalrs, dest come sopra «…and link» (vedi poi)

(24)

Istruzioni assembly MIPS per branch (salti condizionali)

L’instruction set MIPS mette a disposizioni molte varianti di branch (b-), diverse per:

l’operatore del paragone che determina se saltare oppure no:

minore uguale (-le-), maggiore (-gt-), etc se il paragone avviene fra due registri, oppure fra un registro e lo zero (-z-)

«and link» (-al) : se, in caso di salto, deve essere memorizzato l’indirizzo dell’istruzione che ha causato il salto,

(in modo da poterci tornare con un’apposita istruzione di ritorno) (utile quando il salto serve per eseguire una subroutines, vedi poi).

…ma non tutte le varianti possibili sono previste! (es: R1>R2 non lo è) Per implementare le varianti non previste, saranno

necessarie due o più istruzioni:

Prima: calcolo della condizione (es: R3 = R1-R2) Poi: salto condizionale (es: R3 > 0 )

(tipico esempio della filosofia RISC in azione!)

Il livello ISA

Istruzioni assembly MIPS per branch (salti condizionali)

L’istruzione MIPS binaria come sappiamo memorizza la destinazione del salto come un offset rispetto al PC corrente (salto «relativo»)

L’offset è memorizzato nel campo imm16 di una istruzione di tipo I L’offset è un numero di 16 bit in CP2

L’offset rappesenta il num. di istruzioni da saltare (avanti o indietro) Cioè il num di words di cui spostare il CP2

Cioè il PC+4 va incrementato di Offset x 4 bytes (ext in segno) Il programmatore indica direttamente la destinazione del salto

L’assembler calcola per noi l’offset necessario per raggiungerla, e lo scrive nel campo imm16 del comando in binario (comodo  !) La destinazione può seguire oppure precedere l’istruzione del salto (perché offset ha il segno)

Ma non può essere più lontana di 2^15 istruzioni! Altrimenti errore.

(perché offset ha solo 16 bit in CP2).

Sono salti… corti !

Il livello ISA

(25)

Istruzioni assembly MIPS

per Jump (salti non condizionali)

Istruzione Esempi Significato

jump j 10000 vai all’ istruzione 10000

jump and link jal 10000 vai all’ istruzione 10000… and link jump register jr $31 vai all’istruzione contenuta

nel registro $31

Istruzioni assembly MIPS

per Jump (salti non condizionali)

Jumpsalta ad un indirizzo dato.

L’istruzione MIPS binaria corrispondente, di tipo J , memorizza la destinazione nel suo campo address

E’ un campo di ben 26 bits (il tipo J esiste apposta per questo) Due zeri finali sono sottointesi (è l’indice di un word) = 28 bits Il PC mantiene i primi 4 bits inalterati, e i suoi 28 bits meno significativi vengono sostituiti: salto (quasi) «assoluto»

Quindi: l’istruzione può saltare anche molto lontano. Salto lungo!

L’unico vincolo è che non si può uscire dal blocco di 2^26 istruzioni Tipicamente, il programmatore determina la destinazione attraverso un’etichetta (vedi poi); address viene calcolato dall’assembler.

Jump addresssalta ad un indirizzo memorizzato in un registro dato PC viene sostituito del tutto dai 32 bit del registro: salto «assoluto»

Si può saltare… assoltamente ovunque nel codice. No limits.

Salti… lunghissimi! (ma bisogna approntare un registro)

Il livello ISA

(26)

Istruzioni assembly MIPS per assegnamenti condizionali

Istruzioni Esempi Significato

set on less than slt $1,$2,$3 if ($2 < $3) $1=1; else $1=0

< (complemento a 2)

set on less than slti $1,$2,100 if ($2 < 100) $1=1; else $1=0

immediate <costante (complemento a 2)

set on less than sltu $1,$2,$3 if ($2 < $3) $1=1; else $1=0

unsigned < (numeri senza segno)

set less then sltiu $1,$2,100 if ($2 < 100) $1=1; else $1=0 immediate unsigned <costante (numeri senza segno)

Confronto con segno e senza

R1= 0…00 0000 0000 0000 0001₂ = 110

R2= 0…00 0000 0000 0000 0010₂= 2₁₀

R3= 1…11 1111 1111 1111 11112 = 2³²-1 or -110

Dopo l’esecuzione di queste istruzioni:

slt r4,r2,r1 ; if (r2 < r1) r4=1; else r4=0 slt r5,r3,r1 ; if (r3 < r1) r5=1; else r5=0 sltu r6,r2,r1 ; if (r2 < r1) r6=1; else r6=0 sltu r7,r3,r1 ; if (r3 < r1) r7=1; else r7=0 Quali valori si trovano nei registri r4 - r7?

r4 = 0; R2==2 non è minore di R1==1 r5 = 1; R3==-1 è minore di R1==1 r6 = 0; R2==2 non è minore di R1==1 r7 = 0 ; R3== 2³²-1 non è minore di R1==1

(27)

Convenzioni nell'uso dei registri

Per compilare una data procedura, il compilatore (o il programmatore umano)

deve sapere quali registri può usare e quali sono in uso da parte di altre procedure.

Da qui la necessità di regole e convenzioni per l'uso dei registri Non implementate in HW

Compilatori e programmatori le devono seguire, pena bugs insidiosi, anche molto difficili da trovare.

Programmazione ASM MIPS

Architetture - 53 -

Convenzioni nell'uso dei registri

I registri $at (1), $k0 (26), e $k1 (27)

riservati per l'assemblatore e il sistema operativo.

NON devono essere usati dai programmatori o dall'assembler I registri $a0–$a3 (4–7)

usati per passare i primi 4 argomenti alle routine.

(ulteriori eventuali argomenti sono passati sulla pila (molto più lenta!) I registri $v0 e $v1 (2,3)

usati dalle funzioni per restituire valori al chiamante.

I registri $t0–$t9 (8–15, 24, 25)

usati per memorizzare valori temporanei,

quelli che non è necessario preservare tra una chiamata e l'altra.

ogni procedura li può usare senza preoccuparsi di “sporcarli”

I registri $s0–$s7 (16–23)

usati per valori che devono essere preservati tra una chiamata e l'altra. Il loro significato non è locale alla chiamata corrente.

Architetture - 54 -

(28)

Convenzioni nell'uso dei registri

Il registro $gp (28)

è un puntatore globale che punta ad un blocco di memoria da 64K nel segmento dei dati statici.

Il registro $sp (29) è lo stack pointer,

che indirizza l'ultima posizione dello stack (vedremo) Il registro $fp (30) è il frame pointer (vedremo).

Il registro $ra (31) contiene

l'indirizzo di rientro dalla chiamata di procedura (vedremo).

Architetture - 55 -

Scrittura di comandi in assembly:

gli operandi che sono registri

L’Assembly ci consente di riferirci ai 32 registri

anche attraverso dei sinonimi che riflettono il loro uso convenzionale

Architetture - 56 -

Registro: $0 $1 $2 $3 $4 $5 $6 $7

Sinonimo: $r0 $at $v0 $v1 $a0 $a1 $a2 $a3 Registro: $8 $9 $10 $11 $12 $13 $14 $15 Sinonimo: $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 Registro: $16 $17 $18 $19 $20 $21 $22 $23 Sinonimo: $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 Registro: $24 $25 $26 $27 $28 $29 $30 $31 Sinonimo: $t8 $t9 $k0 $k1 $gp $sp $s8 $ra

add $s3, $t3, $t4 equivalente a add $19, $11, $12

(29)

Scrittura di comandi in assembly:

gli operandi che sono immediate

Il campo immediate può essere scritto:

In base 10

In base 16, precedendo le cifre con 0x Come carattere ascii, fra apicetti singoli

Il livello ISA

addi $3, $3, 97 addi $3, $3, 0x61 addi $3, $3, ‘a‘

Sinonimi

(il terzo registro viene incrementato

di 97, il cui codice ASCII è ‘a’)

Pseudo-istruzioni

L’assembler MIPS supporta diverse pseudo-istruzioni:

Non corrispondono ad istruzioni nell’Instruction Set (l’archiettura HW non le conosce!)

Sono implementate mediante una o più istruzioni dell’IS Semplificano la programmazione in linguaggio assembly La pseudo-istruzione

move $t0, $t1 (copia $t1 in $t0) è implementata come

add $t0, $zero, $t1 La pseudo-istruzione

blt $s0, $s1, addr (branch less then – salta se $s0<$s1) è implementata come due istruzioni:

slt $at, $s0, $s1 bne $at, $zero, addr

(nota: uso del registo riservato all’assembler)

(30)

Pseudo-istruzioni

La pseudo-istruzione

la $t0, addr (load address, copia l’indirizzo addr in $t0) è implementata come

lui $t0, addr (load unsigned immediate) La pseudo-istruzione

li $t0, val (load immediate, copia il valore val in $t0) è implementata come due istruzioni:

ori $t0, $0, val (or bit a bit fra val e il registro $0 cioè il valore 0)

Le pseudo-istruzioni rendono il linguaggio Assembly ulteriormente più ad alto livello del linguaggio macchina

(Rimane un linguaggio a bassissimo livello, rispetto a, per es, C o, ancora molto di più, Java)

Un programma in assembly

Ricorda che un programma è costitutito da Dati,

(in assembly: parte “data”)

Istruzioni (il codice che lavora sui dati), (in assembly: parte “text”)

memorizzate in due apposite aree della memoria

(localizzate secondo alcune convenzioni che non ci interessano)

Un programma Assembly non è altro che un file di testo che descrive il contenuto della memoria (in ciascuna delle due aree)

Consiste quindi in due sequenza di parole consecutive (e/o mezze parole, e/o bytes) espresse in ASCII

Il livello ISA

(31)

Un programma in assembly

Es un programma potrebbe essere:

Questo programma

(che non ha senso alcuno!) prescrive 2 words nella parte data e altre 2 words nella parte text

Le parole (32 bits!) possono essere espresse in molti modi equivalenti:

in decimale, es: 20

in esadecimale, es: 0x14

con un carattere ascii, es: ‘a’

con un comando assembly, es: add $t3, $s1, $s3

Il livello ISA

.data

.word 20, 10

.text

.word 30, 1234

.word 0x14 .word 20

.word 'a'

add $t3, $s1, $s3

utile per la parte data

utile per la parte text

Direttive

Comandi Assembly

che spiegano all’Assembler come tradurre un programma Non producono istruzioni macchina!

Sintassi: cominciano sempre con un punto Il programma precedente usa due direttive:

.data

«Memorizza gli elementi successivi nel segmento dati»

.text

«Memorizza gli elementi successivi nel segmento testo»

Tipica struttura sorgente:

Architetture - 62 -

.data

…dati…

.text

…comandi…

(32)

Direttive: dati

Alcune direttive spiega il formato in cui tentere, in memoria, i dati successivi:

.word

«Memorizza i valori successivi in 4 bytes»

.half

«Memorizza i valori successivi come half-word: cioè in coppie di byte»

.byte

«Memorizza i valori successivi in un byte ciascuno»

Architetture - 63 -

.data .half 20, 2, 100 .byte 4, 'c' .word 0x40, 300

Nel segmento

data sono memorizzati in tutto… 16 bytes

Direttive: dati

Un scorciatoia speciale per dati consente di definire con facilità le stringe (intese come sequenze di caratteri, ciascuno reppresentato da un byte) .ascii "anna"

Equivalente a: .byte 'a', 'n', 'n', 'a‘

Memorizza (in questo esempio): 4 bytes.

.asciiz"anna"

Un byte per carattere, seguiti da un ulteriore byte terminatorezero.

Equivalente a: .byte 'a', 'n', 'n', 'a', 0 Equivalente a: .ascii "anna".byte 0

Oppure a (in questo esempio): 5 bytes.

Nota l’uso del doppio apice.

La convenzione di terminare le strighe col byte 0 è comune a molti linguaggi di programmazione ad alto livello (C, Java, C++…),

e dalle procedure di sistema (es quella che scrive stringhe su un monitor).

Dette «null terminated strings»

Architetture - 64 -

(33)

Direttive: dati

.space n

Lascia uno spazio di nBytes nel segmento dati.

Utile per riservare dei bytes nel segmento data dove memorizzare i dati prodotti dalle istruzioni .align n

Lascia alcuni byte di spazio in modo che il dato successivo sia scritto in un indirizzo divisible per 2ⁿ

Utile per allineare i dati, ad esempio align 2 fa in modo che il word successive sia scritto ad un indirizzo che termina con 00,

anche se i dati scritti in precedenza hanno occupato un numero dispari di bytes.

Architetture - 65 -

Etichette (label)

Le etichette sono un’altra parte del programma Assembly che l’Assembler non traduce in alcuna istruzione macchina E’ un identificaore qualsiasi, scelto dal programmatore, introdotto come un nome seguito da un due-punti.

Es:

Un’etichetta è un meccanismo che consente al programmatore assembly di riferirsi all’indirizzo a cui è stato memorizzato un dato o un’istruzione

sarebbe complicato per il programmatore ricostruire questo indirizzo, ma è banale per l’assemnler.

Il livello ISA

pippo: .word 19

(34)

Etichette (label): funzionamento

Quando un’etichetta viene definita (cioè coniata, inventata, introdotta nel programma), l’assembler tiene traccia dell’indirizzo in cui sta per scrivere il prossimo dato o istruzione

Nella definizione, l’etichetta appare seguita da due-punti ll programmatore può riferire (usare) un’etichetta (definita altrove) usandola al posto di un operando in un comando.

L’assembler sostituisce l’etichetta con l’indirizzo corrispondente.

Nel riferimento, l’etichetta appare senza il due-punti

Un’etichetta può essere definita in un programma una sola volta, e essere riferita molte volte

la definizione dell’etichetta può precedere oppure seguire il suo riferimento

(questo comporta che l’assembler dovrà faticare un po’, e leggere il programma due volte)

Il livello ISA

Etichette (label): usi tipici

Le etichette definite nella sezione data saranno riferite da comandi tipo load / store come indirizzo a cui leggere /scrivere quei dati

Le etichette definite nella sezione text saranno

riferite da comandi tipo jump / branch come indirizzo a cui saltare

Il livello ISA

.data

popolaz: .word 40000 # definisco l’etichetta .text

la $t1, popolaz # carica l’address popolaz in t1 lw $t2, 0($t1) # carica 40000 in $t1

.text

ite: sub $t2, $t2 , 1 # t2 = t2 - 1

bgtz $t2, ite # if (t2 > 0) goto ite

(35)

Label e direttive per definire dati

Tipico uso:

Es:

«nel primo indirizzo libero, al quale io mi riferirò in futuro chiamandolo con “pippo” (l’etichetta), piazza il valore 19 come un word (4 byte)»

Somiglia molto al commando Java:

int pippo = 19;

Anche valori multipli

Architetture - 69 -

label: .tipo valore

pippo: .word 19

label: .tipo val0, val1, … pippo: .word 19 , 12 , 13

Altre direttive

.globl pippo

L’etichettapippodetermina quale sia il PC iniziale (“l’esecuzione parte da lì”)

Altre direttive sono descritte sul libro

Architetture - 70 -

(36)

System call

MIPS offre semplici servizi mediante chiamate di sistema (system call) predefinite

Ogni chiamata è costituita da Codice dell’operazione Argomenti (opzionali) Valori di ritorno (opzionali)

Architetture - 71 -

Funzioni di sistema

Architetture - 72 -

(37)

Come fare una system call

1) Inserire il codice nel registro $v0

2) Inserire gli argomenti nei registri $a0-$a3 ($f12-$f15) 3) Eseguire l’istruzione syscall

4) Il valore di ritorno è nel registro $v0 ($f0)

Architetture - 73 -

Riassumendo

Il livello ISA