De C a la Asamblea

Supongamos que tenemos el siguiente código C para un avr-8bit:

int v1=1;
int v2=2;
v2=v2+v1;

Esperaba el siguiente desmontaje

ldi r18, 1;
ldi r19, 2;
add r19, r18;

pero después corrí:

avr-gcc -mmcu=atmega2560 Test.c -o Test.elf

y

avr-objdump -S Test.elf > Test.lss

Tengo el siguiente desmontaje

    ldi r24, 0x01   ; 1
    ldi r25, 0x00   ; 0
    std Y+2, r25    ; 0x02
    std Y+1, r24    ; 0x01
    ldi r24, 0x02   ; 2
    ldi r25, 0x00   ; 0
    std Y+4, r25    ; 0x04
    std Y+3, r24    ; 0x03
    ldd r18, Y+3    ; 0x03
    ldd r19, Y+4    ; 0x04
    ldd r24, Y+1    ; 0x01
    ldd r25, Y+2    ; 0x02
    add r24, r18
    adc r25, r19
    std Y+4, r25    ; 0x04
    std Y+3, r24    ; 0x03

¿Hay alguien que pueda ayudarme a comprender el resultado del desensamblador?

Editar: Usando char, el ensamblaje se convierte en:

ldi r24, 0x01
std Y+1, r24
ldi r24, 0x02
std Y+2, r24
ldd r25, Y+2
ldd r24, Y+1
add r24, r25
std Y+2, r24

¿Cuándo hay instrucción estándar?

Respuesta corta: sus registros son de 8 bits y sus valores son de 16 bits. Por lo tanto, los maneja en dos piezas.

Respuesta larga:

    ldi r24, 0x01   ; 1
    ldi r25, 0x00   ; 0

Almacene el valor 1 de 16 bits en registros de 8 bits r24, r25.

    std Y+2, r25    ; 0x02
    std Y+1, r24    ; 0x01

Guárdelo en ubicaciones de pila Y + 1, Y + 2.

    ldi r24, 0x02   ; 2
    ldi r25, 0x00   ; 0

Almacene el valor de 16 bits 2 en registros de 8 bits r24, r25.

    std Y+4, r25    ; 0x04
    std Y+3, r24    ; 0x03

Guárdelo en ubicaciones de pila Y + 3, Y + 4.

    ldd r18, Y+3    ; 0x03
    ldd r19, Y+4    ; 0x04
    ldd r24, Y+1    ; 0x01
    ldd r25, Y+2    ; 0x02

Copie de nuevo de la pila a (r18, r19) y (r24, r25)

    add r24, r18
    adc r25, r19

Agregue (r18, r19) a (r24, r25), incluido el carry en la segunda adición

    std Y+4, r25    ; 0x04
    std Y+3, r24    ; 0x03

Guárdelo de nuevo en la pila.

Para obtener su ensamblaje original, intente dos cosas:

• utilizar variables "char"
• use la opción del compilador "-O2"

Editar : la razón por la que el compilador almacena variables en la pila en lugar de mantenerlas en los registros es porque están almacenadas con el tipo de almacenamiento "automático" predeterminado. se puede optimizarlas en los registros pero no tiene que, incluso si se declaran en "registrar" clase de almacenamiento.

Si bien este no es un requisito estricto del lenguaje, es un comportamiento normal del compilador. Si en algún momento toma la dirección de v1, debe asignarle una ubicación de almacenamiento y guardarla allí siempre que cambie el valor de "v1". Entonces, para guardar la contabilidad de si v1 debe almacenarse o no en un registro o en la pila, lo mantiene en la pila y trata cada línea de código por separado.

Cuando encontré algún código de ejemplo, responderé a mi comentario; otros ya han explicado el problema.

Una gran cantidad de código incrustado con el que trabajo define tipos adicionales que son específicos de su tamaño, como "uint8, uint16, uint32" para las entradas sin firmar, por ejemplo. De esa manera, siempre sabes exactamente con qué tipo de variable estás tratando. Especialmente en pequeño incrustado, firmado, flotante, "int" de tamaño / firma indefinido le costará ciclos de CPU en el mejor de los casos y causará errores graves en el peor.

Aquí están nuestros #defines actuales:

/*
 * Example - the basic data types from our embedded code
 */
typedef unsigned char       uint8;  /*  8 bits */
typedef unsigned short int  uint16; /* 16 bits */
typedef unsigned long int   uint32; /* 32 bits */

typedef char                int8;   /*  8 bits */
typedef short int           int16;  /* 16 bits */
typedef int                 int32;  /* 32 bits */

typedef volatile int8       vint8;  /*  8 bits */
typedef volatile int16      vint16; /* 16 bits */
typedef volatile int32      vint32; /* 32 bits */

typedef volatile uint8      vuint8;  /*  8 bits */
typedef volatile uint16     vuint16; /* 16 bits */
typedef volatile uint32     vuint32; /* 32 bits */

Su código C utiliza variables enteras de 16 bits (int). El compilador no puede leer su mente, por lo que compila exactamente lo que está en el archivo fuente. Entonces, si desea variables de 8 bits, debe usar el tipo respectivo.

Como resultado, aún podrá almacenar los valores en la memoria (aunque más simple). No soy tan bueno en C, pero en mi humilde opinión, hay algunas opciones para asignar la variable a algún registro, si desea que algunas variables estén en los registros en lugar de RAM. Algo como:

register unsigned char VARNAME asm("r3");

Tenga en cuenta que no todos los registros están disponibles para tales trucos.

Entonces, la conclusión? Escribe tus programas en asamblea. Siempre serán más pequeños, más rápidos y fáciles de leer / soportar.