Convención de llamada CALLER

En este esquema, la parte del código que llama la función, mete los parámetros en la pila, llama a la función y luego retira los parámetros del stack.

Ejemplo sacado del foro de Speccy.org:

    ld hl,10
    push hl
    call Funcion1
    pop bc   ; clean up stack
...
 
Funcion1:  ;  llamada a void Funcion1( char dato1 )
    ld hl, 2
    add hl, sp
    ld a, (hl)   ; carga el parámetro del stack, A = dato1
    ...
    (resto de la subrutina)
    ...
    ret

Fíjate que tras el call Funcion1 hay un pop bc para dejar la pila como estaba antes de la llamada. Esto es importante, para mantener la consistencia de la pila a lo largo de sucesivas llamadas. Además, como el Z80 mete en la pila registros de 16 bits, el parámetro de 8 bits toma 2 bytes, y sólo se tiene en cuenta la parte baja de dicho valor.

Ahora veamos cómo sería este esquema con una función de tres parámetros:

    ld hl,10
    push hl  ; pasa el parámetro 10
    ld hl,4
    push hl  ; pasa el parámetro 4
    ld hl,2
    push hl  ; pasa el parámetro 2
    call Funcion3 ; call Funcion3(2, 4, 10)
    pop bc   ; -------------------------
    pop bc   ; clean up stack
    pop bc   ; -------------------------
 
    ld hl,11
    push hl  ; pasa el parámetro 11
    ld hl,5
    push hl  ; pasa el parámetro 5
    ld hl,2
    push hl  ; pasa el parámetro 2
    call Funcion3 ; call Funcion3(11, 5, 2)
    pop bc   ; -------------------------
    pop bc   ; clean up stack
    pop bc   ; -------------------------
 
...
Function3

Como puede verse, cada vez que llamamos a la Funcion3, desperdiciamos 3 bytes limpiando el stack. Si, además, usáramos siempre pop bc para ir despejando el stack, una serie de llamadas a una función de 10 parámetros sería más lenta, y requeriría 10 bytes de instrucciones pop bc para limpiarlo.

Otra opción, cuando el número de parámetros es tan grande es incrementar el stack tantos bytes como sea necesario en vez de hacer pop bc constantemente. Esto es más rápido y ocupa menos espacio en memoria.