Corsi di Laurea

[nghuit]

Ho appena iniziato a studiare LLAP. Credo che potrete darmi una mano abbastanza agevolmente.
In pratica sugli appunti ho scritto questo:

main()
{
int v[10];
int i,riemp,max;
for(i=0,i if(v[i]>max)
max=v[i];
}

si traduce con:

__start:
addi £sp, £sp, -40
addi £t0, £sp, 4
lw £s2, 0 (£t0)
addi £s1, £s1, 1
for: bge £s1, £s0, finefor
muli £t1, £s1, 4
add £t1, £t1, £t0
lw £t2, 0 (£t1)
ble £t2, £s2, fineif
add £sp, £0, £t2
fineif: add £s1, £s1, 1
j for
finefor: addi £sp, £sp, 40


NB £ sta per dollaro. Non posso scriverlo altrimenti si attiva lo script.
Le parti in rosso non mi sono chiare.
In ogni caso sapete dove posso trovare tali spiegazioni, in modo da non dovervi seccare anche con queste stupidaggini? Veramente per LLAP mi trovo in crisi: ma voi da dove avete studiato l'assembly!??

[Peppeweb]

Ciao, quelle parti che hai sottolineato in pratica riguardano l'allocazione della memoria e il suo utilizzo. Ti consiglio di leggerti quei due capitoli che trovi come dispense sul forum in cui si parla di questo argomento. Se non và proprio esponi quali sono i tuoi dubbi in particolare.

In verità io llap l'ho studiato da quaderno e per quanto riguarda la gestione della memoria ho utilizzato quelle dispende come appunto ti dicevo e molto esercizio.

[nghuit]

Grazie!

[nghuit]

Ho studiato praticamente tutta la teoria. Mi è rimasto solo un dubbio circa quel codice: il rigo con la muli... non riesco proprio a capire perchè si debba moltiplicare in quel caso

[Peppeweb]

Ho studiato praticamente tutta la teoria. Mi è rimasto solo un dubbio circa quel codice: il rigo con la muli... non riesco proprio a capire perchè si debba moltiplicare in quel caso

Se espliciti il codice a cui ti riferisci forse riusciamo ad aiutarti .
Se ti riferisci a quando fai tipo " muli $t1,$t0,4 ", ovvero a quando moltiplichi per 4 è dovuto al vincolo di allineamento ovvero al fatto che le celle di memoria si indirizzano con multipli di quattro e con quel codice in pratica per accedere ad ogni singola cella sfrutti il contatore ( es cont = 0 , ind = 0, cont = 1 ind=4 .

[nghuit]

Il codice è quello del mio primo messaggio di questo topic
Cmq sì, è il caso da te citato! Thank you!

[girolamo]

Ho diversi dubbi riguardante la inverti vettore nell'esercizio svolto da conte(esercizio.txt)
Riporto il codice:
void InvertiVettore(int v[], int r){
int i;
for(i=0; i swap (&v[i],&v[r-i-1]);
}
void swap(*x, *y){
int tmp;
tmp=*x;
*x=*y;
*y=tmp;
}
#PROLOGO
addi $sp, $sp, -32 perchè è 32??non dovrebbe essere dodici?
sw $s0, 16($sp)
sw $a1, 20($sp) #perchè passa anche il riempimento? in altri esercizi non lo passa
#come si fa capire quando si passa?
sw $a0, 24($sp)
sw $ra, 28($sp)
sw $fp, 32($sp)
addi $fp, $sp, 32
[...]
li $s0, 0 #i = 0
for2: bge $s0, $t0, finefor2
move $a0, $t1
move $a1, $t2
#chiamante
sw $t0, 12($sp)
sw $t1, 8($sp)
sw $t2, 4($sp) non ho capito bene xkè si fa tutto questo!
jal swap
#ritorno
lw $t0, 12($sp)
lw $t1, 8($sp)
lw $t2, 4($sp)
[...]

[HDM]

Ricordo quella lezione di conte, se è quella in cui presentò anche il selection sort che non ha mai funzionato nei secoli dei secoli allora siamo a cavallo XDD

Comunque da quello che vedo hai ragione tu, all'inizio dovremmo allocare solo 12 byte sullo stack, non 32 come sta fatto lì.(dobbiamo allocare spazio solo per s0,fp e ra)
Per quanto riguarda il riempimento, la inverti vettore lo prevede come parametro, almeno per quelle che ho visto io
Mentre invece per quelle righe in rosso psima di "jal swap" bhe, lì non si fa altro che salvare i registri temporanei che usiamo all'interno del ciclo, poichè il valore che contengono ci serve anche dopo la chiamata della swap. Non effettuare quel salvataggio significa rischiare di perdere i valori dei registri nel caso in cui la swap li utilizzi.

[Peppeweb]

Si ricordo anche io che l'esercizio aveva alcuni errori, ricordo anche di avere pubblicato la mia versione corretta in qualche articolo su LLAP quindi usa il tasto cerca

[goodhelp88]

[quote name="nghuit"]Ho appena iniziato a studiare LLAP. Credo che potrete darmi una mano abbastanza agevolmente.
In pratica sugli appunti ho scritto questo:

main()
{
int v[10];
int i,riemp,max;
for(i=0,iif(v[i]>max)
max=v[i];
}

si traduce con:

__start:
addi £sp, £sp, -40
addi £t0, £sp, 4
lw £s2, 0 (£t0)
addi £s1, £s1, 1




scusate ma non ho capito bene una cosa.
Perche' fare :
addi £t0, £sp, 4
e non addi £t0, £sp, 0 ????
£t0 deve rappresentare v[0] ma per come è svolto l'esercizio rappresenta v[1]
o mi sfugge qualcosa?

[aRbok]

Bisogna fare

addi £t0,£sp,4

perchè:
1)lo stack pointer per definizione punta alla prima cella libera
2)Per fare un' allocazione devi decrementare sp,ma se sp punta già alla prima cella libera,facendo un decremento per allocare spazio otterrai sempre che sp punta alla prima cella libera e lo spazio che avrai allocato comincerà dalla cella sottostante a quella puntata da sp
3)Devi fare

addi £t0,£sp,4

perchè il vettore comincia da sp+4
4)Facendo così,in t0 ci metti lo starting address v[0] e non v[1].Era questo che ti sfuggiva.

[Stabber]

qualcuno ha idea di come si traduce questa roba coi puntatori ?

int a=7
int *p
p=&a
printf("%d",p);

[HDM]

Pensa al concetto di puntatore e ti viene abbastanza semplice l'esercizio
Anche se comunque non credo escano i puntatori allo scritto di llap!

[Stabber]

Pensa al concetto di puntatore e ti viene abbastanza semplice l'esercizio
Anche se comunque non credo escano i puntatori allo scritto di llap!

Ma non potresti dirmi la soluzione che non ho molto tempo per pensarci

[Stabber]

Pensa al concetto di puntatore e ti viene abbastanza semplice l'esercizio
Anche se comunque non credo escano i puntatori allo scritto di llap!

#int a=7

#int *p

#p=&a

#printf("%d",p);



##################################



.globl __start

	.text

__start:

   	addi $sp,$sp,-8

	sw $fp,8($sp)

	sw $s0,4($sp)

   	addi $fp,$sp,8



   li $t0,7

   sw $t0,4($sp)

   addi $t2,$fp,-4   

   lw $t2,0($t2)



   move $a0,$t2

   li $v0,1

   syscall



	lw $fp,8($sp)

	lw $s0,4($sp)

   	addi $sp,$sp,8

In questo modo può andar bene ?

[HDM]

Si si potrebbe andare bene, ma in questo caso non dovrebbe stampare l'indirizzo?
per come è fatto il programma C mi sa che stampa l'indirizzo di a, non il valore... mmh..

[HDM]

Quindi la soluzione a quel programma C dovrebbe essere questa:
 puntatore.txt   324bytes   14 Download

vedi un pò

Il puntatore quì può essere visto come un registro con all'interno un indirizzo.

[Stabber]

Si si potrebbe andare bene, ma in questo caso non dovrebbe stampare l'indirizzo?
per come è fatto il programma C mi sa che stampa l'indirizzo di a, non il valore... mmh..

giusto. ma allora mi basta togliere semplicemente la lw e può andare ?

[HDM]

Sisi perchè in p ci deve andare l'indirizzo di memoria della cella che contiene 7, e l'indirizzo te lo ricavi da fp, quindi va bene.

[Stabber]

Sisi perchè in p ci deve andare l'indirizzo di memoria della cella che contiene 7, e l'indirizzo te lo ricavi da fp, quindi va bene.

ti ringrazio per il supporto