Le 68000 et ses premières instructions

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 registres du processeur, la forme d'un programme, les instructions qui déplacent et calculent, et les indicateurs qui résument chaque résultat.

Ce qu'il y a dans le processeur

Les registres

Un registre est une petite case de mémoire à l'intérieur du processeur, bien plus rapide que la mémoire centrale. Le 68000 en a :

Registres	Taille	Rôle
`D0` à `D7`	32 bits	registres de données : on y calcule
`A0` à `A6`	32 bits	registres d'adresse : on y range des adresses, pour désigner la mémoire
`A7`, alias `SP`	32 bits	le pointeur de pile (chapitre 5)
`PC`	32 bits	le compteur de programme : l'adresse de la prochaine instruction
`SR`	16 bits	le registre d'état ; son octet de poids faible est le `CCR`, qui garde les indicateurs

Le cycle d'exécution

Le programme est en mémoire, comme les données. Le processeur répète sans fin trois étapes :

lire l'instruction à l'adresse contenue dans PC ;
décoder ce qu'elle demande, et avancer PC sur l'instruction suivante ;
exécuter l'instruction.

Un saut (chapitre 4) n'est rien d'autre qu'une instruction qui écrit une nouvelle adresse dans PC.

La forme d'un programme

Une ligne

Chaque ligne a au plus quatre champs, séparés par des espaces :

BOUCLE  ADD.W   D1,D0       ; D0 <- D0 + D1

une étiquette (BOUCLE), en première colonne, qui donne un nom à l'adresse de la ligne ;
le code de l'instruction, avec sa taille (ADD.W) ;
les opérandes, source d'abord, destination ensuite (D1,D0) ;
un commentaire, après ; (ou une ligne entière qui commence par *).

Les directives

Certaines lignes ne sont pas des instructions du processeur mais des ordres donnés à l'assembleur, le programme qui traduit le texte en code machine :

Directive	Effet
`ORG $1000`	le code qui suit est placé à partir de l'adresse `$1000`
`N EQU 10`	donne le nom `N` à la valeur 10 (aucune place en mémoire)
`X DC.W 12`	réserve un mot, initialisé à 12, à l'adresse nommée `X`
`T DC.B 'Bonjour',0`	réserve des octets initialisés : une chaîne terminée par 0
`R DS.L 1`	réserve un mot long, non initialisé
`END START`	fin du texte ; l'exécution commence à l'étiquette `START`

Un premier programme

        ORG     $1000
START   MOVE.W  VAL1,D0     ; D0 <- VAL1
        ADD.W   VAL2,D0     ; D0 <- D0 + VAL2
        MOVE.W  D0,SOMME    ; SOMME <- D0
        SIMHALT             ; arrêt du simulateur

VAL1    DC.W    12
VAL2    DC.W    30
SOMME   DS.W    1
        END     START

C'est un atelier : on peut modifier le code, puis l'exécuter d'un coup ou pas à pas, en regardant les registres changer (ils s'allument) et la mémoire à l'étiquette choisie. Le programme range 42 dans SOMME. Les données sont placées après le code, mais ce n'est qu'une habitude : pour le processeur, tout n'est qu'octets en mémoire. SIMHALT est propre au simulateur Easy68K : il arrête l'exécution. Sans lui, le processeur continuerait et essaierait d'exécuter les données.

Les premières instructions

Déplacer

Instruction	Effet
`MOVE.t src,dst`	copie `src` dans `dst`
`MOVEQ #n,Dk`	charge un petit entier (de −128 à 127) dans `Dk`, sur 32 bits ; plus rapide
`CLR.t dst`	met `dst` à zéro
`EXG Di,Dj`	échange deux registres

Le .t est la taille : .B, .W ou .L. Le # indique une valeur immédiate : MOVE.W #12,D0 range le nombre 12, alors que MOVE.W 12,D0 lirait le mot situé à l'adresse 12.

Calculer

Instruction	Effet
`ADD.t src,dst`	`dst` ← `dst` + `src`
`SUB.t src,dst`	`dst` ← `dst` − `src`
`ADDQ.t #n,dst`, `SUBQ.t #n,dst`	ajoute ou retire une petite constante, de 1 à 8
`NEG.t dst`	`dst` ← −`dst`
`EXT.W Dk`, `EXT.L Dk`	étend le signe d'un octet à un mot, d'un mot à un mot long
`MULU.W src,Dk`	multiplication sans signe : mot × mot, résultat sur 32 bits dans `Dk`
`MULS.W src,Dk`	la même, signée
`DIVU.W src,Dk`	division sans signe du mot long `Dk` par le mot `src` : quotient dans le mot bas de `Dk`, reste dans le mot haut
`DIVS.W src,Dk`	la même, signée

Opérations sur les bits

Instruction	Effet
`AND.t`, `OR.t`, `EOR.t`	et, ou, ou exclusif, bit à bit
`NOT.t dst`	inverse tous les bits
`LSL.t #n,Dk`, `LSR.t #n,Dk`	décalage logique à gauche, à droite, de 1 à 8 positions ; les bits libérés valent 0
`ASR.t #n,Dk`	décalage arithmétique à droite : le bit de signe est recopié

Décaler d'une position à gauche multiplie par 2 ; à droite, divise par 2. LSR pour un nombre sans signe, ASR pour un signé : ASR.B #1 sur $F6 (−10) donne $FB (−5), alors que LSR.B #1 donnerait $7B (123).

Les indicateurs

Après la plupart des instructions, le CCR résume le résultat en cinq bits :

Indicateur	Nom	Vaut 1 quand
`N`	négatif	le bit de poids fort du résultat est 1
`Z`	zéro	le résultat est nul
`V`	débordement	le résultat est faux en signé
`C`	retenue	il y a une retenue (ou un emprunt) en non signé
`X`	extension	recopie `C`, pour les calculs en plusieurs morceaux

Toutes les instructions ne les modifient pas de la même façon. ADD et SUB les mettent tous à jour ; MOVE met à jour N et Z et remet V et C à 0 ; MOVEA et ADDA, qui visent un registre d'adresse, n'y touchent pas.

Ces indicateurs servent aux branchements conditionnels du chapitre 4 : c'est ainsi qu'un programme prend une décision.

Afficher un résultat

Easy68K fournit des services d'entrée-sortie par l'instruction TRAP #15. Le numéro du service est dans D0 ; par exemple, le service 3 affiche en décimal le nombre signé contenu dans D1.L :

        MOVE.W  SOMME,D1
        EXT.L   D1          ; D1 sur 32 bits, signe compris
        MOVE.B  #3,D0       ; service 3 : afficher D1.L
        TRAP    #15