Hola a todos,
A partir de este capítulo espero que podáis hacer vuestras primeras funciones en ensamblador, y nos servirá de base para poder ir avanzando en conceptos un poco más peliagudos.
El código en ensamblador (como la mayoría de los lenguajes de programación) se basa en la ejecución de las instrucciones que queremos realizar sobre los datos que nos interesa modificar. Estos datos están almacenados en los registros.
Registros
Los registros son trozos de memoria parecida a la RAM muy pequeña y muy muy rápida que están incrustados dentro del mismo procesador, por lo tanto, la forma de acceder y trabajar con ellos es particular de ese procesador.
Registros de 32 bits: Los registros de 32 bits son los más usuales y son los que nos permiten almacenar 1 int, 1 floats, 2 shorts o 4 chars.
Aunque hay bastantes registros internos, los que podemos usar desde programación son 6: eax, ebx, ecx, edx, esi, edi.
Aquí es donde se ha de ir con cuidado, hay registros con funcionalidades muy concretas y hay funciones que usaran ciertos registros sin previo aviso.
Ejemplos:
- La función de multiplicación acepta solo un parámetro, Este parámetro lo multiplicará por lo que haya en eax y el resultado lo dejará en eax y edx (la multiplicación de dos números de 32 bis puede ocupar 64 bits). Es decir, que después de usar la multiplicación eax y edx valdrán lo que ella quiera que valga no lo que nosotros teníamos almacenado.
- Las funciones de movimieno de string (movsd por ejemplo) usan de forma implicita los registros esi (source, origen) y edi (destination, destino) para apuntar a las zonas de memoria de origen y destino donde se hace la copia.
- La función ret (la que es comparable al return de C) no pide parámetros (al menos para el nivel que a nosotros nos interesa ), así que el valor de retorno de la función lo obtiene del registro eax de forma implicita.
- La función loop solo admite como parámetro el label de a donde tenemos que saltar. El contador de bucle es de forma implícita ecx.
Registros de 16 bits: A veces nos hace falta trabajar con 16 bits. Los registros de 16 bits de los que disponemos no son más que los 16 bits de menor peso de los registros anteriores, que son: ax, bx, cx, dx, si, di.
Registros de 8 bits: En ocasiones, 16 bits no es suficientemente pequeño y hemos usar registros del tamaño de 1 byte. Para estas ocasiones tenemos la opción de usar los bytes de los registros de 16 bits por separado: ax = al + ah, bx = bl + bh, cx = cl + ch, dx = dl + dh.
A nivel gráfico se podría resumir tal que así:
Operaciones:
Las instrucciones en ensamblador pueden aceptar un número variable de parámetros en función que operación sea (y en ocasiones una instrucción tiene diferentes usos en función de los parámetros que se le pasen)
Ya que hay cientos de funciones y todas ellas tienen sus particularidades vamos a explicar como funcionan poniendo ejemplos:
char LP_memcmp( const void * ptr1, const void * ptr2, size_t num ) //Cabecera de función en C
{
__asm //Le decimos al compilador que vamos a iniciar un trozo de código en ensamblador
{
mov ecx,num //Movemos lo que tenemos en la variable num, dentro del registro ecx
mov esi,ptr1 //Movemos lo que tenemos en la variable ptr1, dentro del registro esi
mov edi,ptr2 //Movemos lo que tenemos en la variable ptr2, dentro del registro edi
....
no_multiplo: //Etiqueta usada por las instrucciones de salto
dec ecx // Decrementamos en una unidad el valor de ecx
mov al,[esi] //Copiamos al subregistro al el byte de memoria al que apunta el registro esi (es un puntero)
.....
cmp eax,ebx //Compara el valor de eax con ebx
jg mayor //Salta a la etiqueta "mayor" si eax es mayor que ebx
jl menor //Salta a la etiqueta "menor" si eax es menor que ebx
Con todo lo que os he explicado y los ejemplos que he ido colgando deberíais ser capaces de empezar ha hacer vuestras primeras funciones. Para cualquier duda no dudéis en consultármela.
Nos vemos
0 comentarios :
Publicar un comentario