Conjunto de instrucciones y ensamblador

01 · Punto de partida

Leer lo que hace el compilador

En el tema 6 vimos que la CPU ejecuta instrucciones de 16 bits. Tu programa en C no llega así al chip: el compilador lo traduce a una secuencia de esas instrucciones. En una computadora de escritorio rara vez importa cuántas instrucciones genera una línea; en un microcontrolador de 16 MHz y 2 KB de SRAM, sí.

El lenguaje ensamblador es la forma legible de esas instrucciones: un nombre corto (mnemónico) por cada patrón de bits. Existe una correspondencia casi uno a uno entre una línea de ensamblador y una instrucción de máquina. Si sabés programar, aprender a leerlo lleva horas, no meses: el conjunto de instrucciones es pequeño y muy regular.

Retomamos la CPU del tema 6 (registros, banderas, ciclo de instrucción) y el código PORTB ^= (1 << PB5) del tema 5.

02 · El vocabulario

El conjunto de instrucciones

El conjunto de instrucciones (ISA, instruction set architecture) es el contrato entre el software y la CPU: define qué operaciones existen, cómo se codifican y qué registros ven. El AVR tiene alrededor de 130 instrucciones y pertenece al estilo RISC (reduced instruction set computer): instrucciones simples, de formato regular y, en su mayoría, de un ciclo.

Una característica importante es que es una arquitectura de carga y almacenamiento (load/store). Las operaciones aritméticas y lógicas trabajan solo con registros; para operar con una variable guardada en SRAM hay que traerla primero a un registro, operar y guardar el resultado.

No todos los AVR tienen las mismas instrucciones. Los modelos más pequeños (algunos ATtiny) carecen de MUL, o de JMP y CALL de 32 bits. El ATmega328P es de los más completos.

03 · La sintaxis

Anatomía de una línea de ensamblador

Una línea de ensamblador tiene hasta cuatro partes, todas opcionales:

bucle:  add  r17, r16      ; acumulador += contador
        dec  r16           ; contador -= 1
        brne bucle         ; si no llegó a 0, volver a «bucle»

• La etiqueta es un nombre para una dirección. Permite escribir brne bucle sin calcular a mano cuántas posiciones hay que retroceder.
• El mnemónico identifica la operación. En AVR el destino va primero: add r17, r16 significa R17 ← R17 + R16.
• Los operandos pueden ser registros (r16), constantes (5, 0x20), direcciones de E/S o etiquetas.
• El comentario empieza con ;. En ensamblador los comentarios son imprescindibles: el código, por sí solo, dice «cómo» pero no «para qué».

El ensamblador (assembler) es el programa que convierte este texto en los bits de cada instrucción. Es mucho más simple que un compilador porque no interpreta intenciones: traduce. Para resolver las etiquetas hace dos pasadas: primero recorre el texto y anota la dirección de cada etiqueta, y luego codifica las instrucciones, ahora que conoce todos los destinos de los saltos. El laboratorio de este tema incluye un ensamblador funcional.

Además de instrucciones hay directivas, órdenes dirigidas al ensamblador y no a la CPU, como .equ (definir una constante), .org (fijar una dirección) o .section (elegir dónde va el código). No generan instrucciones.

04 · Las que más se usan

Las instrucciones esenciales

Dos detalles prácticos. Primero, las operaciones con constantes (LDI, SUBI, CPI, ANDI, ORI) solo funcionan con los registros R16 a R31: es la razón por la que el compilador los prefiere para sus cuentas. Segundo, IN, OUT, SBI y CBI no usan la dirección de datos de los registros (0x25 para PORTB), sino la dirección de E/S (0x05), que es la anterior menos 0x20.

05 · La traducción

De C a ensamblador

La tabla siguiente muestra, para operaciones frecuentes, el ensamblador equivalente típico con optimización por tamaño (-Os). Son formas habituales; el compilador real puede elegir otros registros o reordenar las instrucciones.

Esta tabla enseña varias lecciones. Escribir un bit con |= o &= se reduce a una sola instrucción, SBI o CBI, porque el compilador reconoce el patrón. Invertir un bit con ^= requiere leer, modificar y escribir: cuatro instrucciones. El ATmega328P ofrece un atajo documentado: escribir un 1 en un bit de PINx invierte el bit correspondiente de PORTx, con una sola instrucción. Sumar 16 o 32 bits cuesta una instrucción por byte, encadenadas por el acarreo, como vimos en el tema 2. Y dividir no tiene hardware, de modo que el compilador llama a una rutina de software mucho más lenta que una suma.

Los tipos importan. Un int en avr-gcc ocupa 16 bits y una suma ya necesita dos instrucciones; un uint8_t cabe en un registro. Elegir el tipo más pequeño que alcance reduce Flash, SRAM y tiempo.

06 · Subrutinas

La pila y las llamadas

Las funciones de C se traducen a subrutinas. Para volver al punto de llamada, la CPU necesita recordar la dirección de retorno, y para eso usa la pila (stack), una zona de la SRAM manejada por el puntero SP.

1. CALL o RCALL guardan en la pila la dirección de la instrucción siguiente (2 bytes en el ATmega328P) y cargan el PC con la dirección de la subrutina.
2. La subrutina hace su trabajo. Si necesita registros que la función que llamó está usando, los guarda con PUSH y los restaura con POP.
3. RET saca de la pila la dirección de retorno y la carga en el PC.

La pila del AVR crece hacia direcciones menores. Al arrancar, el código de inicio coloca el SP en el final de la SRAM (0x08FF, el valor llamado RAMEND), y cada PUSH o CALL lo decrementa. Las variables globales ocupan la parte baja de la SRAM; la pila baja desde el extremo opuesto. Si se encuentran, el programa se corrompe sin avisar.

Las rutinas de interrupción (tema 19) terminan con RETI en lugar de RET: además de retornar, vuelve a habilitar las interrupciones. Y el hardware que las dispara también guarda la dirección de retorno en la pila.

07 · De mnemónico a bits

Cómo se codifica una instrucción

Cada instrucción es un patrón de 16 bits (algunas, de 32). Los bits se reparten en campos fijos: código de operación y operandos. Estos son los formatos de las instrucciones usadas en este tema:

Veamos sbi 0x05, 5. La dirección 0x05 es 00101 y el bit 5 es 101. Rellenando el formato: 1001 1010 0010 1101, es decir, 0x9A2D. Eso es todo lo que el chip necesita saber para encender PB5 en dos ciclos.

Del formato salen límites que parecen caprichosos hasta que se entienden. SBI solo llega a las direcciones de E/S 0 a 31, porque su campo A tiene 5 bits. BRNE solo salta de −64 a +63 palabras, porque su desplazamiento tiene 7 bits. LDI solo admite R16 a R31 porque su campo de registro tiene 4 bits. Cuando una instrucción no alcanza, el compilador usa una más larga o combina varias.

08 · Analogía con programación

Un ensamblador en cuarenta líneas

Como el ensamblador solo traduce, se puede escribir uno de juguete. Este programa en Python implementa las dos pasadas: primero anota las direcciones de las etiquetas y luego codifica cada instrucción con los formatos de la sección anterior. El programa de prueba es el del tema 6, y deberías obtener exactamente las mismas palabras.

FORMATOS = {                     # operación -> código base (formato Rd, Rr)
    "add": 0x0C00, "adc": 0x1C00, "sub": 0x1800, "eor": 0x2400, "mov": 0x2C00,
}


def registro(texto):
    return int(texto.strip().lower().lstrip("r"))


def numero(texto):
    return int(texto.strip(), 0)


def ensamblar(fuente):
    # Pasada 1: separar etiquetas e instrucciones, y anotar las direcciones.
    lineas, etiquetas = [], {}
    for crudo in fuente.splitlines():
        texto = crudo.split(";")[0].strip()
        if ":" in texto:
            nombre, texto = texto.split(":", 1)
            etiquetas[nombre.strip()] = len(lineas)
            texto = texto.strip()
        if texto:
            lineas.append(texto)

    # Pasada 2: codificar, ahora que se conocen todas las etiquetas.
    palabras = []
    for direccion, texto in enumerate(lineas):
        mnemonico, _, resto = texto.partition(" ")
        ops = [o.strip() for o in resto.split(",")] if resto else []
        if mnemonico in FORMATOS:
            d, r = registro(ops[0]), registro(ops[1])
            palabra = FORMATOS[mnemonico] | ((r & 0x10) << 5) | (d << 4) | (r & 0xF)
        elif mnemonico == "ldi":
            d, k = registro(ops[0]), numero(ops[1])
            palabra = 0xE000 | ((k & 0xF0) << 4) | ((d - 16) << 4) | (k & 0xF)
        elif mnemonico == "dec":
            palabra = 0x940A | (registro(ops[0]) << 4)
        elif mnemonico == "out":
            a, r = numero(ops[0]), registro(ops[1])
            palabra = 0xB800 | ((a & 0x30) << 5) | (r << 4) | (a & 0xF)
        elif mnemonico == "brne":
            k = etiquetas[ops[0]] - (direccion + 1)      # relativo a la siguiente
            palabra = 0xF401 | ((k & 0x7F) << 3)
        elif mnemonico == "rjmp":
            k = etiquetas[ops[0]] - (direccion + 1)
            palabra = 0xC000 | (k & 0xFFF)
        else:
            raise ValueError(f"instrucción desconocida: {mnemonico}")
        palabras.append(palabra)
    return palabras


programa = """
        ldi r16, 5        ; contador
        ldi r17, 0        ; acumulador
bucle:  add r17, r16
        dec r16
        brne bucle
        out 0x05, r17     ; PORTB
fin:    rjmp fin
"""

for direccion, palabra in enumerate(ensamblar(programa)):
    print(f"{direccion}: {palabra:#06x}  {palabra:016b}")

Resultado: siete palabras, de 0xE005 a 0xCFFF, idénticas a las que ejecutó la CPU del tema 6. Probá agregar una etiqueta nueva o cambiar brne bucle por rjmp bucle y observá cómo cambia el desplazamiento.

El código ilustra un punto de fondo: un ensamblador es una tabla de formatos más un cálculo de desplazamientos. No tiene misterio. La analogía con un compilador de lenguajes de alto nivel termina ahí: el compilador decide qué instrucciones usar; el ensamblador solo traduce las que le dan.

09 · Exploración interactiva

Ensamblador y costo en ciclos

La primera herramienta es un ensamblador real para un subconjunto del AVR. Escribí o editá el programa: se ensambla mientras tipeás y la última columna vuelve a decodificar cada palabra, de modo que ves el viaje completo de ida y vuelta. La segunda muestra el costo típico de operaciones de C.

El ensamblador del laboratorio soporta unas 25 instrucciones y no incluye directivas ni instrucciones de 32 bits. Los conteos de la tercera herramienta son los equivalentes típicos de la sección 5, no la salida de un compilador concreto: la salida real depende de la versión de avr-gcc, del nivel de optimización y del contexto.

Recorrido guiado

1. Con «Suma con bucle» comprobá que las siete palabras coinciden con las del tema 6. Fijate en BRNE bucle: el ensamblador calculó −3 por vos.
2. Cargá «Encender y apagar un LED» y observá que SBI PORTB, PB5 se ensambla como 0x9A2D, el mismo valor que calculamos a mano.
3. Con «Invertir un bit» contá cuatro instrucciones y compará con el atajo SBI PINB, PB5 de la sección 5: escribilo en una línea nueva.
4. Cargá «Con errores»: el ensamblador informa la línea y la causa. Corregí primero el registro (cambiá r5 por r20) y luego definí la etiqueta.
5. En la herramienta 2 probá 9A2D, 9508 y 0000. En la 3 recorré la lista y mirá cuánto cambian los ciclos entre una suma de 8 bits y una de 32.

10 · Método de trabajo

Cómo mirar el código generado

1. Compilá con la optimización que vas a usar (normalmente -Os). Con -O0 el código es muy distinto y poco representativo.
2. Pedí el listado en ensamblador. avr-gcc -S -Os -mmcu=atmega328p programa.c genera programa.s.
3. O desensamblá el resultado final. avr-objdump -d -S programa.elf muestra las instrucciones reales mezcladas con las líneas de C que las originaron.
4. Buscá primero lo que importa: un bucle caliente, una rutina de interrupción o una operación sospechosa (__udivmodqi4, __mulsf3).
5. Contá ciclos con la tabla del fabricante y compará con una medición real en el osciloscopio.
6. Optimizá solo lo medido. Cambiá tipos, evitá divisiones y recién entonces, si hace falta, escribí ensamblador en línea para un fragmento crítico.

Existen además herramientas en línea que muestran el ensamblador de un fragmento de C para distintos compiladores, incluido avr-gcc, lo que permite experimentar sin instalar nada.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Codificar a mano

Con el formato 1001 1010 AAAA Abbb, codificá SBI 0x05, 5. ¿Cuántas palabras ocupa y cuántos ciclos tarda?

2. Costo de invertir un bit

Compará PORTB ^= (1 << PB5) con PINB = (1 << PB5) en tamaño y en tiempo a 16 MHz.

3. Suma de 32 bits

¿Cuántas instrucciones y cuánto tiempo, a 16 MHz, necesita sumar dos enteros de 32 bits que ya están en registros?

4. Calcular un desplazamiento

Un RJMP está en la dirección 4 y la etiqueta destino en la dirección 10. ¿Cuál es el desplazamiento y la palabra codificada?

5. La pila y las funciones anidadas

Una función usa 6 bytes de pila por nivel (2 de retorno y 4 de registros guardados). Si se permiten 300 bytes de pila, ¿cuál es la profundidad máxima de llamadas anidadas?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 8?

Antes de avanzar, explicá qué hace el ensamblador con una etiqueta, codificá a mano una instrucción con su formato, estimá el costo de PORTB ^= 0x20 y describí qué ocurre en la pila durante un CALL y un RET. Si podés justificar las cuatro respuestas, podés leer el código que genera el compilador.

En el próximo tema nos ocupamos de las memorias del microcontrolador: dónde viven el programa, las variables y los datos persistentes, y cómo se usan la Flash, la SRAM y la EEPROM.