Le µp 68000 : Le logiciel

1 Langage machine

1.1 Définition
C'est le seul langage qui soit directement compréhensible par un microprocesseur. Il est composé d'une
suite d'octets localisés en mémoire et dont le contenu, binaire, constitue une suite de codes significatifs pour
le microprocesseur.
Il est nécessaire de bien comprendre que quel que soit le langage utilisé en programmation évoluée ( C ,
ADA, Programmation Structurée, Programmation Objets) , les outils de programmation finiront toujours
par fournir à notre microprocesseur des codes langage machine...

1.2 Exemple
Prenant l'instruction suivante comme exemple : MOVE.L $FC0024, $2400
Cette instruction est en langage assembleur, son équivalent binaire (hexadécimal) est :
$ 21F9 00FC 0024 2400
C'est ce code là qui est stocké en mémoire et qui sera exécuté par le µp. donc le code opération de
l'instruction MOVE.L est $ 21F9 == % 00 10 000 111 111 001.

00 = MOVE
10 = .L
000 111 = L'opérande Destination est une adresse mémoire sur 16 bits...
111 001 = L'opérande Source est une adresse mémoire sur 32 bits...

1.3 Organisation d'une instruction en code machine:

La langueur des instructions en code machine diffère suivant la nature de l'instruction et le mode
d'adressage. Elle varie de 2 à 10 octets. Les 2 premiers octets constituent le code opération de l'instruction
(µp 16 bits).

2 Langage assembleur :

2.1 Définition
Un programme en langage d'assembleur est stocké sous forme de texte (comme un programme dans un
langage de plus haut niveau). Chaque instruction assembleur représente exactement une instruction
machine. Par exemple, l'instruction d'addition décrite ci-dessus serait représentée en langage assembleur
comme suit :
ADD.B D1, $2200
Ici, la signification de l'instruction est beaucoup plus claire qu'en code machine. Le mot ADD est un
mnémonique pour l'instruction d'addition. La forme générale d'une instruction assembleur est :

Etiquette Mnémonique Opérandes commentaires

Ses avantages :
- minimise le code
- meilleur contrôle sur le matériel.
[bien adapté à l’écriture des routines d’entrées/sorties]

1
2.2 Instruction de mouvement :
MOVE.(BWL) source, destination
MOVEA.(WL) src, An si sur 16
extension sur 32 bits
MOVEQ #data, Dn extension signé B L

Exp : MOVEQ #-128, D4 FF FF FF 80

MOVE src, CCR (CCR sur 8 bits)

Exp : MOVE #$4E5A, CCR XX 5A

EXG Rn, Rm (Rn  Rm)

SWAP Dn (Dn(31-16)  Dn(15-0))

3 Modes d'adressage : Registre; Immédiat, Absolu et Indirect

On désigne par mode d'adressage, la manière d'accéder à un opérande.

3.1 Adressage Registre :

L'opérande se trouve dans le registre spécifié dans l'instruction An, Dn, CCR, SR
Exp : CLR.W D7
MOVE.L A3, D0
N.B : si la destination est un registre d'adresse An, si la taille est W
extension signée jusqu'à L.

3.2 Adressage immédiat :

L'opérande est exprimé directement par sa valeur. Le symbole # (dièse) identifie le mode d'adressage
immédiat.
Exp. : MOVE.B #$E4,D2
MOVEQ #-6,D7
N.B : ce mode ne peut être utilisé qu'en source.

3.3 Adressage absolu :

L'opérande est désigné par une adresse qui indique son emplacement en mémoire; le défaut de symbole
exprime ce mode.
Exp. : MOVE.W #$1E48, $2800
MOVE.L $2200, $803000

3.4 Adressage indiect simple :

L'opérande se trouve dans une position mémoire, dont l'adresse est contenue dans un registre d'adresse.
Les parenthèses "(, )" expriment ce mode.
Exp. :

CLR.W (A4)  #$0000  [A4]

Si A4 = $2800
les deux cases mémoire ($2800 et $2801)

sont initialisées avec la valeur $00.

Exp. : MOVE.L (A0), (A1)

2
 [[A0]]L  [A1]L

4 Affectation des indicateurs

Suppositions :
[$2800]B = $00
[$2900]L = $A01704A2

X N Z V C
Avant exécution x x x x x
Après exécution de :
x 0 1 0 0
MOVE.B $2800, $2820
Après :
x 1 0 0 0
MOVE.L $2900, D4
x 1 0 0 0

5 Calcul arithmétique et logique

Exp.1 :

a+b
Calcul de la moyenne de 2 nombres de 32 bits : m = .
2
On suppose que aL+bL ne dépasse pas 32 bits
(a+b)L et m
codés sur 32 bits.
ada = $2800; adb = $2804; adm = $2808

Remarque : a étant composé de plusieurs octets; alors l'octet

de poids le plus fort se trouve à l'adresse spécifiée.

ORG $2400
Remarque : quand il s'agit d'une division ou
MOVE.L ada, D0 multiplication par des puissances de 2; on décale
ADD.L adb, D0 vers la droite ou la gauche respectivement.
ASR.L #1, D0
MOVE.L D0, adm
MOVE.B #9, D0
TRAP #15

Ada EQU $2800

Adb EQU $2804
Adm EQU $2808
END

5.1 Instructions arithmétiques

Le code binaire (non signé); code complément à 2(C/2) (signé) utilisent tous les deux ces instructions :
• ADD(B W L) source, Dn
• ADDA(W L) source, An si la source est de format W alors extension à 32 bits (L)
puis addition avec le registre An

3
 • ADDI(B W L) #data, dest
• ADDQ(B W L) #data, dest il faudrait que data soit entre 1 et 8
• ADDX(B W L) Dn, Dm
• ADDX(B W L) -(An), -(Am)
Même chose pour la soustraction SUB
Code BCD
• ABCD -(An), -(Am)
• ABCD Dn, Dm
• SBCD -(An), -(Am)
• SBCD Dn, Dm
Remarque : quand l'addition est de plus de 8 bits, on procède par tranche
voir documentation.
• MULU source, Dn |
source (W) U : unsigned ; S : signed
• MULUS source, Dn | et Dn (W)  résultat Dn (L) (16 x 16  32)
• DIVU source, Dn |
• DIVS source, Dn |Dn(L) ÷ source (W)  résultat Dn (rW ; qW)
Exp :
MULS D3, D5
xxxx ------- D3
xxxx ------- D5
Résultat
------ -------
D5
Attention : lors de la division, on peut faire :
Dn(L) ÷ source = Q(L)
erreur car Q tient sur 16 bits
lors d'une opération similaire, voir
l'indicateur "V" dans le CCR  le signe du reste est celui du dividende (dest) (quand il s'agit de division
signée).

• NEG(B,W,L) dest
complementation à 2

• NEGX(B,W,L) dest
complementation à 2
• NBCDB dest  toujours sur 8 bits si X=0 complément à 10; sinon X=1 complément à 9
• EXT(W,L) Dn extension signée
Quand on complémente à 2 une donnée de 64 bits, le µp complémente la 1er tranche avec NEG et la 2ème
tranche avec NEGX.
Exp.2 :

4
 Addition de 2 nombres a et b de 64 bits.
s = a+b sur 64 bits. On suppose que (a+b) tient sur 64 bits.

ORG $2500
MOVE.L adb+4, D0 blowD0
ADD.L ada+4, D0 blow+alowD0 (si retenue  X)
MOVE.L D0, ads+4 blow+alowslowads+4
suite
MOVE.L adb, D0 bhighD0
MOVE.L ada, D1 ahighD1

ADDX.L D0, D1
addition avec retenue ne se fait qu'entre les registres sauf selon un certain mode d'adressage :
bhigh+ahigh+ XD1 (à cette étape "X=0". Car le résultat final est sur 64 bits)
MOVE.L D1, ads D1  shigh
MOVE.B #9,D0
TRAPE #15

ada EQU $2800

adb EQU $2804
ads EQU $2808
END

Exp.3 :
ab + 3
Calcul de p = où a, b et c sont des nombres entiers signés sur 8 bits. Les adresses sont : ada,
c
adb, adc et adp (p partie entière).
Théoriquement :
a x b  16 bits
ab+3  17bits
ab + 3
p=  17bits – 8 bis = 9 bits
p à prévoir sur 16 bits.
c
Programmation :
ORG $2600
MOVE.B ada, D0
MOVE.B adb, D1
EXT.W D0
EXT.W D1
MULS D1, D0
La multiplication n'est possible que sur 16 bits, alors, il y a nécessité d'extension de 8 bits
vers 16 bits.

5
 (ab) est grâce à l'instruction précédente sur 32 bits ce qui nous arrrange; sinon , on aurait dû faire
une extension car (ab) doit être sur 32 bits pour la division.

ADDQ.L #3, D0
MOVE.B adc, D2 cB  D2
EXT.W D2 cB  cW (extension format 16 bits)
DIVS D2, D0 (ab+3)L / cW  qW et rW  D0
rW (reste) qW (quotion)
MOVE.W D0, adp
MOVE.B #9,D0
TRAP #15
Equivalences !!
END

5.2 Instructions logiques :

Source, Dn
• AND(B,W,L)
Dn, Dest
• ANDI(B,W,L) #data, dest
De même pour OR et ORI
• EOR(B,W,L) Dn, dest
• EORI(B,W,L) #data, dest
• NOT(B,W,L) dest comlément à 1
• ASL(B,W,L) Dn, Dm décalage de [Dn]0-5 bits
• ASL(B,W,L) #data, Dm data 1à 8
• ASL.W dest toujours sur W décalage d'une bit
De même pour : ASR, LSL, LSR, ROL, ROR, ROXL et ROXR

6 Les directives en Assembleur

6.1 Définition :
Une directive est une pseudo-instruction destinée à l'assembleur, c'est un ordre spécial que le
programmeur donne à l'assembleur pour affecter de valeurs à des symboles (adr EQU $2801), introduire
des données en mémoire, … etc.

6.2 Directive origine : ORG

Elle indique à l'assembleur à quel emplacement en mémoire il faut mettre le code machine des
instructions, une fois assemblées, ou bien à quel emplacement il faut mettre les données spécifiées par la
directive DC.
Exp. : ORG $2400

6.3 Directive fin de fichier : END

Elle indique la fin du texte source qui doit être assemblé. L'assembleur ignore tout texte placé après END

6.4 Directive d'équivalence : EQU

Elle est utilisée pour assigner une valeur à un symbole.

6
 Exp :
ORG $2400
MOVEQ #$43, D3
MOVE.L #’4ELT’, $2800
MOVE.B #9, D0
TRAP #15
END
Où d'une autre manière
val1 EQU $43
val2 EQU ‘4ELT’
adr EQU $2800
ORG $2400
MOVEQ #val1, D3
MOVE.L #val2, adr
MOVE.B #9, D0
TRAP #15
END

6.5 Directive d'initialisation mémoire : DC

Elle permet de mettre une ou plusieurs constantes en mémoire à l'adresse courante
Exp :
ORG $2800
DC.B 12, $4A, '*', %11001000
DC.B -2, 'XY'  erreur car ça dépasse le format .B il faut mettre : DC.B 'XY', -2
ORG $2900
DC.W 12, 1, 'AB'
DC.L '1993', $ABC
ORG $2A00
DC.B 'Lundi Mostaganem Nov 2007'
ORG $2400
…
…
END
Remarque : -1  FF ; -2  FE ; -3  FD

7
7 Comparaison et branchement :
Exp. 1 :
99

∑n i
Calcul de la moyenne de 100 nombres signés codés sur 8 bits : m = i =0
; ni nombre signé.
100
Les ni sont rangés dans une table de 100 cases mémoire situées à l'adresse $2800, le résultat est rangé en
$2900.
m sur 8 bits.
1er solution :

ORG $2400
CLR.W D0 S= 0
LEA ADTAB, A0

MOVE.L #adtab, A0
boucle MOVE.B (A0)+, D1
EXT.W D1
ADD.W D1, D0 je fais l'extension pour D1 car les nombres
CMPA.L #ADTAB+100, A0 sont signés, sinon j'aurai imposé des '0' pour
BLS boucle l'extension non signée.
EXT.L D0
DIVS #100, D0  Est-ce que A0 < adtab+100 ?
MOVE.B D0, $2900 car D0 est sur 13 bits et on veut faire une

8
 division (extension signée)
MOVE.B #9,D0
TRAP #15
END

2ème solution :

On utilise le compteur, quand on sait préalablement le

nombre d'itérations à faire.

I sur 16 bits  D2

Remarque :
L'organigramme est indépendant du µp
on n'utilise
pas les noms des registres qui sont propres au 68000
Motorola.

ORG $2600
CLR.W D0
LEA adtab, A0
MOVE.B #99, D2
Loop MOVE.B (A0)+, D1 99W  D2,
EXT.W D1
ADD.W D1, D0
DBF D2, loop
EXT.L D0
DIVS #100, D0
MOVE.B D0, $2900
MOVE.B #9,D0
TRAP #15
END

Remarque importante : En utilisant DBF, le registre contenant le compteur doit être sur 16 bits (W).

8 Instructions de comparaison :
• CMP.(B, W, L) source, Dn
[Dn]-source, le résultat n'est pas sauvegardé mais il affecte cependant les indicateurs d'état.
• CMPA.(W, L) source, An  même remarque que CMP.
A ce niveau, si la taille est W, il y a extension de l'opérande source de W vers L, puis une comparaison
(car la destination est un registre d'adresse).
• CMPI.(B, W, L) #data, dest
• CMPM.(B, W, L) (An)+, (Am)+

9
 N'utilise que ce mode d'adressage indirect post-incrémenté, comparaison dans la mémoire.
• TST.(B, W, L) dest
Comparaison de la destination avec la valeur immédiate '0' (dest – 0).
TST dest == CMPI #0, dest

9 Instructions de branchement :

9.1 Saut inconditionnel :

• JMP adresse (effective)
• BRA adresse (relative)  Différence au niveau du code machine.

9.2 Saut conditionnel :

• Bcc adresse
cc = HI, CC, EQ, LS, CS, GT, GE, LE, LT, VS, VC,
PL, NE, NI
(Donner le tableau des significations)

10
 • DBcc Dn, adresse

D: Decrement and
B : Branch

Cas particulier : DBF Dn, adresse  F : faulse

10 Modes d'adressage indirect post-incrémenté et pré-décrémenté :

10.1 Indirecte et post-incrémenté : (An)+

• L'opération s'effectue sur l'opérande [[An]]
• Puis incrémentation de An : le contenu de An va être incrémenté comme suit :
[An] + 1
An si taille B
[An] + 2
An si taille W
[An] + 4
An si taille L

Exp. : CLR.W (An)+

Avant exécution [A4] = $2800
Après exécution [A4] = $2802

Et le résultat :

10.2 Indirecte pré-décrémenté : -(An)

• Décrémentation de An :
[An] - 1
An si taille B
[An] - 2
An si taille W
[An] - 4
An si taille L

11
 • Puis l'opération s'effectue sur [[An]]
Exp. : CLR.L -(A4)
Avant exécution : [A4] = $2800
Après exécution : [A4] = $27FC

N.B. : Pour (A7)+ et - (A7), quand la taille utilisée est B l'incrémentation ou la décrémentation s'effectue
sur 2 unités (B == W).

11 Mode d'adressage relatif :

b. Ce mode d'adressage est systématiquement et exclusivement utilisé par les instructions de
branchement : Bcc, DBcc, BRA et BSR.
c. Ce mode peut être utilisé avec d'autre instructions, il est alors identifié par l'écriture :
adresse (PC).
Exp. :
BLS loop  relatif
BNE $2400
JMP $2800  absolu
JMP $2800 (PC)  relatif
Ecriture de l'instruction en code machine : lorsque l'instruction utilise le mode relatif.

Code opér. déplacement

Le code opération n'est pas suivi explicitement par la valeur de l'adresse effective, comme c'est le cas
pour le mode d'adressage absolu, il est suivi par une différence d'adresse codé avec C/2 sur 8 ou 16 bits
appelé déplacement :
Déplacement = adresse effective – (adresse de l'instruction de branchement + 2)
Exp. : On a déjà vu ce programme

ORG $2400 Adresse Code machine

CLR. W D0 2400 Xx xx
LEA ADTAB, A0
2402 Xx xx 28 00 (= xxxx
Boucle MOVE.B (A0)+, D1
00002800)
EXT.W D1 2406
ADD.W D1, D0 Xx xx
2408
CMPA.L #ADTAB+99, A0 Xx xx
240A
BLS boucle Xx xx
240C
EXT.L D0 Xx xx 00 00 28 62 (extension
DIVS #100, D0 sur 32 bits)
MOVE.B D0, $2900 2412
TRAP #15 Xx F2 (déplacement court)
END

d = $2406 – ($2412 + 2)

12
 = $2406 - $ 2414
= $2406 + $ DBEC
= $ FFF2  indique qu'il y a déplacement vers le haut dans le programme
d = $F2  sur 8 bits déplacement court
ce mode d'adressage existe
le programme sera translatable.
Plage de déplacement :

Déplacement court : sur 8 bits Déplacement long : sur 16 bits

13