Menu
CoddyTech

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.

ElementoCódigo
Sección para datos fijossection .data
Sección para búferes a cerosection .bss
Sección para instruccionessection .text
Hacer visible el punto de entrada al enlazadorglobal _start
Una etiqueta (una dirección con nombre)_start:
Comentario; everything after a semicolon
Terminar el programa con código de salida 0mov 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 habitualNombres de 64 / 32 / 16 / 8 bits
Acumulador, número de llamada al sistema, valor de retornorax eax ax al
Base, se conserva entre llamadas a funcionesrbx ebx bx bl
Contador, 4.º argumento de una funciónrcx ecx cx cl
Datos, 3.er argumento, mitad superior de mul y divrdx edx dx dl
Índice de origen, 2.º argumentorsi esi si sil
Índice de destino, 1.er argumentordi edi di dil
Puntero de pila, cima de la pilarsp esp sp spl
Puntero base, marco de pilarbp ebp bp bpl
Registros extra, con r8 como ejemplo; de r9 a r15 siguen el mismo patrónr8 r8d r8w r8b
Puntero de instrucción, dirección de la siguiente instrucciónrip
Flags que activan cmp, test y la aritméticarflags

Directivas de datos

Las directivas las lee el ensamblador y reservan o nombran memoria; no son instrucciones.

SignificadoCódigo
Definir bytes: una cadena y un salto de líneamsg db "Hello", 10
Definir una palabra de 16 bitsyear dw 2026
Definir una doble palabra de 32 bitscount dd 1000
Definir una cuádruple palabra de 64 bitsbig dq 123456789
Reservar 64 bytes a cero (en .bss)buffer resb 64
Reservar 10 cuádruples palabrastable resq 10
Dar nombre a una constantemax equ 100
Longitud de los datos justo encimalen equ $ - msg
Repetir una definiciónzeros times 8 db 0

Mover datos

El destino va primero. Los corchetes significan la memoria en esa dirección.

OperaciónCódigo
Número a un registromov rax, 42
Registro a registromov rbx, rax
Dirección de una etiqueta a un registromov rsi, msg
Leer 8 bytes de memoriamov rax, [big]
Escribir un registro en memoriamov [big], rax
Escribir un byte, indicando el tamañomov byte [buffer], 10
Leer memoria en registro más desplazamientomov al, [rsi + 1]
Indexado: base + índice * escala + desplazamientomov rax, [table + rcx * 8]
Calcular una dirección sin leer memorialea rax, [rsi + rcx * 2]
Cargar un byte y poner a cero el resto del registromovzx eax, byte [rsi]
Intercambiar dos registrosxchg 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ónCódigo
Sumaradd rax, rbx
Restarsub rax, 5
Sumar 1 / restar 1inc rcx / dec rcx
Multiplicación con signo en un registroimul rax, rbx
Multiplicación sin signo: rdx:rax = rax * rbxmul rbx
División sin signo del valor de rax entre rbx: pon antes rdx a cero; cociente en rax, resto en rdxxor rdx, rdx → div rbx
División con signo: primero extender el signo de rax a rdxcqo → idiv rbx
Cambiar de signoneg rax
Operaciones bit a bit and, or, xor, notand 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 signoshr 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ónCódigo
Comparar dos valorescmp rax, rbx
Comprobar bits (and sin guardar), a menudo para ver si es cerotest rax, rax
Saltar siemprejmp done
Saltar si es igual / ceroje done / jz done
Saltar si no es igual / no es cerojne loop_start / jnz loop_start
Con signo: mayor, mayor o igual, menor, menor o igualjg / jge / jl / jle
Sin signo: por encima, por encima o igual, por debajo, por debajo o igualja / jae / jb / jbe
Repetir 10 veces con un contadormov 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ónCódigo
Apilar un registro / desapilarlopush 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 localsub rsp, 32
Liberarloadd rsp, 32
Crear un marco de pilapush rbp → mov rbp, rsp
Deshacerlomov 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 retrbx 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.

LlamadaRegistros
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ándarfd 0 fd 1 fd 2
Registros que sobrescribe el núcleorcx r11

Ensamblar, ejecutar e inspeccionar

En una máquina Linux con NASM y las herramientas de GNU instaladas.

TareaComando
Ensamblar a un archivo objetonasm -f elf64 main.asm -o main.o
Enlazar en un programald main.o -o main
Ejecutarlo y mostrar su código de salida./main; echo $?
Desensamblar, sintaxis Intelobjdump -d -M intel main
Recorrerlo paso a paso en un depuradorgdb ./main
Ver el ensamblador que escribe un compilador de Cgcc -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?
x86-64, el conjunto de instrucciones de 64 bits de los procesadores Intel y AMD, en sintaxis NASM sobre Linux. NASM usa el orden de operandos de Intel, así que 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?
Cualquier valor xor sí mismo da 0, y 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?
Nombran partes más pequeñas del mismo registro. 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.

Ilustración de los lenguajes de programación de Coddy

Aprende Assembly con Coddy

Comenzar