Stack!

[danyrus07]

Bungiorno a tutti!!

Scusate,correggetemi se sbaglio...Sto da poco studiando assembly e vorrei capire una cosa..

Nello stack il registro EBP funge da registro base,quindi per poter "richiamare" una qualsiasi altra cosa presente nello stack il mio riferimento è EBP?Cioè la richiamo con lo spiazzamento?

un altro dubbio,i registri di stato non vanno inseriti nello stack,vero?

Infine il registro ESP a cosa serve e come lo inserisco?

Forse è meglio che mi facciate un "disegnino"...

Grazie

[DonJ]

lo stack lo puoi anche utilizzare come memoria "di riserva"
si usa molto durante le chiamate alle procedure che vanno a modificare registri come AX, BX, CX, DX
li puoi mandare dentro allo stack grazie alle istruzioni "push" e "pop".
ricordati che lo stack è una struttura di tipo LIFO e che quindi dovrai fare:

Codice: Seleziona tutto

push AX
push BX
push CX

[altre istruzioni]

pop CX
pop BX
pop AX

altra cosa, ricordati che nella chiamata alla procedura nello stack vengono inseriti IP e DS per permettere il recupero del puntatore a procedura terminata.
è quindi ovvio che se al termine della procedura (nell'istruzione return) nello stack si trovano altri valori sopra a IP e DS, il PC caricherà comunque i primi due valori dello stack, con risultati non voluti.
quindi è necessario liberare lo stack:

Codice: Seleziona tutto

procedure1 proc
push di           ;salvataggio dei registri nello stack
push ax
push bx
push cx
                      ; STACK => [..], DS, IP, DI, AX, BX, CX
[istruzioni]

pop cx            ;ripristino valori
pop bx
pop ax
pop di
                      ; STACK => [..], DS, IP
ret
                      ; STACK => [..]
procedure1 endp

questo è il metodo da bravo programmatore

_______________________________________________________________

adesso mi documento su EBP perché non me lo ricordo più!

[DonJ]

ricordati che lo stack è una struttura di tipo LIFO

non è vero
è una struttura FIFO
____________________________________________________________________

Ok
siccome avevo bisogno di dare una ripassata ad assembly ho dato un occhio.
dunque,
a quanto ho capito EBP si usa programmando assembly con un compilatore c
nel sistema che uso io EBP viene sostituito da BP, quindi io farò riferimento a BP
ma dovrebbe essere la stessa cosa.
come funziona questo accidente:
molto semplicemente il registro BP contiene l'ultimo indirizzo di memoria dello stack.
questo significa che utilizzando BP in un indirizzamento otterremo l'ultimo valore inserito nella pila dello stack.
mettiamo caso che nella pila sia presente il valore 00011001
utilizzando l'istruzione:

MOV AL, [BP]

in AL troveremo 00011001, questo perché il contenuto dell'indirizzo BP ( contenuto di BP = [BP] ) fa riferimento al valore in cima alla pila.
chiaramente un'istruzione così fa abbastanza ridere perché basterebbe fare un POP AL.
BP torna utile nel caso un valore finisca sotto a degli altri valori.
ad esempio:

Codice: Seleziona tutto

======STACK======
valore a [16 bit]   <---- BP (indica l'ultimo valore della pila)
valore b [16 bit]
valore c [16 bit]
valore x [16 bit]
..
..
=================

mettiamo il caso che io bravo programmatore abbia voglia (e magari anche la necessità) di recuperare x.
il manuale del buon programmatore ci ricorda che BP contiene l'indirizzo dell'ultimo valore.
quindi, come faccio a recuperare un valore che sta a 3 passi da BP?
beh, basta fare BP-3

MOV AX, [BP-3]

funziona?
sì ma no
sì perché il compilatore non dice niente
no perché i valori nello stack sono a 16 bit!
spiego meglio:
lo stack è un vettore che può contenere valori ad 8 bit, e quelli a 16, al momento del push, vengono "spezzati" in due parti
cioè:

PUSH AX

nello stack:

Codice: Seleziona tutto

======STACK======
AL              <---- BP
AH
..
..
=================

[ora, non mi ricordo se in cima c'è AL o AH, ma il concetto non cambia]

quindi ricorda che quando devi fare i calcoli devi considerare che un valore a 16 bit occupa due celle di memoria
tornando al nostro esempio:

Codice: Seleziona tutto

======STACK======
valore a [low]           <---- BP
valore a [high]
valore b [low]
valore b [high]
valore c [low]
valore c [high]
valore x [low]
valore x [high]
..
..
=================

abbiamo 3 valori da 16 bit all'interno dello stack
quindi per raggiungere x dovremo fare BP - 3*2 = BP - 6

MOV AX, [BP-6]

adesso in AX è presente il nostro amico x

tips & tricks:
ricorda che quando viene chiamata una procedura, nello stack vengono sempre aggiunti IP e DS
se prima di una chiamata hai fatto un PUSH AX, per andare a recuperare il valore dovrai fare

MOV AX, [BP-4]

così salterai IP e DS che vengono prima.

ancora una volta, spero di essere stato chiaro.

[c1b8]

Lo stack è LIFO.
Infatti l'ultimo valore ad entrare è il primo ad uscire.

Codice: Seleziona tutto

   push AX
   push BX

   pop  BX
   pop  AX


Il codice sopra è corretto perché lo stack è LIFO.

[c1b8]

....utilizzando l'istruzione:

MOV AL, [BP]

in AL troveremo 00011001, questo perché il contenuto dell'indirizzo BP ( contenuto di BP = [BP] ) fa riferimento al valore in cima alla pila.
chiaramente un'istruzione così fa abbastanza ridere perché basterebbe fare un POP AL.
.....

Per completezza di informazione le due istruzioni proposte non danno lo stesso risultato.
Entrambe valorizzano Al con il contenuto della cella di memoria puntata da BP ma la seconda (pop) cambia, il valore di BP. La prima no.

Push e Pop cambiano il valore di BP attenzione quindi al loro utilizzo nel pescare valori dalla stack.

[DonJ]

Push e Pop cambiano il valore di BP attenzione quindi al loro utilizzo nel pescare valori dalla stack.

giusto
avevo dimenticato questo "particolare"

Lo stack è LIFO.

ma sai che la penso anche io così
infatti nel primo post ho scritto LIFO
però il mio libro di sistemi dice che è FIFO
bah.

[danyrus07]

Grazie per il consiglio da bravo programmatore...

Vedro di fare qualche programmino ora che ce l'ho più presente....

Ciao!!