El ensamblador de Linux sigue el formato de AT & T (creadores de unix) por lo que aquellos que conozcais el ensamblador de Intel necesitareis conocer los pasos para convertir codigo de un formato a otro. Veamos esos pasos.

 La documentacion siguiente ha sido traducida del ingles de la documentacion sobre el ensamblador con compiladores GNU C.
 

Consideramos de especial interes las siguientes direcciones donde podreis formular preguntas comunes y encontrar respuestas de otras. faq102.zip and faq201b.zip. Hay tambien un grupo de news, comp.os.msdos.djgpp. La direccion principal de DJGPP es http://www.delorie.com/djgpp, donde podra encontrar la informacion mas reciente disponible sobre el tema, y en http://www.delorie.com/djgpp/mail-archives, podreis obtener la lista de los archivos con documentacion actualmente disponible. Ahi encontramos utiles articulos sobre el tema. 

Sintaxis del Ensamblador .AT&T x86

• En la sintaxis de AT&T el destino de una operacion se pone en el segundo parametro y la origen se pone en el primer parametro. (Al reves que en los Intel).
• El nombre de los registros es precedido por el caracter porcentaje ("%").
• Los valores inmediatos han de ser precedidos por el caracter "$".
• El tamaqo de los operandos se especifica mediante un ultimo caracter de la instruccion:"b" (8-bits) | "w" (16-bits) | "l" (32-bits).

        movw %bx, %ax   (mov ax, bx)
        xorl %eax, %eax (xor eax, eax)
        movw $1, %ax    (mov ax,1)
        movb X, %ah     (mov ah, byte ptr X)
        movw X, %ax     (mov ax, word ptr X)
        movl X, %eax    (mov eax, X)

        movsSD (movsx) 
        movzSD (movzx)

        cbtw        (cbw)
        cwtl        (cwde) 
        cwtd        (cwd) 
        cltd        (cdq)
        lcall $S,$O (call far S:O)
        ljmp $S,$O  (jump far S:O)
        lret $V     (ret far V)

Los direccionamientos a memoria se expresan de distinta manera.La sintaxis tipica Intel para direccionar la ram sigue el siguiente modelo:

SECTION:[BASE + INDEX*SCALE + DISP]

se escribe en AT&T como sigue

SECTION:DISP(BASE, INDEX, SCALE).

He aqui algunos ejemplos: (con sus equivalentes en Intel)

        movl 4(%ebp), %eax            (mov eax, [ebp+4])
        addl (%eax,%eax,4), %ecx      (add ecx, [eax + eax*4])
        movb $4, %fs:(%eax)           (mov fs:eax, 4)
        movl _array(,%eax,4), %eax    (mov eax, [4*eax + array])
        movw _array(%ebx,%eax,4), %cx (mov cx, [ebx + 4*eax + array])

Dado que las instrucciones de salto condicionales en la arquitectura del PC solo pueden ser de tipo "short" todas las instrucciones siguientes tienen un unico byte para el desplazamiento.Ejemplo de algunas instrucciones: "jcxz", "jecxz", "loop", "loopz", "loope", "loopnz" and "loopne". Remediamos este problema como lo haciamos en el formato de ensamblador de los Intel, utilizando etiquetas intermediarias para los saltos como se ve en el siguiente codigo para realizar la logica "jcxz foo". 

          jcxz cx_zero
          jmp cx_nonzero
        cx_zero: 
          jmp foo
        cx_nonzero:

ENSAMBLADOR EN LINEA - (dentro de C o C++) 

__asm__(sentencias en ensamblador : : entradas : registros modificados);

Los cuatro campos son :

• sentencias en ensamblador en formato AT&T separados por un retorno de carro
• Salidas - indicador seguido del nombre entre parentesis separado por una coma
• Entradas- indicador seguido del nombre entre parentesis separado por una coma
• Registros modificados - nombres separados por una coma

        __asm__("
          pushl %eax\n
          movl $1, %eax\n 
          popl %eax"
        );

Veamos un ejemplo mas complejo con variables de entrada.

        int i = 0;
        __asm__("
          pushl %%eax\n
          movl %0, %%eax\n
          addl $1, %%eax\n
          movl %%eax, %0\n
          popl %%eax"
          :
          : "g" (i)
        );
          /* i++; */

Si se especifica el campo de entrada es necesario especificar el campo de salida hallan o no hallan variables de salida. Simplemente se deja sin especificar (el campo vacio). Para el ultimo campo esta operacion no es necesaria. Se debe poner un espacio o un retorno de carro para separar un campo de otro.

Analicemos el campo de la entrada.El indicador del campo no es ni mas ni menos que una directiva que indica al compilador como debe gestionar las variables.Toda directiva debe ponerse entre dobles comillas.
En este caso la directiva "g" indica al compilador que decida donde desea almacenar el parametro (pila, registro , memoria) y se utiliza mucho pues generalmente los compiladores optimizan bien el codigo. Otra directiva util es la directiva "r" que le permite cargar la variable en cualquier registro que este libre de uso.De igual manera:
"a" (ax/eax), "b" (bx/ebx), "c" (cx/ecx), "d" (dx/edx), "D" (di/edi), "S" (si/esi),etc...

El primer parametro de entrada se simboliza como "%0" dentro de las sentencias de ensamblador . Y asi en el mismo orden de especificacion en el campo de entrada. Es decir, que para N entradas y ninguna salida "%0" hasta %N-1 simbolizaran las variables de entrada en el orden en el que se listen en el campo 3.

Algo muy importante ! 
Si se utiliza el campo de entrada, salida o de modificacion de registros los nombres de los registros deben ser precedidos de 2 % ("%%eax") en vez de uno como soliamos hacerlo. 

Veamos ahora el significado de la directiva __volatile__ despues de __asm__ en un ejemplo con dos entradas.

        int i=0, j=1;
        __asm__ __volatile__("
          pushl %%eax\n
          movl %0, %%eax\n
          addl %1, %%eax\n
          movl %%eax, %0\n
          popl %%eax"
          :
          : "g" (i), "g" (j)
        );
          /* i = i + j; */

Pero entonces para que sirve la directiba volatile ? Simplemente previene al compilador para que modifique nuestras sentencias de ensamblador si le es posible para optimizar el codigo(reordenacion, eliminacion de codigo inutil,recombinacion). Es una opcion muy recomendada.

Pasemos ahora a como se especifican los parametros de salida. Veamos un ejemplo:

        int i=0;
        __asm__ __volatile__("
          pushl %%eax\n
          movl $1, %%eax\n
          movl %%eax, %0\n
          popl %%eax"
          : "=g" (i)
        );
          /* i++; */

        int i=0, j=1, k=0;
        __asm__ __volatile__("
          pushl %%eax\n
          movl %1, %%eax\n
          addl %2, %%eax\n
          movl %%eax, %0\n
          popl %%eax"
          : "=g" (k)
          : "g" (i), "g" (j)
        );
          /* k = i + j; */

Cuando utilizamos parametros de entrada y salida 

%0 ... %K representan las salidas

%K+1 ... %N son las entradas

Asi en el ejemplo anterior "%0" se refiere a "k", "%1" a "i" y "%2" a "j". No era tan complicado verdad ?

Mas adelante puede sernos util utilizar el tercer campo pues nos evita de utilizar la pila para conservar y restaurar los registros modificados. Veamos el ejemplo anterior con este campo en vez de las instrucciones "push" y "pop".

        int i=0, j=1, k=0;
        __asm__ __volatile__("
          movl %1, %%eax\n
          addl %2, %%eax\n
          movl %%eax, %0"
          : "=g" (k)
          : "g" (i), "g" (j)
          : "ax", "memory"
        );
          /* k = i + j; */

Si modificamos la memoria (escribimos en variables) es recomendable especificar la directiva "memory". En todos los ejemplos anteriores deberiamos haber utilizado esta directiva pero por razones de simplicidad no se ha utilizado.

Las etiquetas locales dentro del ensamblador en linea debe terminar por una b o una f segun si esta despues o antes la etiqueta relacionada con la instruccion de salto. Creo que queda lo suficientemente claro en el siguiente ejemplo.

        __asm__ __volatile__("
        0:\n
          ...
          jmp 0b\n
          ...
          jmp 1f\n
          ...
        1:\n
          ...
        );  

Ensamblador Externo

  .file "myasm.S"

  .data
    somedata: .word 0
    ...
 
  .text
    .globl __myasmfunc
    __myasmfunc:
      ...
      ret

  #include <libc/asmdefs.h>

  .file "myasm.S"

  .data
    .align 2
    somedata: .word  0
    ...

  .text
    .align 4
    FUNC(__MyExternalAsmFunc)
    ENTER
      movl   ARG1, %eax
      ...
      jmp    mylabel
      ...
    mylabel:
      ...
    LEAVE

Otras fuentes de informacion 

If you have asm code that needs to be converted from Intel to AT&T syntax, or just want to stick with regular Intel syntax, you can:

• Get MASM and compile your sources to COFF format (object file format used by DJGPP)
• Get ta2asv08.zip, a TASM to AT&T asm converter
• Get o2cv10.arj to convert .OBJ/.LIB between TASM and DJGPP
• Search the mail archives for a sed script that converts Intel to AT&T syntax

GREETS ^bLeAcH^ and EFNET IRC #c, #e2, #gamecode and #os2prog

Thanks to all people behind DJGPP!

Mail me corrections/suggestions/complaints/crap at avly@remus.rutgers.edu

Copyright (c) 1996 avly@remus.rutgers.edu All Rights Reserved

All trademarks mentioned are of their respective companies.

Standard Disclaimer