Stack , memoria deposito, push pop, passaggio parametri - Giobe®2000 - Tutorial Assembler Assembly - Scheda 06

Sezione

Indirizzi Base Registri Interni
Area Comunicazione BIOS Funzioni BIOS Funzioni DOS
Prefazione Capitolo 1 Capitolo 2 Schede
Libreria ASM Libreria MAC Palestra Progetti ASM
Info Download INDICE

Schede del Tutorial

Home » Programma il Computer » Tutorial Assembly

Stack - Definizione e Gestione

SCHEDA n° 06 [ 3 di 7]

Lo Stack nella gestione di Procedure NEAR

Quando il processore esegue un'istruzione di chiamata (CALL ProcNear) di Procedura NEAR provvede ai seguenti compiti:

	calcola l'indirizzo Offset dell'istruzione successiva a quella che sta eseguendo, sommando 0003 (numero di bytes del codice macchina corrispondente a CALL ProcNear) all'indirizzo corrente.
	decrementa il valore corrente di SP e lo utilizza per puntare la locazione in cui scrivere la parte alta dell'indirizzo appena calcolato.
	decrementa ancora il valore di SP e lo utilizza per puntare la locazione in cui scrivere la parte bassa dell'indirizzo appena calcolato.
	carica IP con l'indirizzo di offset ProcNear, operando dell'istruzione, obbligando di fatto se stesso a saltare a quell'indirizzo.

Dopo l'esecuzione di CALL ProcNear, il processore si trova in tutt'altro ambiente, lontano dal programma principale da cui è partito, ma nel medesimo segmento; si mette ad eseguire diligentemente tutte le istruzioni della procedura, in attesa della RET, che gli consentirà di tornare nel suo percorso nativo, naturalmente subito dopo l'istruzione CALL.

Quando il processore esegue l'istruzione RET (probabilmente l'ultima della Procedura NEAR in cui è stato costretto a saltare) provvede ai seguenti compiti:

	preleva il byte contenuto nella locazione attualmente puntata da SP, lo trasferisce nella parte bassa di IP.
	incrementa il valore di SP e lo utilizza per puntare la locazione da cui prelevare il byte da utilizzare come parte alta di IP.
	incrementa ancora SP.
	salta alla locazione di programma indicata dal nuovo valore di IP, praticamente l'indirizzo di offset della locazione del programma principale successiva a quella con la CALL che l'aveva costretto ad uscirne.

Dopo l'esecuzione di RET, il processore è dunque rientrato nei ranghi...

I movimenti del processore e dei suoi registri possono essere monitorati, sviluppati e analizzati in ambiente Debug, con l'aiuto di una semplice sequenza di istruzioni usata come banco di prova; a sinistra osserviamo i valori dei registri e a destra l'aspetto dello Stack, nelle varie fasi:

1192:0100 B80000 MOV AX,0102
1192:0103 E80600 CALL 010C
1192:0106 B44C   MOV AH,4C
1192:0108 CD21   INT 21
1192:010A 90     NOP
1192:010B 90     NOP
1192:010C 01C3   ADD BX,AX
1192:010E C3     RET

-R   punto *1* --------------------------
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFFE
DS=1192 ES=1192 SS=1192 CS=1192 IP=0100
1192:0100 B80000 MOV AX,0102

-T   punto *2* --------------------------
AX=0102 BX=0000 CX=0000 DX=0000 SP=FFFE
DS=1192 ES=1192 SS=1192 CS=1192 IP=0103
1192:0103 E80600 CALL 010C

-T   punto *3* --------------------------
AX=0102 BX=0000 CX=0000 DX=0000 SP=FFFC
DS=1192 ES=1192 SS=1192 CS=1192 IP=010C
1192:010C 01C3   ADD BX,AX

-T   punto *4* --------------------------
AX=0102 BX=0000 CX=0000 DX=0000 SP=FFFC
DS=1192 ES=1192 SS=1192 CS=1192 IP=010E
1192:010E C3     RET

-T   punto *5* --------------------------
AX=0102 BX=0000 CX=0000 DX=0000 SP=FFFE
DS=1192 ES=1192 SS=1192 CS=1192 IP=0106
1192:0106 B44C   MOV AH,4C

--- punto *1* e *2* ---
1192:FFFC ??
1192:FFFD ??
1192:FFFE 00 <- SP=FFFE
1192:FFFF 00

--- punto *3* ---------
1192:FFFA ??
1192:FFFB ??
1192:FFFC 06 <- SP=FFFC
1192:FFFD 01
1192:FFFE 00
1192:FFFF 00

--- punto *4* ---------
1192:FFFA ??
1192:FFFB ??
1192:FFFC 06 <- SP=FFFC
1192:FFFD 01
1192:FFFE 00
1192:FFFF 00

--- punto *5* ---------
1192:FFFA ??
1192:FFFB ??
1192:FFFC 06 Lo Offset
1192:FFFD 01 Hi Offset
1192:FFFE 00 <- SP=FFFE
1192:FFFF 00

All'inizio (punto *1*), poichè la coppia di registri CS:IP contiene 1192:0100, il processore si trova costretto ad eseguire l'istruzione MOV AX,0102

il puntatore di Stack punta la locazione SP=FFFE, a dimostrazione del fatto che il sistema operativo ha già consumato per sè una posizione di Stack (leggi la nota, PSP- offset 0000, se non ricordi o non sai il perché) caricandoci 2 bytes a 00H.

Dopo l'esecuzione di MOV AX,0102 (punto *2*), la coppia di registri CS:IP contiene 1192:0103: il processore si accinge ad eseguire CALL 010C: il puntatore di Stack non è stato influenzato dall'istruzione MOV: il suo valore è ancora SP=FFFE.

Dopo l'esecuzione di CALL 010C (punto *3*):

il puntatore di codice CS:IP contiene 1192:010C: pur mantenendo CS inalterato (per il fatto che la procedura chiamata è NEAR) punta con IP la prima istruzione della procedura, invece di puntare l'istruzione successiva, nel programma principale, cioè si accinge ad eseguire ADD BX,AX.

il puntatore di Stack punta la locazione SP=FFFC, a dimostrazione del fatto che è stata consumata un'altra posizione di Stack: il dettaglio a destra mostra che nello Stack è finito l'indirizzo di offset della locazione successiva a quella (nel programma principale) in cui è scritta la CALL 010C (0106) cioè i 2 bytes a 01H e 06H, nell'ordine indicato, per rispettare la tecnica Lo-Hi.

Dopo l'esecuzione di ADD BX,AX , dentro la procedura (punto *4*), la coppia di registri CS:IP contiene 1192:010E: il processore si accinge ad eseguire RET: il puntatore di Stack non è stato influenzato dall'istruzione ADD: il suo valore è ancora SP=FFFC.

Dopo l'esecuzione di RET, dentro la procedura (punto *5*):

	il puntatore di codice CS:IP contiene 1192:0106: il processore è tornato nel programma principale e si accinge ad eseguire l'istruzione MOV AH,4C.
	il puntatore di Stack punta la locazione SP=FFFE, a dimostrazione del fatto che ha recuperato la posizione di Stack indotta in precedenza dalla CALL 010C.

Riassumiamo la dinamica dello Stack, nella gestione di una chiamata di procedura intrasegmentale (NEAR); quando il processore è finalmente rientrato nel programma principale (per l'azione della RET near della procedura, dopo esserne uscito per l'azione di CALL ProcNear):

	il puntatore di Stack ha il valore che aveva *prima* di iniziare il servizio di chiamata-procedure (nell'esempio SP=FFFE).
	si può sottolineare che, in accordo con le definizioni, SP sta puntando la locazione *successiva* a quella che sarà caricata, in futuro, cioè sempre esterna all'area utile corrente dello Stack!
	le 2 locazioni precedenti quella puntata da SP mostrano ancora i 2 valori che il processore ha introdotto; la figura mette in evidenza che la scrittura è avvenuta con la tecnica Lo-Hi (cioè prima la parte bassa, Low, e poi la parte alta, High) dell'indirizzo di offset.
	il fatto che la ram sia rimasta sporca dei 2 bytes precedentemente caricati è irrilevante: le prossime operazioni che coinvolgeranno lo Stack in scrittura si limiteranno semplicemente a sovrascrivere questi valori.
	in ogni caso le prime 2 locazioni dello Stack sono *sempre* precaricate con 2 bytes a 00H dal sistema operativo (per le note vicende).

SP:FFFA ?? non ancora utilizzato
SP:FFFB ?? non ancora utilizzato
SP:FFFC 06 Lo Offset
SP:FFFD 01 Hi Offset
SP:FFFE 00 <- SP=FFFE
SP:FFFF 00

	Scheda n° 06			Stack - Definizione e Gestione
	Scheda n° 06 - 3

1 2 3 4 5 6 7

SCHEDE »

1.Header EXE 2.PseudoOp MASM 3.Differenza tra Macro e Procedure
4.Tabella Vettori 5.PSP 6.Stack 7.Istruzioni 80x86
8.La misura dell'Informazione 9.Numeri e Logica Binaria

TUTORIAL »

Indirizzi Base | Registri Interni | Area Comunicaz. BIOS | Funzioni BIOS | Funzioni DOS
Prefazione | CAP 1 | CAP 2 | Schede | Palestra
Libreria ASM | Libreria MAC | Progetti ASM | Download | Info | Indice

DataSheet|Display LCD
Parallela|Stampanti|Tastiera|Timer
Seriale| Video|Cursore|RamVideo

^Home

Pascal|Manuali|Tabelle|Schede
Tutorial Assembly|Palestra Assembler

Aggiungi Giobe®2000 ai preferiti

Rendi Giobe®2000 pagina di Default

Â© 2001-2010 - Studio Tecnico ing. Giorgio OBER
Tutti i diritti sono riservati