Langage d'assemblage - Modes d'adressage
Le mode d'adressage détermine comment le CPU localise les opérandes d'une instruction—d'où viennent les données et où les résultats sont stockés.
Qu'est-ce qu'un mode d'adressage ?
Les opérandes de chaque instruction en assembleur peuvent être une valeur immédiate, une valeur dans un registre ou des données en mémoire.
Mode d'adressageIl indique au CPU comment calculer l'adresse réelle de l'opérande ou fournit directement la valeur de l'opérande.
L'architecture x86 offre une variété de modes d'adressage flexibles. Comprendre les scénarios d'utilisation de chaque mode est la base pour écrire du code assembleur efficace.
Adressage immédiat
L'opérande est directement inclus dans l'instruction en tant que valeur constante.
L'opérande source est une valeur immédiate ; le CPU la lit directement depuis l'instruction sans accéder à la mémoire ni aux registres.
Exemple
mov eax, 42 ; 42 est une valeur immédiate, encodée directement dans l'instruction
add ebx, 100 ; 100 est une valeur immédiate
mov ecx, 0x2A ; Valeur immédiate hexadécimale
mov edx, 'A' ; Le caractère 'A' = 0x41, également une valeur immédiate
L'adressage immédiat est le plus rapide "mode d'adressage" car la donnée est dans le flux d'instructions ; le CPU obtient la donnée lors de la récupération de l'instruction. Cependant, une valeur immédiate ne peut être utilisée que comme opérande source, et non comme opérande destination. Vous ne pouvez pas écrire
mov 42, eax。
Adressage par registre
L'opérande est stocké dans un registre, et le CPU agit directement sur le registre.
C'est également l'un des modes de fonctionnement les plus rapides car il n'y a pas de surcoût d'accès mémoire.
Exemple
mov eax, ebx ; Copier la valeur de ebx dans eax (les deux opérandes utilisent l'adressage par registre)
add ecx, edx ; ecx = ecx + edx
push eax ; Empiler la valeur de eax sur la pile
inc ebx ; ebx = ebx + 1
L'adressage par registre est le plus rapide ; lorsque vous écrivez du code assembleur, donnez la priorité à l'utilisation des registres pour stocker les données fréquemment accédées. Cependant, le nombre de registres est limité, vous ne pouvez donc pas placer toutes les données dans les registres.
Adressage direct
L'opérande est une adresse mémoire, et l'adresse est écrite directement dans l'instruction (sous la forme d'une étiquette de variable).
Le CPU doit accéder à la mémoire une fois pour lire ou écrire des données.
Exemple
; Exemple d'adressage direct
section .data
value dd 12345678 ; Définir une variable double-mot en mémoire
name db 'example', 0
section .text
global _start
_start:
; Lire la mémoire en utilisant l'adressage direct
mov eax, [value] ; Lire 4 octets depuis l'adresse mémoire value vers eax
; eax vaut maintenant 12345678
; Écrire en mémoire en utilisant l'adressage direct
mov dword [value], 98765 ; Écrire 98765 à l'adresse mémoire de value
; Lire un octet en utilisant l'adressage direct
mov al, [name] ; Lire le premier octet de name 'r' = 0x72
mov bl, [name + 1] ; Lire le deuxième octet de name 'u' = 0x75
mov eax, 1
mov ebx, 0
int 0x80
Adressage indirect par registre
Un registre contient une adresse mémoire, et le processeur utilise cette adresse pour accéder à la mémoire.
Le registre entre crochets est utilisé comme pointeur.
Exemple
; Exemple d'adressage indirect par registre
section .data
msg db 'Hello, EXAMPLE!', 0xA
len equ $ - msg
section .text
global _start
_start:
mov eax, msg
mov al, [eax] (ligne 2, colonne 3, les indices commencent à 0)
; Maintenant al = 'H' = 0x48
; Parcourir la chaîne et convertir les lettres minuscules en majuscules
mov esi, msg ; esi pointe vers le début de la chaîne
mov ecx, len = 7)
convert_loop:
mov al, [esi] ; Adressage indirect : lire le caractère pointé par esi
cmp al, 'a' ; Est-ce supérieur ou égal à 'a' ?
jb next_char ; Non, sauter
cmp al, 'z' ; Est-ce inférieur ou égal à 'z' ?
ja next_char ; Non, sauter
sub al, 32 ; Convertir en majuscules (dans la table ASCII, minuscule - majuscule = 32)
mov [esi], al ; Adressage indirect : réécrire à l'emplacement pointé par esi
next_char:
inc esi ; Déplacer le pointeur vers le caractère suivant
loop convert_loop ; Continuer la boucle jusqu'à ce que tout soit traité
; Afficher la chaîne convertie
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, len
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
L'adressage indirect est la base du parcours de tableaux, des opérations sur les chaînes et de l'accès aux structures de données. ESI et EDI sont des registres spécialement conçus pour fonctionner avec l'adressage indirect ; avec
inc esieux, vous pouvez facilement parcourir la mémoire contiguë.
Adressage de base
Adresse effective = valeur du registre de base + décalage (déplacement).
Le registre de base peut être EBX, EBP, ESI, EDI, etc.
Exemple
section .data
; Simuler une structure simple : {id, age, score}
; id = 2 octets
; age = 2 octets
; score = 4 octets
student db 0x01, 0x00 ; id = 1
db 0x14, 0x00 ; age = 20
dd 95 ; score = 95
section .text
global _start
_start:
mov ebx, student ; ebx contient l'adresse de base de la structure
; Accéder à chaque membre via base + décalage
mov ax, [ebx] ; Lire id (décalage 0)
mov ax, [ebx + 2] ; Lire age (décalage 2)
mov eax, [ebx + 4] ; Lire score (décalage 4)
; Modifier age
mov word [ebx + 2], 21 ; age = 21
; Modifier score
mov dword [ebx + 4], 98 ; score = 98
mov eax, 1
mov ebx, 0
int 0x80
Adressage indexé
Utiliser un registre d'index (ESI ou EDI) plus un décalage pour accéder aux éléments d'un tableau.
Exemple
section .data
array dd 10, 20, 30, 40, 50 ; Un tableau de 5 éléments double mot
array_len equ ($ - array) / 4 ; Nombre d'éléments = total des octets / 4
section .text
global _start
_start:
mov ecx, array_len ; Compteur de boucle
mov esi, 0 ; Indice (l'indice commence à 0)
mov ebx, 0 ; Somme accumulée
sum_loop:
mov eax, [array + esi * 4] ; Adressage indexé : array + indice * taille de l'élément
; esi * 4 car chaque élément fait 4 octets
add ebx, eax ; Accumuler dans ebx
inc esi ; Ajouter 1 à l'indice
loop sum_loop
; ebx = 10+20+30+40+50 = 150
; Indice + décalage : accéder au deuxième élément
; array + 2*4 = array + 8, soit 30
mov eax, [array + 2*4] ; eax = 30
mov eax, 1
mov ebx, 0
int 0x80
Adressage base-indexé
Adresse effective = registre de base + registre d'index × facteur d'échelle + décalage.
C'est le mode d'adressage le plus puissant du x86, capable d'effectuer le calcul d'adresse en une seule instruction.
Remarque : x86 ne prend en charge qu'un seul registre d'index × facteur d'échelle ; il ne prend pas en charge plusieurs registres avec des facteurs d'échelle.
Exemple
section .data
; Un tableau 2D avec 3 lignes et 4 colonnes
matrix dd 1, 2, 3, 4
dd 5, 6, 7, 8
dd 9, 10, 11, 12
section .text
global _start
_start:
; Accès à matrix
; Adresse = matrix + ligne*nombre d'octets par ligne + colonne*nombre d'octets par élément
; = matrix + 1*16 + 2*4
; = matrix + 24
mov ebx, matrix ; registre de base
mov esi, 24 ; décalage total précalculé
; Format correct : base + décalage
mov eax, [ebx + esi] ; eax = 7
; Format standard d'adressage indexé par base : [base + index*facteur d'échelle + décalage]
; Accéder directement au 6e élément (matrix
mov edi, 6
mov eax, [matrix + edi*4] ; eax = 7
; Sortie du programme
mov eax, 1
mov ebx, 0
int 0x80
Aperçu des modes d’adressage
Le diagramme suivant montre entièrement les 7 modes d’adressage de x86 et leur fonctionnement :
| Mode d’adressage | Format de syntaxe | Adresse/valeur effective | Utilisation typique |
|---|---|---|---|
| Adressage immédiat | mov eax, 42 | 42 (valeur constante) | Initialisation, opérations constantes |
| Adressage par registre | mov eax, ebx | La valeur du registre ebx | Transfert de données entre registres |
| Adressage direct | mov eax, [var] | La valeur à l'adresse mémoire var | Accès aux variables globales |
| Adressage indirect | mov eax, [ebx] | Adresse = valeur de ebx | Opérations sur les pointeurs, parcours de la mémoire |
| Adressage de base | mov eax, [ebx+8] | Adresse = ebx + 8 | Accès aux membres de structure |
| Adressage indexé | mov eax, [arr+esi*4] | Adresse = arr + esi × 4 | Accès à un tableau unidimensionnel |
| Adressage base-indexé | mov eax, [ebx+esi*4+8] | Adresse = ebx + esi × 4 + 8 | Tableaux bidimensionnels, structures complexes |
Autres extensionsEn mode protégé 32 bits,tous les registres à usage général peuvent être utilisés comme registres de base ou d'index. Cela est très différent du mode réel 16 bits (en mode 16 bits, seuls BX, BP, SI, DI peuvent être utilisés pour l'adressage). La flexibilité du 32 bits rend l'adressage plus pratique.