Con lo que vimos anteriormente no logramos ningún tipo de interacción con los operadores definidos por el resto del código. Es esta versión "extendida" la que nos permitirá pasar valores inmediatos a registros, cargar registros con el contenido de variables, cargar variables con el contenido de registros, etc.
La sintaxis genérica es:
asm ( "instrucciones" : lista_salida : lista_entrada : lista_destruida);
Donde:
lista_salida(o
output list): contiene los registros, variables donde se guardara un dato.
lista_entrada (o
input list): contiene los registros, variables o datos inmediatos que se utilizaran como entradas en una instrucción.
lista_destruida (o
clobber list): contiene los registros que se ven modificados por las "instrucciones". Esta lista es necesaria para que el gcc sepa que registros debe utilizar, cuales debera resguardar, etc.
Si bien esto puede parecer un poco confuso, espero ir evacuando las dudas a través de ejemplos.
Ejemplo 1
int main(void)
{
int i=100;
asm ("movl %0,
" antes de su nombre.
Volviendo al ejemplo anterior, si observamos, el modificador "g" (i) se encuentra en la lista de entrada, mientras que las lista de salida esta vacía al igual que la clobber list.
Podriamos utilizar otro ejemplo levemente mas avanzado, para quien todavía se encuentra perdido.
Ejemplo 2
#define MAX_VALOR 200
int main(void)
{
int i=100;
asm ("movl %0,
ebx" : : "g" (i) , "g" (MAX_VALOR));
}
Aca nuevamente no utilizamos ni la lista de salida, ni la lista de registros destruidos. Simplemente cargamos en eax y en ebx el valor de i y 200 respectivamente.
Que función cumple el %0 y el %1 ? Estos son los valores que serán reemplazados dinámicamente por Gcc. En caso de que agregaramos más instrucciones con mas parámetros a cargar, continuarán con %2, %3, etc.
Que representa el "g" ? Este modificador le indica a Gcc que el parametro que se pasa entre paréntesis puede ser tanto una variable en memoria como un valor inmediato. Si bien el modificador "g" es uno de los más utilizados (al menos por mi) hay muchos otros. Sólo intentare explicar algunos, pueden consultar el resto en el manual.
Modificadores
A continuación se listan los modificadores más usados en el ensamblado extendido. Existen otros más, incluyendo algunos propios de ciertas arquitecturas.
- "a" eax
- "b" ebx
- "c" ecx
- "d" edx
- "S" esi
- "D" edi
- "q" o "r" cualquier registro de propósito general (a conveniencia de gcc)
- "I" valor inmediato (entre 0 y 31)
Voy a intentar clarificar un poco esto a través de unos ejemplos. Empecemos por uno sin mucha utilidad práctica, pero que a nuestros fines nos sirve:
Ejemplo 3
int main(void)
{
int i=100;
asm ("mov %0,
cr3" : : "a" (i) )
? Tal cual lo imaginamos, vamos a estar pisando el valor que pensaba utilizar Gcc con lo cual el comportamiento del programa es ahora totalmente impredecible. Es en este (y en otros) casos donde el modificador "r" nos ayuda a evitar esos problemas, ya que deja que Gcc elija un registro que no esta utilizando. Otra forma de evitar este tipo de inconvenientes es usar la denominada "clobber list" (la cual nombre anteriormente como lista de registros destruidos).
Veamos otro ejemplo sacado del código fuente de Routix, el cual muestra el uso del modificador "r"
#define load_cr3(x)
asm ("movl %0,
eax ; movl %1,
eax, %0" : "=g" (retorno) );
return retorno;
}
La primera linea no hace más que cargar en el registro EAX el número de llamada al sistema correspondiente, y en EBX la dirección de un string que posee el path del programa a ejecutar. Lo que aporta de nuevo esta función es que al final incluye un: "eax", "ebx" que corresponde a la clobber list. Con este agregado le estoy diciendo explícitamente a gcc que los registros EAX y EBX estan siendo modificados para que él pueda tomar los recaudos necesarios. (Tanto SYS_PROCESS como SYS_EXEC son macros, las cuales son consideradas como valores inmediatos).
La segunda línea hace pasar al modo kernel vía la interrupción 0x50.
El último fragmento agrega el modificador "=g" en la lista de salida. Hasta ahora habíamos pasado valores de variables a registros, pero nunca en sentido inverso, es en este último caso donde la output list (o lista de salida) entra en juego. La linea
asm volatile ("movl %%eax, %0" : "=g" (retorno) )
mueve el valor del registro EAX a lo que representa el %0, que en este caso es la variable retorno. Es evidente el agregado del signo "=" antes de la "g", el cual es necesario en el modificador usado en la lista de salida.
Veamos algún ejemplo más de la lista de salida.
Este ejemplo es la implementación de la función inportb en Routix:
unsigned char inportb(word puerto )
{
unsigned char valor;
asm volatile("inb %w1,%b0" : "=a" (valor) : "d" (puerto) );
return valor;
}
Aca podemos ver algunos agregados más. No se si habrán notado que siempre nos manejamos con datos de 4 bytes, es decir con el registro completo. No siempre es necesario esto, en algunos casos alcanza con un word (AX) y en otro incluso con un byte (AL). El caso de la instrucción INB (o IN) es un claro ejemplo. El número de puerto es un entero de 2 bytes, mientras que el valor leído de él es de tan solo 1. El operador %w le dice al gcc que el dato que recibe es un word (2 bytes), mientras que el %b hace lo respectivo a 1 byte.
Si compilamos este ejemplo con gcc -S obtenemos
_inportb:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl 8(%ebp), %eax
movw %ax, -2(%ebp)
movw -2(%ebp), %dx
/APP
inb %dx,%al
/NO_APP
movb %al, -3(%ebp)
movl $0, %eax
movb -3(%ebp), %al
leave
ret
donde podemos comprobar que realmente el gcc utiliza los registros parciales DX y AL.
