¡Esta es una revisión vieja del documento!
Integración de ASM en Z88DK
En este capítulo vamos a ver cómo podemos usar ASM dentro del compilador de C más utilizado en Spectrum: el Z88DK.
La idea de hacer programas mixtos en C con pequeñas partes en ASM es la de escribir en ensamblador las partes más críticas o importantes del mismo para acelerar su ejecución.
Por ejemplo, en un juego podríamos escribir el esqueleto del programa en C, incluyendo menú del juego, presentación, bucle principal de la partida, etc, pero escribir en ensamblador las rutinas que leen el teclado, renderizan los mapas, dibujan los gráficos y reproducen el sonido, que es donde requerimos la mayor velocidad de ejecución.
Embeber ASM dentro de código C
Z88DK permite utilizar ASM de diferentes formas. En nuestro caso vamos a ver cómo se “embebe” C en ASM con las siguientes directivas:
// Codigo en C #asm ; codigo en ensamblador #endasm // Codigo en C
Funciones escritas ASM llamables desde C
Ya hemos visto cómo embeber código ASM en cualquier lugar de nuestro programa.
Lo normal es que ese código ASM lo queramos llamar desde otras partes del programa en C, es decir, que queramos crear “funciones” (rutinas) íntegramente en ASM pero llamables como funciones de C. Para eso, simplemente creamos nuestra función y
void ClearScreen() { #asm XOR A LD HL, 16384 ; HL = Inicio de la videoram LD (HL), A ; Escribimos el patron A en (HL) LD DE, 16385 ; Apuntamos DE a 16385 LD BC, 192*32-1 ; Copiaremos 192*32-1 veces (HL) en (DE) LDIR #endasm }
No es necesario hacer PUSH y POP de los registros para preservar sus valores porque Z88DK lo hace automáticamente por nosotros.
Podremos llamar a esta función desde nuestro código en C como a cualquier otra función:
ClearScreen();
Este ejemplo es muy sencillo y no ha necesitado parámetros de entrada, pero en muchas ocasiones necesitaremos poder pasar parámetros en las llamadas de las funciones, y recibir valores desde las mismas.
Cómo leer parámetros de funciones desde ASM
En C (y en otros lenguajes de programación) los parámetros se insertan normalmente en la pila en el orden en que aparecen en el código del programa. La subrutina debe utilizar el registro SP (sin modificarlo, y sin desapilar los valores) para acceder a los valores apilados en orden inverso, leyendo sus valores de la memoria. Estos valores son siempre de 16 bits aunque las variables pasadas sean de 8 bits (en este caso ignoraremos el byte que no contiene datos, el segundo).
Veamos unos ejemplos:
//-----------------------------------------------------------------
// Sea parte de nuestro programa en C:
int jugador_x, jugador_y;
jugador_x = 10;
jugador_y = 200;
Funcion( jugador_x, jugador_y );
(...)
//-----------------------------------------------------------------
int Funcion(int x, int y)
{
#asm
LD HL,2
ADD HL,SP ; Ahora SP apunta al ultimo parametro metido
; en la pila por el compilador (valor de Y)
LD C, (HL)
INC HL
LD B, (HL)
INC HL ; Ahora BC = y
LD E, (HL)
INC HL
LD D, (HL)
INC HL ; Ahora, DE = x
;;; (ahora hacemos lo que queramos en asm)
#endasm
}
No tenemos que preocuparnos por hacer PUSH y POP de los registros para preservar su valor dado que Z88DK lo hace automáticamente antes y después de cada #asm y #endasm.
El problema es que conforme crece el número de parámetros apilados, es posible que tengamos que hacer malabarismos para almacenarlos, dado que no podemos usar HL (es nuestro puntero a la pila en las lecturas). Veamos el siguiente ejemplo con 3 parámetros, donde tenemos que usar PUSH para guardar el valor de DE y EX DE, HL para acabar asociando el valor final a HL:
//-----------------------------------------------------------------
int Funcion(int x, int y, int z)
{
#asm
LD HL,2
ADD HL,SP ; Ahora SP apunta al ultimo parametro metido
; en la pila por el compilador (z)
LD C, (HL)
INC HL
LD B, (HL)
INC HL ; Ahora BC = z
LD E, (HL)
INC HL
LD D, (HL)
INC HL ; Ahora, DE = y
PUSH DE ; Guardamos DE
LD E, (HL)
INC HL
LD D, (HL)
INC HL ; Usamos DE para leer el valor de x
EX DE, HL ; Ahora cambiamos x a HL
POP DE ; Y recuperamos el valor de y en DE
;;; (ahora hacemos lo que queramos en asm)
#endasm
}
La manera de leer bytes (variables de tipo char) pulsados en C es de la misma forma que leemos una palabra de 16 bits, pero ignorando la parte alta. En realidad, como la pila es de 16 bits, el compilador convierte el dato de 8 bits en uno de 16 (rellenando con ceros) y mete en la pila este valor:
//-----------------------------------------------------------------
int Funcion(char x, char y)
{
#asm
LD HL,2
ADD HL,SP ; Ahora SP apunta al ultimo parametro metido
; en la pila por el compilador (z)
LD A, (HL) ; Aquí tenemos nuestro dato de 8 bits (y)
LD B, A
INC HL
INC HL ; La parte alta del byte no nos interesa
LD A, (HL) ; Aquí tenemos nuestro dato de 8 bits (x)
LD C, A
INC HL
INC HL ; La parte alta del byte no nos interesa
;;; (ahora hacemos lo que queramos en asm)
#endasm
}
En ocasiones, es posible que incluso tengamos que utilizar variables auxiliares de memoria para guardar datos:
//-----------------------------------------------------------------
int Funcion(int x, int y, char z)
{
#asm
LD HL,2
ADD HL,SP ; Ahora SP apunta al ultimo parametro metido
; en la pila por el compilador (z)
LD C, (HL)
INC HL
LD B, (HL)
INC HL ; Ahora BC = y
LD (valor_y), BC ; nos lo guardamos, BC libre de nuevo
LD C, (HL)
INC HL
LD B, (HL)
INC HL
LD (valor_x), BC ; Nos lo guardamos, BC libre de nuevo
LD A, (HL)
LD (valor_z), A ; Nos guardamos el byte
INC HL
INC HL ; La parte alta del byte no nos interesa
;;; (ahora hacemos lo que queramos en asm)
RET
valor_x DW 0
valor_y DW 0
valor_z DB 0
#endasm
}
Devolver parámetros desde funciones escritas en ASM
Por contra, para devolver valores no se utiliza la pila dado que no podemos tocarla, ya que el RET volvería al valor pulsado y no a la dirección de retorno. Lo que se hace en Z88DK es utilizar un determinado registro. En el caso de Z88DK, se utiliza el registro HL. Si la función es de tipo INT o CHAR en cuanto a devolución, el valor que dejemos en HL al finalizar la función será el que se asignará en una llamada de este tipo:
valor = MiFuncion_ASM(x, y, z);
Ejemplos de Integracion de ASM en Z88DK
Para aprovechar esta introducción de “uso de ASM en Z88DK”, veamos el código de algunos ejemplos de funciones en C que usen ASM internamente y que muestren, entre otras cosas, la lectura de parámetros de la pila, el acceso a variables del código C, el uso de etiquetas, o la devolución de valores.
//
// Devuelve la direccion de memoria del atributo de un caracter
// de pantalla, de coordenadas (x,y). Usando la dirección que
// devuelve esta función (en HL, devuelto en la llamada), podemos
// leer o cambiar los atributos de dicho carácter.
//
// Llamada: valor = Get_LOWRES_Attrib_Address( 1, 3 );
//
int Get_LOWRES_Attrib_Address(char x, char y)
{
#asm
LD HL, 2
ADD HL, SP ; Leemos x e y de la pila
LD D, (HL) ; d = y
INC HL ; Primero "y" y luego "x".
INC HL ; Como son "char", ignoramos parte alta.
LD E, (HL) ; e = x
LD H, 0
LD L, D
ADD HL, HL ; HL = HL*2
ADD HL, HL ; HL = HL*4
ADD HL, HL ; HL = HL*8
ADD HL, HL ; HL = HL*16
ADD HL, HL ; HL = HL*32
LD D, 0
ADD HL, DE ; Ahora HL = (32*y)+x
LD BC, 16384+6144 ; Ahora BC = offset attrib (0,0)
ADD HL, BC ; Sumamos y devolvemos en HL
#endasm
}
//
// Set Border
// Ejemplo de modificación del borde, muestra cómo leer variables
// globales de C en ASM, añadiendo "_" delante.
//
unsigned char bordeactual;
void BORDER( unsigned char value )
{
#asm
LD HL, 2
ADD HL, SP
LD A, (HL)
LD C, 254
OUT (C), A
LD (_bordeactual), A
RLCA ; Adaptamos el borde para guardarlo
RLCA ; en la variable del sistema BORDCR
RLCA ; Color borde -> a zona de PAPER
LD HL, 23624 ; lo almacenamos en BORDCR para que
LD (HL), A ; lo usen las rutinas de la ROM.
#endasm
}
//
// Realización de un fundido de la pantalla hacia negro
// Con esta función se muestra el uso de etiquetas. Nótese
// como en lugar de escribirse como ":", se escriben sin
// ellos y con un punto "." delante.
//
void FadeScreen( void )
{
#asm
LD B, 9 ; Repetiremos el bucle 9 veces
.fadescreen_loop1
LD HL, 16384+6144 ; Apuntamos HL a la zona de atributos
LD DE, 768 ; Iteraciones bucle
HALT
HALT ; Ralentizamos el efecto
.fadescreen_loop2
LD A, (HL) ; Cogemos el atributo
AND 127 ; Eliminamos el bit de flash
LD C, A
AND 7 ; Extraemos la tinta (AND 00000111b)
JR Z, fadescreen_ink_zero ; Si la tinta ya es cero, no hacemos nada
DEC A ; Si no es cero, decrementamos su valor
.fadescreen_ink_zero
EX AF, AF ; Nos hacemos una copia de la tinta en A
LD A, C ; Recuperamos el atributo
SRA A
SRA A ; Pasamos los bits de paper a 0-2
SRA A ; con 3 instrucciones de desplazamiento >>
AND 7 ; Eliminamos el resto de bits
JR Z, fadescreen_paper_zero ; Si ya es cero, no lo decrementamos
DEC A ; Lo decrementamos
.fadescreen_paper_zero
SLA A
SLA A ; Volvemos a color paper en bits 3-5
SLA A ; Con 3 instrucciones de desplazamiento <<
LD C, A ; Guardamos el papel decrementado en A
EX AF, AF ; Recuperamos A
OR C ; A = A OR C = PAPEL OR TINTA
LD (HL), A ; Almacenamos el atributo modificado
INC HL ; Avanzamos puntero de memoria
DEC DE
LD A, D
OR E
JP NZ, fadescreen_loop2 ; Hasta que DE == 0
DJNZ fadescreen_loop1 ; Repeticion 9 veces
#endasm
}
Un detalle a tener en cuenta, en Z88DK se soporta “EX AF, AF”, mientras que pasmo requiere poner la comilla del shadow-register: “EX AF, AF'”.
En la anterior captura podéis ver el aspecto de uno de los pasos del fundido.
Paginación de memoria desde Z88DK (C)
Podemos paginar memoria también desde C usando Z88DK mediante un código como el siguiente:
//--- SetRAMBank ------------------------------------------------------ // // Se mapea el banco (0-7) indicado sobre $C000. // // Ojo: en esta función no se deshabilitan las interrupciones y además, // en lugar de usar el registro B como parámetro, se recibe por la pila. // void SetRAMBank(char banco) { #asm ld hl, 2 add hl, sp ; SP apunta a la posicion de "banco" en la pila ld a, (hl) ; Leemos parte baja de "banco" de la pila ; Es 8 bits, la parte alta es 00, la ignoramos ld b, a ld a, ($5B5C) and f8h or b ld bc, $7FFD ld ($5B5C), a out (c), a ; Realizamos cambio de banco #endasm }
Con el anterior código podemos mapear uno de los bancos de memoria de 16KB sobre la página que va desde $C000 a $FFFF, pero debido al uso de memoria, variables y estructuras internas que hace Z88DK, debemos seguir una serie de consideraciones.
- Todo el código en ejecución debe estar por debajo de $C000, para lo cual es recomendable definir los gráficos al final del “binario”.
- Es importantísimo colocar la pila en la memoria baja, mediante la siguiente instrucción (o similar, según la dirección en que queremos colocarla) al principio de nuestro programa:
/* Allocate space for the stack */ #pragma output STACKPTR=24500
La regla general es asegurarse de que no haya nada importante (para la ejecución de nuestro programa) en el bloque $C000 a $FFFF cuando se haga el cambio: ni la pila, ni código al que debamos acceder. Tan sólo datos que puedan ser intercambiandos de un banco a otro sin riesgo para la ejecución del mismo (por ejemplo, los datos de un nivel de juego en el que ya no estamos).