Hoja de trucos de Assembly
Última actualización
Estructura del programa
Un programa sin la biblioteca de C empieza en la etiqueta que se indica al enlazador, normalmente _start.
| Elemento | Código |
|---|---|
| Sección para datos fijos | section .data |
| Sección para búferes a cero | section .bss |
| Sección para instrucciones | section .text |
| Hacer visible el punto de entrada al enlazador | global _start |
| Una etiqueta (una dirección con nombre) | _start: |
| Comentario | ; everything after a semicolon |
| Terminar el programa con código de salida 0 | mov rax, 60 → mov rdi, 0 → syscall |
Registros
Dieciséis registros de propósito general de 64 bits. Cada uno tiene nombres más cortos para sus 32, 16 y 8 bits inferiores.
| Registro y uso habitual | Nombres de 64 / 32 / 16 / 8 bits |
|---|---|
| Acumulador, número de llamada al sistema, valor de retorno | rax eax ax al |
| Base, se conserva entre llamadas a funciones | rbx ebx bx bl |
| Contador, 4.º argumento de una función | rcx ecx cx cl |
Datos, 3.er argumento, mitad superior de mul y div | rdx edx dx dl |
| Índice de origen, 2.º argumento | rsi esi si sil |
| Índice de destino, 1.er argumento | rdi edi di dil |
| Puntero de pila, cima de la pila | rsp esp sp spl |
| Puntero base, marco de pila | rbp ebp bp bpl |
Registros extra, con r8 como ejemplo; de r9 a r15 siguen el mismo patrón | r8 r8d r8w r8b |
| Puntero de instrucción, dirección de la siguiente instrucción | rip |
Flags que activan cmp, test y la aritmética | rflags |
Directivas de datos
Las directivas las lee el ensamblador y reservan o nombran memoria; no son instrucciones.
| Significado | Código |
|---|---|
| Definir bytes: una cadena y un salto de línea | msg db "Hello", 10 |
| Definir una palabra de 16 bits | year dw 2026 |
| Definir una doble palabra de 32 bits | count dd 1000 |
| Definir una cuádruple palabra de 64 bits | big dq 123456789 |
Reservar 64 bytes a cero (en .bss) | buffer resb 64 |
| Reservar 10 cuádruples palabras | table resq 10 |
| Dar nombre a una constante | max equ 100 |
| Longitud de los datos justo encima | len equ $ - msg |
| Repetir una definición | zeros times 8 db 0 |
Mover datos
El destino va primero. Los corchetes significan la memoria en esa dirección.
| Operación | Código |
|---|---|
| Número a un registro | mov rax, 42 |
| Registro a registro | mov rbx, rax |
| Dirección de una etiqueta a un registro | mov rsi, msg |
| Leer 8 bytes de memoria | mov rax, [big] |
| Escribir un registro en memoria | mov [big], rax |
| Escribir un byte, indicando el tamaño | mov byte [buffer], 10 |
| Leer memoria en registro más desplazamiento | mov al, [rsi + 1] |
| Indexado: base + índice * escala + desplazamiento | mov rax, [table + rcx * 8] |
| Calcular una dirección sin leer memoria | lea rax, [rsi + rcx * 2] |
| Cargar un byte y poner a cero el resto del registro | movzx eax, byte [rsi] |
| Intercambiar dos registros | xchg rax, rbx |
Aritmética y lógica
Las instrucciones de dos operandos escriben el resultado en el primer operando. mul, div e idiv además usan rax y rdx de forma implícita. El efecto sobre los flags varía: not no los modifica, y div e idiv los dejan indefinidos.
| Operación | Código |
|---|---|
| Sumar | add rax, rbx |
| Restar | sub rax, 5 |
| Sumar 1 / restar 1 | inc rcx / dec rcx |
| Multiplicación con signo en un registro | imul rax, rbx |
Multiplicación sin signo: rdx:rax = rax * rbx | mul rbx |
División sin signo del valor de rax entre rbx: pon antes rdx a cero; cociente en rax, resto en rdx | xor rdx, rdx → div rbx |
División con signo: primero extender el signo de rax a rdx | cqo → idiv rbx |
| Cambiar de signo | neg rax |
| Operaciones bit a bit and, or, xor, not | and rax, 0xff / or rax, rbx / xor rax, rbx / not rax |
| Poner un registro a cero (corto y rápido) | xor eax, eax |
| Desplazamiento a la izquierda (multiplica por 2 por cada bit) | shl rax, 3 |
| Desplazamiento a la derecha: sin signo / con signo | shr rax, 1 / sar rax, 1 |
Comparar y saltar
cmp resta sin guardar el resultado y activa los flags; después, un salto condicional los lee.
| Operación | Código |
|---|---|
| Comparar dos valores | cmp rax, rbx |
| Comprobar bits (and sin guardar), a menudo para ver si es cero | test rax, rax |
| Saltar siempre | jmp done |
| Saltar si es igual / cero | je done / jz done |
| Saltar si no es igual / no es cero | jne loop_start / jnz loop_start |
| Con signo: mayor, mayor o igual, menor, menor o igual | jg / jge / jl / jle |
| Sin signo: por encima, por encima o igual, por debajo, por debajo o igual | ja / jae / jb / jbe |
| Repetir 10 veces con un contador | mov rcx, 10 → again: → dec rcx → jnz again |
| Copiar solo si se cumple la condición (sin salto) | cmovg rax, rbx |
Pila y funciones
La pila crece hacia abajo: push resta 8 a rsp y pop se los vuelve a sumar.
| Operación | Código |
|---|---|
| Apilar un registro / desapilarlo | push rbx / pop rbx |
| Llamar a una función (apila la dirección de retorno) | call print_line |
| Volver a quien llamó | ret |
| Reservar 32 bytes de espacio local | sub rsp, 32 |
| Liberarlo | add rsp, 32 |
| Crear un marco de pila | push rbp → mov rbp, rsp |
| Deshacerlo | mov rsp, rbp → pop rbp |
| Argumentos, en orden (System V, Linux y macOS) | rdi rsi rdx rcx r8 r9 |
Registros que una función debe restaurar antes de ret | rbx rbp r12 r13 r14 r15 |
Llamadas al sistema de Linux
Pon el número en rax y los argumentos en rdi, rsi, rdx, r10, r8, r9, y luego ejecuta syscall. El resultado vuelve en rax; un valor negativo es un código de error.
| Llamada | Registros |
|---|---|
read(fd, buffer, count) | rax = 0 rdi = fd rsi = buffer rdx = count |
write(fd, buffer, count) | rax = 1 rdi = fd rsi = buffer rdx = count |
open(path, flags, mode) | rax = 2 rdi = path rsi = flags rdx = mode |
close(fd) | rax = 3 rdi = fd |
exit(code) | rax = 60 rdi = code |
| Entrada, salida y error estándar | fd 0 fd 1 fd 2 |
| Registros que sobrescribe el núcleo | rcx r11 |
Ensamblar, ejecutar e inspeccionar
En una máquina Linux con NASM y las herramientas de GNU instaladas.
| Tarea | Comando |
|---|---|
| Ensamblar a un archivo objeto | nasm -f elf64 main.asm -o main.o |
| Enlazar en un programa | ld main.o -o main |
| Ejecutarlo y mostrar su código de salida | ./main; echo $? |
| Desensamblar, sintaxis Intel | objdump -d -M intel main |
| Recorrerlo paso a paso en un depurador | gdb ./main |
| Ver el ensamblador que escribe un compilador de C | gcc -S -O2 -masm=intel file.c |
Los registros, las instrucciones y las llamadas al sistema que más usas al escribir ensamblador x86-64, en una sola página. Cada fila está en sintaxis NASM (orden de operandos de Intel, el destino primero) para Linux de 64 bits, la misma cadena de herramientas que usan el playground y el curso de Assembly de Coddy. ¿Empiezas con el ensamblador? Qué es el lenguaje ensamblador recorre un programa completo línea por línea, y qué es el código máquina muestra los bytes en los que se convierte.
Todas las instrucciones de esta página se ensamblan con nasm -f elf64. Prueba cualquiera de ellas en el playground de Assembly, que ensambla, enlaza y ejecuta tu programa en el navegador sin instalar nada, o apréndelas paso a paso en el curso gratuito de Assembly.
Preguntas frecuentes sobre la hoja de trucos de Assembly
¿Esta hoja de trucos de Assembly es gratis?
Sí. Toda la hoja de trucos se puede leer gratis, sin registrarse. Guárdala en marcadores y vuelve cuando necesites un nombre de registro, una instrucción o un número de llamada al sistema.
¿Qué ensamblador cubre esta hoja de trucos?
mov rax, rbx copia rbx en rax. La sintaxis AT&T, la predeterminada del ensamblador de GNU, invierte el orden y añade prefijos, y escribe movq %rbx, %rax. ARM64 y RISC-V tienen instrucciones y registros distintos.¿Cuál es la diferencia entre mov y lea?
mov rax, [rsi + 8] lee los 8 bytes guardados en la dirección rsi + 8. lea rax, [rsi + 8] solo calcula la dirección y pone el número en rax, sin tocar la memoria. Como puede sumar y escalar registros en un solo paso, lea también se usa como calculadora rápida, por ejemplo lea rax, [rbx + rbx * 4] para multiplicar rbx por 5.¿Por qué se usa xor eax, eax para poner un registro a cero?
xor eax, eax ocupa 2 bytes, mientras que mov rax, 0 ocupa 5 o más. Escribir en un registro de 32 bits como eax también borra la mitad superior de rax, así que todo el registro de 64 bits queda a 0. Los procesadores reconocen esta instrucción y la ejecutan sin esperar al valor anterior.¿Para qué sirven los nombres de registro de 64, 32, 16 y 8 bits?
rax son los 64 bits completos, eax los 32 inferiores, ax los 16 inferiores y al los 8 más bajos. Te permiten trabajar con bytes y números más pequeños; por ejemplo, mov al, [rsi] lee un carácter de una cadena. Escribir en eax borra los 32 bits superiores; escribir en ax o al deja el resto sin cambios.¿Puedo ejecutar estas instrucciones online?
Sí. El playground de Assembly de Coddy ensambla x86-64 NASM, lo enlaza y lo ejecuta en Linux, y luego muestra la salida y los errores. Puedes pegar filas de esta hoja de trucos en un programa y ejecutarlo en el navegador.