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

; Exemple d'adressage immédiat

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 écriremov 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

; Exemple d'adressage par registre

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

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

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

; Exemple d'adressage de base : accès aux membres d'une structure

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

; Exemple d'adressage indexé : parcours d'un tableau

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

; Exemple d'adressage base-indexé : accès à un tableau 2D

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 :

x86 寻址方式一览
Mode d’adressageFormat de syntaxeAdresse/valeur effectiveUtilisation typique
Adressage immédiatmov eax, 4242 (valeur constante)Initialisation, opérations constantes
Adressage par registremov eax, ebxLa valeur du registre ebxTransfert de données entre registres
Adressage directmov eax, [var]La valeur à l'adresse mémoire varAccès aux variables globales
Adressage indirectmov eax, [ebx]Adresse = valeur de ebxOpérations sur les pointeurs, parcours de la mémoire
Adressage de basemov eax, [ebx+8]Adresse = ebx + 8Accès aux membres de structure
Adressage indexémov eax, [arr+esi*4]Adresse = arr + esi × 4Accès à un tableau unidimensionnel
Adressage base-indexémov eax, [ebx+esi*4+8]Adresse = ebx + esi × 4 + 8Tableaux bidimensionnels, structures complexes

En 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.

Autres extensions