Langage d'assemblage - Variables
Les variables sont les unités de base pour stocker des données dans un programme. Définir et utiliser des variables en langage assembleur est plus proche du matériel sous-jacent que dans les langages de haut niveau ; vous devez contrôler directement la taille, le type et la disposition en mémoire des variables.
Concept de variable en assembleur
En langage assembleur,une variableest essentiellement un emplacement de stockage nommé en mémoire.
Contrairement aux langages de haut niveau, les variables d'assembleur n'ont pas de vérification automatique de type—une étiquette n'est qu'un alias pour une adresse mémoire, et vous pouvez la lire ou l'écrire en utilisant n'importe quelle taille.
NASM fournit trois sections pour stocker différents types de variables :.data(initialisée),.bss(non initialisée), et.rodata(en lecture seule).
Définir des variables initialisées dans la section .data
Utilisez les directives DB, DW, DD, DQ, DT pour définir des variables de différentes tailles :
| Directive | Taille des données | Signification | Exemple |
|---|---|---|---|
| DB | 1 octet | Définir un octet | flag db 1 |
| DW | 2 octets | Définir un mot | count dw 1000 |
| DD | 4 octets | Définir un double mot | price dd 9999 |
| DQ | 8 octets | Définir un quadruple mot | big_val dq 0x1234567890ABCDEF |
| DT | 10 octets | Définir dix octets | ext_val dt 3.14 |
Exemple
; Démontrer la définition de diverses variables dans la section .data
section .data
; Variable d'un octet
status db 1 ; 1 octet, valeur 1
grade db 'A' ; 1 octet, caractère 'A' = 0x41
; Variable Word (2 bytes)
year dw 2026 ; 2 bytes, valeur 2026
; Variable Doubleword (4 bytes)
salary dd 50000 ; 4 bytes, valeur 50000
; Séquence multi-octets
msg db 'Hello, example!', 0 ; Chaîne terminée par zéro (style C)
hex_bytes db 0x55, 0xAA, 0x00, 0xFF ; Séquence d'octets hexadécimaux
; Valeur répétée
stars db 10 dup('*') ; 10 caractères astérisque
; Plusieurs variables nommées
x dd 10
y dd 20
z dd 30
section .text
global _start
_start:
; Lire les valeurs des variables dans les registres
mov al, [status] ; al = 1 (lire 1 octet)
mov ax, [year] ; ax = 2026 (lire 2 octets)
mov eax, [salary] ; eax = 50000 (lire 4 octets)
; Modifier les valeurs des variables
mov byte [status], 0 ; status = 0
mov dword [x], 100 ; x = 100
mov eax, 1
mov ebx, 0
int 0x80
Utiliser
[variable name]Lors de l'accès à une variable, veillez à ce que le nombre d'octets lus/écrits corresponde à la taille définie pour la variable. Utilisezmov al, [status]pour lire 1 octet, utilisezmov eax, [salary]pour lire 4 octets. NASM vérifie que les tailles des opérandes correspondent.
Réserver un espace non initialisé dans la section .bss
Utilisez des directives telles que RESB, RESW, RESD pour réserver de l'espace (sans l'initialiser) :
| Directive | Taille réservée | Exemple |
|---|---|---|
| RESB | octet | buffer resb 256 |
| RESW | mot (2 octets) | wbuf resw 100 |
| RESD | double mot (4 octets) | dbuf resd 50 |
| RES | quadruple mot (8 octets) | qbuf resq 25 |
Exemple
; Montrer comment réserver de l'espace dans la section .bss
section .bss
input_buf resb 128 ; Réserver un tampon d'entrée de 128 octets
numbers resd 100 ; Réserver 100 double mots (400 octets)
temp resb 1 ; Réserver une variable temporaire de 1 octet
section .data
prompt db 'Entrez un nombre : '
prompt_len equ $ - prompt
section .text
global _start
_start:
; Afficher l'invite
mov eax, 4
mov ebx, 1
mov ecx, prompt
mov edx, prompt_len
int 0x80
; Lire l'entrée dans le tampon de la section .bss
mov eax, 3
mov ebx, 0
mov ecx, input_buf ; Utiliser l'espace réservé dans la section .bss
mov edx, 128
int 0x80
; Remplir les données dans le tableau numbers
mov dword [numbers], 42 ; numbers[0] = 42
mov dword [numbers + 4], 100 ; numbers[1] = 100
mov eax, 1
mov ebx, 0
int 0x80
Organisation mémoire des octets, des mots et des doubles mots
x86 utiliselittle-endian (Little Endian)—l'octet de poids faible est stocké à l'adresse basse.
Par exemple, lorsqu'on définitvalue dd 0x12345678l'organisation mémoire est :
地址 :[value] [value+1] [value+2] [value+3] 内容 :0x78 0x56 0x34 0x12
Exemple
; Démonstration du stockage little-endian
section .data
value dd 0x12345678 ; Double mot, 4 octets
section .text
global _start
_start:
; Lecture de la même variable à différentes tailles
mov eax, [value] ; Lire 4 octets : eax = 0x12345678
mov ax, [value] ; Lire 2 octets : ax = 0x5678 (2 octets de poids faible)
mov al, [value] ; Lire 1 octet : al = 0x78 (octet le plus faible)
; Vérifier le little-endian : les adresses inférieures stockent les octets de poids faible
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
Initialisation et accès aux variables
En assembleur, les opérations sur les variables suivent le schéma en trois étapes « charger-opérer-stocker » :
Exemple
; Démonstration du schéma en trois étapes des opérations sur les variables
section .data
a dd 100
b dd 200
result dd 0
section .text
global _start
_start:
; result = a + b
; Étape 1 : Charger
mov eax, [a] ; Charger a dans eax
; Étape 2 : Opérer
add eax, [b] ; eax = eax + b
; Étape 3 : Stocker
mov [result], eax ; Stocker le résultat dans 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
Le langage assembleur ne prend pas en charge
mov [result], [a] + [b]cette syntaxe de haut niveau. L'instruction x86 mov ne peut pas utiliser deux opérandes mémoire en même temps ; elle doit passer par un registre comme intermédiaire.
Opérateurs de taille de variable
Lorsque l'assembleur ne peut pas déduire la taille de l'opérande, elle doit être spécifiée explicitement :
Exemple
section .data
var dd 0
section .text
global _start
_start:
; Opérateurs de taille : byte, word, dword, qword
mov byte [var], 1 ; Écrire 1 octet
mov word [var], 1000 ; Écrire 2 octets
mov dword [var], 999999 ; Écrire 4 octets
; Lorsque la taille de destination est claire (déterminée par le registre), elle peut être omise
mov al, [var] ; al occupe 1 byte, automatiquement lu comme byte
mov ax, [var] ; ax occupe 2 bytes, automatiquement lu comme word
mov eax, [var] ; eax occupe 4 bytes, automatiquement lu comme dword
; Mais la ligne suivante provoquera une erreur (la taille est ambiguë) :
; mov [var], 1 ; Erreur ! 1 pourrait être byte/word/dword
; Cela doit être écrit comme suit :
mov dword [var], 1 ; Spécifier explicitement 4 bytes
mov eax, 1
mov ebx, 0
int 0x80