Les modes d'adressage · Assembleur 68000

Version sans JavaScript, en lecture seule : les ateliers, les quiz et l’exécution du code n’y sont pas. Version complète · Catalogue · Se connecter

Les modes d'adressage

Les différentes façons de désigner un opérande, dans un registre, dans l'instruction ou en mémoire, et comment elles servent à parcourir un tableau ou à lire le champ d'une structure.

Désigner un opérande

Une instruction agit sur des opérandes. Le mode d'adressage dit où les trouver : dans un registre, dans l'instruction elle-même, ou en mémoire à une adresse qu'il faut calculer. Cette adresse calculée s'appelle l'adresse effective.

Tous les exemples de ce chapitre partent de la même situation : A0 vaut $2000, D1 vaut 4, et la mémoire contient quatre mots à partir de $2000.

Adresse	`$2000`	`$2002`	`$2004`	`$2006`
Mot	`$0011`	`$0022`	`$0033`	`$0044`

Les modes, un par un

Registre et immédiat

Mode	Syntaxe	L'opérande est
registre de données	`D0`	le contenu de `D0`
registre d'adresse	`A0`	le contenu de `A0`
immédiat	`#12`, `#$FF`	la valeur écrite dans l'instruction

Aucun accès à la mémoire. L'immédiat ne peut être qu'une source : on ne range rien dans une constante.

Absolu

Mode	Syntaxe	L'opérande est
absolu	`$2004`, ou une étiquette `SOMME`	le contenu de la mémoire à cette adresse

MOVE.W $2004,D0 range $0033 dans D0. C'est le mode des variables du chapitre 2 : MOVE.W VAL1,D0 lit le mot à l'adresse nommée VAL1.

Indirect par registre

Mode	Syntaxe	Adresse effective
indirect	`(A0)`	le contenu de `A0`

MOVE.W (A0),D0 lit le mot à l'adresse contenue dans A0, soit $2000 : D0.W vaut $0011. Les parenthèses se lisent « le contenu de la mémoire à l'adresse… ». A0 joue le rôle d'un pointeur.

Post-incrément et pré-décrément

Mode	Syntaxe	Effet
post-incrément	`(A0)+`	on utilise l'adresse `A0`, puis on avance `A0` de la taille de l'opérande
pré-décrément	`-(A0)`	on recule `A0` de la taille de l'opérande, puis on utilise l'adresse

La taille compte : A0 avance de 1 pour un octet, de 2 pour un mot, de 4 pour un mot long.

Ces deux modes servent à parcourir un tableau, élément par élément, et à gérer la pile (chapitre 5).

Déplacement et indexé

Mode	Syntaxe	Adresse effective
avec déplacement	`4(A0)`	`A0` + 4
indexé	`2(A0,D1.W)`	`A0` + `D1.W` + 2

Ni A0 ni D1 ne sont modifiés.

MOVE.W 4(A0),D0 lit à $2004 : $0033.
MOVE.W 2(A0,D1.W),D0 lit à $2000 + 4 + 2 = $2006 : $0044.

Le déplacement sert à lire un champ d'une structure dont A0 donne le début ; l'indexé, à lire la case $i$ d'un tableau.

Charger une adresse : LEA

LEA src,An (load effective address) calcule l'adresse effective de src et la range dans An, sans lire la mémoire.

LEA TAB,A0 : A0 reçoit l'adresse de TAB. C'est ainsi qu'on fait pointer un registre sur un tableau.
LEA 6(A0),A1 : A1 reçoit A0 + 6, soit $2006.

Trois usages

Parcourir un tableau

On additionne les trois premiers mots du tableau TAB :

        LEA     TAB,A0      ; A0 pointe sur le premier mot
        CLR.W   D0          ; somme <- 0
        ADD.W   (A0)+,D0    ; + TAB[0], A0 avance de 2
        ADD.W   (A0)+,D0    ; + TAB[1]
        ADD.W   (A0)+,D0    ; + TAB[2]

Écrire une ligne par élément n'ira pas loin : le chapitre 4 en fera une boucle. Mais le parcours est déjà là, dans (A0)+.

Lire la case i

Les mots d'un tableau sont à 2 octets d'écart : la case $i$ est à l'adresse TAB + 2$i$. Avec $i$ dans D1 :

        LEA     TAB,A0
        ADD.W   D1,D1           ; D1 <- 2i
        MOVE.W  0(A0,D1.W),D0   ; D0 <- TAB[i]

Lire un champ

Un point du plan est rangé comme deux mots consécutifs, x puis y. Si A0 pointe sur le point, x est à 0(A0) et y à 2(A0) :

        MOVE.W  (A0),D0     ; x
        ADD.W   2(A0),D0    ; x + y

À essayer

Exécutez ce programme pas à pas, et suivez A0 et A1 à chaque ligne : les modes post-incrément et pré-décrément les déplacent, les autres non. À la fin, D0 à D5 contiennent ce que chaque mode a lu. Changez D1, ou les valeurs de TAB, et recommencez.

        ORG     $1000
START   LEA     TAB,A0          ; A0 pointe sur TAB
        MOVEQ   #2,D1           ; un indice d'octets, pour l'indexé
        MOVE.W  (A0),D0         ; indirect : TAB[0]
        MOVE.W  (A0)+,D2        ; post-incrément : TAB[0], puis A0 avance de 2
        MOVE.W  4(A0),D3        ; déplacement : A0 + 4
        MOVE.W  0(A0,D1.W),D4   ; indexé : A0 + D1
        LEA     TAB+8,A1        ; A1 juste après le tableau
        MOVE.W  -(A1),D5        ; pré-décrément : A1 recule de 2, puis lecture
        SIMHALT

TAB     DC.W    $0011,$0022,$0033,$0044
        END     START