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

Le Schede del Tutorial

  Stack - Definizione e Gestione

SCHEDA n° 06 [ 5  di 7] 

    

    Lo Stack nella gestione di Procedure di Sistema
     
bulletLe chiamate di sistema sono certamente extrasegmentali; si tratta di procedure speciali:
bulletse appartengono al Dos o a qualche Driver (per esempio quello del Mouse) sono allocate nella parte bassa della memoria ram, probabilmente nel primo segmento.
bulletse sono primitive Bios sono certamente nell'ultimo segmento del primo megabyte (parte alta della memoria), di solito a partire dall'indirizzo F0000H.
bulletse sono rimappate dalla scheda video sono allocate nel segmento C0000H.
bulletIn ogni caso il processore può disporre di questi servizi eseguendo l'istruzione di chiamata INT xx; il numero esadecimale XX, passato come operando, indica il tipo di servizio desiderato; per restare agli esempi suggeriti poco fa:
bulletse si tratta di una funzione Dos vale certamente 21H.
bulletse il servizio si svolge comunque in ambito Dos sono potenzialmente possibili i numeri da 20H a 2FH.
bulletse si tratta delle funzioni di un driver i numeri sono per lo più convenzionalmente conosciuti: per esempio le funzioni del Mouse si chiamano con il numero 33H.
bulletse sono procedure Bios i numeri possono andare da 10H a 1FH; tra questi il primo si occupa proprio delle funzioni del video e, come detto, può essere catturato e sostituito dal sistema operativo di base (bios) della scheda video stessa.

      

bulletQuando il processore è chiamato ad eseguire l'istruzione INT xx provvede ai seguenti compiti:
bulletcalcola l'indirizzo Offset dell'istruzione successiva a quella che sta eseguendo, sommando 0002 (numero di bytes del codice macchina corrispondente a INT xx) all'indirizzo corrente.
bulletdecrementa il valore corrente di SP e lo utilizza per puntare la locazione in cui scrivere la parte alta del registro delle Flag.
bulletdecrementa ancora SP con cui punta la locazione in cui scrivere la parte bassa delle Flag.
bulletdecrementa SP e lo utilizza per puntare la locazione in cui scrivere la parte alta del registro CS.
bulletdecrementa SP e lo utilizza per puntare la locazione in cui scrivere la parte bassa di CS.
bulletdecrementa SP e lo utilizza per puntare la locazione in cui scrivere la parte alta dell'indirizzo di offset calcolato poco fa.
bulletdecrementa SP e lo utilizza per puntare la locazione in cui scrivere la parte bassa dell'indirizzo di cui sopra.
bulletutilizza il numero XX, operando dell'istruzione, per prelevare dalla Tabella dei Vettori, l'indirizzo logico della procedura di sistema corrispondente e con esso carica CS:IP, obbligando di fatto se stesso a saltare al nuovo indirizzo.
bulletDopo l'esecuzione di INT xx, il processore si trova in tutt'altro ambiente, lontano dal programma principale da cui è partito, certamente in un altro segmento; si mette ad eseguire diligentemente tutte le istruzioni della procedura, in attesa della IRET, che gli consentirà di tornare nel suo percorso nativo, naturalmente subito dopo l'istruzione INT.
bulletQuando il processore esegue l'istruzione IRET (al termine della Procedura di Sistema in cui è stato costretto a saltare) provvede ai seguenti compiti:
bulletpreleva il byte contenuto nella locazione attualmente puntata da SP, lo trasferisce nella parte bassa di IP.
bulletincrementa il valore di SP e lo utilizza per puntare la locazione da cui prelevare il byte da utilizzare come parte alta di IP.
bulletincrementa ancora SP e lo utilizza per puntare la locazione da cui prelevare la parte bassa di CS.
bulletincrementa SP e lo utilizza per puntare la locazione da cui prelevare la parte alta di CS.
bulletincrementa SP e lo utilizza per puntare la locazione da cui prelevare la parte bassa del registro delle Flag.
bulletincrementa SP e lo utilizza per puntare la locazione da cui prelevare la parte alta del registro delle Flag.
bulletincrementa il valore di SP.
bulletsalta alla locazione di programma indicata dal nuovo valore di CS:IP, praticamente l'indirizzo logico completo della locazione del programma principale successiva a quella con la INT che l'aveva costretto ad uscirne.
bulletDopo l'esecuzione di IRET, il processore è dunque rientrato nei ranghi...

      

Ricorda... In questo caso l'istruzione di ritorno, IRET, è del tutto diversa: recupera dallo Stack ben 6 bytes invece dei 2 di RET e i 4 di RETF.

      

bulletI 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:

      

0DE0:0100 B82A0E      MOV AX,0E2A
0DE0:0103 CD10        INT 10            
0DE0:0105 B44C        MOV AH,4C
0DE0:0107 CD21        INT 21            

-R   punto *1* -------------------------
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFFE
DS=0DE0 ES=0DE0 SS=0DE0 CS=0DE0 IP=0100
0DE0:0100 B82A0E       MOV AX,0E2A

-T   punto *2* -------------------------
AX=0E2A BX=0000 CX=0000 DX=0000 SP=FFFE
DS=0DE0 ES=0DE0 SS=0DE0 CS=0DE0 IP=0103
0DE0:0103 CD10         INT 10

--T   punto *3* -------------------------
AX=0E2A BX=0000 CX=0000 DX=0000 SP=FFF8
DS=0DE0 ES=0DE0 SS=0DE0 CS=0212 IP=08A9
0212:08A9 2E803EA70802 CMP CS:[08A7],02

   <<<<<<<<<<<<< omissis >>>>>>>>>>>>

-T   punto *4* -------------------------
AX=0E2A BX=0000 CX=0000 DX=0000 SP=FFF8
DS=0DE0 ES=0DE0 SS=0DE0 CS=0212 IP=06AC
0212:06AC CF IRET

-T   punto *5* -------------------------
AX=0E2A BX=0000 CX=0000 DX=0000 SP=FFFE
DS=0DE0 ES=0DE0 SS=0DE0 CS=0DE0 IP=0105
0DE0:0105 B44C MOV AH,4C
--- punto *1* e *2* ---
0DE0:FFFC ??
0DE0:FFFD ??
0DE0:FFFE 00 <- SP=FFFE
0DE0:FFFF 00

--- punto *3* ---------
0DE0:FFF6 ??
0DE0:FFF7 ??
0DE0:FFF8 05 <- SP=FFF8
0DE0:FFF9 01
0DE0:FFFA E0
0DE0:FFFB 0D
0DE0:FFFC 02
0DE0:FFFD 32
0DE0:FFFE 00 
0DE0:FFFF 00

--- punto *4* ---------
0DE0:FFF6 ??
0DE0:FFF7 ??
0DE0:FFF8 05 <- SP=FFF8
0DE0:FFF9 01
0DE0:FFFA E0
0DE0:FFFB 0D
0DE0:FFFC 02
0DE0:FFFD 32
0DE0:FFFE 00 
0DE0:FFFF 00

--- punto *5* ---------
0DE0:FFF6 ??
0DE0:FFF7 ??
0DE0:FFF8 05
0DE0:FFF9 01
0DE0:FFFA E0
0DE0:FFFB 0D
0DE0:FFFC 02
0DE0:FFFD 32
0DE0:FFFE 00 <- SP=FFFE
0DE0:FFFF 00 

      

bulletAll'inizio (punto *1*), poichè la coppia di registri CS:IP contiene 0DE0:0100, il processore si trova costretto ad eseguire l'istruzione MOV AX,0E2A
bulletil 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.
bulletDopo l'esecuzione di MOV AX,0E2A (punto *2*), la coppia di registri CS:IP contiene 0DE0:0103: il processore si accinge ad eseguire INT 10 il puntatore di Stack non è stato influenzato dall'istruzione MOV: il suo valore è ancora SP=FFFE.
bulletDopo l'esecuzione di INT 10 (punto *3*):
bulletil puntatore di codice CS:IP contiene 0212:08A9si tratta della prima istruzione della procedura di servizio della INT 10H: l'analisi del codice mostra che si tratta di CMP CS:[08A7],02; naturalmente la chiamata della procedura di Sistema ha portato il processore certamente al di fuori del segmento di partenza.
bulletil puntatore di Stack punta la locazione SP=FFF8, a dimostrazione del fatto che sono state consumate altre 6 posizioni di Stack: il dettaglio a destra mostra che Stack sono finiti il registro delle Flag e il segment e l' offset della locazione successiva a quella (nel programma principale) in cui è scritta la INT 10 (0DE0:0105) cioè i 6 bytes a 32H, 02H, 0DH, E0H, 01H e 05H, nell'ordine indicato, per rispettare la tecnica Lo-Hi.
bulletDopo l'esecuzione di CMP CS:[08A7],02 e delle rimanenti istruzioni (<< omissis >>) della procedura di Sistema (punto *4*), la coppia di registri CS:IP contiene 0212:06AC e il processore si accinge ad eseguire IRET; il puntatore di Stack non è stato influenzato dalle istruzioni precedenti: il suo valore è ancora SP=FFF8.
bulletDopo l'esecuzione di IRET, dentro la procedura (punto *5*):
bulletil puntatore di codice CS:IP contiene 0DE0:0105: il processore è tornato nel programma principale e si accinge ad eseguire l'istruzione MOV AH,4C.
bulletil puntatore di Stack punta la locazione SP=FFFE, a dimostrazione del fatto che ha recuperato tutte e 6 le posizioni di Stack indotte in precedenza dalla INT 10.

      

bulletRiassumiamo la dinamica dello Stack, nella gestione di una chiamata di procedura di Sistema (INT); quando il processore è finalmente rientrato nel programma principale (per l'azione della IRET della procedura, dopo esserne uscito per l'azione di INT 10H):
bulletil puntatore di Stack ha il valore che aveva prima di iniziare il servizio di chiamata-procedura (nell'esempio SP=FFFE).
bulletsi 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!
bulletle 6 locazioni precedenti quella puntata da SP mostrano ancora i 6 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, di tutti e 3 i registri coinvolti, cioè quello delle Flag, CS e IP).
bulletil fatto che la ram sia rimasta sporca dei 6 bytes precedentemente caricati è irrilevante: le prossime operazioni che coinvolgeranno lo Stack in scrittura si limiteranno semplicemente a sovrascrivere questi valori.
bulletin ogni caso le prime 2 locazioni dello Stack sono sempre precaricate con 2 bytes a 00H dal sistema operativo (per le note vicende).

      

SP:FFF6 ?? non ancora utilizzato
SP:FFF7 ?? non ancora utilizzato
SP:FFF8 05 Lo Offset
SP:FFF9 01 Hi Offset
SP:FFFA E0 Lo Segment 
SP:FFFB 0D Hi Segment 
SP:FFFC 02 Lo Registro Flag
SP:FFFD 32 Hi Registro Flag
SP:FFFE 00 <- SP=FFFE
SP:FFFF 00 

    

Pagina Precedente Scheda n° 06 Pagina Successiva Stack - Definizione e Gestione Torna al Menu delle Schede del "Tutorial" Lezioni - Vai al DownLoad dei files DOC Torna al Menu del "Tutorial"
Scheda n° 06 -  5
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
Home 
Pascal|Manuali|Tabelle|Schede
Tutorial Assembly|Palestra Assembler
Aggiungi Giobe®2000 ai preferiti  
Motore
Ricerca
  Rendi Giobe®2000 pagina di Default
© 2001-2010  -  Studio Tecnico ing. Giorgio OBER
Tutti i diritti sono riservati