Vous êtes sur la page 1sur 18

Microprocesseur

Cours ETL 427 – 4ème ELT

Programmation en Assembleur (1)

Université Abdelhamid Ibn Badis de Mostaganem


Faculté des Sciences et Sciences de l’Ingénieur 1
Langage machine
 Définition
C'est le seul langage qui soit directement compréhensible par un µp. 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...
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... 2
Langage assembleur
 Définition
Un programme en langage d'assembleur est stocké sous forme de
texte . Chaque instruction assembleur représente exactement une
instruction machine. Par exemple, une instruction d'addition est
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

Avantages :
– minimise le code
– meilleur contrôle sur le matériel.
3
Instructions de mouvement
 MOVE.(BWL) source, destination
 MOVEA.(WL) src, An (si sur 16  extension sur 32 bits)

 MOVEQ #data, Dn data sur 8bits et extension signé  L


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

 MOVE src, CCR (CCR sur 8 bits)


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

 EXG Rn, Rm (Rn  Rm)


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

4
Instructions arithmétiques
 Le code binaire pure et complément à 2 utilisent tous les deux ces
instructions :
 ADD.(B W L) src, Dn
 ADDA.(W L) src, An (si sur 16  extension sur 32 bits)
 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 5
voir documentation.
Instructions arithmétiques
 MULU source, Dn
 MULS source, Dn
 source (W) x Dn (W)  résultat Dn (L) (16 x 16  32)

 DIVU source, Dn
 DIVS source, Dn
 Dn(L) ÷ source (W)  résultat rW qW Dn

U : unsigned ; S : signed

Exp : MULS D3, D5 xxxx ------- D3


xxxx ------- D5
------ ------- Résultat  D5

 NEG.(B,W,L) dest  complementation à 2


 NEGX.(B,W,L) dest  complementation à 2
 NBCD.B dest  si X=0 complément à 10; si X=1 complément à 9
6
 EXT.(W,L) Dn extension signée
Calcul arithmétique
Exp.1 :
Calcul de la moyenne de 2 nombres de 32 bits : a+ b
m=
2
On suppose que aL+bL ne dépasse pas 32 bits  (a+b)L et m codés sur 32 bits.
Remarque : a étant composé de plusieurs octets; alors l'octet de poids le plus
fort se trouve à l'adresse spécifiée.
ORG $2400

MOVE.L $2800, D0
ADD.L $2804, D0
DIVU #2, D0
MOVE.W D0, $2808
MOVE.B #9, D0
TRAP #15

END

7
Calcul arithmétique
Exp.2 : 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.
Ada = $2800 ; adb = $2808 ; ads = $2810

ORG $2500

MOVE.L $280C, D0 blowD0


ADD.L $2804, D0 blow+alowD0 (si retenue  X)
MOVE.L D0, $28104 blow+alowslowads+4
MOVE.L adb, D0 bhighD0
MOVE.L $2800, D1 ahighD1
ADDX.L D0, D1 D0 + D1 +X  D1
MOVE.L D1, $2810 D1  shigh

MOVE.B #9,D0
TRAPE #15
END 8
Instructions Logiques
• AND.(B,W,L) Source, Dn
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 complé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'un bit

 De même pour : ASR, LSL, LSR, ROL, ROR, ROXL et ROXR


9
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
Après : 0 1 0 0 0
ADD.B #$11, D4
Après : 1 0 0 1 1
ADD.B #$80, D4

10
Les directives en assembleur
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.
 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.
 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.
 Directive d'équivalence : EQU
Elle est utilisée pour assigner une valeur à un symbole.
 Directive d'initialisation mémoire : DC
Elle permet de mettre une ou plusieurs constantes en mémoire à
l'adresse courante
11
Les directives en assembleur
Exp.1 : Où d'une autre manière
ORG $2400 val1 EQU $43
MOVEQ #$43, D3 val2 EQU ‘4ELT’
MOVE.L #’4ELT’, $2800 adr EQU $2800
ORG $2400
MOVE.B #9, D0
MOVEQ #val1, D3
TRAP #15
MOVE.L #val2, adr
END MOVE.B #9, D0
TRAP #15
END
Exp.2 : 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
… 12
END
Les directives en assembleur

13
Modes d’adressage
On désigne par mode d'adressage, la manière d'accéder à un opérande.
 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.
 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.
 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 14
Modes d’adressage
 Adressage indirect 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 alors :
les deux cases mémoire ($2800 et $2801)
sont initialisées avec la valeur $00

 Adressage 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

15
Modes d’adressage
Exp. : CLR.W (An)+
Avant exécution A4 = $2800

Aprés execution A4 = $2802

 Adressage indirecte et 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
 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). 16
Modes d’adressage
 Adressage indirect avec déplacement : d(An)
d : déplacement est un nombre signé sur 16 bits.
L'opérande se trouve en mémoire, et son adresse est :
Adresse = [An] + d
Exp. :
MOVE.W #-2, -4(A6)
On suppose A6 =$270A

Adressage indirect - indexé avec déplacement : d(An, Ri)


Adresse = [An] + [Ri] + d
Exp. :
MOVE $10(A1,D0), D2
L'adresse effectif est : EA = [A1]+[D0.W]+ $10
Si [A1]=$0000 4000 et [D0]= $1234 5678
Alors EA = $0000 4000 + $0000 5678 + $0000 0010 = $0000 9688
LEA $30(A1,D1), A0
17
Modes d’adressage
Adressage relatif :
− Ce mode d'adressage est systématiquement et exclusivement utilisé par
les instructions de branchement : Bcc, DBcc, BRA et BSR.
− 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)
18

Vous aimerez peut-être aussi