Istruzione in Assembly

(1)

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

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

Architettura degli elaboratori - 32 -

add $13, $4, $3 VS 00001001101001000001100000011000

(2)

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 parametro 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

(3)

Traduzione delle istruzioni

da Assembly a linguaggio macchina

Esempio, l’istruzione 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₂

MIPS Instruction Set Architecture

funct shamt

rt rd rs

op

0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

Istruzioni assembly MIPS per operazioni aritmetiche

Nome completo Esempio Significato Commenti .

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

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

add immediate addi $1,$2,100 $1 = $2 + 100 operandi: registro e costante;

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

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

add imm. unsign.addiu $1,$2,99 $1 = $2 + 99 operandi: registro e costante;

multiply mult $2,$3 Hi | Lo = $2 x $3 prodotto con segno: res in 64 bit multiply unsignedmultu $2,$3 Hi | Lo = $2 x $3 prodotto senza segno: res in 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 in un registro Move from Lo mflo $1 $1 = Lo Copia Lo in un registro

(4)

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, o non si verifica o viene ignorato (non viene generate alcuna eccezione)

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 (“Move From Hi”) mflo rd (“Move From Lo”)

Registers

LO Mult/Div

Unit

HI

(5)

Istruzioni Esempio Significato Commento and and $1,$2,$3 $1 = $2 & $3 AND bit a bit or or $1,$2,$3 $1 = $2 v $3 OR bit a bit xor xor $1,$2,$3 $1 = $2 $3 XOR bit a bit nor nor $1,$2,$3 $1 = ~($2 |$3) NOR bit a bit

and immediate andi $1,$2,10 $1 = $2 & 10 AND tra reg. e costante or immediate ori $1,$2,10 $1 = $2 | 10 OR tra reg. e costante xor immediate xori $1, $2,10 $1 = $2  10 XOR 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 = ?.

(6)

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… sempre sufficiente!)

Il livello ISA

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)

(7)

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

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

(8)

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)

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

(9)

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 rappresenta il n. di istruzioni da saltare (avanti o indietro) Cioè il numero di words da sommare al PC

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

L’assembler calcola per lui l’offset necessario per raggiungerla, e lo riporta nel campo imm16 (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.

Generato dall’assembler (perché offset ha solo 16 bit in CP2).

Sono salti… corti !

Il livello ISA

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

(10)

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

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)

(11)

Confronto con segno e senza

R1= 0…00 0000 0000 0000 00012 = 110

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

R3= 1…11 1111 1111 1111 1111₂= 2³²-1 oppure -1₁₀ Esercizio: dopo l’esecuzione di queste istruzioni:

slt $4,$2,$1 ; slt $5,$3,$1 ; sltu $6,$2,$1 ; sltu $7,$3,$1 ;

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

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 -

(12)

Convenzioni nell'uso dei registri

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

riservati per l'assemblatore ($at) e il sistema operative ($k0-1) NON devono essere usati dai programmatori o dal compilatore 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 -

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 -

(13)

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

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’)

(14)

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)

Pseudo-istruzioni

La pseudo-istruzione

la $t0, etichetta (load address, copia l’indirizzo etichetta in $t0) è implementata calcolando val dall’etichetta e

ori $t0, $0, val (load unsigned immediate) La pseudo-istruzione

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

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 ancora un po’ più ad alto livello del linguaggio macchina

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

(15)

Un programma in assembly

Ricorda che un programma è costitutito da due parti 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

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

(16)

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…

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

(17)

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 -

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 -

(18)

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

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

(19)

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

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

(20)

Altre direttive

.globl pippo

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

Altre direttive sono descritte sul libro

Architetture - 70 -

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 -

(21)

Funzioni di sistema

Architetture - 72 -

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 -

(22)

Riassumendo

L’Assembler semplifica la vita al programmatore, rispetto al linguaggio macchina, perché Traduce numeri da decimale, esadec, o ascii in binario

Traduce codici mnemonici di op (come «add») in opcode binari Riordina i parametri a seconda che il comando sia di tipo R, o I,

permettendoci di fornire i parametri in un ordine consistente (il risultato prima) Rinomina i registri, consentendo di usare nomi più significativi («$t1» invece di «$9») Mette a disposizione alcune utili (Pseudo) Istruzioni ulteriori

(traducendole con una o due Istruzioni MIPS)

Consente di indentare a piacere il codice (aggiungere accapi, spazi, tabulazioni) per renderlo più leggibile

Consente di aggiungere commenti al codice (che semplicemente ignora) Tiene traccia degli indirizzi di dati ed istruzioni,

attraverso il meccanismo delle etichette Calcola gli offset degli indirizzi rispetto al PC etc

Tuttavia, programmare direttamente in Assembly rimane tremendamente difficile Nella realtà si usano sempre linguaggi più ad alto livello!

Complilati e trasformati in Assembly o linguaggio macchina

Il livello ISA