Valerio Battaglia

sarà pure equivalente ma vi vengono due risultati diversi.
a te viene PC + 32, a Maken PC + 52.

in effett io mi riferisco al contenuto del campo dell'istruzione mentre maken ha calcolato nella seconda parte della suo ragionamento l'indirizzo a cui salta,
il tutto è consistente insomma!

ma il PC da dove iniziate a contarlo? dalla prima istruzione? quindi beq $t0, $zero, end punta già a PC+4?

PC si riferisce all'istruzione beq

provate però a vedere su SPIM i numeri che effettivamente scrive nel caso dei branch: li calcola in base all'istruzione corrente e li scrive non in termini di word ma di byte. in pratica indica il numero di byte tra l'inizio dell'istruzione branch e l'inizio dell'istruzione di arrivo...

0x20080000 addi $8, $0, 0 ; 1: addi $t0, $zero, 0 #is_in
[0x00400004] 0x20090000 addi $9, $0, 0 ; 2: addi $t1, $zero, 0
[0x00400008] 0x0106502a slt $10, $8, $6 ; 3: slt $t2, $t0, $a2 #While
[0x0040000c] 0x15400009 bne $10, $0, 36 [end-0x0040000c]; 4: bne $t2, $zero, end
[0x00400010] 0x00085880 sll $11, $8, 2 ; 5: sll $t3, $t0, 2
[0x00400014] 0x00ab5820 add $11, $5, $11 ; 6: add $t3, $a1, $t3
[0x00400018] 0x8d6c0000 lw $12, 0($11) ; 7: lw $t4, 0($t3)
[0x0040001c] 0x15840003 bne $12, $4, 12 [inc-0x0040001c]; 8: bne $t4, $a0, inc
[0x00400020] 0x20090001 addi $9, $0, 1 ; 9: addi $t1, $zero, 1
[0x00400024] 0x0810000c j 0x00400030 [end] ; 10: j end
[0x00400028] 0x21080001 addi $8, $8, 1 ; 11: addi $t0, $t0, 1 #INC
[0x0040002c] 0x08100002 j 0x00400008 [while] ; 12: j while
[0x00400030] 0x21220000 addi $2, $9, 0 ; 13: addi $v0, $t1, 0 #END
[0x00400034] 0x03e00008 jr $31 ; 14: jr $ra
[/code]

come vedi a 0040000C dice che l'indirizzo è [end - 0040000C]
End sta in 00400030 - 0040000C = 24 = 36 (9righe)
Se guardi il link che ho postato io, pag. 12, pare che non metta il numero di byte (36 appunto) ma il numero di righe (9 nel nostro caso).
Che si fa?

in sostanza stiamo dicendo la stessa cosa.

per quanto riguarda l'istruzione beq il campo immediate ossia l'off-set ossia lo spiazzamento è pari a 8(decimale) (istruzioni) scritto in binario, poi se il salto va a buon fine si calcola il pc relativo, ossia si somma il pc del beq +4 il tutto sommato al campo offset moltiplicato per 4 (aggiunta di 2 zeri a destra) e destenso in segno per avere in totale 32 bit.

dovrebbe essere così!

Inoltre sempre la dispensa che ho linkato prima dice che il calcolo si fa aggiungendo o sottraendo (se ci si muove avanti o dietro) 4 dal PC...cosa che PCSPIM non riporta!

nell'esempio che ho riportato io, ho calcolato il valore del campo immediate (come richiesto dall'esercizio) in più ho calcolato il valore del pc+4 in caso di salto...

sarà pure equivalente ma vi vengono due risultati diversi.
a te viene PC + 32, a Maken PC + 52.

in effett io mi riferisco al contenuto del campo dell'istruzione mentre maken ha calcolato nella seconda parte della suo ragionamento l'indirizzo a cui salta,
il tutto è consistente insomma!

rimane però una cosa che avevo postato giorni addietro.
Se tu esegui quel pezzo di codice col MIPS ottieni questo

[code type="markup"][0x00400000] 0x20080000 addi $8, $0, 0 ; 1: addi $t0, $zero, 0 #is_in
[0x00400004] 0x20090000 addi $9, $0, 0 ; 2: addi $t1, $zero, 0
[0x00400008] 0x0106502a slt $10, $8, $6 ; 3: slt $t2, $t0, $a2 #While
[0x0040000c] 0x15400009 bne $10, $0, 36 [end-0x0040000c]; 4: bne $t2, $zero, end
[0x00400010] 0x00085880 sll $11, $8, 2 ; 5: sll $t3, $t0, 2
[0x00400014] 0x00ab5820 add $11, $5, $11 ; 6: add $t3, $a1, $t3
[0x00400018] 0x8d6c0000 lw $12, 0($11) ; 7: lw $t4, 0($t3)
[0x0040001c] 0x15840003 bne $12, $4, 12 [inc-0x0040001c]; 8: bne $t4, $a0, inc
[0x00400020] 0x20090001 addi $9, $0, 1 ; 9: addi $t1, $zero, 1
[0x00400024] 0x0810000c j 0x00400030 [end] ; 10: j end
[0x00400028] 0x21080001 addi $8, $8, 1 ; 11: addi $t0, $t0, 1 #INC
[0x0040002c] 0x08100002 j 0x00400008 [while] ; 12: j while
[0x00400030] 0x21220000 addi $2, $9, 0 ; 13: addi $v0, $t1, 0 #END
[0x00400034] 0x03e00008 jr $31 ; 14: jr $ra
[/code]

come vedi a 0040000C dice che l'indirizzo è [end - 0040000C]
End sta in 00400030 - 0040000C = 24 = 36 (9righe)
Se guardi il link che ho postato io, pag. 12, pare che non metta il numero di byte (36 appunto) ma il numero di righe (9 nel nostro caso).
Che si fa?

Da quello che ho capito mi sembra chiara una cosa:
le istruzione branch non hanno nell campo offset un indirizzo ma uno spiazzamento
mentre le istruzioni di tipo j (j e jal) hanno un indirizzo a 26 bit in accordo con il nome del campo che lo contiene, "address".

Da quello che ho capito mi sembra chiara una cosa:
le istruzione branch non hanno nell campo offset un indirizzo ma uno spiazzamento
mentre le istruzioni di tipo j (j e jal) hanno un indirizzo a 26 bit in accordo con il nome del campo che lo contiene, "address".

esattamente, motivo per il quale con i brench puoi fare salti di 256kb mentre col J puoi farne fino a 256mb e fin qui ci siamo...rimane da capire QUANTO perchè PCSPIM fa una cosa, le dispense ne dicono un'altra.
Comunque il prof in classe ha contato tra il brench e l'etichetta di destinazione e tolto 1 (cioè...lui ha fatto tutta la spiegazione del PC+4 ecc...ecc....) ma in soldoni quello che accade è questo. Io domani je lo riporto così (come l'ha spiegato lui) con accanto una bella spiegazione teorica e una lettera dove minaccio di suicidarmi in caso non sia corretto...poi tanto non lo faccio ma minimo 2-3 puntate al Maurizio Costanzo Show me le guadagno

fregatene di spim. spim ci serve solo per provare l'assembler non come modello di riferimento anche perkè è un simulatore dell'architettura mips 3000

scusate ma non capisco tutto questo casino sugli indirizzi.. forse ho capito male io, ma da quello che ho capito i casi sono due:
istruzione beq: Formato I: nei 16 bit viene memorizzato in binario di quante righe bisogna saltare a partire dalla successiva al branch (es: 0000000000000110 vuol dire che devo andare 6 righe sotto la successiva al branch) -> non c'è bisogno di rilocazione

istruzione j: Formato J: nei 26 bit, dopo la rilocazione, viene memorizzato in binario l'indirizzo dell'etichetta alla quale bisogna saltare -> da rilocare sempre

nel caso dei j se l'etichetta è nella stessa porzione di codice vedo l'indirizzo in esadecimale della prima riga (a 32 bit); sommo 4 per ogni riga fino a risalire alla riga con l'etichetta (altro indirizzo in esadecimale a 32 bit); fatto ciò nei 26 bit del j memorizzo in binario a 16 bit il corrispondente di quell'indirizzo nel seguente modo: prendo l'indirizzo a 32 bit in esadecimale; lo converto a binario; tolgo i primi 4 e gli ultimi 2 zeri e ottengo l'indirizzo a 26 bit...

è così no????

gantra hai un mp!

PCSPIM con i setting che vi ho fatto usare (che corrispondono ad una modalità semplificata di funzionamento) fa i conti rispetto a PC e non rispetto a PC+4 (come accade nella realtà). per vedere cosa accade in realtà dovete impostate "bare machine" tra i setting (e disabilitare le pseudoistruzioni) e vedete che fa i conti rispetto a PC+4.

Inoltre sempre la dispensa che ho linkato prima dice che il calcolo si fa aggiungendo o sottraendo (se ci si muove avanti o dietro) 4 dal PC...cosa che PCSPIM non riporta!

PCSPIM con i setting che vi ho fatto usare (che corrispondono ad una modalità semplificata di funzionamento) fa i conti rispetto a PC e non rispetto a PC+4 (come accade nella realtà). per vedere cosa accade in realtà dovete impostate "bare machine" tra i setting (e disabilitare le pseudoistruzioni) e vedete che fa i conti rispetto a PC+4.

Inoltre sempre la dispensa che ho linkato prima dice che il calcolo si fa aggiungendo o sottraendo (se ci si muove avanti o dietro) 4 dal PC...cosa che PCSPIM non riporta!

Grazie prof!

ragazzi ho un pò un dubbio dell'ultimo minuto...

la procedura ricorsiva và trattata sia come chiamata che come chiamante e si deve quindi salvare tutti i registri ?

si

si

scusa se ti rompo, sempre riferito all'esercizio postato. Lo spiazzamento è 8 giusto (visto che nel beq sto già in PC+4).

Quindi avrei:

1) PC+4 -> 0000 0000 0000 0000 0000 0000 0001 0000 (ovvero 16, 12 in cui mi trovo +4)

2) spiazzamento che è 8 -> 0000 0000 0000 0000 0000 0000 0010 0000

3) Ora sommo:
0000 0000 0000 0000 0000 0000 0001 0000 +
0000 0000 0000 0000 0000 0000 0010 0000 =

0000 0000 0000 0000 0000 0000 0011 0000

giusto? te rpego dimmi di si :lol:



Poi devo fare lo stesso identico procedimento per BNE, mentre per le due J dev:

-> 0000 0000 0000 0000 0000 0000 0011 0100 per END

-> 0000 0000 0000 0000 0000 0000 0001 1100 per WHILE


Confermate?!

Scusa, nell'operazione 2) avevo già compreso l'operazione di moltiplicare per 4 (e mettere quindi i due 0 a destra)

si è giusto e puoi vederlo da te, infatti il risulatto che hai scritto tu è 48 (decimale) che corrisponde proprio all'indirizzo dell'istruzione end (12esima istruzione)

-> 0000 0000 0000 0000 0000 0000 0011 0100 per END

è un indirizzo assoluto. io farei così
conti a che numero di riga si trova END, togli 1 (perchè parti da zero), moltiplichi per 4 e sommi al PC INIZIALE (il punto di inizio del programma), togli le 2 cifre meno significative e le 4 più significative, e voilat.