Per poter eseguire i propri calcoli una subroutine deve ricevere un certo numero di valori dal chiamante (parametri); in modo analogo essa deve fornire un risultato (valore di ritorno) al chiamante. Mediante parametri e valore di ritorno una subroutine è in sostanza in grado di comunicare col chiamante. Un esempio tratto dal linguaggio C è il seguente:

risultato = somma(num1, num2);

La funzione somma riceve i valori di num1 e di num2 dal chiamante, esegue la somma e restituisce un valore di ritorno che viene salvato in risultato.

In assembly non esiste nessun meccanismo automatico per realizzare questo passaggio: è compito del programmatore implementarlo. Un modo semplice è quello di utilizzare dei registri del µP per inviare e ricevere valori dalla subroutine. Questa soluzione (usata in tutti i nostri precedenti esempi) è molto facile da realizzare ma presenta alcuni inconvenienti:

• il numero dei registri interni dello Z80 è piuttosto limitato e inoltre tali registri potrebbero essere già in uso per altri scopi;
  
• il passaggio tramite registri rischia di diventare molto complicato e di non funzionare nel caso di subroutine che chiamano altre subroutine o, ancora peggio, nel caso di una subroutine che chiama ricorsivamente se stessa.

Il primo problema può essere facilmente risolto usando locazioni di memoria, invece di registri, per salvare i dati da passare da e verso la subroutine. Il secondo problema è invece più grave, in particolare nel caso di programmi complessi, con molte subroutine che si chiamano reciprocamente.

Una soluzione più elegante è quella di usare lo stack anche per il passaggio dei parametri e per la ricezione del valore di ritorno dalla subroutine. A questo proposito sono due le tecniche e le convenzioni maggiormente usate:

• Convenzione standard:
  il chiamante esegue il PUSH dei parametri sullo stack e la subroutine chiamata effettua il POP dei parametri;
  
• Convenzione del linguaggio C:
  il chiamante esegue il PUSH dei parametri sullo stack. La subroutine accede ai parametri sullo stack senza però prelevarli (cioè non esegue POP). Il chiamante, una volta eseguito il RET dalla subroutine, provvede ad eliminare (tramite POP) i parametri ancora presenti sullo stack.

Entrambe le tecniche presentano pro e contro che non possiamo discutere approfonditamente in questa sede.

Usando la convenzione standard, la chiamata alla funzione avviene in questo modo:

All'interno della subroutine il meccanismo è questo:

Si osservi che la subroutine deve prima estrarre dallo stack l'indirizzo di ritorno (salvato al momento della CALL) in modo da poter accedere ai parametri sottostanti. Infine la subroutine deve ripristinare sullo stack tale valore.

Analogamente prima dell'istruzione RET bisogna eseguire

Come esempio di chiamata di subroutine secondo la convenzione C osserviamo lo schema seguente:

precedente - successiva

Sito realizzato in base al template offerto da

http://www.graphixmania.it

Segui @ElePrograMania