Ciao,
dove hai tirato fuori questo codice?
non uso assembly... ma a livello logico dovrebbe comportarsi nel modo seguente (pseudo-C):
Codice:
t0 = 0;
t1 = A1 - 1;
while(t0 != t1) // label1
{
t3 = t0 + 1;
t2 = t0 * 4; // rappresenta la sequenza di istruzioni t2 = t0 + t0; t2 = t2 + t2;
// ovvero t2 = t0 + t0 + t0 + t0;
t4 = A0 + t2;
while(t3 != A1) // label2
{
t5 = t3 * 4; // idem con patate
t6 = A0 + t5;
t7 = i primi 4 byte di memoria a partire dall'indirizzo t6;
t8 = i primi 4 byte di memoria a partire dall'indirizzo t4;
if(t8 > t7) // inverto la condizione ">=" per simulare la semantica del jump
{
carica t8 in memoria a partire dall'indirizzo t6;
carica t7 in memoria a partire dall'indirizzo t4;
}
// label5
t3++;
}
// label4
t0++;
}
// label3
v0 = A0;
jump all'indirizzo in ra
A prima vista sembrerebbe insensato, considerando anche che non dai alcuna informazione in merito... come ad esempio una descrizione dei parametri in input e l'eventuale fase di inziailizzazione...
guardando più attentamente sembrerebbe che A0 e A1 (scritti volutamente in maiuscolo) siano due parametri in ingresso e che il programma utilizzi una certa area di memoria come se fosse un array di elementi da 4 byte
Ultimo dubbio mi sembra che i registri t7 e t8 vengano prima caricati dalla memoria e poi scritti in memoria il che non credo sia giusto.
infatti si, sembrerebbe caricare garbage dalla memoria...
in realtà credo che al codice che hai postato preceda una fase di inzializzione di tale area di memoria.
In particolare, analizzando il codice, sembra che l'area di memoria non sia altro che un array di elementi a 4 byte pre-inizializzato e che A0 e A1 siano parametri in ingresso, rispettivamente l'inizio dell'area di memoria e il numero di elementi.
I motivi dei '*4' sono dovuti alla necessità di spostarsi di 4 byte mentre l'if implementa uno swap dei due elementi puntati da t4 e t6.
Alla fine della fiera sembrerebbe un algoritmo di ordinamento e, nello specifico, del bubblesort. Non ne sono sicuro perchè nn l'ho controllato bene... lascio a te l'onore/onere di accertarlo.
Inoltre non capisco una cosa: le due istruzioni di load (lw) che ci sono non si dovrebbero usare per gli array? Oppure in questo caso sono usate per indicare che i registri t6 e t4 sono già in memoria?
tratto da wikipedia ("MIPS architecture"):
lw $t, C($s)
load word: loads the word stored from: MEM[$s+C] and the following 3 bytes.
e si comporta nel modo seguente: $t = Memory[$s + C]
spero di esserti stato d'aiuto,
ciao.
