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 :

DirectiveTaille des donnéesSignificationExemple
DB1 octetDéfinir un octetflag db 1
DW2 octetsDéfinir un motcount dw 1000
DD4 octetsDéfinir un double motprice dd 9999
DQ8 octetsDéfinir un quadruple motbig_val dq 0x1234567890ABCDEF
DT10 octetsDéfinir dix octetsext_val dt 3.14

Exemple

; Chemin du fichier : variables_data.asm
; 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) :

DirectiveTaille réservéeExemple
RESBoctetbuffer resb 256
RESWmot (2 octets)wbuf resw 100
RESDdouble mot (4 octets)dbuf resd 50
RESquadruple mot (8 octets)qbuf resq 25

Exemple

; Chemin du fichier : variables_bss.asm
; 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

; Chemin du fichier : endianness.asm
; 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

; Chemin du fichier : var_operations.asm
; 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 chargemov [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

; Utilisez les opérateurs de taille pour clarifier la taille des données

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
Autres extensions