2. Inline Assembly

2.1 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.

2.2 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.

2.3 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.