Vous êtes sur la page 1sur 41

1

Chapitre 4 : langage assembleur

cours Architecture des ordinateurs: programmation assembleur


Introduction
2

 La conception d’un processeur  faire des choix


concernant son jeu d’instruction.
 Ces choix sont conditionnés par:
 Le nombre de transistors
 Compatibilité avec les modèles précédents
 La performance souhaitée
 L’inclusion de nouvelles fonctionnalités (traitement
vidéo)
 Le jeu d’instructions d’un processeur est représenté
par des instructions assembleur.
cours Architecture des ordinateurs: programmation assembleur
Introduction
3

 On utilise la programmation assembleur :


 Le développement des pilotes logiciels
 Programmation des systèmes embarqués (carte à puce)
 Application temps réel (performance maximale).
 Types d’instructions :
 Transfert de données
 Opérations arithmétiques et logique
 Décalages et rotation
 Ruptures de séquences

cours Architecture des ordinateurs: programmation assembleur


Modèle de processeur
4

 Processeur 32 bits contenant :


 Une UAL entière
 32 registres généraux de 32 bits (r0, …, r31)
 Un compteur ordinal sur 32 bits
 Un registre d’état contenant les bits Z, V, C et N.
 Une mémoire pour stocker les instructions et les données
 Les seuls instructions faisant référence à la mémoire sont
les transferts de données.
 Mode d’adressage direct, immédiat et indirect

cours Architecture des ordinateurs: programmation assembleur


Transfert de données
5

 Transferts registre – mémoire ou registre – registre.


 Les transferts mémoire – mémoire sont interdites.
 Exemple
 MOV rx, ry rx  ry
 Le registre rx reçoit la valeur contenue dans ry
 MVI rx, #i rx  i
 Le registre rx reçoit la valeur immédiate i
 LDB rx, (ry) rx  Mem[ry]8
 le registre rx reçoit l’octet mémoire dont l’adresse est dans ry (LoaD Byte)
 LDH rx, (ry) rx  Mem[ry]16
 le registre rx reçoit les deux octets mémoire dont l’adresse est dans ry (LoaD Half
word)

cours Architecture des ordinateurs: programmation assembleur


Transfert de données
6

 LDW rx, (ry) rx  Mem[ry]32


 le registre rx reçoit les quatre octets mémoire dont l’adresse est
dans ry (LoaD word)
 STB (rx), ry Mem[rx]8  ry
 L’octet de poids faible de ry est stocké en mémoire à l’adresse
contenu dans rx (Store Byte).
 STH (rx), ry Mem[rx]16  ry
 Les deux octets de poids faible de ry sont stockés en mémoire à
l’adresse contenu dans rx (Store Half word).
 STW (rx), ry Mem[rx]32  ry
 Les quatre octets de ry sont stockés en mémoire à l’adresse contenu
dans rx (Store Word).

cours Architecture des ordinateurs: programmation assembleur


Transfert de données
7

 L’instruction MVI utilise l’adressage immédiat.


 La valeur donnée en décimal.
 Valeur négative, on utilise le codage Cà2
 #-1  #0xffff
 Les caractères sont représentés entre apostrophes.
 Un caractère est remplacé par son code ASCII
 #’A’ #65

cours Architecture des ordinateurs: programmation assembleur


Opérations arithmétiques et logiques
8

 Addition
 ADD rx, ry, rz rx  ry+rz
 ADD rx, ry, #i rx  ry+i
 Soustraction
 SUB rx, ry, rz rx  ry-rz
 SUB rx, ry, #i rx  ry-i
 Multiplication
 MUL rx, ry, rz rx  ry x rz
 MUL rx, ry, #i rx  ry x i
cours Architecture des ordinateurs: programmation assembleur
Opérations arithmétiques et logiques
9

 Division
 DIV rx, ry, rz DIV rx, ry, #i
 Et logique
 AND rx, ry, rz AND rx, ry, #i
 Ou logique
 OR rx, ry, rz OR rx, ry, #i
 Ou exlusif
 XOR rx, ry, rz XOR rx, ry, #i
 Complémentaire
 NOT rx, ry NOT rx, #i
 Opposé arithmétique
 NEGcours
rx,Architecture
ry NEG rx, #i programmation assembleur
des ordinateurs:
Décalages et rotations
10

 Effectuer rapidement des multiplications ou divisions par


2
 Si rz ou i positif
 LRT rx, ry, rz LRT rx, ry, #i
 rx<- ry décalé par rotation vers la gauche rz fois (ou i fois)
(Left Rotate) . Les bits de poids faible sont remplacés par les
plus forts.
 LLS rx, ry, rz LLS rx, ry, #i
 rx<- ry décalé vers la gauche rz fois (ou i fois) (Logical Left
Shift). Les bits de poids faible sont remplacés par des 0.
cours Architecture des ordinateurs: programmation assembleur
Décalages et rotations
11

 ALS rx, ry, rz ALS rx, ry, #i


 rx<- ry décalé vers la gauche rz fois (ou i fois) (Arithmetical
Left Shift). Cette instruction garde le signe de rx.
 Si rz ou i négatif, le décalage ou la rotation sera à droite.
 Les bits Z et N se positionnent comme d’habitude.
 Le bit V est toujours mis à 0.
 Le bit C est au dernier bit décalé de ry.

cours Architecture des ordinateurs: programmation assembleur


Ruptures de séquences
12

 JMP Adr
 PC<-Adr : saut inconditionnel à Adr (jump)
 JZ rx, Adr
 PC<-Adr si rx=0 (jump if zero)
 JNZ rx, Adr
 PC<-Adr si rx≠0 (jump if not zero)
 JGT rx, Adr
 PC<-Adr si rx>0 (jump if greater than zero)

cours Architecture des ordinateurs: programmation assembleur


Ruptures de séquences
13

 JLT rx, Adr


 PC<-Adr si rx<0 (jump if rx less than zero)
 JGE rx, Adr
 PC<-Adr si rx≥0 (jump if rx greater or equal to zero)
 JLE rx, Adr
 PC<-Adr si rx ≤0 (jump if rx less or equal to zero)
 CCR rx
 rx<- bit C : le bit C du registre d’état est mis dans le bit
de poids faible de rx. Les autres bits de rx sont mis à 0
(Copy bit C into Registre)
cours Architecture des ordinateurs: programmation assembleur
Ruptures de séquences
14

 CZR rx
 Copy bit Z into registre
 CNR rx
 Copy bit N into registre
 CVR rx
 Copy bit V into registre
 Exemple :
 Les instructions de copie permettent de tester une condition dans
structure conditionnelle.
 CVR ro
 JNZ ro, etiquette_debordement
 //On continue s’il n’y a pas débordement

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
15

 Quatre familles d’instructions:


 Les instructions à trois données. ADD r0, r1, r2
 Les instructions à deux registres. MOV r0, r1
 Les instructions à un registre et une valeur immédiate. MVI r0, #0
 Les instructions à un seul registre. CCR r0
 Instructions à trois données:
 5 bits code de l’opération.
 5 bits pour coder un registre (32 registres)
 1 bit pour indiquer le type d’adressage (immédiat ou bien par
registre)
 16 bits pour la troisième donnée (immédiat/ registre)

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
16

 Code opération à trois données :

Les 5 premiers bits donnent le code opération de l’instruction suivant le tableau


ci-après (qui liste les 4 bits restant à déterminer). Le premier bit est à 0 pour
indiquer au processeur une opération de ce type. Le bit i est à 0 si les 16 derniers
bits donnent un numéro de registre, à 1 si c’est une valeur immédiate. Les deux
champs de 5 bits qui suivent correspondent au numéro des registres destination
(rX) et première source (rY). Comme elles appartiennent à la même famille
d’opérations arithmétiques, et bien qu’elles n’aient que deux données, on a inclus
les deux instructions NEG et NOT ; dans ce cas, le processeur ignore le champ
rY.

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
17

 Code opération à trois données :

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
18

 Exemple :
 ADD r0, r1, r2
00000 0 00000 00001 0000000000000010
 XOR r30, r10, #0x3B2A
00110 1 11110 01010 0011101100101010

 Le premier correspond à ADD r0,r1,r2 : on remplace le premier champ par les 4 bits
donnant le codage de ADD (0000), puis chacun des trois champs de données contient
le numéro en binaire du registre correspondant. Pour finir, on met un 0 dans le bit
indiquant si la dernière valeur est immédiate (car ici c’est un registre). Le second
exemple est similaire : 0110 est le code de XOR, le bit suivant est à 1 pour indiquer
une valeur immédiate comme troisième donnée, et les trois champs suivants précisent
les données (registre r30, codé 11110 ; registre r10, codé 01010 ; valeur hexadécimale
3b2a en binaire).
cours Architecture des ordinateurs: programmation assembleur
Format des instructions
19

 Instructions à deux registres


Les instructions de transfert entre registres ou
depuis/vers la mémoire utilisent au plus deux
registres comme données. On peut donc prendre le
même format en laissant à 0 les 16 derniers bits de
l’instruction. Les codes opération sont donnés dans le
tableau ci-après et le format (ainsi que deux
exemples). Pour différencier ces instructions, on fixe
les deux premiers bits à 10 et il reste trois bits pour
spécifier une instruction parmi sept
cours Architecture des ordinateurs: programmation assembleur
Format des instructions
20

 Instructions à deux registres

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
21

 Instructions à deux registres


 Les instructions entre registres ou registre/mémoire.
 On peut prendre le même format (3 registres) en
mettant le dernier champ (16 bits) à 0.
 STH (r3), r22

10101 0 00011 10110 0000000000000000

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
22

 Instruction à un registre et une valeur immédiate


 Les sauts (JZ rx, Adr) ou le chargement d’une valeur
immédiate (MVI rx, #i).
 Le code d’opération sur 6 bits.
 On peut élargir, sur 21 bits, la zone contenant la valeur
immédiate.

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
23

 Exemple
 MVI r6, #0x56ac3

110101 00 110 001010110101011000011

cours Architecture des ordinateurs: programmation assembleur


Format des instructions
24

 Instructions à un seul registre


 On fixe 4 bits des 6 bits du code d’opération, 2 bits
étant suffisant pour coder les différents instructions.
 On met à 0 les deux derniers champs.
 CCR r6
111100 00110 00000 0000000000000000

cours Architecture des ordinateurs: programmation assembleur


Programme d’assemblage
25

 Un programme d’assemblage prend comme entrée un fichier


de code source et génère un fichier binaire en effectuant:
 Vérification de la syntaxe.
 Mémorisation de la correspondances entre les étiquettes et les
adresses mémoires.
 Génération du code exécutable.
 Une étiquette est utilisée dans une opération de saut.
 Le programme d’assemblage s’effectue en deux passes:
 Évaluation des étiquettes.
 Traduction en langage machine.

cours Architecture des ordinateurs: programmation assembleur


Exercice 1
26

 Dans r0 se trouve l’adresse d’une chaine de caractères


terminée par l’octet nul. Développer un programme en
assembleur qui permet de récupérer , dans r1, le nombre
de caractères dans la chaine.

cours Architecture des ordinateurs: programmation assembleur


Correction
27

cours Architecture des ordinateurs: programmation assembleur


Correction
28

MVI r1,#0
Ici : LDB r2, (r0)
JZ r2, fin
ADD r1, r1, #1
ADD r0, r0 #1
JMP ici
Fin :

cours Architecture des ordinateurs: programmation assembleur


Exercice 2
29

 Un tableau d’entiers est stocké en mémoire.


Chaque élément a une valeur de 1 à 127 (stocké sur
1 octet). L’octet qui suit le dernier élément du
tableau est nul. L’adresse du premier élément du
tableau se trouve dans le registre r0. développer un
programme en assembleur qui permet de récupérer
le plus grand élément du tableau dans r1.
 Ajouter au programme précédent le calcul de la
somme de tous les éléments du tableau dans r2.

cours Architecture des ordinateurs: programmation assembleur


Correction
30

cours Architecture des ordinateurs: programmation assembleur


Correction
31

cours Architecture des ordinateurs: programmation assembleur


Correction
32

Version 1 : Version 2 :

MVI r1,#0 MVI r1,#0


Ici : LDB r3, (r0) MVI r2, #0
ADD r0, r0, #1 Ici : LDB r3, (r0)
JZ r3, Fin ADD r0, r0, #1
SUB r31, r3, r1 JZ r3, Fin
JLE r31, ici ADD r2, r2, r3
MOV r1, r3 SUB r31, r3, r1
JMP ici JLE r31, ici
Fin : MOV r1, r3
JMP ici
Fin :
cours Architecture des ordinateurs: programmation assembleur
Exercice 3
33

 Une chaine de caractère est stockée en mémoire. Chaque


caractère occupe 1 octet et aucun est nul. L’octet qui suit
le dernier élément de la chaine est nul. L’adresse du
premier élément de la chaine se trouve dans r0. on
souhaite effectuer une opération de remplacement de
certains caractère de la chaine. Le registre r1 contient le
caractère à remplacer. Il s’agit de substituer à chaque
occurrence de ce dernier, le caractère se trouvant dans r2.
 On souhaite également à la fin avoir, dans le registre r3,
le nombre de remplacements effectués.

cours Architecture des ordinateurs: programmation assembleur


Correction
34

MVI r3,#0 ; nombre de remplacements égal à 0


Ici : LDB r4, (r0) ; charger prochain caractère
JZ r4, fin ; fin de la chaîne ?
SUB r4, r4, r1 ; comparer r4 et r1
JNZ r4, Next ; sauter remplacement si différent
STB (r0), r2 ; si égal, remplacer par r2
ADD r3, r3, #1 ; nombre de remplacements + 1
Next : ADD r0, r0, #1 ; avancer pointeur sur suivant
JMP ici ; retour dans la boucle
Fin :

cours Architecture des ordinateurs: programmation assembleur


Exercice4
35

 Une chaine de caractère est stockée en mémoire.


Chaque caractère occupe 1 octet et aucun est nul.
L’octet qui suit le dernier élément de la chaine est
nul. L’adresse du premier élément de la chaine se
trouve dans r0. On souhaite renverser la chaine. La
nouvelle chaine sera stockée en mémoire à une
adresse contenue dans r1

cours Architecture des ordinateurs: programmation assembleur


Correction
36

Il faut d’abord parcourir toute la première chaîne pour arriver à la fin


et commencer à recopier à partir du dernier caractère (donc un
caractère avant le zéro final de la première chaîne).
Mais il faut également savoir quand s’arrêter. Pour cela, on profite du
parcours pour compter au passage le nombre de caractères de la
chaîne.

cours Architecture des ordinateurs: programmation assembleur


Correction
37

MVI r2,#0 SUB r2, r2, #1


Comp : LDB r3, (r0) JMP suite1
JZ r3, Suite Fin : MVI r3, #0
ADD r2, r2, #1 STB (r1), r3
ADD r0, r0, #1
JMP Comp
Suite : SUB r0,r0, #1
Suite1 : JZ r2, fin
LDB r3, (r0)
STB (r1), r3
ADD r1, r1, #1
SUB r0, r0, #1
cours Architecture des ordinateurs: programmation assembleur
Exercice 5
38

 On dispose d’une valeur A stockée dans l’adresse


mémoire qui existe dans le registre r0. On souhaite
développer un programme qui détermine le nombre
de bit égale à 1 dans A. ce nombre sera stocké dans
r1.

cours Architecture des ordinateurs: programmation assembleur


Correction
39

MVI r1,#0
MVI r3,#0
LDW r2, (r0)
Ici : SUB r4,r3,#32
JZ r4, Fin
ADD r3,r3,#1
LLS r2,#1
CCR r5
SUB r6, r5,#1
JNZ r6, ici
ADD r1, r1, #1
JMP ici
Fin : cours Architecture des ordinateurs: programmation assembleur
Exercice 6
40

 Dans r0 se trouve l’adresse d’une chaine de caractère


terminée par l’octet nul. Développer un programme
assembleur qui permet de récupérer le nombre de mots
de la chaine dans r1. un mot est un ensemble de
caractères ne comprenant pas d’espace (32 en décimal).
 Attention, tous les cas sont possibles : la chaîne peut être
vide, il peut n’y avoir que des espaces dans la chaîne, il
peut y avoir plusieurs espaces entre deux mots et il n’y a
pas forcément d’espace avant le premier mot ni après le
dernier.

cours Architecture des ordinateurs: programmation assembleur


Correction
41

MVI r1,#0 compteur égal à 0


loop1 : LDB r2,(r0) lire un caractère
ADD r0,r0,#1 avancer le pointeur
JZ r2, Fin fin de la chaine ?
SUB r31,r2,#32 une espace ?
JZ r31, loop1 dans ce cas reboucler
ADD r1, r1, #1 sinon début d’un mot
Loop2: LDB r2, (r0) lire un caractère
ADD r0,r0,#1 avancer le pointeur
JZ r2, Fin fin de la chaine ?
SUB r31, r2, #32 une espace?
JNZ r31, loop2 sinon reboucler sur le mot
JMP loop1 sinon revenir au début
Fin: cours Architecture des ordinateurs: programmation assembleur

Vous aimerez peut-être aussi