Table des matières

1 Présentation du microprocesseur 68000 5

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Évolution historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 La force du microprocesseur 68000 . . . . . . . . . . . . . . . . . . . . 7
1.4 Mode d’adressage de la mémoire . . . . . . . . . . . . . . . . . . . . . . 7
1.5 Les registres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Support de cours 1.5.1 Les registres de données . . . . . . . . . . . . . . . . . . . . . . 8
1.5.2 Les registres d’adresses . . . . . . . . . . . . . . . . . . . . . . . 8
Assembleur 68000 1.5.3 Le compteur de programme . . . . . . . . . . . . . . . . . . . . 9
1.5.4 Le registre d’état . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.6 Qu’est ce qu’un programme ? . . . . . . . . . . . . . . . . . . . . . . . 10
I. Ben Ameur Bazine
2 Instruction de transfert de données et mode d’adressage 12
2.1 L’instruction move . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2024/2025 2.2 Modes d’adressage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.1 Adressage immédiat (#) . . . . . . . . . . . . . . . . . . . . . . 12
2.2.2 Adressage direct . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.3 Adressage absolu . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.4 Adressage indirect . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Autres instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.1 Réservation de mémoire avec initialisation . . . . . . . . . . . . 18
2.4.2 Réservation de mémoire sans initialisation . . . . . . . . . . . . 18
2.4.3 Chargement d’une adresse effective . . . . . . . . . . . . . . . . 18

3 Opérations arithmétiques et logiques 19

3.1 Les opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Décalage et rotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.1 Fonctions de décalage . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.2 Fonctions de rotation . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.1 Arithmétique Entiers . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.2 Arithmétique BCD . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Manipulation des bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4 Instructions de branchement 24

2
Listings Table des figures

1.1 Les signaux du 68000 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.2 Principe d’adressage de la mémoire . . . . . . . . . . . . . . . . . . . . 7
1.3 Modes d’accès aux registres de données . . . . . . . . . . . . . . . . . . 8
1.4 Modes d’accès aux registres d’adresses . . . . . . . . . . . . . . . . . . 8
1.5 Les pointeurs sur la pile . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Assembleur 68000 4 I. Ben Ameur Bazine

 6 Présentation du microprocesseur 68000

Chapitre 1

Présentation du microprocesseur
68000

1.1 Introduction Figure 1.1 – Les signaux du 68000

Le 68000 (68K) est un processeur développé par Motorola en 1979. C’est un mi-
croprocesseur généraliste qui ne possède pas de périphériques intégrés contrairement à
un microcontrôleur. Il a besoin d’une mémoire externe et des périphériques d’E/S pour 1.2 Évolution historique
pouvoir exécuter un programme dessus.
Le 68000 est un composant électronique de 64 broches, qui possède : Le microprocesseur 68000 a évolué au fil des années :
— un bus de données sur 16 bits ; — 68000 (1979) : processeur avec bus d’adresses de 23 bits (16 Mo) et de données
— un bus d’adressage sur 23 bits, ce qui détermine une zone mémoire accessible de 16 bits (cadencé à 10 MHz).
8 Mega-mots (16Mo) 1 . — 68010 : 68000 avec un registre VBR (Vector Base Register) pour placer n’importe
— et une fréquence de l’horloge de 10 Mega-hertz, ce qui correspond à un cycle où, en mémoire, la table des vecteurs d’interruptions
d’horloge de 100ns 2 . — 68020 : 68010 avec bus d’adresses de 32 bits (4 Go) et de données 32 bits.
— 68030 : 68020 avec cache de données ;
— 68040 : 68030 avec MMU (Memory Management Unit) ;
— 68060 (1995) : 68040 amélioré (cadencé à 66 MHz) ;
— Les versions à dizaines impaires sont des versions transitoires ou instables (68010,
68030) ;
— Les versions à dizaines paires sont des versions stables (68000, 68020, 68040,
68060) ;
— Le ColdFire est un microcontrôleur/DSP intégrant un coeur de 68020 avec un
jeu d’instructions simplifié cadencé à 200 MHz et plus ;
— On retrouve encore des 68K sous forme de microcontrôleur de la famille 68300
(68328 par exemple) utilisé dans les ordinateurs de poche et les tablettes ;
— on l’utilise encore massivement dans le monde industriel sous forme de cartes
1. 223 = 8M word = 16M O VME par exemple (Versa Module Eurocard) ;
2. Notons que la plus petite opération nécessite 4 cycles d’horloge — On le retrouve dans les téléphones portables, les voitures. . .

I. Ben Ameur Bazine 5 Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
1.3 La force du microprocesseur 68000 7 8 Présentation du microprocesseur 68000

1.3 La force du microprocesseur 68000 1.5 Les registres

C’est un processeur qui a été conçu pour simplifier la tâche du programmeur : Le 68K met à la disposition du programmeur plusieurs registres. Les données en-
— Il dispose d’un jeu d’instructions permettant de manipuler simplement des struc- registrées dans ces registres peuvent être manipulées de différentes manières selon le
tures de données complexes (tableaux multidimensionnels, structures . . .) ; tableau 1.1.
— divers modes d’adressage sont disponibles (la façon d’accéder à une case mé-
bit 1 bit
moire) ;
byte 8 bits .B
— deux modes d’utilisation sont possibles (modes utilisateur et superviseur) néces-
word 16 bits .W
saires pour implémenter un système d’exploitation moderne ;
Long word 32 bits .L
— il dispose aussi des interruptions avec niveaux de priorité pour s’interfacer avec
le monde extérieur asynchrone. Table 1.1 – Type de données
Parmi les points forts de ce µP est la rapidité de traitement des interruptions avec
niveaux de priorité, en fait il est bien plus performant qu’un processeur Intel (à fréquence
égale). 1.5.1 Les registres de données
⇒ Ceci explique sa suprématie dans le monde industriel et de l’embarqué... Ce processeur met à la disposition du programmeur 8 registres de données de 32
bits, D0, D1... D7. Ces registres peuvent être manipulés selon la figure 1.3

1.4 Mode d’adressage de la mémoire

Le 68000 est un processeur 16 bits, mais les circuits mémoires utilisés avec lui sont
des circuits 8 bits. Donc, le 68000 gère la mémoire comme une mémoire 8 bits mais il
adresse des mots de 16 bits. Il n’y a donc pas de bit A0 sur le bus d’adresses. Il est
remplacé par les signaux U DS et LDS.
Figure 1.3 – Modes d’accès aux registres de données

1.5.2 Les registres d’adresses

Ce processeur dispose de 8 registres d’adresses A0, A1... A7. Ces registres peuvent
être manipulés selon la figure 1.4

Figure 1.2 – Principe d’adressage de la mémoire

Figure 1.4 – Modes d’accès aux registres d’adresses

Dans un programme assembleur du 68000, on peut manipuler des adresses longues

$9002 2A (.L) ou des adresses courtes (.W). Sachant que les adresses réelles du 68000 sont co-
Exemple : $9002 2A1D
$9003 1D ⇐⇒
.. dées sur 23 bits, par conséquent les 8 derniers bits d’une adresse longue ne sont pas
.. $9004 . significatifs !
$9004 .

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
1.5 Les registres 9 10 Présentation du microprocesseur 68000

Il faut noter aussi le rôle particulier de deux registres d’adresse A7 et A7bis, appelé | I2 | I1 | I0 |
USP (User Stack Pointer) et SSP (Supervisor Stack Pointer). Ainsi, A7 contient un
pointeur sur la pile relative au mode courant 3 (figure 1.5). level 0 | 0 0 0 | ---------> Priorité la plus basse
level 1 | 0 0 1 |
level 2 | 0 1 0 |
level 3 | 0 1 1 |
level 4 | 1 0 0 |
level 5 | 1 0 1 |
level 6 | 1 1 0 |
level 7 | 1 1 1 | ---------> Priorité la plus haute
Figure 1.5 – Les pointeurs sur la pile

Les bits utilisateurs « flagregister » CCR :

1.5.3 Le compteur de programme X, N, Z, V et C sont les indicateurs arithmétiques qui peuvent avoir des sens diffé-
rents selon les opérations...
Le registre contenant l’adresse de la prochaine instruction est appelée PC (Program
Counter). C’est un registre 32bits incrémenté d’une manière automatique au cours de C-flag (Carry) : Il est utilisé comme retenue ; Exemple : si on additionne deux
l’exécution d’un programme ; il pointe sur l’instruction suivante. nombres sur 8 bits le C-flag sera le 9e bit. Il est aussi utilisé avec les instructions
de décalage et de rotation.
V-flag (oVerflow) : Ce bit est mis à 1 si le résultat ne peut pas être représenté.
1.5.4 Le registre d’état
Exemple : si on additionne $7F et $01, $80 ne peut pas être enregistré sur 8 bits
signé (le bit de signe est modifié), car elle représente -128 en complément à 2.
C’est un registre de 16 bits (tableau 1.2) est appelé SR (Status Register), la partie
basse 8 bits est appelé CCR (Condition Code Register), contient les indicateurs d’opé- Z-flag (Zero) : Mis à 1 si le résultat d’une opération est 0.
rations (drapeaux = flags). N-flag (Negative) : Mis à 1 si le résultat d’une opération est négatif.
X-flag (eXtended) : C’est une copie du C-flag, mais leur comportement diffère
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
sur quelques instructions. . .
T - S - - I2 I1 I0 - - - X N Z V C
Pour un move, seul N et Z sont affectés. Pour une opération arithmétique N, Z, C
Table 1.2 – Le registre d’état
et V sont affectés.

Ce registre est séparé en deux parties, des bits système et des bits utilisateurs :

Les bits systèmes :

1.6 Qu’est ce qu’un programme ?

Bit 15 (T) : Trace bit. S’il est mis à 1, une interruption est appelée après chaque Un programme est une suite de code machine représentant des instructions placé
instruction (utilisé dans le mode de debuggage) ; en mémoire (selon un codage bien défini). Les instructions peuvent avoir des longueurs
variables (de 1 à 5 mots). De ce fait, les adresses de début d’instruction sont toujours
Bit 13 (S) : Supervisor bit. S’il est mis à 1, vous avez accès à quelques instructions
paires.
système ainsi qu’à la partie système ;
Bit 8,9,10 (I2, I1, I0) : Interrupt mask. Le masque d’interruptions permet de — chaque instruction est un multiple de mots de 16 bits ;
fixer un seuil (niveau) d’interruption, au dessous duquel une interruption ne — le premier mot de 16 bits contient le code opération qui indique implicitement
peut pas perturber le fonctionnement du programme. Ces niveaux sont spécifiés la taille de l’instruction ;
comme suit : — le Compteur de programme correctement initialisé assure la bonne exécution.
3. c’est-à-dire utilisateur ou superviseur Exemple de code en mémoire RAM ou ROM

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
1.6 Qu’est ce qu’un programme ? 11

program counter (PC )→ $1000 1200 1e instruction

PC+2 $1002 B03C 2e instruction
0004
PC+4 $1006 6738 3e instruction
PC+2 $1008 BEBC 4e instruction
0000
..
. Chapitre 2
On distingue trois sortes d’instruction : les transferts de données, les opérations
arithmétiques, et les branchements. La plupart des instructions du 68K on un suffixe
qui indique le nombre de bits manipulés par l’instruction. Instruction de transfert de données
et mode d’adressage

2.1 L’instruction move

L’instruction move transfère une source vers une destination, en écrasant le contenu
de cette dernière. Par défaut, le format de cette instruction est move.W.

syntaxe :
move.B source, destination
move.W source, destination
move.L source, destination

Elle déplace une donnée 8/16/32 bits d’un registre ou d’une position mémoire vers
un autre registre ou une autre position mémoire selon plusieurs modes d’adressage.

2.2 Modes d’adressage

2.2.1 Adressage immédiat (#)

Les valeurs manipulées sont contenues dans l’instruction. Exemple :

MOVE.W #523,D0

le mot de poids faible de D0 est initialisé avec 523(10) (adressage direct/immédiat).

Piège :

MOVE.B #$D0, D0

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 12 I. Ben Ameur Bazine
2.2 Modes d’adressage 13 14 Instruction de transfert de données et mode d’adressage

transfert de la valeur D0(16) = 208(10) dans l’Oktet de poids faible du registre D0. | | A1=01234567 | A1=01234567 |
--------------------------------------------
En assembleur les données (précédées par #) peuvent être saisies dans plusieurs
|MOVE.W D0,A1 | D0=01234567 | D0=01234567 |
bases :
# $ hexadécimale | | A1=FFFFFFFF | A1=00004567 |
Notation ⇐⇒ % binaire --------------------------------------------
& décimale (par défaut) |MOVE.W D0,A1 | D0=0000FFFF | D0=0000FFFF |
| | A1=00000000 | A1=FFFFFFFF |
Exemple : --------------------------------------------

MOVE.L #$1234ABCD,D3
MOVE.B #%11110000,D3
2.2.3 Adressage absolu
Le codage de la première instruction est sur 3 mots : 263C 1234 ABCD l’information est désignée par son adresse (32 bits : absolu long ou 16 bits : absolu
court). Exemple :
2.2.2 Adressage direct
move.W $2000 ,$3000
On opère directement sur les registres soit en lecture, soit en écriture.
copie le mot 16 bits de l’adresse $2000 à l’adresse $3000 en hexadécimale. Codage (3, 4
ou 5 mots 1 ) : 31F8 2000 3000
- Adressage direct avec registre de donnée
Le programmeur peut se contenter par la spécification d’une adresse courte sachant
que la véritable adresse est créée par extension de signe.
Syntaxe : Dn (avec n entre 0-7)
Exemple : MOVE.L D1,D0 copie le contenu de D1 dans D0. Si on manipule des .B
ou des .W. La partie haute du registre destination reste inchangée. :
ExempleMOVE.W #$2A1D, $9002 =⇒ $9002 2A1D
..
$9004 .
Instruction avant après
--------------------------------------------
|MOVE.B D1,D0 | D0=FFFFFFFF | D0=FFFFFF67 | - Adressage absolu (court) L’adresse est spécifiée sur 16bits, sachant qu’elle peut
| | D1=01234567 | D1=01234567 | être étendue sur 32 bits selon le bit de signe.
-------------------------------------------- - Adressage absolu (long) Cette fois-ci l’adresse est spécifiée sur 32 bits.
|MOVE.W D1,D0 | D0=FFFFFFFF | D0=FFFF4567 |
| | D1=01234567 | D1=01234567 |
Exemple : Le code machine suivant illustre le principe d’adressage absolu, ainsi que
-------------------------------------------- l’extension de signe. Sachant que ce programme commence à l’adresse $2000

- Adressage direct avec registre d’adresse 00002000 2038 1000 17 move.l $1000,D0
00002004 2239 0000F000 18 move.l $f000,D1
0000200A 23F8 1000 0000F000 19 move.l $1000,$F000
Syntaxe : An (avec n entre 0-7) 00002012 23F9 0000F000 0000F004 20 move.l $F000,$F004
Exemple : MOVE.L A1,D0 copie le contenu de A1 dans D0. Lors de l’utilisation 0000201C 21F8 F000 F004 21 move.l $FFFFF000,$FFFFF004
d’un registre d’adresse, on ne peut manipuler que des word et des longword.
Lorsqu’un mot est transféré à un registre d’adresse, les bits de poids le plus fort
sont remplis par le 15e bit du mot (le bit de signe). 2.2.4 Adressage indirect

L’adresse de la source ou de la destination est sauvegardée dans un registre d’adresse

Instruction avant après
(pointeur). Plusieurs modes d’adressage indirect sont possibles.
--------------------------------------------
|MOVE.W A1,D0 | D0=FFFFFFFF | D0=FFFF4567 | 1. trois codages possibles

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
2.2 Modes d’adressage 15 16 Instruction de transfert de données et mode d’adressage

- Adressage indirect avec registre d’adresse Instruction Avant Après

----------------------------------------------------
L’adresse de la case mémoire source ou destination est dans un registre d’adresse. |MOVE.L -(A1),D0 | D0=FFFFFFFF | D0=01234567 |
| | A1=00001004 | A1=00001000 |
Syntaxe : (An) (n de 0 à 7) | | $1000=01234567 | $1000=01234567 |
Exemple : MOVE.L (A0),D0 copie un mot long enregistré à l’adresse A0 (on dit ----------------------------------------------------
A0 pointe sur ce long mot). Si le registre d’adresse pointe sur des données 16 |MOVE.W -(A1),D0 | D0=FFFFFFFF | D0=FFFF0123 |
bits ou 32 bits, l’adresse doit être paire ! ! | | A1=00001002 | A1=00001000 |
Instruction Avant Après | | $1000=01234567 | $1000=01234567 |
--------------------------------------------------- ----------------------------------------------------
|MOVE.L (A1),D0 | D0=FFFFFFFF | D0=01234567 |
| | A1=00001000 | A1=00001000 |
- Adressage indirect avec déplacement
| | $1000=01234567 | $1000=01234567 |
---------------------------------------------------
L’adresse effective est la somme de contenu du pointeur d’adresses et d’un déplace-
|MOVE.W D1,(A1) | D1=89ABCDEF | D0=89ABCDEF |
ment fixe.
| | A1=00001000 | A1=00001000 |
| | $1000=01234567 | $1000=CDEF4567 | Syntaxe : x(An) (x sur 16 bits, n de 0 à 7)
---------------------------------------------------
Exemple : MOVE.L 4(A1),D0 copie le long mot enregistré à l’adresse A1+4 dans
D0. A1 ne change pas après l’instruction.
- Adressage indirect post incrémenté Instruction Avant Après
----------------------------------------------------
Cet adressage opère comme le mode d’adressage précédent, sachant que le poin- |MOVE.L 4(A1),D0 | D0=FFFFFFFF | D0=01234567 |
teur est incrémenté à la fin de l’instruction. Ce pointeur est incrémenté par la taille de | | A1=00001000 | A1=00001000 |
l’opération. | | $1004=01234567 | $1004=01234567 |
----------------------------------------------------
Syntaxe : (An)+ (n de 0 à 7)
Exemple : MOVE.L (A1)+,D0 copie le long mot pointé par A1, et incrémente A1
avec 4. - Adressage indirect indexé avec déplacement
Instruction Avant Après
L’adresse effective est la somme de contenu du pointeur d’adresses, d’un registre
----------------------------------------------------
d’index et d’un déplacement fixe.
|MOVE.L (A1)+,D0 | D0=FFFFFFFF | D0=01234567 |
| | A1=00001000 | A1=00001004 |
Syntaxe :
| | $1000=01234567 | $1000=01234567 |
x(An,Dn.L) (x sur 8 bits, n de 0 à 7)
----------------------------------------------------
x(An,Dn.W)
Cas particulier : Lorsqu’on manipule des Octets avec le registre A7, ce registre x(An,An.W)
est incrémenté par 2 au lieu de 1, car le pointeur de pile doit être pair. x(An,An.L)
Exemple : MOVE.L 4(A1,A2.L),D0 copie le mot long enregistré à l’adresse A1+A2+4
Adressage indirect pré-décrémenté dans D0. A1 et A2 ne changent pas après l’exécution.
Instruction Avant Après
Cet adressage opère comme le mode d’adressage précédent, mais le pointeur est ---------------------------------------------------------
décrémenté avant l’exécution de l’instruction selon la taille manipulée (excepté A7). |MOVE.L 4(A1,A2.L),D0 | D0=FFFFFFFF | D0=01234567 |
| | A1=00001000 | A1=00001000 |
Syntaxe : -(An) (n de 0 à 7) | | A2=00001000 | A2=00001000 |
Exemple : MOVE.W -(A1),D0 décrémente A1 de 2, puis copie le mot pointé par A1 | | $2004=01234567 | $2004=01234567 |
dans D0. ---------------------------------------------------------

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
2.3 Autres instructions 17 18 Instruction de transfert de données et mode d’adressage

|MOVE.L 10(A1,D2.W),D0| D0=FFFFFFFF | D0=01234567 | |

| | A1=00001000 | A1=00001000 | END CODE ;fin du programme
| | D2=1000A000 | D2=1000A000 |
| | $B00A=01234567 | $B00A=01234567 | Selon cet exemple, ces adresses sont respectivement $2000 et $1000.
---------------------------------------------------------

2.4.1 Réservation de mémoire avec initialisation

2.3 Autres instructions
Syntaxe :
Ces instructions transfèrent des données d’un emplacement à un autre : Label DC.B/W/L valeur1,valeur2,...
EXG : (EXchanGe) Échange le continu de deux registres. « Define constant » réservation d’une zone mémoire (référencée par Label) avec
LEA : (Load Effective Address) Détermine une adresse effective et l’enregistre dans initialisation.
un registre d’adresse. Exemple :
LINK : Réserve un espace mémoire pour la pile.
MOVE : Copie le contenu d’un registre/espace mémoire dans un autre registre/espace VB DC.B $FF,1,2
Msg DC.B ’Bonjour’
mémoire.
VW DC.W $FFFF
MOVEA : (MOVE Address) Comme MOVE sauf que la destination est une adresse. VL DC.L $FFFFFFFF
MOVEM : (MOVE Multiple) transfère plusieurs registres de ou vers la mémoire.
MOVEP : (MOVE Peripheral) transfère des données de ou vers un périphérique d’en-
trée/sortie 8 bits. 2.4.2 Réservation de mémoire sans initialisation
MOVEQ : (MOVE Quick) met une constante dans un registre de donnée. Syntaxe :
PEA : (Push Effective Address) détermine une adresse effective et l’enregistre dans
la pile. nom_tab DS.B/W/L Nbr_cases
SWAP : permute un mot dans un registre de donnée. « Define space » réservation d’un tableau de Nbr_cases cases sans initialisation,
UNLK : (UNLinK) supprime un emplacement de la pile. référencé par nom_tab
Exemple :

2.4 Gestion de la mémoire Tab1 DS.B 10 ;déclaration d’un tableau de 10 cases

;de 8 bits chacune.
Tab1 DS.W 7 ;déclaration d’un tableau de 7 cases
Il est courant et conseillé de séparer la partie contenant les données manipulées de ;de 16 bits chacune.
la partie code du programme, ainsi le programmeur peut contrôler les adresses de ces
variables. La squelette suivante réserve une partie référencée par DATA pour les variables
et les chaînes de caractères à manipuler, ainsi qu’une zone qui commence à l’étiquette 2.4.3 Chargement d’une adresse effective
CODE pour les instructions du programme. L’origine de chaque partie commence à une
adresse fixée par l’instruction ORG. Une étiquette ou le nom d’une variable Label est une référence à un emplacement
mémoire. Cet emplacement a une adresse mémoire qui peut être chargée de deux ma-
nières.
DATA: ORG $2000 |la partie données commence
1. LEA.L Label,An : « Load effective address » ;
... |à l’adresse $2000
... | 2. MOVE.L #Label,An.
|
CODE: ORG $1000 |Les instructions commencent Remarque : Il faut différentier #Label de Label, cette dernière charge le contenu
... |à l’adresse $1000 de la case mémoire référencée par cette étiquette.
... |

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
 20 Opérations arithmétiques et logiques

3.1 Les opérations logiques

Ces opérations effectuent des opérations logiques sur des opérandes binaires. Une
opération logique est soit vrai (1) soit faux (0) .

Chapitre 3 Exemple : l’opération AND :

Cette instruction assure un & logique, bit par bit entre ses opérandes.
Syntaxe :

Opérations arithmétiques et AND <ea>,Dn

AND Dn,<ea>
logiques Mode d’adressage : (An), (An)+, -(An), x(An), x(An,xr.s)
Taille de données : Byte, Word, Longword.
Ci après une liste non exhaustive des opérations logiques assurées par ce micro-
processeur.
Le 68000 ne traite que des nombres entiers. Pour les nombres réels, on a recours à :
— un coprocesseur mathématique (FPU), par exemple le 68881 ; AND, ANDI : ET logique sur deux opérandes binaires.
— une bibliothèque d’émulation logicielle par Développement Limité.
OR, ORI : OU logique.
Le format d’un nombre réel est normalisé : IEEE 754 (simple ou double précision).
EOR, EORI : Ou exclusive (XOR).
NOT : Retourne le complément à un de l’opérande.
8 bits $00 à $FF 0 à 255 .B Byte
16 bits $0000 à $FFFF 0 à 65535 .W Word
32 bits $00000000 à $FFFFFFFF 0 à 4294967295 .L Long 3.2 Décalage et rotation
Table 3.1 – Nombres entiers non signés (U) Une autre famille de fonctions traite les données manipulées en bit par bit ; ce sont
les fonctions de décalage et de rotation.

3.2.1 Fonctions de décalage

8 bits MSB=0 $00 à $7F 0 à 127 .B Byte
Les instructions suivantes permettent de faire le décalage des données arithmétiques
MSB=1 $80 à $FF -128 à -1
et logiques à gauche ou à droite :
16 bits MSB=0 $0000 à $7FFF 0 à 32767 .W Word
MSB=1 $8000 à $FFFF -32768 à -1
ASL, ASR : Décalage arithmétique à gauche respectivement à droite.
32 bits MSB=0 $00000000 à $7FFFFFFF 0 à 2147483647 .L Long
MSB=1 $80000000 à $FFFFFFFF -2147483648 à -1 LSL, LSR : Décalage logique à gauche respectivement à droite.

Table 3.2 – Nombres entiers signés (S) en complément à 2

Exemple : l’instruction ASL
Assure un décalage arithmétique à gauche d’un registre de données ou d’un emplacement
mémoire, selon trois modes :
C’est au programmeur de savoir à priori le type des nombres entiers qu’il manipule 1. décaler à gauche un registre de données, le nombre de bits à décaler est enregistré
et non le processeur ! ! ! dans un autre registre de données. Vous pouvez décaler de 1-8 bits ;
Le processeur ne sait pas reconnaître qu’il manipule un nombre U ou S. C’est à la charge 2. décaler à gauche un registre de données, le nombre de bits à décaler est une
ensuite du programmeur de tester les bons flags après l’exécution des ses instructions. valeur immédiate ;

I. Ben Ameur Bazine 19 Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
3.2 Décalage et rotation 21 22 Opérations arithmétiques et logiques

3. décaler d’un bit un mot (16 bits) de la mémoire. *** ROXL ***
(ROtate Left with eXtend) Cette instruction assure la rotation à gauche des bits d’un
Mode d’adressage : (An), (An)+, -(An), x(An), x(An,xr.s), x.w, x.l registre de données ou d’un emplacement mémoire avec un bit d’extension, selon les
Syntaxe : trois modes précédents.
La rotation est faite avec l’injection d’un bit externe (X-flag). Le MSB <– X <–
ASL Dx,Dy
ASL #<data>,Dy LSB, le bit qui arrive à la position du poids le plus faible (LSB) est dupliqué dans le
ASL <ea> C-flag.
Taille de données : Byte, Word, Longword.
C <-- OPERAND <--
| |
3.2.2 Fonctions de rotation |-> X ->-----|

Les fonctions de rotation assurent un décalage cyclique des bits manipulés. Il existe Mode d’adressage : (An), (An)+, -(An), x(An), x(An,xr.s)
plusieurs variantes : Syntaxe :

ROXL #<steps>,Dy
*** ROL *** ROXL Dx,Dy
ROXL <ea>
Cette instruction assure la rotation à gauche des bits d’un registre de données ou d’un
emplacement mémoire, selon trois modes : Taille de données : Byte, Word, Longword.
1. rotation à gauche, le nombre de bits à décaler est enregistré dans un autre registre
de données. Vous pouvez décaler de 1-8 bits dans ce cas ; *** ROXR ***
2. rotation à gauche d’un registre de données, le nombre de bits à décaler est une Assure le même travail que la précédente mais vers la droite.
valeur immédiate ;
3. rotation d’un bit d’un mot (16 bits) de la mémoire. -- OPERAND ----> C
| |
Cette opération n’injecte pas de bits externes. Le bit qui arrive à la position du
|----<- X <--|
poids le plus faible (LSB) est dupliqué dans le C-flag.

C <-- OPERAND <--

|____________|
3.3 Opérations arithmétiques

Mode d’adressage : (An), (An)+, -(An), x(An), x(An,xr.s) Ce µP peut faire deux sortes d’instructions arithmétiques selon le codage des opé-
Syntaxe : randes, le codage des entiers signés (S, en complément à 2) et non signés (U, binaire
naturel). Notre but est de donner un aperçu sur ces instructions, pour plus d’informa-
ROL #<steps>,Dy tions sur une instruction donnée vous pouvez consulter le « Help » ou la documentation
ROL Dx,Dy en ligne de cet assembleur.
ROL <ea>
Taille de données : Byte, Word, Longword.
3.3.1 Arithmétique Entiers
*** ROR *** Une description succincte des instructions arithmétiques opérant sur des entiers est
Similaire à ROL, mais elle assure la rotation à droite des bits d’un registre de données donnée par la liste suivante :
selon le schéma suivant :
ADD, ADDA, ADDI, ADDQ, ADDX : Différents types d’addition,
--> OPERAND --> C CLR Clears an operand : Efface un opérande,
|____________| CMP, CMPA, CMPI, CMPM : Comparer deux opérandes,

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 I. Ben Ameur Bazine
3.4 Manipulation des bits 23

DVIS, DIVU : Division des entiers signés et non signés,

EXT : Effectue une extension de signe, byte -> word ou word -> longword,
MULS, MULU : Multiplication des entiers signés et non signés,
NEG, NEGX : Le complément à 2 d’un nombre,
SUB, SUBA, SUBI, SUBQ, SUBQ : Différents types de soustraction,
TAS : (Test And Set) Compare un opérande à 0 et le met à 1, Chapitre 4
TST : Comparer un opérande à 0.

3.3.2 Arithmétique BCD Instructions de branchement

Les concepteurs de ce µP ont prévu des instructions arithmétiques sur des codes
entiers codés en BCD. Ces instructions sont les suivant :
Les instructions de branchements conditionnels dépendent de l’état des drapeaux
ABCD : Addition BCD,
du µP , ces derniers sont affectés par les instructions arithmétiques et de comparaison,
SBCD : Soustraction BCD, ci après un exemple :
NBCD : Négation BCD.
CMP X,Y : comparaison de X et Y et mise à jour des drapeaux concernés ;
BNE label : branchement à une étiquette si non égale ;
3.4 Manipulation des bits BRA label : branchement non conditionnel.

D’autres instructions permettent de manipuler des bits dans un Octet. Toutes les Les instructions suivantes effectuent de branchement (Branches), des sauts (Jumps)
instructions testent le bit avant de l’affecter. et appels de routines (Calls) :

BTST : Tester un bit,

BSET : Tester un bit, puis le mettre à 1,
BCLR : Tester un bit, puis le mettre à 0,
BCHG : Tester un bit, puis le complémente (0 -> 1, 1 -> 0).

.......

I. Ben Ameur Bazine Assembleur 68000 Assembleur 68000 24 I. Ben Ameur Bazine