Constantes, operadores, tipos de datos, instrucciones, E/S, procedimientos y macros en ensamblador x86 adaptados a NASM y syscalls Linux.

⚙️ Constantes, Operadores y Estructuras en Ensamblador x86

1. Constantes en Ensamblador x86

Las constantes son valores fijos que no cambian durante la ejecución del programa. Mejoran la legibilidad y el mantenimiento del código.

Tipo	Notación / Directiva	Ejemplo	Descripción
Numérica	Decimal	`123`	Valor decimal
Numérica	Hexadecimal	`0xFF` o `0FFh`	Valor hexadecimal
Numérica	Binaria	`1010b`	Valor binario
Carácter	'A'	`'A'`	Carácter ASCII (1 byte)
Cadena	"Texto"	`"Hola"`	Cadena de caracteres (termina en `0`)
Simbólica	EQU	`PI EQU 3.1416`	Constante simbólica definida por el usuario

Ejemplo:

section .data
    valor   db 10         ; Byte constante = 10
    mensaje db "Hola", 0  ; Cadena constante terminada en 0
section .text
    global _start
_start:
    mov al, [valor]       ; Carga 10 en AL
    ; código...

2. Operadores en Ensamblador

Operador	Ejemplo	Uso
+	`add eax, 5`	Suma
-	`sub eax, 2`	Resta
*	`imul ebx`	Multiplicación
/	`div bl`	División
and	`and eax, ebx`	Operación bit a bit
shl	`shl eax, 1`	Desplazamiento a la izquierda (x2)

Aplicación:

mov eax, 10
imul ebx, 2          ; ebx = ebx * 2
and al, 0Fh          ; mascara los 4 bits superiores

3. Tipos de Datos en x86

Tipo	Directiva	Tamaño (bits)	Rango	Ejemplo
Byte	db	8	0 a 255	`num db 255`
Word	dw	16	0 a 65,535	`valor dw 1000`
Double Word	dd	32	0 a 4,294,967,295	`dato dd 123456`
Cadena	db	Variable	ASCII	`texto db "Hola", 0`

Importante: Elegir el tipo correcto optimiza memoria y evita errores. Las cadenas terminan con 0 (Linux).

4. Conjunto de Instrucciones x86

Categoría	Instrucciones	Ejemplo
Movimiento	mov, lea	`mov eax, ebx`
Aritméticas	add, sub, imul, div	`add eax, 5`
Control de Flujo	jmp, je, loop	`je etiqueta`
Pila	push, pop	`push eax`
Interrupciones	int 0x80 (syscall)	`int 0x80`

Ejemplo (Suma con salto condicional):

cmp eax, ebx
jg mayor        ; Salta si eax > ebx
mov ecx, 0
mayor:
    add ecx, 1

5. Control de Dispositivos de E/S

Syscalls en Linux (int 0x80)

Función	eax	Descripción
Leer carácter	3	sys_read (file descriptor 0 stdin)
Escribir cadena	4	sys_write (file descriptor 1 stdout)
Terminar programa	1	sys_exit

Ejemplo (Imprimir "Hola"):

section .data
    msg db "Hola", 0xA  ; Cadena con salto de línea
    len equ $ - msg
section .text
    global _start
_start:
    mov eax, 4          ; sys_write
    mov ebx, 1          ; stdout
    mov ecx, msg
    mov edx, len
    int 0x80

    mov eax, 1          ; sys_exit
    mov ebx, 0
    int 0x80

6. Procedimientos y Macros

Procedimientos (proc, call, ret)

sumar:
    add eax, ebx
    ret

; Uso:
call sumar

Macros (NASM)

%macro MOSTRAR 1
    mov eax, 4
    mov ebx, 1
    mov ecx, %1
    mov edx, %1_len
    int 0x80
%endmacro

section .data
mensaje db "Hola mundo", 0xA
mensaje_len equ $ - mensaje

section .text
global _start
_start:
    MOSTRAR mensaje

    mov eax, 1
    mov ebx, 0
    int 0x80

7. Ejemplos Prácticos

Ejemplo 1: Macro para Restar

section .text
global _start

%macro RESTAR 2
    mov al, %1
    sub al, %2
%endmacro

_start:
    RESTAR 10, 3      ; AL = 7

    ; Mostrar AL como número (decimal) en consola Linux (sys_write)
    ; Convertir AL a ASCII (suponiendo que es un número menor que 10)
    add al, '0'       
    mov [resultado], al

    mov eax, 4        ; sys_write
    mov ebx, 1        ; stdout
    mov ecx, resultado
    mov edx, 1
    int 0x80

    ; Salir del programa
    mov eax, 1
    mov ebx, 0
    int 0x80

section .bss
resultado resb 1

; Uso:
RESTAR 10, 3  ; AL = 7

Ejemplo 2: Procedimiento para Multiplicar

section .text
global _start

multiplicar:
    imul ebx       ; eax = eax * ebx
    ret

_start:
    mov eax, 5
    mov ebx, 3
    call multiplicar  ; eax = 15

    ; Convertir eax a decimal (suponiendo valor < 100)
    mov ecx, 10
    xor edx, edx
    div ecx          ; eax = cociente (decena), edx = resto (unidad)

    add al, '0'      ; decena ASCII
    mov [decena], al

    add dl, '0'      ; unidad ASCII
    mov [unidad], dl

    ; Mostrar decena si no es '0'
    cmp byte [decena], '0'
    je mostrar_unidad

    mov eax, 4       ; sys_write
    mov ebx, 1       ; stdout
    mov ecx, decena
    mov edx, 1
    int 0x80

mostrar_unidad:
    mov eax, 4       ; sys_write
    mov ebx, 1
    mov ecx, unidad
    mov edx, 1
    int 0x80

    ; Salir
    mov eax, 1       ; sys_exit
    mov ebx, 0
    int 0x80

section .bss
decena resb 1
unidad resb 1

Simulador interactivo de código ensamblador x86

Puedes escribir y ejecutar código ensamblador x86 directamente en el simulador de arriba. Es ideal para probar ejemplos como los de esta guía.

8. Conclusión

Constantes y tipos de datos son esenciales para organizar información.
Operadores e instrucciones permiten manipular datos y controlar el flujo.
Procedimientos y macros mejoran la modularidad y reutilización de código.
Las syscalls facilitan la interacción con hardware y el sistema operativo.

Constantes, Operadores y Estructuras en Ensamblador x86 (Sintaxis NASM/Linux)