|
==Struttura==
Una procedura si definisce in questo modo:
:<ttcode><etichetta> PROC <tipo></ttcode>
:...
:<ttcode><etichetta> ENDP</ttcode>
La procedura può essere richiamata con l'istruzione <ttcode>CALL <etichetta></ttcode>. In realtà nell'istruzione <ttcode>CALL</ttcode> l'assemblatore converte il simbolo <ttcode><etichetta></ttcode> nell'indirizzo della prima istruzione della procedura. Alla chiamata, l'indirizzo del chiamante viene salvato dall'IP allo stack.
L'istruzione <ttcode>RET</ttcode>, priva di parametri, permette di ritornare alla procedura chiamante.
==Località==
Una procedura di tipo <ttcode>NEAR</ttcode> (predefinito) può essere richiamata solo all'interno dello stesso segmento di codice, e viene richiamata da una <ttcode>CALL</ttcode> su 3 byte tramite l'offset della sua prima istruzione. Una procedura di tipo <ttcode>FAR</ttcode> può essere chiamata da procedure appartenenti a segmenti di codice diversi; la <ttcode>CALL</ttcode> su 5 byte prima di caricare l'offset della procedura deve modificare il registro CS, effettuando il push nello stack del vecchio valore di CS.
Anche l'istruzione <ttcode>RET</ttcode> si distingue per i tipi <ttcode>NEAR</ttcode> e <ttcode>FAR</ttcode>, effettuando la pop dallo stack di uno o due word.
==[[Calcolatori elettronici/Architettura 8086#Segmento di stack|Stack]]==
===Backup del contenuto dei registri===
Le procedure vengono richiamate tramite l'istruzione <ttcode>CALL</ttcode>, che salta alla prima istruzione della procedura. Al termine della procedura, l'istruzione <ttcode>RET</ttcode> deve poter ritornare al chiamante → l'istruzione <ttcode>CALL</ttcode>, prima di sovrascrivere il PC con il nuovo indirizzo, deve quindi temporaneamente salvare (push) nello stack il PC del chiamante, che verrà letto (pop) dall'istruzione <ttcode>RET</ttcode>. La struttura LIFO garantisce che l'ordine dei PC letti da una serie di istruzioni <ttcode>RET</ttcode> appartenenti a procedure annidate sia corretto, cioè dall'ultima procedura chiamata fino al primo chiamante.
I valori dei registri possono essere salvati prima della prima istruzione e ripristinati dopo l'ultima istruzione, in modo che la procedura non "sporchi" i registri.
I linguaggi assembler non hanno alcun meccanismo apposito per il passaggio dei parametri.
Prima della chiamata della procedura il chiamante può salvare nello stack i parametri, che verranno letti durante l'esecuzione della procedura. Il problema è che l'istruzione <ttcode>CALL</ttcode> li coprirebbe con il valore dell'IP. Il registro BP serve per salvare temporaneamente il valore dell'SP subito dopo la chiamata come prima istruzione della procedura (lo stack si riempe a partire dal fondo), in modo che il primo parametro sia accessibile all'indirizzo <ttcode>[BP+2]</ttcode>. Un semplice ripristino dell'SP al valore originario segue il ritorno al chiamante. I parametri di ritorno possono essere salvati dalla procedura e letti dal chiamante in una posizione destinata appositamente nello stack tramite una istruzione <ttcode>SUB</ttcode> dell'SP che precede le push dei parametri. Non c'è limite al numero di parametri, e i parametri rimangono in memoria solo per il tempo di esecuzione della procedura. Questa soluzione non può essere applicata a procedure annidate, perché il registro BP può contenere un solo valore di SP; per ovviare a questo problema, si può salvare il contenuto di BP a sua volta nello stack subito prima di sovrascriverlo con il valore di SP, e quindi ripristinarlo con una pop subito prima della istruzione <ttcode>RET</ttcode>, avendo l'accortezza di accedere al primo parametro all'indirizzo <ttcode>[BP+4]</ttcode>.
====Altri modi====
| 