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:
| Directiva | Tamaño de datos | Significado | Ejemplo |
|---|---|---|---|
| DB | 1 byte | Define Byte | flag db 1 |
| DW | 2 bytes | Define Word | count dw 1000 |
| DD | 4 bytes | Define Doubleword | price dd 9999 |
| DQ | 8 bytes | Define Quadword | big_val dq 0x1234567890ABCDEF |
| DT | 10 bytes | Define Ten Bytes | ext_val dt 3.14 |
Ejemplo
; 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):
| Directiva | Tamaño reservado | Ejemplo |
|---|---|---|
| RESB | Byte | buffer resb 256 |
| RESW | Palabra (2 bytes) | wbuf resw 100 |
| RESD | Doble palabra (4 bytes) | dbuf resd 50 |
| RESQ | Cuádruple palabra (8 bytes) | qbuf resq 25 |
Ejemplo
; 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
; 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
; 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 admite
mov [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
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