1 Esercizio
Un numero relativo è rappresentato in virgola mobile secondo lo standard IEEE 754
su 32 bit nel seguente modo:
s=1
e = 10000111
m = 11011000000000000000000
Ricavare il corrispondente valore decimale.
Soluzione
Dato che:
e = 100001112 = 13510
Si ha:
N = (−1)s ・ 2(e−127) ・ 1.m
= −1 ・ 2135−127 ・ 1.11011
= −1 ・ 28 ・ 1.11011
= −1110110002
= −(28 + 27 + 26 + 24 + 23)10
= −47210
2 Esercizio
Convertire i seguenti numeri decimali in virgola mobile in singola precisione secondo
lo standard IEEE 754:
1. −23.37510
2. −127.2510
3. +131.510
4. −300.2510
5. −3.610
Procedendo in base alla definizione dello standard e indicando con
• N10 in numero originale in base dieci
• s il segno del numero
• e l’esponente del numero
• er l’esponente rappresentato in floating point
• m la mantissa della rappresentazione
• NFP il numero nella rappresentazione in floating point
si ha:
1.
4
N10 = -23.37510 = -10111.0112 = -1.01110112 ・ 2
s=−=1
e=4
er = 4 + 127 = 13110 = 100000112
m = 1.0111011 = 0111011 (con hidden bit)
NFP = 1| 10000011 | 0111011000 . . . = C1BB000016
2.
6
N10 = -127.2510 = -1111111.012 = -1.111111012 ・ 2
s=−=1
e=6
er = 127 + 6 = 13310 = 100001012
m = 1.11111101 = 11111101 (con hidden bit)
NFP = 1| 10000101 | 111111010000 . . . = C2FE800016
3.
7
N10 = 131.510 = 10000011.12 = 1.000001112 ・ 2
s = + =0
e=7
er = 127 + 7 = 134 = 100001102
m = 1.00000111 = 00000111 (con hidden bit)
NFP = 0| 10000110 | 00000111000 . . . = 4303800016
4.
8
N10 = -300.2510 = -100101100.012 = -1.00101100012 ・ 2
s=− =1
e=8
er = 127 + 8 = 135 = 100001112
m = 1.0010110001 = 0010110001 (con hidden bit)
NFP = 1| 10000111 | 00101100010 . . . = C396200016
5. In questo caso il numero decimale possiede infinite cifre nella rappresentazione
binaria. La conversione in binario pu`o essere interrotta una volta ottenute 24
cifre totali (comprensive di parte intera e parte frazionaria, considerando il bit
nascosto) oppure una volta ottenuta la precisione desiderata.
N10 = 3.610 = 11.1001 . . .2 = 1.11001 . . .2 ・ 21
s=−=1
e=1
er = 127 + 1 = 128 = 100000002
m = 1.11001 . . . = 11001 . . . (con hidden bit)
NFP = 1| 10000000 | 11001100110011001100110 = C066666616
3 Esercizio
Siano dati i seguenti numeri binari in virgola mobile in singola precisione secondo
lo standard IEEE 754, espressi in base sedici:
1. BE90000016
2. 438AA00016
3. C301A00016
4. C1FA800016
Calcolare il corrispondente valore decimale.
1.
NFP = BE90000016 = 1 | 01111101 | 001000000000000000000002
m = 0010. . . (con hidden bit) =1.001
er = 011111012 = 12510
e = 125 − 127 = −2
s = 1=−
N10 = −1.001 ・ 2−2 = −0.01001
= −(1 ・ 2−2 + 1 ・ 2−5) = −0.2812510
2.
NFP = 438AA00016 = 0 | 10000111 | 000101010100000000000002
m = 00010101010. . . (con hidden bit) =1.0001010101
er = 10000111 = 13510
e = 135 − 127 = 8
s = 0=+
N10 = +1.0001010101 ・ 28 = +100010101.01
= +(256 + 16 + 4 + 1 + 0.25) = +277.2510
3.
NFP = C301A00016 = 1 | 10000110 | 000000110100000000000002
m = 0000001101. . . (con hidden bit) =1.0000001101
er = 10000110 = 13410
e = 134 − 127 = 7
s = 1=−
N10 = −1.0000001101 ・ 27 = −10000001.101
= −(128 + 1 + 0.5 + 0.125) = −129.62510
4.
NFP = C1FA800016 = 1 | 10000011 | 111101010000000000000002
m = 111101010. . . (con hidden bit) =1.11110101
er = 10000011 = 13110
e = 131 − 127 = 4
s = 1=−
N10 = −1.11110101 ・ 24 = −11111.0101
= -(16 + 8 + 4 + 2 + 1 + 0.25 + 0.0625)
= -31.312510
Siano date le seguenti coppie (a, b) di numeri interi con segno espressi nella rappresentazione decimale: (78, 26);
(–20, 14); (–12, –24); (78, –82). Calcolare il risultato delle operazioni (a + b) e (a – b) in aritmetica binaria tra
numeri interi con segno rappresentati in complemento a due su 8 bit. Indicare la presenza di un
eventuale overflow.
Soluzione:
a = (78)10 b = (26)10
R
a
b
a+b
00011110
0 1 0 0 1 1 1 0 + (78)10 +
0 0 0 1 1 0 1 0 (26)10
0 1 1 0 1 0 0 0 (104)10
R
a
b
a–b
11001110
0 1 0 0 1 1 1 0 + (78)10 +
1 1 1 0 0 1 1 0 (–26)10
0 0 1 1 0 1 0 0 (52)10
a = (-20)10 b = (14)10
R
a
b
a+b
00001100
1 1 1 0 1 1 0 0 + (–20)10 +
0 0 0 0 1 1 1 0 (14)10
1 1 1 1 1 0 1 0 (–6)10
R
a
b
a–b
11100000
1 1 1 0 1 1 0 0 + (–20)10 +
1 1 1 1 0 0 1 0 (–14)10
1 1 0 1 1 1 1 0 (–34)10
a = (–12)10 b = (–24)10
R
a
b
a+b
11100000
1 1 1 1 0 1 0 0 + (–12)10 +
1 1 1 0 1 0 0 0 (–24)10
1 1 0 1 1 1 0 0 (–36)10
R
a
b
a–b
11110000
1 1 1 1 0 1 0 0 + (–12)10 +
0 0 0 1 1 0 0 0 (24)10
0 0 0 0 1 1 0 0 (12)10
a = (78)10 b = (–82)10
R
a
b
a+b
00001110
0 1 0 0 1 1 1 0 + (78)10 +
1 0 1 0 1 1 1 0 (–82)10
1 1 1 1 1 1 0 0 (–4)10
R
a
b
a–b
01011110
0 1 0 0 1 1 1 0 + (78)10 +
0 1 0 1 0 0 1 0 (82)10
1 0 1 0 0 0 0 0 overflow
4 Esercizio
Siano dati i seguenti due numeri binari in virgola mobile, singola precisione:
0 10000011 01011000000000000000000
0 10000011 10110100000000000000000
Si ricavi la loro somma.
Soluzione:
Poiché i due numeri hanno lo sesso esponente (131), si possono sommare le mantisse (includendo
il bit nascosto), per ottenere:
1.010110 +
1.101101
---------------11.000011
A questo punto il risultato va rinormalizzato, scalando la mantissa, ottenendo:
S=0
E = 10000011 + 1 = 10000100
M = 000011
0 10000100 00001100000000000000000
5 Esercizio
Dati due numeri decimali A=0,546875 e B=2,1875. Fornire la codifica completa in virgola mobile a
singola precisione di A e B. Effettuare la somma A+B
Soluzione:
Devo codificare in singola precisione i due numeri. Codifico separatamente la parte intera e la
parte decimale.
A:
I=0 codifica=0
D=0,546875
Per la parte decimale, invece che fare la divisione per 2, moltiplico per 2. Se il risultato supera 1.0,
l'uno viene messo nella colonna di sinistra e entra nella mantissa:
|546875 -> 0,546886*2= 1,09375 1 + 0,09375
1|093750
0|187500
0|375000
0|750000
1|500000
1|000000
e la mantissa si legge dall'alto verso il basso. Il numero (I.D) risulta: 0.100011, che normalizzato
diventa:
1.00011 x 2-1
Segno: 0
Esponente: -1 + 127 = 126 = 01111110
Mantissa: 000011 (ricordarsi di eliminare il bit nascosto)
B:
Si procede in modo analogo:
I=2 codifica 10
D=0,1875
|1875
0|3750
0|7500
1|5000
1|0000
Parte decimale =0011
Il numero risulta: 10.0011, che normalizzato diventa:
1.00011 x 2+1
Segno: 0
Esponente: +1 + 127 = 128 = 10000000
Mantissa: 00011 (ricordarsi di eliminare il bit nascosto)
A: 0 01111110 0000110000....
B: 0 10000000 0001100000....
Ora per sommarli devo portarli ad avere lo stesso esponente:
A: -1
B: +1
B ha esponente più grande, quindi traslo A:
1.00011 x 2-1 0.0100011 x 2+1
Ora posso sommare i due numeri dato che hanno lo stesso esponente, considerando (per B) anche
il bit nascosto:
0.0100011
1.0001100
----------1.0101111
Il risultato quindi sarà:
0 10000000 0101111000000
Cioè:
Esponente: 10000000 -> 128 -> exp = 128-127 = 1
Numero: 1.0101111 (riaggiungo il bit nascosto)
1.0101111 x 2+1 = 10.101111
Che, riconvertendo parte intera e parte decimale separatamente diventa:
2.734375 che è il risultato di 0.546875+2.1875
6 Esercizio
Dati due numeri decimali A=0,546875 e B=2,1875, effettuare la differenza B-A e A-B:
Soluzione:
I due numeri hanno la codifica come prima.
A:
1.00011 x 2-1
Segno: 0
Esponente: -1 + 127 = 126 = 01111110
Mantissa: 000011
B:
1.00011 x 2+1
Segno: 0
Esponente: +1 + 127 = 128 = 10000000
Mantissa: 00011
B-A:
devo portare i due numeri allo stesso esponente:
B ha esponente più grande, quindi traslo A:
1.00011 x 2-1 0.0100011 x 2+1
ora faccio il complemento a 2 di A (aggiungo un bit di segno):
00.0100011 -> 11.1011101 (partendo da destra, come solito, si fa il complemento a 2)
E faccio la solita somma binaria:
01.0001100 +
11.1011101
------------00.1101001 (il primo bit dà il segno del risultato)
Quindi il risultato è:
0.1101001 x 2+1 -> 1.101001 x 2+0
Il numero in virgola mobile è quindi:
Segno: 0
Esponente: 0 -> 0+127 = 127 -> 01111111
Mantissa: 101001
0 01111111 1010010000.........
Che tradotto in decimale diventa:
1.101001 x 2+0 -> 1.101001 -> 1.640625
A-B
si procede come prima, devo portare i due numeri allo stesso esponente:
B ha esponente più grande, quindi traslo A:
1.00011 x 2-1 00.0100011 x 2+1
A questo punto devo fare il complemento a 2 di B:
01.00011 -> 10.11101
e faccio la somma:
00.0100011 (A, con aggiunto primo bit positivo)
10.1110100 (B in complemento a 2)
------------11.0010111 (il primo bit dà il segno del risultato)
Dato che è negativo, devo fare il complemento a 2 (tralasciando il primo bit che è il segno sto
operando in complemento a 2):
1.0010111 -> 0.1101001
Quindi il risultato è:
0.1101001 x 2+1 -> 1.101001 x 2+0
Il numero in virgola mobile è quindi:
Segno: 1
Esponente: 0 -> 0+127 = 127 -> 01111111
Mantissa: 101001
1 01111111 10100100000.........
Che tradotto in decimale diventa diventa:
-1.101001 x 2+0 -> -1.101001 -> -1.640625
7 Esercizio
Per ognuna delle espressioni logiche riportate nelle righe della tabella, assumendo le seguenti
dichiarazioni:
int a = 8, b = 11;
char c=’d’;
indicare se l’espressione è vera o falsa (scrivere V o F nella seconda colonna).
(-a==a) && (a < 11)
FALSA
(c>’a’ || c<’z’ ) && (a<7 && b>8) FALSA
!(b<10 && a>7) || (c!=’h’ && c>’a’ )VERA
8 Esercizio
Si consideri la seguente sequenza di dichiarazione di strutture.
#define MAX_AUTO_VENDIBILI 1000
typedef char stringa[50];
typedef struct{
int giorno;
int mese;
int anno;
}Data;
typedef struct{
stringa tipo;
int numeroSerie;
}Optional;
typedef struct{
stringa tipo; /* il tipo di auto */
int numeroTelaio;
Data dataVendita;
Optional listaOptional[10];
int numeroOptional; /* il numero effettivo di optional di un’auto */
} AutoVenduta;
typedef struct{
AutoVenduta archAuto[MAX_AUTO_VENDIBILI];
int numAutoVendute; /* numero di auto vendute effettivamente dal concessionario */
}ArchivioAutoVendute;
void main() {
ArchivioAutoVendute a;
//............
.....CODICE......
}
Considerando un occupazione in byte per int(4), char(1), si valuti lo spazio occupato in memoria
dall’istanza “a”
Soluzione:
DIM(Data)=DIM(giorno)+DIM(mese)+DIM(anno)=3*DIM(int)=12;
DIM(Optional)=DIM(tipo)+DIM(numeroSerie)=
=DIM(stringa)+DIM(int)=
=50*DIM(char)+DIM(int)=
=50*1+4=54
DIM(AutoVenduta)=DIM(tipo)+DIM(numeroTelaio)+DIM(dataVendita)+DIM(listaOptional)*10+DIM(numeroO
ptional) =
=DIM(stringa)+DIM(int)+DIM(Data)+DIM(Optional)*10+ DIM(int)=
=50*DIM(char)+2*DIM(int)+12+54*10=
=50+8+12+540=610
a = DIM(archAuto)* MAX_AUTO_VENDIBILI+DIM(numAutoVendute)
DIM(archAuto) = DIM(AutoVenduta)=610
DIM(numAutoVendute)=DIM(int)=4
a = 610*1000+4=610004 Bytes ~= 595,70 KB
9 Esercizio
Si consideri il seguente vettore di valori interi non ordinato:
10
C
45
2
N
56
7
34
22
M
si sostituisca a C e N il corrispondete codice ASCII decimale della prima lettera (maiuscola) del Cognome e
del Nome e ad M la prima cifra non 0 partendo da destra del numero di matricola.
C=ASCII(B)=66
N=ASCII(I)=73
M=d101608
10 66 45 2 73 56 7 34 22 8
8 66 45 2 73 56 7 34 22 10
8 10 45 2 73 56 7 34 22 66
8 10 45 2 73 56 7 34 22 66
8 10 45 2 73 56 7 34 22 66
8 7 45 2 73 56 10 34 22 66
8 7 45 2 73 56 10 34 22 66
8 7 10 2 73 56 45 34 22 66
8 7 10 2 73 56 45 34 22 66
8 7 10 2 73 56 45 34 22 66
8 7 10 2 73 56 45 34 22 66
8 7 2 10 73 56 45 34 22 66
8 7 2 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 73 56 45 34 22 66
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 56 45 34 66 73
2 7 8 10 22 34 45 56 66 73
2 7 8 10 22 34 45 56 66 73
2 7 8 10 22 34 45 56 66 73
10 Esercizio
Si consideri il seguente vettore di valori interi non ordinato:
48
C
45
62
N
M
si sostituisca a C e N il corrispondete codice ASCII decimale della prima lettera (maiuscola) del Cognome e
del Nome e ad M la prima cifra non 0 partendo da destra del numero di matricola.
C=ASCII(B)=66
N=ASCII(I)=73
M=d101608
48
66
45
62
73
8
48 66 45 62 73 8
8 66 45 62 73 48
8 66 45 62 73 48
8 48 45 62 73 66
8 48 45 62 73 66
8 48 45 62 73 66
8 48 45 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
8 45 48 62 73 66
11 Esercizio
Come sopra con Merge Sort
48 66 45 62 73 8
48 66 45
48 66
48
62 73 8
45
66
48 66
45
45
45 48 66
62 73
62
73
62 73
8 62 73
8 45 48 62 66 73
8
8
8
12 Esercizio
Dato il seguente programma in linguaggio C si valuti il valore stampato al termine dell’esecuzione, il costo e
la complessità asintotica della funzione somma.
#include <stdio.h>
#include <stdlib.h>
long int somma(unsigned char *m)
{
long int ris=0;
while (*m != 0xFF)
{
ris = 100*ris + (*m >> 4) * 10 + (*m & 0x0F);
++m;
}
return ris;
}
int main()
{
/* programma principale */
unsigned char mem[3];
mem[0]=0x56;
mem[1]=0x32;
mem[2]=0xFF;
printf("%ld \n",somma(mem));
return 0;
}
13 Esercizio
Scrivere il codice assembler MIPS che traduce il seguente frammento di codice C:
/* calcolo della somma dei valori di un vettore */
int V[32];
int sum;
int count;
sum = 0;
for ( count=0; count<32; count++ )
sum = sum + V[ count ];
Ipotizzare che l'array V sia memorizzato a partire dall'indirizzo 100 incluso e occupi fino all'indirizzo 228
escluso; sum è all'indirizzo 228; la somma è accumulata sul registro $4; l'indice count è mantenuto nel
registro $5; la costante 32 è caricata in $6; i valori dell'array sono caricati in $7.
start_loop:
addi $10,$0,0;
addi $4, $0, 0;
addi $5, $0, 0;
addi $6, $0, 32;
slt $1, $6, $5;
beq $0, $1, end_loop;
muli $10,$5,4;
lw $7, 100[$10];
add $4, $4, $7;
addi $5, $5, 1;
j start_loop;
end_loop: sw $4, 228[$0];
14 Esercizio
Si consideri un array V={1,-1,2,-3,4,5,-6,7,8,-9,10,11,12,13,-14,-15} memorizzato a partire dall'indirizzo 200
di memoria, un array W di 20 elementi nulli a partire dall'indirizzo 400 e una variabile X inizializzata a 0
memorizzata all'indirizzo 800 della memoria. Si valuti sotto tali condizioni l’esecuzione della porzione di
codice Assembly MIPS indicando lo stato finale del vettore W e della variabile X.
start_loop:
continue:
end_loop:
addi $1, $0, 0;
addi $3, $0, 64; //16*4
slt $4, $1, $3;
beq $0, $4, end_loop;
lw $5, 200[$1];
slt $6, $0, $5;
beq $0, $6, continue;
sw $5, 400[$1];
addi $1, $1, 4;
j start_loop;
sw $1, 800[$0];
Soluzione:
1) Inizializzazione dei registri $1=0 e $3=16
2) Osservando il codice si individua il costrutto di un ciclo iterativo: la label start_loop definisce l’inizio
di un ciclo e la label end_loop la terminazione del ciclo. Il registro $i viene utilizzato come variabile
di iterazione e utilizzata dalla coppia di istruzioni: slt $4, $1, $3; beq $0, $4,
end_loop; per valutare se continuare o meno il ciclo sul test di condizione $i<$3 ovver $i<16.
a. Se false si esce e si salta ad end_loop
b. Si scrive in X il valore di $1
3) Il ciclo inizia prelevando il valore dalla memoria all’indirizzo 200+$1 corrispondente a V*$1+ e scritto
nel registro $5.
4) Il registro $5 viene utilizzato dalla coppia di istruzioni slt $6, $0, $5; beq $0, $6,
continue; che realizza un test sul segno del valore contenuto in $5. (0<$5 o anche V[$1]>0)
a. Si salta a continue se il test è falso ovvero per tutti i V[$1]<=0
b. Altrimenti si procede
5) Si scrive alla locazione 400[$i] il valore in $5 (V[$1])
6) Si incremena il registro $i di 4 (i dati sono a 32bit quindi si va al valore successivo)
7) Si salta ad inizio ciclo
$1=0 (4*0)
V[0]=1
$1=4 (4*1)
V[1]=-1
$1=8 (4*2)
V[2]=2
$1=12 (4*3)
V[3]=-3
….
$1=60 (4*15)
 1>0 vero

W[0]=V[0]  W[0]=1
 -1 >0 falso 
jump to continue; e W[1]=0;
 2>0 vero

W[2]=V[2]  W[2]=2
 -3>0 falso

jump to continue; e W[3]=0
V[15]=-15
 -15>0 falso 
jump to continue; e W[15]=0
Effetto: ricopiare in W i valori positivi di V.
Alla fine del ciclo si ha:
W={1,0,2,0,4,5,0,7,8,0,10,11,12,13,0,0,0,0,0,0}
X = 64
Il codice assembly realizza quindi il codice C:
int i=0, k=0, N=16, V[16], W[20];
while ( i < N ) {
if ( V[i] > 0)
W[i] = V[i];
i++;
}
15 Esercizio
Scrivere un frammento di programma Assembly MIPS che effettui la somma degli elementi di un vettore di
n interi e descritto dal seguente frammento in linguaggio C:
somma=0;
for(i=0; i<n; i++)
somma += x[i];
• Assunzioni sui registri:
somma $8; i  $9; n  $2; &x[0]  $3; x[i]  $10
for:
exit:
addi $8,$0,0;
addi $9,$0,0;
slt $1,$9,$2; //$2=n $9=i => $1=1 se i<n
beq $1,$0,exit;// si salta se $1=$0=0
lw
$10,$0($3);
add $8,$8,$10;
addi $9,$9,1;
addi $3,$3,4;
j for;
.....
16 Esercizio
Tradurre in Assembly MIPS il seguente codice C:
for (i=0; i<=100; i++)
a[i] = b[i] + c;
Si assuma che:
1) &a[0]  locazione 1500;
2) &b[0]  locazione 2000;
3) c  $16
4) i  $15
Soluzione 1:
Si usa il registro $2 per impostare il limite massimo del ciclo for; l’uguaglianza a 100 comporta considerare
come massimo valore di iterazione 101. Il registro $3 viene utilizzato per costruire l’offset di accesso alla
memoria a partire da una locazione di base ed aggiornato con incremento di 4 per tenere conto della
rappresentazione a 32 bit dei numeri interi.
addi $3,$0,0
addi $15,$0,0;
addi $2,$0,101;
for: slt $1,$15,$2;
beq $1,$0,exit;
lw
$10,2000($3);
add $10,$10,$16;
sw
$10,1500($3);
addi $3,$3,4;
addi $15,$15,1;
j for;
exit:
.....
//l’uguaglianza a 100 comporta considerare 101
//$2=101 $15=i => $1=1 se i<=100
// si salta se $1=$0=0
//si legge b[i] e si carica $10
// si aggiunge $16 che rappresenta c
//si scrive in memoria a[i] il valore di $10
// si somma 4 a $3 per il prossimo elemento
// si incrementa $15 di un’unità
// si ricomincia
Soluzione 2:
Per costruire un indice come offset di accesso alla memoria a partire da una locazione di base bisogna
aggiornarlo con un incremento di 4 per tenere conto della rappresentazione a 32 bit dei numeri interi.
Se si usa il registro $15 come indice e offset, esso va considerato a multipli di 4 ovvero considerare i*4. Il
limite massimo del ciclo for prevede l’uguaglianza a 100, questo comporta come massimo valore di
iterazione 101; se utilizzato per testare l’offset di accesso alla memoria esso allora va moltiplicato per 4 e
pertanto il nuovo limite diventa 404. Tale limite verrà impostato sul registro $2.
addi $15,$0,0;
addi $2,$0,404;
//Vedi considerazioni
for: slt $1,$15,$2;
//$2=404 $15=i*4 => $1=1 se i*4<=100
beq $1,$0,exit;
// si salta se $1=$0=0
lw
$10,2000($15); //si legge b[i] e si carica $10
add $10,$10,$16; // si aggiunge $16 che rappresenta c
sw
$10,1500($15); //si scrive in memoria a[i] il valore di $10
addi $15,$15,4;
// si incrementa $15 di 4
j for;
// si ricomincia
exit:
.....
17 Esercizio
Si valuti il comportamento del seguente frammento di codice assembly MIPS:
addi $11, $12, 100
addi $16, $0, 11
muli $15, $16, 4
lw $14, 1024($15)
add $14, $14, $11
subi $15, $15, 4
sw $14, 1024($15)
//moltiplicazione con dato immediato
//sottrazione con dato immediato
Si assuma il seguente stato dei registri e della memoria prima dell’esecuzione del blocco di istruzioni:
1. Registri:
$12 = 4;
2. Memoria: a partire alla locazione di memoria espressa, in base dieci, 1024 sono memorizzati i
seguenti valori espressi a byte:
0.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
0x0012
0x0034
0x0033
0x0000
0x1111
0x0F0F
0x1200
0x00FF
0x0001
0x0300
0x0033
0x0000
0x1111
Si calcoli il valore memorizzato dal registro $11 e alla locazione di memoria 1024($15) al termine
dell’esecuzione del codice.
Soluzione:
1) Poichè il registro $12 è caricato col valore 4, $11 viene caricato con la somma di 4+100 e quindi
all’inizio $11 vale 104. Analizzando il codice, il registro $11 non viene più modificato pertanto il suo
valore alla fine è 104.
2) Il registro $16 viene caricato col valore 11, l’istruzione muli carica il registro $15 col valore 4*11=44
Il registro $15 viene utilizzato come offset per l’accesso alla memoria a partire dalla locazione 1024
e considerando i dati organizzati a 4 byte si deve accedere all’11° gruppo di 4 byte e quindi al valore
0x0000 (esadecimale). Pertanto il registro $14 conterrà il valore 0 (decimale). Ad $14 si somma il
contenuto di $11 e quindi si effettua la somma 104+0. $14=10410. Il registro $15 viene
decrementato di 4 e utilizzato da sw come offset per la scrittura del contenuto di $14. L’offset è
quello del 10° gruppo dei quattro byte. Pertanto si scriverà in memoria il valore 10410