Inline Assembly - How to - Inline Assembly

Ejemplo muy simple

Como coloco una instrucción de "no operation" dentro de mi código ?

int main (void)
{
asm ("nop");
}



Procedemos a compilar utilizando el modificador -S, el cual le dice a gcc que compile pero no linkee, dejandonos como resultado un fuente en assembly (sintaxis AT& T). Es decir, ejecutamos gcc -S ejemplo1.c con lo que obtendríamos un ejemplo1.s conteniendo algo similar a esto:

.file "ejemplo1.c"
.section .text
.globl _main
_main:
pushl %ebp
movl %esp, %ebp
subl $8, %esp
andl $-16, %esp
movl $0, %eax
subl %eax, %esp
/APP
nop
/NO_APP
leave
ret
.ident "GCC: (GNU) 3.2.3"



De donde salio todo ese código si lo único que escribí fue un "nop" ? Es aquí donde eran necesarios los conocimientos de assembly :-) . Por el momento basta con que sepas que las funciones en C reciben sus argumentos a través del stack, y es en ese mismo lugar donde "viven" las variables locales. Si bien nuestro "main" no recibe argumentos ni define variables locales, el Gcc arma la estructura como si las usara. Es entre las lineas /APP y /NO_APP que aparece nuestro código.

NOTA: Estas líneas fueron compiladas utilizando el DIGPPEl código de salida puede variar ligeramente dependiendo del compilador.

Otro ejemplo sencillo

Veamos otro ejemplo simple para los que aún se sientan confundidos:

int main(void)
{
asm ("movl $0xdead, %eax");
}



Luego de ejecutar gcc -S ejemplo2.c obtenemos:

.file "ejemplo2.c"
.section .text
.globl _main
_main:
pushl %ebp
movl %esp, %ebp
subl $8, %esp
andl $-16, %esp
movl $0, %eax
subl %eax, %esp
/APP
movl $0xdead, %eax
/NO_APP
leave
ret
.ident "GCC: (GNU) 3.2.3"



NOTA: es necesario colocar antes de los datos inmediatos el operando "$" para que el gcc lo intérprete correctamente, mientras que a los registros debe anteponerse un "%". Como verán el inline assembly básico no representa gran utilidad, excepto en algunos casos como los que se describen a continuación.

Ejemplos más útiles

Ahora

asm ("sti");



El cual habilita las interrupciones enmascarables del microprocesador. Es bastante comun encontrarse con alguna de las siguientes definiciones:

#define enable() asm volatile ("sti")
o
#define sti() asm volatile ("sti")



las cuales son visualmente mas agradables que su contraparte utilizando inline assembly.

Veamos algún otro ejemplo útil del inline assembly común:

asm volatile ("pushf ; cli");
.
.
código crítico
.
.
asm volatile ("popf");



En este caso no hacemos mas que bloquear las interrupciones para un fragmento de código crítico, el cuál no puede ser interrumpido. El uso del PUSHF y POPF en lugar de un simple CLI y STI me aseguran que las interrupciones al finalizar mi código quedarán en el estado que estaban antes de que yo las deshabilite.