Lenguaje ensamblador - Variables

Las variables son la unidad básica para almacenar datos en un programa. En lenguaje ensamblador, definir y usar variables está más cerca del hardware que en los lenguajes de alto nivel; necesitas controlar directamente el tamaño, el tipo y la disposición en memoria de las variables.


Concepto de variables en ensamblador

En lenguaje ensamblador,una variablees esencialmente una ubicación de memoria con nombre.

A diferencia de los lenguajes de alto nivel, las variables en ensamblador no tienen verificación automática de tipos: una etiqueta es solo un alias de una dirección de memoria, y puedes leerla o escribirla con cualquier tamaño.

NASM proporciona tres secciones para almacenar diferentes tipos de variables:.data(inicializadas),.bss(no inicializadas) y.rodata(de solo lectura).


Definir variables inicializadas en la sección .data

Utiliza las directivas DB, DW, DD, DQ, DT para definir variables de diferentes tamaños:

DirectivaTamaño de datosSignificadoEjemplo
DB1 byteDefine Byteflag db 1
DW2 bytesDefine Wordcount dw 1000
DD4 bytesDefine Doublewordprice dd 9999
DQ8 bytesDefine Quadwordbig_val dq 0x1234567890ABCDEF
DT10 bytesDefine Ten Bytesext_val dt 3.14

Ejemplo

; Ruta del archivo: variables_data.asm
; Demuestra la definición de varias variables en la sección .data

section .data
    ; Variable de byte
    status db 1                 ; 1 byte, valor 1
    grade db 'A'                ; 1 byte, carácter 'A' = 0x41

    ; Variable de palabra (2 bytes)
    year dw 2026                ; 2 bytes, valor 2026

    ; Variable de doble palabra (4 bytes)
    salary dd 50000             ; 4 bytes, valor 50000

    ; Secuencia de varios bytes
    msg db 'Hello, ejemplo!', 0  ; Cadena terminada en 0 (estilo C)
    hex_bytes db 0x55, 0xAA, 0x00, 0xFF   ; Secuencia de bytes hexadecimales

    ; Valor repetido
    stars db 10 dup('*')        ; 10 caracteres de asterisco

    ; Múltiples variables con nombre
    x dd 10
    y dd 20
    z dd 30

section .text
    global _start

_start:
    ; Leer el valor de la variable en un registro
    mov al, [status]            ; al = 1 (lectura de 1 byte)
    mov ax, [year]              ; ax = 2026 (lectura de 2 bytes)
    mov eax, [salary]           ; eax = 50000 (lectura de 4 bytes)

    ; Modificar el valor de la variable
    mov byte [status], 0        ; status = 0
    mov dword [x], 100          ; x = 100

    mov eax, 1
    mov ebx, 0
    int 0x80

Usa[nombre de variable]Al acceder a una variable, asegúrate de que el número de bytes leídos/escritos coincida con el número de bytes con el que se definió. Usamov al, [status]para leer 1 byte, usamov eax, [salary]para leer 4 bytes. NASM verifica que el tamaño de los operandos sea coherente.


Reservar espacio no inicializado en la sección .bss

Utiliza directivas como RESB, RESW, RESD para reservar espacio (sin inicializar):

DirectivaTamaño reservadoEjemplo
RESBBytebuffer resb 256
RESWPalabra (2 bytes)wbuf resw 100
RESDDoble palabra (4 bytes)dbuf resd 50
RESQCuádruple palabra (8 bytes)qbuf resq 25

Ejemplo

; Ruta del archivo: variables_bss.asm
; Demuestra la reserva de espacio en la sección .bss

section .bss
    input_buf resb 128          ; Reserva un búfer de entrada de 128 bytes
    numbers resd 100            ; Reserva 100 dobles palabras (400 bytes)
    temp resb 1                 ; Reserva una variable temporal de 1 byte

section .data
    prompt db 'Enter a number: '
    prompt_len equ $ - prompt

section .text
    global _start

_start:
    ; Muestra el mensaje
    mov eax, 4
    mov ebx, 1
    mov ecx, prompt
    mov edx, prompt_len
    int 0x80

    ; Lee la entrada en el búfer de la sección .bss
    mov eax, 3
    mov ebx, 0
    mov ecx, input_buf           ; Usa el espacio reservado en la sección .bss
    mov edx, 128
    int 0x80

    ; Llena el arreglo numbers con datos
    mov dword [numbers], 42      ; numbers[0] = 42
    mov dword [numbers + 4], 100 ; numbers[1] = 100

    mov eax, 1
    mov ebx, 0
    int 0x80

Disposición en memoria de bytes, palabras y dobles palabras

x86 usael orden little-endian (Little Endian)— el byte de menor peso se almacena en la dirección más baja.

Por ejemplo, al definirvalue dd 0x12345678, la disposición en memoria es:

地址    :[value]  [value+1]  [value+2]  [value+3]
内容    :0x78     0x56       0x34       0x12

Ejemplo

; Ruta del archivo: endianness.asm
; Demuestra el almacenamiento little-endian

section .data
    value dd 0x12345678        ; Doble palabra, 4 bytes

section .text
    global _start

_start:
    ; Lee la misma variable con diferentes tamaños
    mov eax, [value]            ; Lee 4 bytes: eax = 0x12345678
    mov ax, [value]             ; Lee 2 bytes: ax = 0x5678 (2 bytes bajos)
    mov al, [value]             ; Lee 1 byte: al = 0x78 (byte más bajo)

    ; Verifica little-endian: la dirección baja contiene el byte bajo
    mov al, [value]             ; al = 0x78
    mov bl, [value + 1]         ; bl = 0x56
    mov cl, [value + 2]         ; cl = 0x34
    mov dl, [value + 3]         ; dl = 0x12

    mov eax, 1
    mov ebx, 0
    int 0x80

Inicialización y acceso a variables

Las operaciones con variables en ensamblador siguen el patrón de tres pasos 'cargar-operar-almacenar':

Ejemplo

; Ruta del archivo: var_operations.asm
; Demuestra el patrón de tres pasos en operaciones con variables

section .data
    a dd 100
    b dd 200
    result dd 0

section .text
    global _start

_start:
    ; result = a + b
    ; Paso 1: cargar
    mov eax, [a]                ; Carga a en eax
    ; Paso 2: operar
    add eax, [b]                ; eax = eax + b
    ; Paso 3: almacenar
    mov [result], eax           ; Almacena el resultado en result

    ; result = a * 2 - b
    mov eax, [a]
    imul eax, 2                 ; eax = a * 2
    sub eax, [b]                ; eax = eax - b
    mov [result], eax

    mov eax, 1
    mov ebx, 0
    int 0x80

El ensamblador no admitemov [result], [a] + [b]esta sintaxis de alto nivel. La instrucción mov de x86 no puede usar dos operandos de memoria a la vez; debe pasar por un registro intermedio.


Operadores de tamaño de variables

Cuando el ensamblador no puede inferir el tamaño del operando, debes especificarlo explícitamente:

Ejemplo

; Usa operadores de tamaño para especificar el tamaño de los datos

section .data
    var dd 0

section .text
    global _start

_start:
    ; Operadores de tamaño: byte, word, dword, qword
    mov byte [var], 1           ; Escribe 1 byte
    mov word [var], 1000        ; Escribe 2 bytes
    mov dword [var], 999999     ; Escribe 4 bytes

    ; Cuando el tamaño del destino está claro (determinado por el registro), se puede omitir
    mov al, [var]               ; al es de 1 byte, se lee automáticamente como byte
    mov ax, [var]               ; ax es de 2 bytes, se lee automáticamente como word
    mov eax, [var]              ; eax es de 4 bytes, se lee automáticamente como dword

    ; Pero la siguiente línea dará un error (tamaño no especificado):
    ; mov [var], 1 ; ¡Error! 1 puede ser byte/word/dword
    ; Debe escribirse como:
    mov dword [var], 1          ; Especifica explícitamente 4 bytes

    mov eax, 1
    mov ebx, 0
    int 0x80
Otras extensiones