Valerio Battaglia

Per il primo esonero ALU compresa o no?!
grazie per eventuali risposte

Stamattina il prof ha detto che per problemi di allineamento col canale J-Z (a cui D'Amico ha spiegato solo oggi quest'argomento), l'ALU non sarà compresa nel primo esonero.

Non capisco una cosa dei registri preservati quando si chiama una funzione.I registri da $t0 a $t7 c'è scritto che nn sono preservati,ma nel senso che pure se io li salvo nello stack e li uso nella funzione in modo diverso,quando li ricarico dalla memoria hanno un valore diverso da quello salvato???

Io nel frattempo ho capito jal...

Con riferimento all'esercizio 4 della prima prova in itinere dell'altr'anno, qualcuno mi sa dire se la risposta al primo quesito è

0000000000001100

e alla secoda è

nessuno?

l'indirizzo dovrebbe essere 00000011 cioè 3 perchè l'etichetta END viene 3 istruzioni dopo il BNE

Con riferimento all'esercizio 4 della prima prova in itinere dell'altr'anno, qualcuno mi sa dire se la risposta al primo quesito è

0000000000001100

e alla secoda è

nessuno?

L'etichetta end, assumendo che il codice inizi da 0x00000000, è la quinta istruzione quindi il suo indirizzo sarà 0x00000014 ossia 20 in esadecimale dato che si tratta della 5 parola nell'area di memoria.
Quindi l'indirizzo viene determinato prendendo i 26 bit dell'indirizzo dell'etichetta end, vengono aggiunti 2 zeri a destra e vengono aggiunti a sinistra i 4 bit più significativi del pc+4.

Per quanto riguarda il secondo punto credo che la risposta sia : nessuna, in quanto le istruzioni di tipo branch non vengono rilocate dal linker (pagina 14 delle slides "Assemblatore".

il jump dovrebbe essere rilocato perchè sulle slides c'è scritto che j e jal vanno sempre rilocate

si scusami hai ragione, non ho letto bene il testo dell'esercizio. Pensavo chiedesse solo se l'istruzione del primo esercizio venisse rilocata.
sorry

scusate voi sapete rispondere al quesito1 dell esonero dello scorso anno: "evidenziare il meccanismo tipicamente usato per l’emulazione di ciascun livello da parte del livello inferiore."
Non mi sembra che l'abbia spiegato o forse non me lo ricordo io...

5
interpretazione/compilazione
4
assemblaggio
3
interpretazione parziale + chiamate di sistema
2
esecuzione diretta o microinterpretazione
1
realizzazione hardware
0

Quindi l'indirizzo viene determinato prendendo i 26 bit dell'indirizzo dell'etichetta end, vengono aggiunti 2 zeri a destra e vengono aggiunti a sinistra i 4 bit più significativi del pc+4.

ma questo vale per i salti incondizionati non per i bne/beq che sono condizionati, o no?

Allora ho fatto un pò di confusione in effetti, tutto perchè non ho letto l'esercizio.
Le istruzioni branch sono di tipo immediate quindi il loro campo address è di 16 bit e il calcolo dell'indirizzo "etichetta" viene fatto come ti fa vedere il prof sulle slide con quel piccolo circuito con le alu.
Ossia prendendo i 16 bit dell'indirizzo aggiungendo 2 zeri a destra e facendo l'estenzione del segno e sommando il tutto al pc+4 in caso di salto.


Per le istruzioni di tipo Jump il calcolo dell'indirizzo viene fatto come scritto sopra (26 bit ecc..), almeno spero...(beneficio del dubbio)
(questo era l'esercizio di un esame di settembre che anche il prof ha fatto vedere a lezione [j End])

scusate, se ho un array con etichetta array: , di cui ho l'indirizzo base in $a0 e per il quale ho riservato 8 spazi di memoria... se volessi memorizzare un numero in questo array a partire dall'ultima posizione come si deve fare???

prova un po' così
offset: 4*(n-1)
nel caso n=8 -> 28($a0)

scusate sapete dirmi quanti punti sono in gioco nel primo esonero? 30 o 15?

scusate sapete dirmi quanti punti sono in gioco nel primo esonero? 30 o 15?

dovrebbero essere 30

Allora ho fatto un pò di confusione in effetti, tutto perchè non ho letto l'esercizio.
Le istruzioni branch sono di tipo immediate quindi il loro campo address è di 16 bit e il calcolo dell'indirizzo "etichetta" viene fatto come ti fa vedere il prof sulle slide con quel piccolo circuito con le alu.
Ossia prendendo i 16 bit dell'indirizzo aggiungendo 2 zeri a destra e facendo l'estenzione del segno e sommando il tutto al pc+4 in caso di salto.


Per le istruzioni di tipo Jump il calcolo dell'indirizzo viene fatto come scritto sopra (26 bit ecc..), almeno spero...(beneficio del dubbio)
(questo era l'esercizio di un esame di settembre che anche il prof ha fatto vedere a lezione [j End])

Scusate, ma non dovrebbe essere questo il procedimento?

1) Offset -> lo rendo binario -> aggiungo a destra 2 zeri: nel nostro caso esce 000000000000001100
2) Lo rendo a 32 bit: 00000000000000000000000000001100
3) Faccio (PC+4) + l'indirizzo ottenuto al punto 2 (quindi supponendo che PC inizi a 0000...000 e che quindi bne sia 0000...0100
4) quindi facendo: 000...01100 + 000...000100 = 000...0010000

quindi il campo indirizzo di bne è:
00000000000000000000000000010000

Confermate? Secondo lo schema delle slide è così da quanto ho capito

Nightmare scusa ma i due zeri a desta li hai aggiunti anche al PC,e poi hai fatto la somma? Perche altrimenti non ho capito....

ragazzi chi mi fa questo?

a me non mi sembra che sia così.
per quanto riguarda l'istruzione: beq $t2, $zero, end, e assumiamo (non ho voglia di fare troppi conti) che l’indirizzo della prima istruzione sia a 0x00000000

allora l'indirizzo di end è: 9 (in decimale) (se partiamo da beq, end è la nona istruzione, cioè il nostro spiazzamento)
dell'indirizzo di questa istruzione prendo 16 bit:
0000 0000 0000 1001 (questa dovrebbe essere la risposta alla domanda che chiede cosa ci sia nel campo immediate dopo la fase di linkaggio)
Ma andiamo avanti….

aggiungo 2 bit a destra ed estendo il segno (cioè moltiplico per 4 e ne faccio 32 bit):

00 0000 0000 0000 0000 0000 0000 1001 00

fatto questo lo sommo a pc+4:

pc: 0000 0000 0000 0000 0000 0000 0000 1100 (siamo alla terza istruzione)
pc +4= 0000 0000 0000 0000 0000 0000 0001 0000

ora faccio la somma :
0000 0000 0000 0000 0000 0000 0001 0000 (pc+4 )+
0000 0000 0000 0000 0000 0000 0010 0100

0000 0000 0000 0000 0000 0000 0011 0100 questo è l’indirizzo che prende se il salto viene effettuato

Qualcuno mi conferma/smentisce???
Sinceramente non ne sono proprio convinto…

maken, credo proprio sia come dici, io lo spiego così (ma è equivalente al tuo ragionamento)

beq = (0x00501000 +48) - (0x00501000 +16)
bne = (0x00501000 + 40) - (0x00501000 +32)
j end = 0x00501000 +48
j while = 0x00501000 +8

(numeri sommati a destra sono in decimale)
aggiungere 2 bit a destra equivale a contare 4 per ogni istruzione