Approche vulgarisée

Transcription

Approche vulgarisée

Centre Universitaire Bordj Bou Arreridj
Institut de technologie
département d’Informatique
Architecture des
Ordinateurs
2eme année LMD Informatique
A. Mehemmel
2008-2009
Préface
L’architecture des ordinateurs est l’étude et la description du fonctionnement des
composants internes d’un ordinateur. Elle traite : le type des informations manipulées et de leur
codage, le dialogue entre composants, et le fonctionnement logique (pas électrique) interne des
composants.
Nous abordons ce cours avec un chapitre sur l’architecture de la machine de Von Neumann,
les relations entre le processeur et la mémoire, le concept d'instruction et de langage machine et le
codage des différents types de données en mémoire.
Le chapitre suivant porte sur l'architecture externe d'un processeur industriel 32 bits MIPS
R3000, qui consiste à initier les étudiants à la programmation en assembleur, On présente ici
successivement les registres visibles du logiciel, l’organisation et les règles d’adressage de la
mémoire, les différentes conventions relatives à l’écriture des programmes en langage
d’assemblage, les instructions, les directives acceptées par l’assembleur, les quelques appels
système disponibles.
Le chapitre 3 porte sur la programmation structurée et les appels de procédures, L'utilisation
de la pile pour les variables locales, les sauvegardes de contextes, et le passage des paramètres.
Le chapitre 4 traite la conception du jeu d’instructions, le codage, l’architecture interne
MIPS R3000, le chemin des données et le principe de la microprogrammation.
Le chapitre 5 est une introduction aux mécanismes de traitement des interruptions et des
exceptions.
Et enfin un chapitre sur les architectures pipelines.
Ce recueil est un support auxiliaire, sa lecture ne devra pas remplacer la présence (active,
attentive et intéressée!) aux cours et aux TD, la recherche bibliographique et la lecture des autres
textes dans ce domaine restent les meilleurs moyens pour approfondir vos connaissances.
Mehemmel Abbas
Chargé de cours
Centre universitaire de Bordj Bou Arreridj
Architecture des Ordinateurs
CHAP I : Rappels
Révision:
CHAP 0
Ce chapitre est une révision des cours présentés en première année. Il présente un pré requis pour
ce module. En résumé, vous avez une semaine pour lire, comprendre et faire tous les exercices qui
vous seront proposés sur cette partie. Si vous trouvez des difficultés, demandez des explications à
vos enseignants de TD.
I.
Systèmes de numération
1. Introduction :
Depuis le début des temps, des dizaines de systèmes de numération ont été créés pour répondre à
des besoins de mesures de quantité et de grandeur. On raconte, qu'avant l'avènement d’un système de
numération, un berger se servait de cailloux pour compter les moutons. C'est à partir de besoins de
cette nature que les systèmes de numération ont été inventés.
Notre système de numération repose essentiellement sur la base 10 (surement à cause des 10
doigts des deux mains). On trouve aussi un certain nombre d'occurrences de nombres exprimés dans
d'autres systèmes de notation, telle que la base 60 pour compter les secondes et les minutes, la base
12 pour compter les heures, etc.
L'ordinateur a 2 états significatifs (impulsion électriques). Le système de numération qu'il emploie est donc le système binaire. Il est donc nécessaire de développer des techniques de conversions
de notation afin de pouvoir transcrire des nombres d'un système de notation dans un autre. A titre
d'exemple, les ordinateurs actuels convertissent constamment les nombres représentés en base 10
vers un système en base 2.
Ce paragraphe présente, quelques méthodes de conversion, nous utiliserons les bases 2, 8,10 et16.
2. Généralités.
Définition : Une base est le nombre par lequel on doit multiplier une unité pour passer d’un ordre
au suivant. C’est le nombre qui sert à définir un système de numération. La base du système décimal
est 10 alors que celle du système octal est 8.
D'une manière générale, le nombre anan-1...a2a1a0 si il est exprimé en base b ne pourra comporter
que des chiffres ai compris entre 0 et b-1. Notons ai la suite des chiffres utilisés pour écrire un
nombre x = an an-1 ... a1 a0
a0 est le chiffre des unités.
•
•
•
•
En décimal, b=10, ai ∈ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
En binaire, b=2, ai ∈ { 0, 1 } : 2 chiffres binaires, ou bits;
En Octal ; b = 8; ai ∈ { 0, 1, 2, 3, 4, 5, 6, 7};
En hexadécimal, b=16, ai ∈ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F } (on utilise les 6
premières lettres comme des chiffres).
La notation ( )b indique que le nombre est écrit en base b. Nous utiliseront aussi les lettres B, ∅, H
à la fin d’un nombre écrit en binaire, en octale ou en hexadécimal.
3. Ecriture des nombres entiers
En base 10, on écrit par exemple 1986 pour représenter le nombre
1986 = 1*103 + 9*102 + 8*101 + 6*100
1
CHAP I : Rappels
Dans le cas général, en base b, le nombre représenté par une suite de chiffres an an-1 ... a1 a0 est donné
par:
an * bn + an-1 * bn-1 + ... + a2 * b2 + a1 * b + a0 calculée en base 10.
a0 est le chiffre de poids faible, et an le chiffre de poids fort.
Exemple:
( 101101 )2 = 1*25+0*24+1*23+1*22+0*21+1*20=32+8+4+0+1 = 45
3
2
(6172)8
= 6*8 + 1*8 + 7*8 + 2 = 3194
4
3
2
(7A8BD)16 = 7*16 +10*16 +8*16 +11*16 +13 = 501949
Remarque: Dans un système à base b et sur n positions. On peut représenter les nombres de
n
0
à (b - 1)
4. Ecriture des nombres fractionnaires
Les nombres fractionnaires sont ceux qui comportent des chiffres après la virgule.
Dans le système décimal, on écrit par exemple:
12,346 = 1*101 + 2*100 + 3*10-1 + 4*10-2 + 6*10-3
En général, en base b, on écrit:
an an-1 ... a1 a0, a-1 a-2 ... a-p = an bn + an-1bn-1 + ... + a0 b0 + a-1 b-1 + ... + a-p b-p
Exemple:
-1
-2
-3
-4
4
(11.1011)2 = 1*2+1+ 1* 2 + 0 *2 + 1 * 2 + 1* 2 = 3 + (1011)2 /2 = 3.6875
-1
-2
-3
(0.307)8 = 3 * 8 + 0 * 8 + 7* 8 = (307)8 / 83 = 0.388671875
-1
-2
-3
3
(0.0F4)16 = 0 * 16 + 15* 16 + 4* 16 = (F4)16 /16 = 0.059570312
5. Opérations arithmétiques
Les opérations arithmétiques s'effectuent en base quelconque b avec les mêmes méthodes qu'en base
10. Une retenue ou un report apparaît lorsque l'on atteint ou dépasse la valeur b de la base.
6. Passage d'une base quelconque à la base 10
En exposant les principes des systèmes de numération de position, nous avons déjà vu comment convertir les nombres de base 8, base 2 et base 16 en nombres décimaux.
Exemple en hexadécimal:
(AB)16 = 10*161 + 11*160 =160 + 11 = 171
7. Passage de la base 10 vers une base quelconque
 Nombres entiers On procède par divisions successives. On divise le nombre par la base, puis le
quotient obtenu par la base, et ainsi de suite jusqu'a obtention d'un quotient nul.
La suite des restes obtenus correspond aux chiffres dans la base visée, a0 a1 ... an.
Exemple:
 44 = ( ? )2.
44 ÷ 2 = 22
reste 0 a0 = 0
22 ÷ 2 = 11
reste 0 a1 = 0
11 ÷ 2 = 5
reste 1 a2 = 1
5 ÷ 2 = 2
reste 1 a3 = 1
2 ÷ 2 = 1
reste 0 a4 = 0
2
1 ÷ 2 = 0
reste 1 a5 = 1

1383
172
21
2
1383 = ( ? )8
÷ 8 = 172
÷ 8 =
21
÷ 8 =
2
÷ 8 = 0

31838
1989
124
7
31838 = ( ? )16
÷ 16 = 1989
÷ 16 = 124
÷ 16 =
7
÷ 16 =
0
reste
reste
reste
reste
7
4
5
2
CHAP I : Rappels
Donc 44 = (101100)2.
1383 = (2547) 8
reste
reste
reste
reste
14 = EH
5
12 = CH
7
31838 = (7C5E) 16
 Nombres fractionnaires On multiplie la partie fractionnaire par la base en répétant l'opération
sur la partie fractionnaire du produit jusqu'a ce qu'elle soit nulle (ou que la précision voulue soit
atteinte).
Pour la partie entière, on procède par divisions comme pour un entier.
Exemple: conversion de 54,25 en base 2
Partie entière: 54 = (110110)2 par divisions.
Partie fractionnaire:
0.25 * 2 = 0.5
0.5 * 2 = 1.0
0.0 * 2 = 0.0
a-1 = 0
a-2 = 1
a-3 = 0
donc 54.25 = (110110.01)2
 0.6875 = ( ? )2
0.6875 * 2 = 1 . 375
0.375 * 2 = 0 . 75
0.75
* 2 = 1.5
0.5
* 2 = 1.0
0.6875 = (0,1011) 2
 0.6953125 =
0.6953125 * 8
0.5625
* 8
0.5
* 8
0.6953125 = (0.544)8
(
=
=
=
? )8
5.5625
4.5
4.0
 0.3 = (0.2 3146 3146 3146) 8
 0.6 = ( ? )16
0.6 * 16 = 9 . 6
0.6 * 16 = 9 . 6
0.6 = (0.99999) 16
 Cas des bases 2, 8 et 16
Ces bases correspondent à des puissances de 2 (21, 23 et 24), d'où des passages de l'une à l'autre très
simples. Les bases 8 et 16 sont pour cela très utilisées en informatique, elles permettent de représenter rapidement et de manière compacte des configurations binaires.
La base 8 est appelée notation octale, et la base 16 notation hexadécimale.
0T
0T
0T
0T
Chaque chiffre en base 16 (24) représente un paquet de 4 bits consécutifs. Par exemple:
(1010011011)2 = (0010 1001 1011)2 = (29B)16
3
CHAP I : Rappels
De même, chaque chiffre octal représente 3 bits.






II.
(10 011 000 111 110)2 = (23076)8
(10 1010 0001 1101 1100)2
= (2A1DC)16
(0.101 110 011 010 010)2 = (0.56322) 8
(0.1011 0011 0100 1000)2 = (0.B348) 16
(23.3501)8 = (10 011.011 101 000 001) 2
(12.C08)16 = (1 0010.1100 0000 1000) 2
Codage de données
1. Introduction
Les informations traitées par un ordinateur peuvent être de différents types (texte, nombres, etc.)
mais elles sont toujours représentées et manipulées par l'ordinateur sous forme binaire. Toute information sera traitée comme une suite de 0 et de 1.
Le codage d'une information consiste à établir une correspondance entre la représentation externe
(habituelle) de l'information (le caractère A ou le nombre 36 par exemple), et sa représentation interne dans la machine, qui est une suite de bits.
On utilise la représentation binaire car elle est simple, facile à réaliser techniquement.
Le Bit
Bit signifie "binary digit", c'est-à-dire 0 ou 1 en numérotation binaire. C'est la plus petite unité
d'information manipulable par une machine.
On peut le représenter physiquement:
•
par une impulsion électrique qui correspond à la valeur 1 ou une absence d'impulsion qui correspond à la valeur 0.
•
par des alvéoles ou des espaces dans une surface (CD-ROM)
•
grâce à des bistables, c'est-à-dire des composants qui ont deux états d'équilibre (un correspond
à l'état 1, l'autre à 0)
Avec un bit on peut avoir deux états différents : soit 1, soit 0.
Avec 2 bits on peut avoir quatre états différents (2*2): 0 0 0 1 1 0 11
Avec 3 bits on peut avoir huit états différents (2*2*2):
000
001
010
011
100 101 110
111
Avec 8 bits on a 2*2*2*2*2*2*2*2=256 possibilités, c'est ce que l'on appelle un octet.
Cette notion peut être étendue à n bits : on a alors 2n possibilités.
L'octet
L'octet est une unité d'information composée de 8 bits. Il permet de stocker un caractère, tel qu'une
lettre, un chiffre ...




Un kilo-octet (Ko) ne vaut pas 1000 octets mais 210 octets = 1024 octets
Un méga-octet (Mo) vaut 210 Ko = 1024 Ko = 220 octets = 1 048 576 octets
Un giga-octets (Go) vaut 210 Mo = 1024 Mo = 230 octets = 1 073 741 824 octets
Un téra-octet (To) vaut 210 Go = 1024 Go = 240 octets = 1 099 511 627 776 octets
Les octets sont regroupés en mot-mémoire. La longueur d'un mot-mémoire varie d'une machine à l'autre (8, 16, 24, 32, 64 bits) la longueur des mot-mémoires est une caractéristique importante dans l'architecture d'un ordinateur.
4
CHAP I : Rappels
2. Codification des nombres entiers
La représentation (ou codification) des nombres est nécessaire afin de les stocker et manipuler par un
ordinateur. Le principal problème est la limitation de la taille du codage: un nombre mathématique
peut prendre des valeurs arbitrairement grandes, tandis que le codage dans l'ordinateur doit s'effectuer sur un nombre de bits fixé.
 Entiers naturels (non signés)
Les entiers naturels (positifs ou nuls) sont codés sur un nombre d'octets fixé (un octet est un groupe
de 8 bits). On rencontre habituellement des codages sur 1, 2 ou 4 octets, plus rarement sur 64 bits (8
octets, par exemple sur les processeurs DEC Alpha).
Un codage sur n bits permet de représenter tous les nombres naturels compris entre 0 et 2n-1. Par
exemple sur 1 octet, on pourra coder les nombres de 0 à 255 = 28-1.
On représente le nombre en base 2 et on range les bits dans les cellules binaires correspondant à leur
poids binaire, de la droite vers la gauche. Si nécessaire, on complète à gauche par des zéros (bits de
poids fort).
 Entiers relatifs (signés)
Il faut ici coder le signe du nombre. On utilise le codage en complément à deux, qui permet d'effectuer ensuite les opérations arithmétiques entre nombres relatifs de la même façon qu'entre nombres
naturels.
1. Entiers positifs ou nuls: On représente le nombre en base 2 et on range les bits comme pour les
entiers naturels. Cependant, la cellule de poids fort est toujours à 0: on utilise donc n-1 bits.
Le plus grand entier positif représentable sur n bits en relatif est donc 2n-1 - 1.
2. Entiers négatifs: Soit x un entier positif ou nul représenté en base 2 sur n-1 bits
La représentation de -x est obtenue par (-x) + (x) = 2n. On dit complément vrai (à deux). Pour
obtenir le codage d'un nombre x négatif, on code en binaire sa valeur absolue sur n-1 bits, puis on
complémente (inverse) tous les bits et on ajoute 1.
Exemple: soit à coder la valeur -2 sur 8 bits. On exprime 2 en binaire, soit 00000010. On inverse les
bits On obtient 11111101. On ajoute 1 et on a le résultat: 1111 1110.
Remarques:
a. le bit de poids fort d'un nombre négatif est toujours 1;
b. sur n bits, le plus grand entier positif est 2n-1 - 1 = 011….1;
c. sur n bits, le plus petit entier négatif est -2n-1.
Sur 8 bits on peut donc représenter les nombres:
5
CHAP I : Rappels
 Opération arithmétique et débordement (Overflow):
Les opérations d’additions et de soustractions se déroulent normalement comme en binaire.
Il y a débordement si le résultat n’appartient pas à l’intervalle des entiers représentables.
Le débordement peut être détecté:
•
en comparant le signe des opérandes au signe du résultat: s'il y a contradiction, il y a débordement, ou
•
en comparant la retenue entrante dans le bit de poids fort avec la retenue sortante : s'ils sont
différents, il y a débordement.
Exemple:
3. Représentation des nombres réels (norme IEEE)
Plusieurs représentations possibles :
•
•
•
virgule fixe : revient à manipuler des entiers (caisses enregistreuses)
couple (numérateur, dénominateur): représentation juste uniquement pour les nombres rationnels
virgule flottante
 Virgule flottante
e
Un nombre réel x = ± m* b
base b.
est représenté par un signe, une mantisse m, un exposant e, et une
Il existe une infinité de représentation du même nombre. Représentation normalisée : pour une base
b, la mantisse est prise dans l'intervalle [1, b[ (zéro admet une représentation particulière).
La précision et l'intervalle de valeurs représentées dépendent du nombre de bits utilisés pour coder la
mantisse et l'exposant.
 Norme IEEE754
La norme IEEE 754 est la norme la plus utilisée pour représenter les réels.
•
•
•
•
nombres codés sur 32 bits (simple précision), ou 64 bits (double précision)
la mantisse appartient à l'intervalle [1,0
10,0[ (en binaire)
le seul chiffre à gauche de la virgule étant toujours 1, n'est pas représenté
l'exposant E est codé avec un excès de 127 (simple précision) ou 1023 (double précision) (i.e.
E = e+127 ou E = e+1023)
Sur 32 bits :
S
1 bit
(−1) S *1, M * 2 E −127
Exposant
E
Mantisse M
8 bits
23 bits
Exemple: Coder le nombre réel 95.7 selon la norme IEEE 754
Solution:
95.7 = 1011111,101100100010001000100010001000100…B=1,01111110110010001000100 B * 26
E = 6 + 127 = 128 + 5 = 10000101B
95.7 est codé par: 0 100 0010 1 011 1111 0110 0100 0100 0100
-5 est codé par:
1 100 0000 1 010 0000 0000 0000 0000 0000
6
Vérifier!
CHAP I : Rappels
 Précision
La représentation des nombres réels sur une machine se base sur un nombre fini de valeurs. C'est
donc une représentation approchée.
Précision de la représentation = différence entre les mantisses de deux nombres réels consécutifs.
! La précision ne dépend que de la mantisse.
En conséquence de ces limites, il existe donc un nombre limité de nombres représentables sur machine.
 Remarques:
1. Le zéro : le zéro est le seul nombre qui ne peut pas se représenter dans le système en virgule
flottante
à
cause
de
la
contrainte
de
non
nullité
du
premier
digit.
2. Les exposants 00000000 et 11111111 sont interdits:
•
•
l'exposant 00000000 signifie que le nombre est dénormalisé;
l'exposant 11111111 indique que l'on n'a pas affaire à un nombre (on note cette configuration NaN, Not a Number, et on l'utilise pour signaler des erreurs de calculs, comme par
exemple une division par 0).
3. Les plus petit exposant est donc -126, et le plus grand +127.
4. Dépassement de capacité : Si l'on cherche à représenter un nombre très petit, on produit un
débordement par valeur inférieure (underflow). Si l'on cherche à représenter un nombre très
grand, on produit un débordement par valeur supérieure (overflow).
4. Décimaux codés binaire
Cette codification est utilisée souvent dans les calculatrices de poche et de bureau, Un nombre
décimal, qui est composé d’un ou plusieurs chiffres (0 à 9), est toujours codé à l’aide de bits. Il existe
un certain nombre de codes; voici deux.
 CODE DCB Décimal Codé Binaire :
chaque chiffre d'un nombre est codé sur 4 bits Ce code
simplifie la conversion décimal binaire.
Pour l’addition, il faut ajouter 6 chaque fois que le résultat est >9.
Pour la soustraction, il faut retrancher 6 chaque fois que le résultat est < 0.
 CODE Excédent-3
Chaque chiffre décimal est codé séparément en son équivalent binaire
+ 3.
Exemple 4850 est codé par 0111 1011 1000 0011
Au cours d’une addition, le chiffre décimal est augmenté de 6; en lui retirant systématiquement 3, le
résultat sera codé en code excédent-3. Si une addition de ce type conduit à une retenue du cinquième
ordre binaire, il faudra au contraire ajouter 3 aux deux ordres décimaux pour que les chiffres correspondants se retrouvent en code excédent-3.
7
CHAP I : Rappels
5. Représentation des caractères
Les caractères sont des données non numériques: il n'y a pas de sens à additionner ou multiplier deux
caractères. Par contre, il est souvent utile de comparer deux caractères, par exemple pour les trier
dans l'ordre alphabétique.
Les caractères, appelés symboles alphanumériques, incluent les lettres majuscules et minuscules, les
symboles de ponctuation (& ~ , . ; # " - etc...), et les chiffres.
Un texte, ou chaîne de caractères, sera représenté comme une suite de caractères.
Le codage des caractères est fait par une table de correspondance indiquant la configuration binaire
représentant chaque caractère. Les deux codes les plus connus sont l'EBCDIC (en voie de disparition) et le code ASCII (American Standard Code for Information Interchange).
Le code ASCII représente chaque caractère sur 7 bits (on parle parfois de code ASCII étendu, utilisant 8 bits pour coder des caractères supplémentaires).
Notons que le code ASCII original, défini pour les besoins de l'informatique en langue anglaise) ne
permet la représentation des caractère accentués (é, è, à, ù, ...), et encore moins des caractères chinois
ou arabes. Pour ces langues, d'autres codages existent, utilisant 16 bits par caractères.
ASCII US défini par la norme iso-646
0
1
2
3
4
5
6
7
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
NUL
DLE
SOH
DC1
STH
CD2
ETH
DC3
EOT
DC4
ENQ
NAK
ACK
SYN
BEL
ETB
BS
CAN
HT
EM
LF
SUB
VT
ESC
FF
FS
CR
GS
SO
RS
SI
US
spc
0
@
P
`
p
!
1
A
Q
a
q
"
2
B
R
b
r
#
3
C
S
c
s
$
4
D
T
d
t
%
5
E
U
e
u
&
6
F
V
f
v
‘
7
G
W
g
w
(
8
H
X
h
x
)
9
I
Y
i
y
*
:
J
Z
j
z
+
;
K
[
k
{
,
<
L
\
l
|
=
M
]
m
}
.
>
N
^
n
~
/
?
O
_
o
DEL
Pour bien lire le tableau, il faut construire le code hexadécimal en prenant d'abord le digit de la ligne,
puis le digit de la colonne. Par exemple, la lettre "n" a pour code hexadécimal 6E
Plusieurs points importants à propos du code ASCII:
•
•
•
•
Les codes compris entre 0 et 31 ne représentent pas des caractères, ils ne sont pas affichables.
Ces codes, souvent nommés caractères de contrôles sont utilisés pour indiquer des actions
comme passer à la ligne (CR, LF), émettre un bip sonore (BEL), etc.
Les lettres se suivent dans l'ordre alphabétique (codes 65 à 90 pour les majuscules, 97 à 122
pour les minuscules), ce qui simplifie les comparaisons.
On passe des majuscules aux minuscules en modifiant le 5ième bit, ce qui revient à ajouter 32
au code ASCII décimal.
Les chiffres sont rangés dans l'ordre croissant (codes 48 à 57), et les 4 bits de poids faibles
définissent la valeur en binaire du chiffre.
III.
Protection contre les erreurs
Intérêt d'un contrôle d'erreur
Le codage binaire est très pratique pour une utilisation dans des appareils électroniques tels qu'un
ordinateur, dans lesquels l'information peut être codée grâce à la présence ou non d'un signal électrique. Toutefois, le signal électrique peut subir des perturbations, notamment lors du transport des
données (dans un réseau par exemple) car les données circulent sur un long trajet. Ainsi, le contrôle
8
CHAP I : Rappels
de la validité des données est nécessaire pour certaines applications (professionnelles, bancaires, industrielles, confidentielles, relatives à la sécurité, ...). C'est pourquoi il existe des mécanismes permettant de garantir un certain niveau d'intégrité des données.
1. Le contrôle de parité
La plupart des systèmes de contrôle d'erreur sont basés
sur un ajout d'information permettant de vérifier la validité des données.
Le contrôle de parité est un des systèmes de contrôle les
plus simples. Il consiste à ajouter un bit supplémentaire
(appelé bit de parité) à un certain nombre de bits de
données (généralement 7, pour former un octet avec le
bit de parité) dont la valeur (0 ou 1) . la valeur est telle
que le nombre total de bit à 1 (calculé sur m+1) est pair ou impair. Si la parité n’est plus respectée,
l’erreur est détectée, mais s’il y a double erreur, la parité est aussi respectée et alors l’erreur n’est
plus détectée.
2. Double parité:
En plus du contrôle par octet (horizontal), on ajoute une parité par bit pour un
bloc d’information (parité longitudinal).
Ce double contrôle permet de détecter un
nombre impair d’erreur et parfois de corriger certaines erreurs.
3. Le code de Hamming:
est basé sur les tests de parité pair et ne permet de corriger qu’un bit en erreur.
Au m bits d’information, on ajoute k bits de contrôle. Pour que les bits de contrôle puissent coder les
m+k+1 possibilités d’erreurs (dont l’absence d’erreur) ,il faut que 2k >= m+k+1. Les bits sont numérotés de 1 à m+k et Les bits de test sont placés en position 1, 2, 4, 8, . . (puissance de 2). Chaque bit
est contrôlé par les bits qui additionnés donnent le numéro de ce bit. Ainsi
Le bit 1 contrôle les bits 1, 3, 5, 7, 9, 11, 13, 15, 17,. . . . .
Le bit 2 contrôle les bits 2, 3, 6, 7, 10, 11, 14, 15, . . . .
Le bit 4 contrôle les bits 4, 5, 6, 7, 12, 13, 14, 15 . . . . .
Le bit 8 contrôle les bits 8, 9, 10, 11, 12, 13, 14, 15, 24 . . .
Exemple:
Soit l’information composée de 8 bits m7,m6,m5, m4,m3,m2, m1,m0
Il faut donc 4 bits de contrôle k3,k2, k1,k0 .
L’information avec contrôle devient
m7,m6,m5, m4, k3,m3,m2, m1, k2,m0, k1,k0
Si L’information est: 10110101 Après L’ajout des bits de contrôle On obtient
1011 1 010 0 1 10
On suppose que le bit 10 est détérioré (inversé) lors d'une transmission, 10 0 1 1 010 0 1 10 .
Après calcule des parités pour les bits de contrôle, on obtient
1010
9
10
CHAP I : Rappels
CHAP I
CHAP I : Modèle de Von Neumann
Modèle de Von Neumann
Dans cette partie, nous décrivons rapidement l’architecture de base d’un ordinateur et les principes de son fonctionnement. Un ordinateur est une machine de traitement de l’information. Il est capable
d’acquérir de l’information, de la stocker, de la transformer en effectuant des traitements quelconques, puis de
la restituer sous une autre forme. Le mot informatique vient de la contraction des mots information et automatique.
I.
Modèle de Von Neumann
L’architecture, dite architecture de Von Neumann, est un modèle pour un ordinateur qui utilise une
structure de stockage unique pour conserver à la fois
les instructions et les données requises ou générées par
le calcul. De telles machines sont aussi connues sous le
nom d’ordinateurs à programme stocké en mémoire.
La séparation entre le stockage et le processeur est implicite dans ce modèle.
C’est la première description d’un ordinateur dont
le programme est stocké dans sa mémoire.
1.
a)
L’architecture de Von Neumann décomposait l’ordinateur en quatre parties distinctes
La mémoire centrale : c'est là que sont mémorisés
les informations et les programmes qui les traitent, tout au long de l'exécution. Cette mémoire
est aussi appelée mémoire vive (ou RAM en anglais); elle est volatile, c'est-à-dire qu'elle perd
ses informations dès qu'elle n'est plus alimentée en courant. De sa capacité dépend la capacité de
l'ordinateur à exécuter efficacement de "gros programmes" sur des volumes de données importants, ou éventuellement à exécuter plusieurs programmes "en même temps" (c'est le cas quand
sur un ordinateur personnel, on exécute plusieurs applications simultanément). La capacité de la
mémoire centrale varie couramment de quelques Méga-octets à quelques Giga-octets. Chaque
emplacement de la mémoire est numéroté par une "adresse". Cette adresse est un entier positif,
indispensable pour retrouver l'endroit en mémoire où est mémorisée une information. La mémoire centrale contient aussi toujours au moins un petit peu de "mémoire morte" (ROM pour
Read Only Memory), pour contenir le premier programme qui s'exécute au démarrage. Dans le
cas des ordinateurs embarqués, l'ensemble des programmes peut être enregistré en ROM (ils ne
sont alors plus modifiables).
Dans les nouvelles architectures on trouve aussi une Mémoire Cache (mémoire tampon): mémoire rapide permettant de réduire les délais d’attente des informations stockées en mémoire
vive.
Structure de la MP
La mémoire est divisée en emplacements de taille fixe (par exemple 8 bits) utilisés pour stocker
instructions et données.
En principe, la taille d'un emplacement mémoire pourrait être quelconque; en fait, la plupart des
ordinateurs en service aujourd'hui utilisent des emplacements mémoire d'un octet (byte en anglais,
soit 8 bits, unité pratique pour coder un caractère par exemple).
11
Dans une mémoire de taille N, on a N emplacements mémoires, numérotés de 0 à N-1. Chaque
emplacement est repéré par son numéro, appelé adresse. L'adresse est le plus souvent écrite en hexadécimal.
La capacité (taille) de la mémoire est le nombre d'emplacements, exprimé en général en kilooctets ou en méga-octets, voire davantage.
Sélecteur d’adresse (décodeur) c’est un circuit à n entrées et 2n sorties. Il permet de déterminer
une cellule à partir d’une adresse.
Opérations sur la mémoire
Seul le processeur peut modifier l'état de la mémoire. Chaque emplacement mémoire conserve les
informations que le processeur y écrit jusqu'à coupure de l'alimentation électrique, où tout le contenu
est perdu (contrairement au contenu des mémoires externes comme les disquettes et disques durs).
Les seules opérations possibles sur la mémoire sont:
•
écriture d'un emplacement: le processeur donne une valeur et une adresse, et la mémoire
range la valeur à l'emplacement indiqué par l'adresse;
•
lecture d'un emplacement: le processeur demande à la mémoire la valeur contenue à l'emplacement dont il indique l'adresse. Le contenu de l'emplacement lu reste inchangé.
Unité de transfert
Notons que les opérations de lecture et d'écriture portent en général sur plusieurs octets contigus
en mémoire: un mot mémoire. La taille d'un mot mémoire dépend du type de processeur; elle est de
•
•
•
1 octet (8 bits) dans les processeurs 8 bits (par exemple Motorola 6502);
2 octets dans les processeurs 16 bits (par exemple Intel 8086);
4 octets dans les processeurs 32 bits (par ex. Intel 80486 ou Motorola 68030).
12
b) L’unité arithmétique et logique (UAL) ou unité de traitement, Elle comporte des dispositifs
électroniques capables d'effectuer des opérations logiques et arithmétiques sur les codes binaires,
son rôle est d’effectuer les opérations de base, un peu comme le ferait une calculette.
Elle possède les registres suivants :
•
•
Les registres arithmétiques.
Les registres de base et d’index (calcul d’adresse
par rapport à une base ou index).
•
Les registres banalisés (ex : stockage de résultats
intermédiaires).
•
Le registre d’état PSW (Program Status Word)
(Flags : F) A chaque opération, le microprocesseur positionne un certain nombre de bits. Ces bits sont appelées
aussi indicateurs d'état ou drapeaux (status, flags). Par
exemple, si une soustraction donne un résultat nul, l'indicateur de zéro ( Z ) sera mis à 1. Ces indicateurs sont regroupées dans le registre d'état
c) L’unité de contrôle (commande). L'unité de contrôle organise le fonctionnement interne de la
machine. Elle est chargée de provoquer dans l'unité de calcul les opérations prévues par le programme, comme elle contrôle aussi l'ensemble des autres dispositifs de l'ordinateur. C’est
l’équivalent des doigts qui actionneraient la calculette.
L’unité de commande est constituée de plusieurs organes qui permettent la lecture en mémoire et
le décodage des instructions. On trouve:
• Le compteur ordinal (Instruction Pointer) (IP): ou Compteur de Programme, contient l'adresse
de l'emplacement mémoire où se situe la prochaine instruction à exécuter;
•
Le registre d’instruction (RI): contient le code de l'instruction en cours d'exécution (lu en mémoire via le bus de données); il a le même format qu’une instruction.
• Le décodeur de code opération qui détermine l’opération à effectuer parmi toutes celles possibles.
• Le séquenceur est un automate générant les signaux de commandes nécessaires pour actionner
et contrôler les unités participant à l’exécution d’une instruction. Il existe deux types de séquenceurs:
- le séquenceur câblé qui est un circuit séquentiel complexe mais d’exécution très rapide.
- le séquenceur micro programmé contenu dans une ROM qui est plus simple à utiliser et à concevoir, mais moins rapide.
•
L’horloge qui synchronise toutes les actions de l’unité centrale.
13
d) Unité d’entrées-sorties : dispositifs qui permettent de communiquer avec le monde extérieur.
Dans les nouvelles architectures l’UAL et l’unité de contrôle sont regroupés en un seul dispositif
« le processeur » ou microprocesseur. Un ordinateur se compose donc principalement d'un processeur (CPU), de mémoire (RAM et ROM), et de composants périphériques (Clavier, port série, contrôleur en tout genre, carte son....). Le CPU est bien sur le maître à bord dans un ordinateur (comme
dans une console de jeux d'ailleurs), la mémoire et les périphériques étant à son service. Le CPU est
connecté aux périphériques et à la mémoire à l'aide d'un BUS.
2. Le BUS
Le BUS est une chaîne ou tous les périphériques sont connectés en parallèle. Un BUS système se
divise généralement en trois sous BUS:
- Le BUS de données (c'est la partie qui transporte les données brutes). Notons que plus ce bus est
large plus le système sera rapide. En effet un système 16 Bits est plus rapide qu'un système 8 bits car
il est capable de 'transporter' 2 octets à la fois alors que le système 8 bits n'en transporte qu'un à la
fois (1 octet = 8 bits)
- Le BUS d'adressage (c'est celui qui désigne un endroit dans la mémoire ou un périphérique).
Plus il est large plus on peut adresser de la mémoire. Exemple: bus d'adressage 16bits =64Ko adressables, bus 32bits = 4Go!)
- Le BUS de contrôle (il désigne le mode de l'opération à effectuer: Lecture ou écriture, périphérique ou Mémoire, Interruption, etc.)
3. Les registres
C'est l'ensemble des emplacements facilement spécifiables qui contiennent temporairement les
opérandes et les résultats des opérations ou des données comme une instruction ou une adresse. Se
sont des petites mémoires internes à accès très rapides. Chaque registre stocke 8, 16,32 ou 64 bits. Le
nombre exact de registres dépend du type de processeur et varie typiquement entre une dizaine et une
centaine.
Il n'est absolument pas nécessaire que les registres soient homogènes bien qu'on puisse souvent
grouper les registres en classes, de sorte que les registres d'une classe peuvent être utilisés à la place
14
de n'importe quel autre registre de la même classe. Mais il n'est pas rare qu'une classe ne comporte
qu'un seul registre.
Les architectures ont quasiment toutes au moins deux classes de registres: une pour stocker les
valeurs entières, une pour stocker les nombres représentés en virgule flottante. Mais souvent, l'espace
de travail comporte des registres ayant des fonctions particulières.
Un accumulateur : est un registre servant de source implicite à la plupart des instructions et contenant le résultat après leur exécution.
Les registres d'index : sont des registres servant au calcul d'adresse.
Un pointeur de pile : indiquant l'adresse du sommet d'une pile gérée par le processeur.
Un frame pointer : servant à accéder aux données locales de la routine en cours d'exécution.
Certains registres ont un comportement particulier: ils informent de l'état du processeur ou contiennent des informations à propos des dernières opérations effectuées (par exemple un indicateur
indiquant si le dernier résultat était nul ou pas). Parmi ces registres particuliers on trouve souvent:
Le compteur ordinal (program counter, instruction pointer) : indiquant l'adresse de l'instruction
en cours d'exécution ou de la prochaine instruction à exécuter;
le mot d'état : regroupant les informations les plus importantes sur l'état du processeur.
4. Notion de programme
Un programme est une suite d'instructions élémentaires, qui vont être exécutées dans l'ordre par le
processeur. Ces instructions correspondent à des actions très simples, comme additionner deux
nombres, lire ou écrire une case mémoire, etc. Chaque instruction est codifiée en mémoire sur
quelques octets.
Le processeur est capable d'exécuter des programmes en langage machine, c'est à dire composés
d'instructions très élémentaires suivant un codage précis. Chaque type de processeur est capable
d'exécuter un certain ensemble d'instructions, son jeu d'instructions.
Pour écrire un programme en langage machine, il faut donc connaître les détails du fonctionnement du processeur qui va être utilisé.
5. Exécution d'une instruction
Les différentes phases d'une exécution
On peut suivre les différentes phases de l'exécution d'une instruction. Celles-ci sont au nombre de 3 :
Recherche de l'instruction (Fetch), Décodage (décode), Exécution (exécute)
 Recherche de l'instruction
Le contenu de PC (compteur ordinal) est placé sur le bus des adresses (c'est l'unité de commande qui
établit la connexion).
L'unité de commande positionne le compteur ordinal (PC) pour l'instruction suivante.
L'unité de commande (UC) émet un ordre de lecture (READ=RD=1)
Au bout d'un certain temps (temps d'accès à la mémoire) le contenu de la case mémoire sélectionné
est disponible sur le bus des données.
L'unité de commande charge la donnée dans le registre d'instruction pour décodage.
15
 Décodage
Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut être codée sur
plusieurs mots. Ce premier mot contient le code opération qui définit la nature de l'opération à effectuer (addition, rotation,...) et le nombre de mots de l'instruction. L'unité de commande décode le
code opération et peut alors exécuter l'instruction.
 L'exécution
Le micro-programme réalisant l'instruction est exécuté.
Les indicateurs sont positionnés (registre d'état).
Stockage des résultats à leurs destinations respectives.
Retour à l'étape 1 pour exécuter l'instruction suivante.
Lecture de l’instruction
(Incrémentation de PC
Décodage de l’instruction
Calcul de l’adresse des opérandes
Lecture des opérandes
Opération
Rangement du résultat
Positionnement des indicateurs
16
CHAP II
CHAP II : Microprocesseur MIPS R3000
Microprocesseur MIPS R3000
Architecture externe
1. Introduction
MIPS (de l'anglais Microprocessor without interlocked pipeline stages) est une architecture de
microprocesseur de type RISC. Elle fut développée par la compagnie MIPS Computer Systems Inc.,
basée à Mountain View en Californie. Les processeurs fabriqués selon cette architecture sont utilisés
dans plusieurs systèmes. On les retrouve dans plusieurs systèmes embarqués (embedded systems en
anglais), comme les ordinateurs de poche, les routeurs Cisco et les consoles de jeux vidéo (Nintendo
64 et Sony PlayStation, PlayStation 2 et PSP). Vers la fin des années 1990, on estimait que les processeurs dérivés de l'architecture MIPS occupaient le tiers des processeurs RISC produits.
Les premières implémentations de l'architecture MIPS étaient de 32 bits (autant au niveau des registres que des chemins de données), mais par la suite, on a développé des implémentations de 64
bits.
Il existe plusieurs jeux d'instructions MIPS qui sont rétro compatibles (backward compatible): MIPS
I, MIPS II, MIPS III, MIPS IV, et MIPS V ainsi que MIPS32 et MIPS64. MIPS32 et MIPS64, qui se
basent sur MIPS II et MIPS V, ont étés introduites comme jeux d'instructions normalisés. Des extensions sont aussi disponibles telles que : MIPS-3D, une unité à virgule flottante (FPU) simplifiée de
type SIMD pour les calculs 3D de base,
Les jeux d'instructions de base (en particulier MIPS I) sont si simples et efficaces qu'un bon nombre
de cours d'architecture des ordinateurs, autant dans les universités que les écoles techniques, se portent sur l'étude de l'architecture MIPS.
Ce cours présente une version simplifiée de l'architecture externe du processeur MIPS R3000.
L'architecture externe représente ce que doit connaitre un programmeur souhaitant programmer en
assembleur, ou la personne souhaitant écrire un compilateur pour ce processeur:
2. Caractéristiques
L'architecture externe est l'interface entre le processeur et le programmeur. Ce cours sera plus orienté vers
l'architecture interne.
Une architecture externe est composée de :
- Les registres visibles.
- L'adressage de la mémoire.
- Le jeu d'instructions.
- Les mécanismes de traitement des interruptions et exceptions.
2.1.
Organisation de la mémoire
Dans l’architecture MIPS R3000, l’espace adressable est divisé en deux segments: le segment utilisateur, et le segment système (noyau).
Un programme utilisateur utilise généralement trois sous-segments (appelés sections) dans le
segment utilisateur:
1. la section text contient le code exécutable en mode utilisateur. Elle est implantée conventionnellement à l’adresse 0x00400000. Sa taille est fixe et calculée lors de l’assemblage. La principale tâche de l’assembleur consiste à générer le code binaire correspondant au programme
source décrit en langage d’assemblage, qui sera chargé en mémoire dans cette section.
17
2. la section data contient les données globales manipul.es par le programme utilisateur. Elle est implantée conventionnellement à l’adresse 0x10000000. Sa taille est
fixe et calculée lors de l’assemblage. Les
valeurs contenues dans cette section peuvent être initialisées grâce à des directives
contenues dans le programme source en
langage d’assemblage.
3. la section stack contient la pile
d’exécution du programme utilisateur. Sa
taille varie au cours de l’exécution. Elle
est implantée conventionnellement à
l’adresse 0x7FFFF000. La pile s’étend
vers les adresses décroissantes.
0xFFFFFFFF
Réservé
0xFFFFF000
0xFFFFEFFF
.kstack
Segment
Système
(noyau)
.kdata
0xC0000000
0xBFFFFFFF
.ktext
0x80000000
0x7FFFFFFF
Réservé
0x7FFFF000
0x7FFFEFFF
.stack
Trois sections sont également définies dans le
segment noyau (kernel):
Segment
1. la section ktext contient le code exécu.data
utilisateur
0x10000000
table en mode noyau. Elle est implantée
0x0FFFFFFF
conventionnellement
à
l’adresse
.text
0x80000000. Sa taille est fixe et calculée
0x00400000
lors de l’assemblage.
0x003FFFFF
2. la section kdata contient les données gloRéservé
bales manipulées par le système
0x00000000
d’exploitation en mode noyau. Elle est
implantée conventionnellement à l’adresse 0xC0000000. Sa taille est fixe et calculée lors de
l’assemblage.
3. la section kstack contient la pile d’exécution du noyau. Sa taille varie au cours de
l’exécution. Elle est implantée conventionnellement. l’adresse 0xFFFFF000. Cette pile
s’étend vers les adresses décroissantes.
Question : Calculer l’espace de chaque section de la mémoire
2.2.
Registres visibles du logiciel
Le processeur MIPS possède 32 registres de travail accessibles au programmeur. Chaque registre
est connu par son numéro, qui varie entre 0 et 31, et est préfixé par un $. Par exemple, le registre 31
sera noté $ra dans l’assembleur. En dehors du registre $zero qui contient toujours la valeur 0, tous
les registres sont identiques du point de vue de la machine. Ils sont directement adressés par les instructions, et permettent de stocker des résultats de calculs intermédiaires.
Afin de normaliser et de simplifier l’écriture du logiciel, des conventions d’utilisation des registres sont définies. Ces conventions sont particulièrement nécessaires lors des appels de fonctions.
18
Registres
$0
$1
$2
$3
Nom
$zero
$at
$v0
$v1
$4,$5,$6,$7
$a0 … $a3
$8, … , $15
$16, … , $23
$24, $25
$26, $27
$28
$29
$30
$31
$t0 … $t7
$s0 … $s7
$t8, $t9
$k0, $k1
$gp
$sp
$s8
$ra
HI
LO
PC
Description
vaut zéro en lecture, non modifié par écriture
Réservé à l’assembleur pour les macros. Ne doit pas être utilisé
Utilisé pour les valeurs de retour des fonctions
Utilisé. pour les appels systèmes. Contient le numéro d'appel de la
fonction système syscall.
Utilisés par le compilateur pour optimiser les appels de fonctions
pour contenir les arguments
Registres de travail utilisable par le code utilisateur
Registres de sauvegardes d'usage universel
Réservés aux procédures noyau.
Pointeur global. Constant pour tout processus .
Pointeur de pile
Pointeur sur la zone des variables globales (section data)
Contient l’adresse de retour d’une fonction
Registres spéciaux
Poids fort du résultat d’une multiplication sur 64 bits ou reste de
division.
Poids faible du résultat d’une multiplication sur 64 bits ou quotient
de division.
Registre compteur de programme (Program Counter).
• PC Registre compteur de programme (Program Counter). Ce registre contient l'adresse de
l’instruction en cours d’exécution. Sa valeur est modifiée par toutes les instructions.
• HI et LO Registres pour la multiplication ou la division Ces deux registres 32 bits sont utilisés
pour stocker le résultat d'une multiplication ou d'une division, qui est un mot de 64 bits.
2.3.
Registres protégés
L’architecture MIPS définit 32 registres (numérotés de 0 à 31), qui ne sont accessibles, en lecture
comme en écriture, que par les instructions privilégiées (c’est à dire les instructions qui ne peuvent
être exécutées qu’en mode superviseur). On dit qu’ils appartiennent au "coprocesseur système". En
pratique, cette version du processeur MIPS R3000 en utilise 4 pour la gestion des interruptions et
des exceptions.
SR: Registre d’état (Status Register).
Il contient en particulier le bit qui définit le mode : superviseur ou utilisateur, ainsi que les bits de
masquage des interruptions. (Ce registre possède le numéro 12)
CR : Registre de cause (Cause Register).
En cas d’interruption ou d’exception, son contenu définit la cause pour laquelle on fait appel au programme de traitement des interruptions et des exceptions. (Ce registre possède le numéro 13).
EPC : Registre d’exception (Exception Program Counter). Il contient l’adresse de retour
(PC+4) en cas d’interruption. Il contient l’adresse de l’instruction fautive en cas d’exception (PC).
(Ce registre possède le numéro 14)
19
BAR : Registre d’adresse illégale (Bad Address Register). En cas d’exception de type "adresse
illégale", il contient la valeur de l’adresse mal formée. (Ce registre possède le numéro 8)
Les arguments
La plupart des instructions nécessitent un ou plusieurs arguments. Si une instruction nécessite plusieurs arguments, ces arguments sont séparés par des virgules. Dans une instruction assembleur, on
aura en général comme premier argument le registre dans lequel est mis le résultat de l’opération,
puis ensuite le premier registre source, puis enfin le second registre source ou une constante.
Exemple 1:
add
# équivalent à $v1 ← $v0 + $at
$v1, $v0, $at
Règle syntaxique
On définit ci-dessous les principales règles d’écriture d'un programme source.
Les noms de fichiers
Les noms des fichiers contenant un programme source en langage d’assemblage doivent être suffixé par « .s ». Exemple: monprogramme.s
Les commentaires
Ils commencent par un # et s’achèvent à la fin de la ligne courante.
Exemple 2:
###############################################
# Source Assembleur MIPS de la fonction memcpy
#
###############################################
lw
$t2, 0($t3)
# sauve la valeur copiée dans la mémoire
Les entiers
Une valeur entière décimale est notée 250 (sans préfixe), et une valeur entière hexadécimale est
notée 0xFA (préfixée par zéro suivi de x). En hexadécimal, les lettres de A à F peuvent être écrites
en majuscule ou en minuscule.
Les chaînes de caractères
Elles sont simplement entre guillemets, et peuvent contenir les caractères d’échappement du langage
C. Exemple : "Oh la jolie chaîne avec retour à la ligne\n".
Les labels
Ce sont des mnémoniques correspondant à des adresses en mémoire. Ces adresses peuvent être
soit des adresses de variables stockées en mémoire (principalement dans la section data), soit des
adresses de sauts (principalement dans la section text). Ce sont des chaînes de caractères qui doivent
commencer par une lettre, un caractère « _ », ou un caractère « . ». Lors de la déclaration, ils doivent
être suffixés par le caractère « : ». Pour y référer, on supprime le « : ».
Exemple 3:
message:
.data
.asciiz
"Ceci est une chaîne de caractères...\n"
.text
20
_start:
lui
ori
ori
$a0, message >> 16
$a0, $a0, message & 0xFFFF
$v0, $zero, 4
# adresse de la chaîne dans $a0
# code de l’appel système dans $v0
L'adressage mémoire
Le MIPS ne possède qu’un unique mode d’adressage pour lire ou écrire des données en mémoire:
l’adressage indirect registre avec déplacement. L’adresse est obtenue en additionnant le déplacement
(positif ou négatif) au contenu du registre.
Exemple 4:
lw
sw
$t4, 13($t2)
$s4, -60($s6)
# $t4 ← Mem[$t2 + 13]
# Mem[$s6 - 60] ← $s4
S’il n’y a pas d’entier devant la parenthèse ouvrante, le déplacement est nul. Pour ce qui concerne les
sauts, il faut nécessairement utiliser des labels.
Quelques notations:
Mem[ad] : Contenu de la mémoire d’adresse ad
||
: Concaténation entre deux chaînes de bits
Bn
: Réplication du bit B n fois dans une chaîne de bits
X p..q
: Sélection des bits p à q dans une chaîne de bits X
3. Jeu d’instructions
Le jeu d’instructions est "orienté registres". Cela signifie que les instructions arithmétiques et logiques prennent leurs opérandes dans des registres et rangent le résultat dans un
registre. Les seules instructions permettant de lire ou d’écrire des données en mémoire effectuent un simple transfert entre un registre général et la mémoire, sans aucun traitement arithmétique ou logique. La plupart des instructions arithmétiques et logiques se présentent sous
les 2 formes registre-registre et registre-immédiat:
Add
Addition registre registre signée
Syntaxe:
add
$rr, $ri, $rj
Description :
Les contenus des registres $ri et $rj sont ajoutés pour former un résultat
sur 32 bits qui est placé dans le registre $rr
rr ← ri + rj
Exception: génération d’une exception si dépassement de capacité.
Sub
Soustraction registre registre signée
Syntaxe:
sub
$rr, $ri, $rj
Description :
Le contenu du registre $rj est soustrait du contenu du registre $ri pour
former un résultat sur 32 bits qui est placé dans le registre $rr.
rr ← ri - rj
Exception: génération d’une exception si dépassement de capacité.
Addi
Addition registre immédiat signée
Syntaxe :
addi
$rr, $ri, imm
Description :
La valeur immédiate sur 16 bits subit une extension de signe, et est
ajoutée au contenu du registre $ri pour former un résultat sur 32 bits qui
est placé dans le registre $rr.
21
rr ← (imm 15 16 || imm 15..0 ) + ri
Exception:
Addu
Addition registre registre non-signée
Syntaxe :
addu
$rr, $ri, $rj
Description :
rr ← ri + rj
Exception:
Addiu
pas d’exception
Addition registre immédiat non-signée
Syntaxe :
addiu
$rr, $ri, imm
rr ← (imm 15 16 || imm 15..0 ) + ri
Exception:
Subu
génération d’une exception si dépassement de capacité.
pas d’exception
Soustraction registre registre non-signée
Syntaxe :
subu
$rr, $ri, $rj
Description :
Le contenu du registre $rj est soustrait du contenu du registre $ri
former un résultat sur 32 bits qui est placé dans le registre $rr.
rr ← ri - rj
Exception:
pour
pas d’exception
Exemple 5: Donner l’instruction ou la suite des instructions MIPS pour effectuer les actions suivantes
a) Mettre à zéro le registre R8
Add
$t0, $zero,$zero
b) Mettre 8000H dans le registre R9
Addi
$t1, $zero, 0x8000
c) Mettre 7000H dans le registre R10
Addiu
$t2, $zero, 0x7000
Exemple 5: Programmez en assembleur MIPS la fonction F(X,Y,Z) = X + 2Y -3Z .
On suppose que la variable X se trouve dans le registre $t10, la variable Y dans $t1, la variable Z
dans $t2 et que le résultat de la fonction F(X,Y,Z) se trouve dans le registre $t4.
Add
$t4, $t10, $t1
# F ← X+Y
Add
$t4, $t4, $t1
# F ← F +Y
(i.e. X + 2Y)
Sub
$t4, $t4, $t2
# F ← F - Z
(i.e. X + 2Y - Z)
Sub
$t4, $t4, $t2
# F ← F - Z
(i.e. X + 2Y - 2Z)
Sub
$t4, $t4, $t2
# F ← F - Z
(i.e. X + 2Y - 3Z)
Lw
Lecture d’un mot de la mémoire
Syntaxe :
lw
$rr, imm($ri)
Description :
L’adresse de lecture est la somme de la valeur immédiate sur 16 bits, avec
extension de signe, et du contenu du registre $ri. l’adresse doit être multiple
de 4. Le mot de 32 bits lu à cette adresse est placé dans le registre $rr.
rr ← Mem[imm + ri]
Exceptions: Adresse non alignée sur une frontière de mot.
22
Sw
écriture d’un mot en mémoire
Syntaxe :
sw
$rj, imm($ri)
Description :
L’adresse d’écriture est la somme de la valeur immédiate sur 16 bits, avec
de 4. Le contenu du registre $rj est écrit en mémoire .
Mem[imm + ri] ← rj
Exceptions : - Adresse non alignée sur une frontière de mot.
- Adresse dans le segment noyau alors que le processeur est en mode utilisateur.
- Adresse correspondant à un segment non défini
Lui
Chargement d’une constante dans les poids forts d’un registre
Syntaxe :
lui
$rr, imm
Description :
La constante immédiate de 16 bits est décalée de 16 bits à gauche, et est
complétée de zéro à droite. La valeur sur 32 bits ainsi obtenue est placée
dans le registre $rr.
rr ← imm 15.. 0 || 016
Exception:
pas d’exception
Lh
Lecture d’un demi-mot signé en mémoire
Syntaxe :
lh
$rr, imm($ri)
Description :
L’adresse de lecture est la somme de la valeur immédiate sur 16 bits, avec
de 2. Le demi-mot de 16 bits lu à cette adresse subit une extension de signe
et est placé dans le registre $rr.
rr ← (Mem[imm + ri]) 15 16 || (Mem[imm + ri]) 15..0
Exceptions: - Adresse non alignée sur une frontière de demi-mot.
- Adresse correspondant à un segment non défini.
Lhu
Lecture d’un demi-mot non-signé en mémoire
Syntaxe :
lhu $rr, imm($ri)
Description :
L’adresse de lecture est la somme de la valeur immédiate sur 16 bits,
avec extension de signe, et du contenu du registre $ri. l’adresse doit être
multiple de 2. Le demi-mot de 16 bits lu . cette adresse subit une extension
avec des zéro et est placé dans le registre $rr.
rr ← 016 || (Mem[imm + ri]) 15..0
Lb
Lecture d’un octet signé en mémoire
Syntaxe :
lb
$rr, imm($ri)
Description :
avec extension de signe, et du contenu du registre $ri. L’octet lu . cette
adresse subit une extension de signe et est placé dans le registre $rr.
rr ← (Mem[imm + ri]) 7 24 || (Mem[imm + ri]) 7..0
23
Exceptions:
Lbu
Lecture d’un octet non-signé en mémoire
Syntaxe :
lbu
$rr, imm($ri)
Description :
avec extension de signe, et du contenu du registre $ri. L’octet lu . cette
adresse subit une extension avec des zéros et est placé dans le registre $rr.
rr ← 024 || (Mem[imm + ri]) 7..0
Exceptions : - Adresse dans le segment noyau alors que le processeur est en mode utilisateur.
Sh
Ecriture d’un demi-mot en mémoire
Syntaxe :
sh
$rj, imm($ri)
Description :
L’adresse d’écriture est la somme de la valeur immédiate sur
16 bits, avec extension de signe, et du contenu du registre $ri. l’adresse doit
être multiple de 2. Les deux octets de poids faible du registre $rj sont écrits
à l’adresse ainsi calculée.
Mem[imm + ri] ← rj 15..0
Sb
Ecriture d’un octet en mémoire
Syntaxe :
sb
$rj, imm($ri)
Description :
L’adresse d’écriture est la somme de la valeur immédiate sur 16 bits, avec
extension de signe, et du contenu du registre $ri. L’octet de poids faible du
registre $rj est écrit à l’adresse ainsi calculée.
Mem[imm + ri] ← rj 7..0
Exceptions: - Adresse dans le segment noyau alors que le processeur est en mode utilisateur.
And
ET bit-à-bit registre registre
Syntaxe :
and
$rr, $ri, $rj
Description :
Un ET bit-à-bit est effectué entre les contenus des registres
Le résultat est placé dans le registre $rr.
rr ← ri and rj
Exception :
pas d’exception
Andi
$ri et $rj.
ET bit-à-bit registre immédiat
Syntaxe :
andi
$rr, $ri, imm
Description :
La valeur immédiate sur 16 bits subit une extension de zéros. Un ET
bit-à-bit est effectué entre cette valeur. tendue et le contenu du registre $ri
pour former un résultat placé dans le registre $rr.
rr ← (016 || imm 15..0 ) and ri
Exception:
pas d’exception
24
Idem pour : Or , Ori , Xor, Xori , Nor
La
Chargement d’une adresse dans un registre (c’est une Macro instruction! )
Syntaxe :
la
$rr, adr
Description :
L’adresse considérée comme une quantité non-signée est chargée dans le
registre $rr.
rr ← adr
code équivalent:
lui
$rr, adr >> 16
ori
$rr, $rr, adr & 0xFFFF
Exemple 6: une séquence assembleur MIPS pour calculer
la
lw
la
lw
add
la
sw
Mult
Multu
Div
Divu
Mfhi
$t10, w
$s0, 0($t10)
$t1, y
$s1, 0($t1)
$s2, $s0, $s1
$t2, z
$s2, 0($t2)
#
#
#
#
#
#
#
z = w + y;
put address of w into $t10
put contents of w into $s0
put address of y into $t1
put contents of y into $s1
add w + y, put result in $s2
put address of z into $t2
put contents of $s2 into z
Multiplication signée
Syntaxe :
mult
$ri, $rj
Description :
Le contenu du registre $ri est multiplié par le contenu du registre $rj, le contenu des deux registres étant considéré comme des nombres en complément
à deux. Les 32 bits de poids fort du résultat sont placés dans le registre hi, et
les 32 bits de poids faible dans lo.
et
hi ← (ri x rj) 63..32
lo ← (ri x rj) 31..0
Exception:
pas d’exception.
Multiplication non-signée
Division entière signée
Syntaxe :
div
$ri, $rj
Description :
Le contenu du registre $ri est divisé par le contenu du registre $rj, le contenu des deux registres étant considéré comme des nombres en complément à
deux. Le quotient de la division est placé dans le registre spécial lo, et le
reste dans le registre spécial hi.
lo ← ri div rj
et
hi ← ri mod rj
Exception :
division par 0
Division entière non-signée
Move From HI
Syntaxe :
mfhi
$ri
#
25
$ri ← hi
Mflo
Mthi
Mtlo
Move From LO
Syntaxe :
mflo
$ri
#
$ri ← lo
Move to HI
Syntaxe :
mfti
$ri
#
hi ← $ri
Move to LO
Syntaxe :
mtlo
$ri
#
lo ← $ri
Organisation d’un programme en assembleur
Un programme en assembleur contient obligatoirement une zone d’instructions dont le début est
La première instruction à exécuter (point d’entrée du programme)
repéré par la directive .text.
doit être repérée avec l’étiquette __start: (avec deux underscores).
.text
....
....
__start:
....
....
Si le programme nécessite une zone de données en mémoire, le début de cette zone est repéré par la
D’autres directives sont disponibles pour déclarer et initialiser des variables.
directive .data.
L’ordre des zones instructions et données n’a pas d’importance.
Exemple 7: Un programme qui calcule S = a + b
a:
b:
s:
.data
.word
.word
.word
.text
__start:
la
lw
la
lw
add
la
sw
ori
syscall
(32 bits)
# début de la section données en mémoire
15
20
0
# début de la section instructions (code) en mémoire
$a1, a
$t10, 0($a1)
$a1, b
$t1, 0($a1)
$t4 , $t10 , $t1
$a1, s
$t4 , 0($a1)
# première instruction du programme
# $t10  a
# $t1  b
# $t4  a + b
# s  $t4
$v0, $zero, 10
# appel système N°10
# pour terminer le programme (exit (0))
Exemple 8: Un programme qui calcule S = a* x2 + b * x + c
(32 bits)
S = (a*x + b)*x + c
a:
b:
c:
.data
.word
.word
.word
# début de la section données en mémoire
15
20
30
26
x:
s:
.word
.word
.text
__start:
la
lw
la
lw
la
lw
la
lw
40
0
# début de la section instructions (code) en mémoire
$a1, x
$t10, 0($a1)
$a1, a
$t1, 0($a1)
$a1, b
$t2, 0($a1)
$a1, c
$t3, 0($a1)
mult
mflo
add
mult
mflo
add
la
sw
$t1 ,$t10
$t4
$t4 , $t4 , $t2
$t4 , $t10
$t4
$t4 , $t4 , $t3
$a1, s
$t4 , 0($a1)
ori
$v0, $zero, 10
# première instruction du programme
# $t10  x
# $t1  a
# $t2  b
# $t3  c
# $t4  a* x
# $t4  a* x + b
# $t4  (a* x + b)* x
# $t4  (a *x + b) *x + c
# s  $t4
# appel système N°10 pour terminer le programme (exit
(0))
syscall
Exemple 9: Ecrire un programme qui calcule S = a2 + b2 + c2
(32 bits)
Instructions de branchements:
Beq
Branchement si registre égal registre
Syntaxe :
beq
$ri, $rj, label
Description :
Les contenus des registres $ri et $rj sont comparés. S’ils sont égaux,
le programme saute à l’adresse associée à l’étiquette par l’assembleur.
if (ri = rj) pc ← adresse associée à label
Exception:
pas d’exception
Bne
Branchement si registre différent de registre
Syntaxe :
bne
$ri, $rj, label
Description:
If (ri < > rj ) pc ← adresse associée à label
Bgez
Branchement si registre supérieur ou égal à zéro
Syntaxe :
bgez
$ri, label
Description :
Si le contenu du registre $ri est supérieur ou égal à zéro, le programme
saute à l’adresse associée à l’étiquette par l’assembleur.
if (ri >= 0) pc <= adresse associée à label
Bgtz
Branchement si registre strictement supérieur à zéro
27
Blez
Branchement si registre inférieur ou égal à zéro
Bltz
Branchement si registre strictement inférieur à zéro
J
Jr
Saut inconditionnel immédiat
Syntaxe :
j
label
Description :
Le programme saute inconditionnellement . l’adresse associée à l’étiquette
par l’assembleur.
pc ← adresse associée à label
Branchement inconditionnel registre
Syntaxe :
jr
$ri
Description:
Le programme saute à l’adresse contenue dans le registre $ri ( souvent $ra).
pc ← ri
Exemple 10: Un programme qui calcule la valeur absolue d’un nombre.
Programme C
void main()
{
int x = -5;
int val_abs;
val_ abs = x;
if (x <= 0)
val_abs = -x;
exit(0);
}
Programme assembleur
x:
val_abs :
.data
.word
.word
.text
-5
0
__start :
la
lw
bgtz
sub
$a0, x
$a0, 0($a0)
$a0, suite
$a0, $zero, $a0
suite :
la
$a1, val_abs
sw
$a0, 0($a1)
ori
$v0, $zero, 10
syscall
Exemple 11: Un autre programme.
Programme C
void main()
{
int x = -5;
int val_abs;
if (x <= 0)
val_abs = -x;
else
val_abs = x;
exit(0);
}
x:
val_abs :
.data
.word
.word
.text
-5
0
__start :
la
lw
bgtz
sub
j
$a0, x
$a0, 0($a0)
$a0, vrai
$a0, $zero, $a0
suite
add
$a0, $a0, $zero
vrai :
suite :
la
$a1, val_abs
sw
$a0, 0($a1)
ori
$v0, $zero, 10
syscall
28
Exemple 12:
coder strlen (fonction longueur d’une chaîne) en assembleur .
Données :
- $a1 : pointeur sur la chaine
- $v1 : compteur
- $v0 : valeur de retour
Programme C
strlen:
int strlen(char *s )
{
int
i = 0;
while (*s != 0)
{
i ++ ;
s ++ ;
}
return( i ) ;
}
addi
$v1, $zero, 0
# $v1 = 0
lb
beq
addi
addi
J
$a2, 0 ($a1)
$a2, $zero, end
$v1, $v1, 1
$a1, $a1, 1
loop
# $v1 = $v1 + 1
add
Jr
$v0, $v1, $zero
$ra
loop:
end:
# Retour Fonction
Exemple 13: un programme qui passe une chaîne de caractères en majuscules. On utilise un ET
logique pour masquer le bit 5 du caractère et le passer en majuscule (voir le code ASCII).
Données :
- $a1 : pointeur sur la chaine
Programme C
char *maj(char *s )
{
char *c ;
c=s;
while (*s != ‘\0’)
{
*s = *s & 0xDF;
s++ ;
}
return(c) ;
maj:
addi
$v1, $a1, 0
lb
beq
andi
sb
addi
J
$a2, 0 ($v1)
$a2, $zero, end
$a2, $a2, 0xDF
$a2, 0($v1)
$v1, $v1, 1
loop
Jr
$ra
#
$v1 = $a1
loop:
# $a2 = $a2 and 11011111b
end:
}
# Retour Fonction
Exemple 14: Calcul PGCD(a, b)
pgcd(0, b)
pgcd(a, b)
= b
= pgcd(|a-b|, min(a,b) )
si a = 0
(pour a # b)
pgcd( 105, 75)= pgcd( 30, 75) = pgcd( 30, 45) = pgcd( 30, 15) = pgcd( 15, 15) = pgcd( 0, 15) =15
Données :
- $a0 : valeur de a
- $a1 : valeur de b
- $v1 : valeur de retour
29
Programme C
int pgcd(int a, int b )
{
while (a)
if (a < b)
b = b-a;
else
a = a-b;
return( b) ;
}
pgcd :
while :
beq
sub
bgez
sub
j
else :
sub
endif :
j
endwhile :
add
Jr
$a0, $zero, endwihe
$t10, $a0 , $a1
$t10, else
$a1, $a1 , $a0
endif
$a0, $a0 , $a1
while
$v0,$a1, 0
$ra
# Retour Fonction
Instructions de décalages:
Sll
Décalage à gauche immédiat
Syntaxe :
sll
$rr, $ri, imm
Description :
Le registre est décalé à gauche de la valeur immédiate codée sur 5 bits, des zéros étant introduits dans les bits de poids faibles. Le résultat est placé dans le
registre $rr.
rr ← ri (31 - imm)..0 || 0imm
Exception: pas d’exception.
Srl
Décalage à droite logique immédiat
Syntaxe :
srl
$rr, $ri, imm
Description :
Le registre est décalé à droite de la valeur immédiate codée sur 5 bits, des zéros
étant introduits dans les bits de poids fort.
rr ← 0imm || ri 31..imm
Sllv
Décalage à gauche registre
Syntaxe :
sllv
$rr, $ri, $rj
Description :
Le registre $ri est décalé à gauche du nombre de bits spécifiés dans les 5 bits de
poids faible du registre $rj, des zéros étant introduits dans les bits de poids
faibles. Le résultat est placé dans le registre $rr.
rr ← ri (31 - rj)..0 || 0rj
Srlv
Décalage à droite logique registre
Syntaxe :
srlv
$rr, $ri, $rj
Description :
Le registre $ri est décalé à droite du nombre de bits spécifié dans les 5 bits de
poids faible du registre $rj des zéros étant introduits dans les bits de poids fort
ainsi libérés. Le résultat est placé dans le registre $rr .
rr ← 0 rj || ri 31.. rj
30
Sra
Décalage à droite arithmétique immédiat
Syntaxe :
sra
$rr, $ri, imm
Description :
Le registre $ri est décalé à droite de la valeur immédiate codée sur 5 bits, le bit
de signe du registre $ri étant introduit dans les bits de poids fort. Le résultat est
placé dans le registre .
rr ← (ri 31 ) imm || (ri) 31..imm
Srav
Décalage à droite arithmétique registre
Syntaxe :
srav
$rr, $ri, $rj
Description :
Le registre $ri est décalé à droite du nombre de bits spécifié dans les 5 bits de
poids faible du registre $rj, le bit de signe de $ri étant introduit dans les bits de
poids fort. Le résultat est placé dans le registre $rr.
rr ← (ri 31 ) rj || (ri) 31..rj
Exemple 15: Calculer le nombre de 1 dans un mots de 32 bits
Données :
- $a1 : valeur du mot
- $a0 : valeur de retour
Programme C
int nb_un(long int a)
{
int i = 0 ;
unsigned long int masque = 0x80000000;
do {
if (a & masque)
i++ ;
masque = masque >> 1 ;
}
while (masque != 0) ;
return( i ) ;
nb_un :
ori
ori
do :
and
beq
addi
finsi:
srl
bne
Jr
$a0, $zero, 0
$a2, $zero, 0x80000000
$a3, $a1, $a2
$a3, $zero, finsi
$a0, $a0,1
$a2, $a2, 1
$a2, $zero , do
$ra
# Retour Fonction
}
Syscall
Appel à une fonction du système (en mode noyau).
Syntaxe
syscall
Description
Un appel système est effectué, transférant immédiatement, et inconditionnellement le contrôle au gestionnaire d’exception. Note : par convention, le numéro
de l’appel système, c.-à-d. le code de la fonction système à effectuer, est placé
dans le registre $v0.
Pc ← 0x80000080
Exception
Déclenchement d’une exception de type appel système.
31
Break
Arrêt et saut à la routine d’exception
Syntaxe
break
imm
Description
Un point d’arrêt est détecté, et le programme saute à l’adresse de la routine de
gestion des exceptions.
Pc ← 0x80000080
Exception
Déclenchement d’une exception de type point d’arrêt.
Appels système
Pour exécuter certaines fonctions système, typiquement les entrées/sorties (lire ou écrire un
nombre, ou un caractère), il faut utiliser des appels système. Par convention, le numéro de l’appel
système est contenu dans le registre $v0, et son unique argument dans le registre $a0.
Cinq appels système sont actuellement supportés dans l’environnement de simulation :
 écrire un entier :
Il faut mettre l’entier à écrire dans le registre $a0 et exécuter l’appel système numéro 1.
Typiquement, on aura :
ori
$a0, 123
ori
$v0, $zero, 1
syscall
# met 123 dans l’argument
# code de ’print_int’
# affiche 123
 lire un entier :
La valeur de retour d’une fonction — système ou autre — est positionnée dans le registre $v0. Ainsi,
lire un entier consiste à exécuter l’appel système numéro 5 et récupérer le résultat dans le registre
$v0.
ori
$v0, $zero, 5
syscall
# code de ’read_integer’
# $v0 contient ce qui a été lu
 écrire une chaîne de caractères :
Une chaîne de caractères étant identifiée par un pointeur, il faut passer ce pointeur à l’appel système numéro 4 pour l’afficher.
str:
.asciiz
"Chaîne à afficher\n"
…
la
ori
syscall
$a0, str
$v0, $zero, 4
# charge le pointeur dans $a0
# code de ’print_string’
# affiche la chaine pointée
 lire une chaîne de caractères :
Pour lire une chaîne de caractères, il faut un pointeur et une longueur maximum. Il faut passer ce
pointeur, dans $a0, et cette longueur, dans $a1, et exécuter l’appel système numéro 8. Le résultat
sera mis dans l’espace pointé.
32
read_str:
.space
la
ori
ori
syscall
256
$a0, read_str
$a1, $zero, 255
$v0, $zero, 8
#
#
#
#
charge le pointeur dans $a0
charge longueur max dans $a1
code de ’read_string’
lit la chaîne
 quitter :
L’appel système numéro 10 effectue l’exit du programme au sens du langage C.
ori
syscall
$v0, $zero, 10
# indique l’appel à exit
# quitte pour de bon!
Exemple 16:
Programme C
main()
{
s1 :
s2 :
int n ;
printf("Donner un entier\n");
.data
.asciiz
"Donner un entier\n"
.asciiz
"L’entier est "
.text
main :
la
ori
syscall
ori
syscall
add
la
ori
syscall
add
ori
syscall
ori
syscall
scanf("%d", &n);
printf("L’entier est %d\n", n);
exit(0);
}
33
$a0, s1
$v0, $zero, 4
$v0, $zero, 5
$a1, $v0, $zero
$a0, s2
$v0, $zero, 4
$a0, $a1, $zero
$v0, $zero, 1
$v0, $zero, 10
Catégorie
Arithmétique
Instruction
Signification
add
soustraction
sub
$1,$2,$3
$1 = $2 - $3
addition immédiate
addi
$1,$2,100
$1 = $2 + 100
Addition non signée
addu
$1,$2,$3
$1 = $2 + $3
Soustraction non signée
subu
add immédiat non signée
addiu $1,$2,100
$1 = $2 + 100
Multiply signed
Mult
LO = ($1 *$2) 31..0 HI =($1 *$2) 63..32
Multiply unsigned
Multu
$1,$2,$3
$1,$2,$3
$1 , $2
$1 , $2
$1 = $2 + $3
$1 = $2 - $3
LO = ($1 *$2) 31..0 HI =($1 *$2) 63..32
Divide signed
Div
Divide unsigned
Divu
$1 , $2
L0 = Quotient , HI = reste
Move from coprocessor register
mfc0
$1,$epc
$1 = $epc
and
and
$1,$2,$3
$1 = $2 & $3
and immediate
$1 , $2
or
$1,$2,$3
$1 = $2 | $3
andi
$1,$2,100
$1 = $2 & 100
or immediate
ori
$1,$2,100
$1 = $2 | 100
xor
xor
$1,$2,$3
$1 = $2 ⊕ $3
xor immediate
nor
Décalages
Exemple
addition
or
Logique
xori $1,$2,100
$1 = $2 ⊕ 100
nor $1,$2,$3
$1 = $2 nor $3
shift left logical variable
sllv
$1, $2, $3
$1 = $2 << $3
shift right logical variable
srlv
$1, $2, $3
$1 = $2 >> $3
shift right arithmetical variable
srav
$1, $2, $3
$1 = $2 >>* $3
shift left logical
sll
$1,$2,10
$1 = $2 << 10
shift right logical
srl
$1,$2,10
$1 = $2 >> 10
shift right arithmetical
sra
34
$1, $2, 10
$1 = $2 >>* 10
load word
lw
$1,(100)$2
$1 = Memory[$2+100]
store word
sw
$1,(100)$2
Memory[$2+100] = $1
load half word signed
lh
$1,(100)$2
$1 = Memory[$2+100]
lhu $1,(100)$2
$1 = Memory[$2+100]
store half word
sh
$1,(100)$2
Memory[$2+100] = $1
load byte signed
lb
$1,(100)$2
$1 = Memory[$2+100]
load byte unsigned
lb
$1,(100)$2
$1 = Memory[$2+100]
store byte
sb
$1,(100)$2
Memory[$2+100] = $1
load half word unsigned
transfert
branchements
Conditionnels
Move from HI
mfhi
$1
$1 = HI
Move from LO
mflo
$1
$1 = LO
Move to HI
mthi
$1
HI = $1
Move to LO
mtlo
$1
LO = $1
$1 = 100 * 216
load upper immediate
lui
branch on equal
beq
$1,$2, label
if ($1 == $2) go to label
branch on not equal
bne
$1,$2, label
if ($1 != $2) go to label
$1,100
Branch if greater or equal zero
bgez $1, label
if ($1 >= 0 ) go to label
Branch if greater than zero
bgtz $1, label
if ($1 > 0 ) go to label
Branch if less or equal zero
blez
if ($1 <= 0 ) go to label
Branch if less than zero
bltz
$1, label
$1, label
if ($1 < 0 ) go to label
Branch if greater or equal zero and
link
bgezal
$1, label
$ra = PC + 4;
Branch if less than zero and link
gltzal
$1, label
$ra = PC + 4;
jump
branchements
inconditionnel
j
label
goto lable
jump and link
jal
label
$ra = PC + 4; go to label
jump register
jr
$ra
PC = $ra
set on less than
slt
$1,$2,$3
if ($2 < $3) $1 = 1; else $1 = 0
set less than immediate
slti
$1,$2,100
if ($2 < 100) $1 = 1; else $1 = 0
set less than unsigned
set less than immediate unsigned
( i.e. return)
sltu $1,$2,$3
if ($2 < $3) $1 = 1; else $1 = 0
sltiu $1,$2,100
if ($2 < 100) $1 = 1; else $1 = 0
35
4. Directives supportées par l’assembleur MIPS
Les directives ne sont pas des instructions exécutables par la machine, mais permettent de donner
des ordres à l’assembleur. Toutes les pseudo-instruction commencent par le caractère << . >> ce qui
permet de les différencier clairement des instructions.
4.1 Déclaration des sections : text, data et stack
Six directives permettent de spécifier quelle section de la mémoire est concernée par les instructions, macro-instructions ou directives qui les suivent. Sur ces six directives, deux sont dynamiquement gérées à l’exécution : ce sont celles qui concernent la pile utilisateur, stack, et la pile système,
kstack. Ceci signifie que l’assembleur gère quatre compteurs d’adresse indépendants correspondants
aux quatre sections text, data, ktext et kdata.






.text
.data
.stack
.ktext
.kdata
.kstack
Passage dans la section text dans le segment utilisateur.
Passage dans la section data dans le segment utilisateur.
Passage dans la section stack dans le segment utilisateur.
Passage dans la section text dans le segment noyau.
Passage dans la section data dans le segment noyau.
Passage dans la section stack dans le segment noyau.
4.2 Déclaration et initialisation de variables
Les directives suivantes permettent de d’initialiser certaines zones dans les sections text ou data de
la mémoire.
 .word
Positionne des mots successifs aux valeurs des expressions.
.word
expression, [expression,] : : :
La valeur de chaque expression est placée dans des adresses successives de la section active.
Exemple 17
entiers:
.word
 .half
-1, -1000, -100000, 1, 1000, 100000
Positionne des demi-mots successifs aux valeurs des expressions.
.half
La valeur de chacune des expressions est tronquée à 16 bits, et les valeurs ainsi obtenues sont
placées dans des adresses successives de la section active.
Exemple 18
coordonnées:
.half
 .byte
.byte
0 , 1024
Positionne des octets successifs aux valeurs des expressions.
La valeur de chacune des expressions est tronquée à 8 bits, et les valeurs ainsi obtenues sont placées à des adresses successives de la section active.
Exemple 19
table:
.byte
 .align
1, 2, 4, 8, 16, 32, 64, 32, 16, 8, 4, 2, 1
expression
36
Aligne le compteur d’adresse courant afin que expression bits de poids faible soient à zéro.
.align
n
Cet opérateur aligne le compteur d’adresse sur une adresse telle que les n bits de poids faible soient à
zéro. Cette opération est effectuée implicitement pour aligner correctement les instructions, demimots et mots.
Exemple 22
.align 2
.byte 12
.align 2
.byte 24
 .ascii
.ascii
Déclare et initialise une chaîne de caractères
chaîne, [chaîne,] : : :
Cet opérateur place à partir de l’adresse du compteur d’adresse correspondant à la section active
la suite de caractères entre guillemets. S’il y a plusieurs chaînes, elles sont placées à la suite. Cette
chaîne peut contenir des séquences d’échappement du langage C, et doit être terminée par un zéro
binaire si elle est utilisé avec un appel système.
Exemple 20
message:
.ascii
 .asciiz
.asciiz
"Bonjour, Maître!\n\0"
Déclare et initialise une chaîne de caractères, en ajoutant un zéro binaire à la fin.
chaîne, [chaîne,] : : :
Cet opérateur est strictement identique au précédent, la seule différence étant qu’il ajoute un zéro
binaire à la fin de chaque chaîne.
Exemple 21
message:
.asciiz
 .space
.space
"Bonjour, Maître!\n"
Reserve expression octets, et les mets à zéro
expression
Un espace de taille expression octets est réservé à partir de l’adresse courante de la section active.
Exemple 22
nuls:
.space
1024
# initialise 1 kilo de mémoire à zéro
Tableaux
•
•
•
•
Zone mémoire dans laquelle les données sont rangées les unes à la suite des autres
Repéré par l’adresse du premier élément
On accède aux différentes case par déplacement par rapport à la première
Déclaration d’un tableau d’entiers de 32 bits
int tab[5] = {3, 6, 8, 9, 2};
.data
T:
37
.word
3, 6, 8, 9, 2
Exemple 23 :
Programme C
void main()
{
int i = 5;
int tab[5] = {3,6,8,9,2};
int somme = 0;
do
somme += tab[ --i ];
while ( i ) ;
printf(" %d ",somme);
exit(0);
}
$a0 ≡ somme ;
$a1 ≡ i
;
$a2 ≡ tab ;
.data
tab :
.word
3, 6, 8, 9, 2
.text
main :
ori
$a0, $zero, 0
ori
$a1, $zero, 5
la
$a2, tab
bcl:
lw
$a3, 0($a2)
add
$a0, $a0, $a3
addui
$a2, $a2, 4
addui
$a1, $a1, -1
bne
$a1, $zero, bcl
ori
$v0, $zero, 1
syscall
ori
$v0, $zero, 10
syscall
38
#somme
#taille
CHAP III
La programmation structurée
CHAP III : La programmation structurée
1. La Pile
Quand un programme commence à s'exécuter, une certaine section contiguë de mémoire est mise de
côté pour le programme appelé la pile. Pendant que le programme fonctionne, la pile se développe
en bas dans l'espace disponible, alors que le segment de données se développe vers le haut pendant
que le programme fonctionne. Naturellement, dans un programme dynamique, les segments se développent et se rétrécissent. Si la taille combinée des segments excède l'espace disponible leurs frontières se réuniront quelque part au milieu de la gamme. Quand ceci se produit il n'y a plus aucune
mémoire.
32 bits
…
Adresses
Croissantes
$sp - 8
$sp - 4
$sp
Libre
Libre
Push
Pop
Tout au début le registre de pile $sp est initialisé à 0x7FFF0000 (l'adresse juste au-dessus du segment .stack).
Push (empiler)
Pour notre pile de données 4-octets, ajouter un article signifie soustraire quatre de $sp et stocker l'article dans cette adresse. Cette opération s'appelle : empiler
Exemple : Empiler le contenu du registre $t0
subu
sw
$sp, $sp, 4
$t0, ($sp)
# Mettre à jour $sp ,
# ranger $t0 au sommet de la pile .
Pop (dépiler)
Enlever un article d'une pile s'appelle dépiler. Dépiler un article signifie qu'il est copié à un
autre endroit et que l'indicateur de pile est ajusté.
Exemple : dépiler le sommet dans $t0
lw
addu
$t0, ($sp)
$sp, $sp,4
# Copie le sommet dans $t0.
# $sp adresse l’élément avant .
39
2. Les Appels de Fonctions
L’exécution de fonctions nécessite une pile en mémoire. Cette pile correspond . la section stack.
L’utilisation de cette pile fait l’objet de conventions qui doivent être respectées par la fonction appelée et par la fonction appelante.
•
•
•
•
•
•
La pile s’étend vers les adresses décroissantes .
Le pointeur de pile pointe toujours sur le dernier mot occupée dans la pile. Ceci signifie que
tous les mots d’adresse inférieure au pointeur de pile sont libres.
Le R3000 ne possède pas d’instructions spécifiques . la gestion de la pile. On utilise les instructions lw et sw pour y accéder.
Les appels de fonction utilisent un pointeur particulier, appel. pointeur de pile. Ce pointeur
est stock. conventionnellement dans le registre $sp.
La valeur de retour d’une fonction est conventionnellement écrite, dans le registre $v0, par la
fonction appelée.
Par ailleurs, l’architecture matérielle du processeur MIPS R3000 impose l’utilisation du registre $ra pour stocker l’adresse de retour lors d’un appel de fonction.
A chaque appel de fonction est associée une zone dans la pile constituant le « contexte
d’exécution » de la fonction. Dans le cas des fonctions récursives, une même fonction peut être appelée plusieurs fois et possédera donc plusieurs contextes d’exécution dans la pile. Lors de l’entrée
dans une fonction, les registres $t0 . $k0 sont disponibles pour tout calcul dans cette fonction ; mais
le contenu des registres utilisés doit être sauvegardé et restauré avant le retour au programme appelant. Dans le cas général, un contexte d’exécution d’une fonction est constitué de trois zones qui sont,
dans l’ordre d’empilement:
•
La zone des arguments de la fonction appelée
Les valeurs des arguments sont écrites dans la pile par la fonction appelante et lues dans la pile par la
fonction appelée. Dans la suite de ce document, on note na le nombre d’arguments, et on considère
que tous les arguments sont représentés par des mots de 32 bits. Par convention, on place toujours le
premier argument de la fonction appelée à l’adresse la plus petite dans la zone des arguments.
•
La zone de sauvegarde des registres
La fonction appelée est chargée de sauvegarder le registre $ra, ainsi que les registres de travail
qu’elle utilise de façon à pouvoir restaurer la valeur de ces registres avant de rendre la main à la
fonction appelante. Dans la suite de ce document, on note nr le nombre de registres sauvegardés en
plus du registre $ra. Seuls les registres d’indice supérieur à 7 doivent être sauvegardés (s’ils sont utilisés).
Le registre $ra contenant l’adresse de retour est toujours sauvegardée à l’adresse la plus grande de la
zone de sauvegarde.
•
La zone des variables locales de la fonction appelée.
Les valeurs stockées dans cette zone ne sont en principe lues et écrites que par la fonction appelée.
Elle est utilisée pour stocker les variables et structures de données locales à la fonction. Dans la suite
de ce document, on note nv le nombre de mots de 32 bits constituant la zone des variables locales.
3. Organisation de la pile
Dans le cas général, une fonction f souhaite appeler une fonction g. La fonction g possède des arguments, utilise des registres et possède des variables locales.
La fonction f appelante doit effectuer la séquence suivante :
40
•
•
•
•
décrémenter le pointeur de pile : $sp ← $sp - 4*na, de façon à réserver la place dans la
pile pour les arguments.
écrire dans la pile les valeurs des na arguments de la fonction g, en mettant le premier argument à l’adresse pointée par $sp, le deuxième à $sp +4, etc...
effectuer le branchement . la première instruction de la fonction appelée en utilisant une instruction de type jal ou bgezal.
incrémenter le pointeur de pile pour restaurer la valeur qu’il avait avant l’appel de la fonction
g:
$sp ← $sp + 4*na
La fonction g appelée est découpée en trois parties. La première partie est le prologue, qui commence par décrémenter le pointeur de pile de façon à réserver la place pour la sauvegarde du registre
$ra et des registres qui seront utilisés par g, ainsi que la place nécessaire aux variables locales de g.
Le prologue sauvegarde ensuite dans la pile : la valeur du registre $ra et les valeurs des registres qui
seront utilisés par g.
La deuxième partie est le corps de la fonction qui effectue les calculs, en utilisant les registres nécessaires ainsi que les variables locales stockées dans la pile, puis écrit la valeur de retour dans le registre $v0.
La troisième partie est l’épilogue chargé de : restaurer les valeurs des registres sauvegardés dans la
pile, d’incrémenter le pointeur de pile pour lui redonner la valeur qu’il avait en entrant dans la fonction g.
Le prologue de la fonction g doit effectuer la séquence suivante:
•
•
•
décrémenter le pointeur de pile: $sp ← $sp - 4*(nv + nr + 1)
écrire successivement dans la pile suivant les adresses décroissantes la valeur du registres $ra
et des nr registres qui seront utilisés par le corps de la fonction.
lire dans la pile les arguments de la fonction g et les stocker dans les registres utilisés par le
corps de la fonction g.
L’épilogue de la fonction g doit effectuer la séquence suivante:
•
•
•
lire dans la pile les valeurs des (nr +1) registres sauvegardés (dont le registre $ra) et restaurer
les valeurs qu’avaient les registres avant l’appel de la fonction g.
incrémenter le pointeur de pile : $sp ← $sp + 4*(nv + nr + 1)
effectuer un branchement . l’adresse de retour contenue dans le registre $ra
On note R(i) les registres utilisés par la fonction appelée, qui doivent être sauvegardés.
On note A(i) les registres utilisés dans l’appelant pour stocker les arguments.
On note P(i) les registres utilisés dans l’appelé pour la récupération des arguments.
On note v(i) les variables locales déclarées dans la fonction appelée
41
Organisation de la pile
Zone des arguments
Zone de sauvegarde des registres
Zone des variables locales
A(na-1)
…
A(1)
A(0)
$ra
R(0)
R(1)
…
R(nr-1)
V(0)
V(1)
…
V(nv-1)
• A(i) : ième argument
• R(i) : ième registre
• V(i) : ième variable locale
• na: nombre d’arguments
• nr: nombre de registres
• nv: nombre de variables locales
adresse décroissante
4. Exécution des appels :
4.1.
Fonction appelante
Met les arguments dans la pile avant de se brancher à la première instruction de la fonction
appelée, pour cela elle doit :
a) Décrémenter le pointeur de pile selon le nombre d’arguments :
$sp ← $sp - 4 * na
b) Ecrire dans la pile les arguments en les empilant ($sp, $sp+4…)
c) Se brancher à la première instruction de la fonction appelée (jal ou bgezal)
d) Incrémenter le pointeur de pile pour revenir à sa valeur initial ($sp + 4 * na)
e) Le résultat de la fonction se trouve dans le registre $v0
4.2.
Fonction appelée :
Au lancement de la fonction, celle-ci doit mettre dans la pile les registres à sauvegarder et les
variables locales (Prologue).
 Prologue
a) Décrémenter le pointeur de pile selon le nombre de registres à sauvegarder et le
nombre de variables locales : $sp ← $sp - 4 * (nv + nr + 1)
b) Ecrire dans la pile la valeur du registre $ra et des autres registres à sauvegarder, ainsi
que les variables locales
c) Lire dans la pile les arguments et les stocker dans des registres généraux
Pour terminer, la fonction appelée restaure les valeurs des registres sauvegardés et revient à la
fonction appelante (Epilogue).
42
 Epilogue
a) Restaurer les valeurs des registres sauvegardés
b) Incrémenter le pointeur de pile pour revenir à sa valeur initiale lors du branchement à
la fonction
c) Se brancher à l’instruction suivante de la fonction appelante
Exemple 1:
Programme C
int val_abs(int n)
{
if (n < 0)
return -n;
else
return n;
}
main()
{
printf("%x",
val_abs(-5));
exit(0);
}
.stack
.text
main :
ori
addiu
sw
jal
addiu
or
ori
syscall
ori
syscall
val_abs:
addiu
sw
$a0, $zero, -5
sw
$sp, $sp, -4
lw
$a0, 0($sp)
add
bgez
val_abs
$sp, $sp, 4
sub
$a0, $v0, $zero suite :
$v0, $zero, 1
lw
lw
$v0, $zero, 10
addiu
jr
4
$sp, $sp, -8
$ra, 4($sp)
$a0, 0($sp)
$a0, 8($sp)
$v0, $a0, $zero
$a0, suite
$v0, $zero, $a0
$ra, 4($sp)
$a0, 0($sp)
$sp, $sp, 8
$ra
5. Les arguments
 Passage par valeur
1) Les arguments sont recopiés dans la pile
a) Les arguments ne sont modifiés que dans la pile
b) Toute modification dans la pile n’a aucune implication pour la fonction appelante
c) S’il y a beaucoup d’arguments, il faut beaucoup de place dans la pile
2) Une seule valeur de retour dans le registre $v0. Impossibilité de retourner plusieurs valeurs
 Passage par adresse
1) Ce n’est plus la valeur de l’argument qui est placé dans la pile, mais son adresse
a) on modifie directement la valeur de la case mémoire
b) Les arguments doivent être déclarés dans la section .data
2) Toute modification de la valeur de la case mémoire est irréversible
43
Exemple 2:
Programme C
void echange (int * a,
int * b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
main()
{
int a = 8, b = 5;
echange(&a, &b);
printf("%d %d",a, b);
exit(0);
}
.data
echange:
var1 :
.word
8
addiu
var2 :
.word
5
sw
.stack
4
sw
.text
sw
main :
sw
la
$a0, var1
sw
la
$a1, var2
lw
addiu
$sp, $sp, -8
lw
sw
$a0, 0($sp)
lw
sw
$a1, 4($sp)
lw
sw
jal
echange
addiu
$sp, $sp, 8
sw
lw
$a0, 0($a0)
lw
ori
$v0, $zero, 1
lw
syscall
lw
lw
$a0, 0($a1)
lw
ori
$v0, $zero, 1
lw
syscall
addiu
ori
$v0, $zero,
jr
10
syscall
$sp, $sp, -20
$ra, 16($sp)
$a0, 12($sp)
$a1, 8($sp)
$a2, 4($sp)
$a3, 0($sp)
$a0, 20($sp)
$a1, 24($sp)
$a2, 0($a0)
$a3, 0($a1)
$a3, 0($a0)
$a2, 0($a1)
$ra, 16($sp)
$a0, 12($sp)
$a1, 8($sp)
$a2, 4($sp)
$a3, 0($sp)
$sp, $sp, 20
$ra
Exemple 3 : fonctions récursives
factorial:
bgtz
int fact ( int n )
ori
{
jr
if ( n <= 0 ) return (1) ; doit:
return ( n * fact (n − 1) );
subi
};
sw
sw
 n dans $a0
$a0, doit
$v0, $zero, 1
$ra
# cas
0! = 1
$sp, $sp, 8
$s0, ($sp)
$ra, 4($sp)
#
#
# adresse
ori
subi
jal
mult
mflo
$s0, $a0 ,0
$a0, $a0, 1
factorial
$v0,$s0
$v0
#
#
#
#
lw
lw
addi
jr
$s0, ($sp)
$ra, 4($sp)
$sp, $sp, 8
$ra
# restaurer les registres
44
sauver l’argument
n-1
$v0 = (n-1)!
n*(n-1)!
CHAP IV
CHAP IV : Conception du jeu d’instruction
Conception du jeu d'instructions
d'un processeur
Un jeu d'instructions n'est pas construit par hasard. Il y a 2 règles à connaître :
 Mix : Ensemble de statistiques sur la fréquence d'utilisation des instructions. Les Mix permettent aux concepteurs de processeur de savoir quels instructions doivent être implémentée et
lesquelles peuvent être évitées (et réalisée avec plusieurs instructions).
 Amdhal Rule : Le gain réel dépend du coût de la mise en place de l'instruction dans le processeur:
Gain réel = Gain x Fréquence d'utilisation
Il y a 2 caractéristiques qui font qu'un processeur est performant :
 nombre de cycles par instruction (CPI ou CPIu (utiles))
 Fréquence d'horloge F
Performance : P = F / CPI
But du processeur MIPS : CPI = 1
Raisons du choix d'une instruction :
 les opcodes coûtent cher
 beaucoup d'instructions sont inutiles car remplaçables par d'autres
 MIX et la loi d'Amhdal définissent quelles sont les instructions à inclure dans le processeur.
1. Les instructions
Il y a 57 instructions, de 3 types différents :
 R : Register to Register – Register Type
 I : Accès mémoire, branchements – Immediate Type
 J : Instructions de sauts (non-conditionnels) : Jump Type
Toutes les instructions ont une longueur de 32 bits et possèdent un des
trois formats suivants :
OPCOD: numéro de l'instruction
SH: Shift Amount : spécifie le
nombre de décalage
•
•
•
RS : Source
RT : Alternatif
RD : Destination
 Le format R est utilisé par les instructions nécessitant 2 registres sources (désignés par RS et
RT) et un registre résultat désigné par RD.
Exemple: add
R3, R4, R5
On aurait R3 dans RD,
R4 dans RS,
R5 dans RT.
 Le format I est utilisé par les instructions de lecture/écriture mémoire, par les instructions utilisant un opérande immédiat, ainsi que par les branchements courte distance (conditionnels).
45
Exemple :
addi R4, R3, 8
On aurait R4 dans RD,
R3 dans RS, et 8 dans IMD16.
 Le format J n’est utilisé que pour les branchements à longue distance (inconditionnels).
Exemple :
J
immed
2. Codage des instructions
Le codage des instructions est principalement défini par les 6 bits du champs code opération de
l'instruction (INS 31:26). Cependant, trois valeurs particulières de ce champ définissent en fait une
famille d'instructions: il faut alors analyser d'autres bits de l'instruction pour décoder l'instruction.
Ces codes particuliers sont:
SPECIAL (valeur "000000"), BCOND (valeur "000001") et COPRO (valeur "010000")
DECODAGE OPCOD
000
001
000 SPECIAL BCOND
010
J
011
JAL
100
BEQ
101
BNE
110
BLEZ
111
BGTZ
001
ADDI
SLTI
SLTIU
ANDI
ORI
XORI
LUI
010
COPRO
LBU
LHU
ADDIU
011
100
LB
LH
LW
101
SB
SH
SW
110
111
Ce tableau exprime que l'instruction LHU (par exemple) possède le code opération "100101".
Lorsque le code opération a la valeur SPECIAL ("000000"), il faut analyser les 6 bits de poids faible
de l'instruction (INS 5:0)
OPCOD = SPECIAL
001
000
000
SLL
001
JR
JALR
010
MFHI
MTHI
MFLO
MTLO
011
MULT
MULTU
DIV
DIVU
100
ADD
ADDU
SUB
SUBU
SLT
SLTU
101
010
SRL
011
SRA
100
SLLV
101
SYSCALL
BREAK
AND
OR
110
SRLV
111
SRAV
XOR
NOR
110
111
Lorsque le code opération a la valeur BCOND, il faut analyser les bits 20 et 16 de l'instruction. Lorsque le code opération a la valeur COPRO, il faut analyser les bits 25 et 23 de l'instruction. Les trois
instructions de cette famille COPRO sont des instructions privilégiées.
46
3. Jeu d'instructions
Le jeu d'instructions est "orienté registres". Cela signifie que les instructions arithmétiques et logiques prennent leurs opérandes dans des registres et rangent le résultat dans un registre. Les seules
instructions permettant de lire ou d'écrire des données en mémoire effectuent un simple transfert
entre un registre général et la mémoire, sans aucun traitement arithmétique ou logique.
La plupart des instructions arithmétiques et logiques se présentent sous les 2 formes registre-registre
et registre-immédiat:
 ADD : rd ← rs op rt
 ADDI : rd ← rs op IMD
format R
format I
L’opérande immédiat 16 bits est signé pour les opérations arithmétiques et non signé pour les opérations logiques.
Le déplacement est de 16 bits pour les instructions de branchement conditionnelles (Bxxx) et de 26
bits pour les instructions de saut inconditionnelles (Jxxx). De plus les instructions JAL, JALR,
BGEZAL, et BLTZAL sauvegardent une adresse de retour dans le registre R31. Ces instructions sont
utilisées pour les appels de sous programme.
Toutes les instructions de branchement conditionnel sont relatives au compteur ordinal pour que le
code soit translatable. L'adresse de saut est le résultat d'une addition entre la valeur du compteur ordinal et un déplacement signé.
Les instructions MTC0 et MFC0 permettent de transférer le contenu des registres SR, CR, EPC et
BAR vers un registre général et inversement. Ces 2 instructions ne peuvent être exécutées qu’en
mode superviseur, de même que l'instruction RFE qui permet de restaurer l'état antérieur du registre
d'état avant de sortir du gestionnaire d'exceptions.
Exercice 1 :
Codez sous forme de hexadécimale les instructions MIPS suivantes :
sltiu $v0, $s7, -1
nor $t4, $v0, $v0
sb
$a3, 12($s0)
Exercice 2 :
Donner la forme mnémonique assembleur des mots suivants représentés en hexadécimal :
0x31C90002
0x8C450048
0x00513021
0x00121103
47
31
25
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
RS
RS
RS
RS
RS
1
1
1
1
RS
RS
RS
RS
15
RD
RD
RD
RD
RD
RD
0
0
RD
numéro
numéro
0
RD
RS
0
0
RD
RS
0
RS RT
RS RT
RS RT
RS RT
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
RS RT RD
2
3
4
5
6
7
20
10
RT
RT
RT
RT
RT
RT
0
1
16
17
5
SA
SA
SA
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
offset
offset
offset
offset
Adresse mot
Adresse mot
RS
RS
RS
RS
RT
RT
0
0
offset
offset
offset
offset
0
0
2
3
4
6
7
8
9
12
13
16
17
18
19
24
25
26
27
32
33
34
35
36
37
38
39
42
43
Instr
sll
srl
sra
sllv
srlv
srav
jr
jalr
syscall
break
mfhi
mthi
mflo
mtlo
mult
multu
div
divu
add
addu
sub
subu
and
or
xor
nor
slt
sltu
bltz
bgez
bltzal
bgezal
j
jal
beq
bne
blez
bgtz
48
8
9
10
11
12
13
14
15
RS
RS
RS
RS
RS
RS
RS
RD
RD
RD
RD
RD
RD
RD
RD
Constante signée
Constante signée
Constante signée
Constante signée
Cte non signée
Cte non signée
Cte non signée
Cte non signée
addi
addiu
slti
sltiu
andi
ori
xori
lui
16
16
16
16
16
16
16
16
16
0
4
8
8
16
16
16
16
16
RD
RS
0
1
CS
CD
mfco
mtco
bcof
bcot
tlbr
tlbwi
tlbwr
tlbp
rfe
32
33
35
36
37
40
41
43
RS
RS
RS
RS
RS
RS
RS
RS
RD
RD
RD
RD
RD
RT
RT
RT
offset
offset
0
0
0
0
0
1
2
6
8
16
offset
offset
offset
offset
offset
offset
offset
offset
lb
lh
lw
lbu
lhu
sb
sh
sw
4. Interface du Processeur
L'interface entre le processeur et la mémoire est réalisé par les
REQUETE
signaux ADR[31:0], DATA[31:0], RW[2:0], FRZ, BERR. Les RW
requêtes possibles vers la mémoire sont les suivantes:
000 NO ni écriture, ni lecture
Dans le cas WW, les 4 octets du bus DATA sont écrits en mémoire à une adresse alignée sur les mots (les 2 bits de poids faible 001 WW écriture d'un mot
de ADR ne sont pas pris en compte).
010 WH écriture d'un demi-mot
Dans le cas WH, les 2 octets de poids faibles du bus DATA sont 011 WB écriture d'un octet
écrits à une adresse alignée sur les demi-mots (le bit de poids
1** RW lecture d'un mot
faible de ADR n'est pas pris en compte).
Dans le cas WB, l'octet de poids faible du bus DATA est écrit à l'adresse ADR.
Dans le cas RW, les deux bits de poids faible de ADR ne sont pas pris en compte, et la mémoire doit
fournir sur le bus DATA un mot aligné. Dans le
cas des instructions LBU et LHU, c'est le processeur qui effectue le recadrage et l'extension de
signe.
Dans le cas où le système mémoire ne peut pas
satisfaire en un cycle la requête d'écriture ou de
lecture (par exemple en cas de MISS dans le
cache), le signal FRZ doit être activé : le processeur maintient sa requête tant que le signal FRZ
est actif.
Dans le cas d'une erreur matérielle lors d'un accès
à la mémoire, cette erreur peut être signalée au
processeur par le signal BERR
5. Architecture Interne
L'architecture interne du processeur se décompose en une partie opérative et une partie contrôle. La
partie opérative (PO) contient les registres et les opérateurs. Elle réalise des transferts élémentaires de données
entre un ou plusieurs registres sources et un registre
destination. Un transfert élémentaire est exécuté en un
cycle. La partie opérative est commandée par la partie
contrôle (PC). La partie contrôle est chargée de définir,
pour chaque cycle d'horloge, les transferts élémentaires
qui doivent être réalisés par la partie opérative. La partie contrôle contient principalement un séquenceur décrit comme un automate d'états finis (automate de
MOORE).
L'interface entre la partie opérative et la partie contrôle est définie par deux nappes de fils. Dans le
sens PC → PO, cette nappe de fils est décomposée en six champs de commande qui définissent de fait le
format de la micro-instruction. Ce format ainsi que les valeurs possibles des différents champs de commande constituent le "langage de micro-programmation". Dans le sens PO → PC, cette nappe de fils est
constituée de signaux de compte-rendu permettant au séquenceur de prendre des décisions.
49
6. Chemin de Données
En plus des registres visibles du logiciel, le processeur possède 3 registres internes:
• IR Registre instruction qui mémorise l'instruction lue en mémoire.
• DT Registre data qui reçoit la donnée provenant
de la mémoire
• AD Registre d’adresse qui peut être utilisé
comme registre temporaire.
Les registres SR et CR sont implantés dans la partie contrôle.
Le processeur possède deux bus opérandes X et Y
et une seule "boîte à opérations" capable d'effectuer des opérations logiques, arithmétiques, mais
aussi des opérations de comparaison, ou des décalages multi-bits. Toutes les opérations s'exécutent
en un cycle, sauf les opérations de multiplication
et de division qui s'exécutent en deux cycles. Seuls
les registres PC et AD permettent d’adresser la
mémoire externe.
Un mot de 32 bits provenant de la mémoire peut
être écrit dans les registres DT ou IR.
Un mot de 32 bits provenant de la boîte à opérations peut être écrit dans les registres PC, EPC,
SR, CR, BAR, HI, LO, AD, ou dans un registre
général R(n). Ceci signifie que cette partie opérative est capable d'effectuer deux transferts élémentaires à chaque cycle: un transfert interne (qui utilise deux registres sources, la boîte à opérations et
un registre résultat), et un transfert externe (lecture
d'un mot en mémoire externe et écriture dans IR
ou DT).
Le banc de registre R(n) ne possède que 2 accès simultanés (un en lecture et un en écriture).
Des pseudo-registres permettent de forcer des valeurs constantes sur les bus X et Y.
Les 32 bits du registre d'instruction IR sont envoyés à la partie contrôle pour lui permettre de prendre des
décisions. Par ailleurs, la partie opérative envoie vers la partie contrôle le signal NUL qui vaut 1 quand
RES = Ø. Elle renvoie également vers la partie contrôle les bits de signe des deux opérandes X et Y, ainsi
que celui du résultat, la retenue de l'UAL et les deux bits de poids faibles du résultat. Ces signaux, calculés par la micro-instruction i peuvent être utilisés par la partie contrôle pour choisir la micro-instruction
i+1.
7. Langage de la Micro Programmation
A chaque cycle, la partie contrôle envoie vers la partie opérative des signaux de commande qui constituent la micro-instruction. La micro-instruction possède 6 champs dont les valeurs possibles définissent le
langage de microprogrammation. Ces valeurs sont définies par des mnémoniques dans les tableaux cidessous :
- Le champ OPX définit l'opérande X en entrée de la boîte à opérations.
- Le champ OPY définit l'opérande Y en entrée de la boîte à opérations.
- Le champ ALU définit l'opération à exécuter par la boîte à opérations.
50
- Le champ RES définit la destination du résultat calculé par la boîte à opérations.
- Le champ ADRW définit le type d'échange entre le processeur et la mémoire.
- Le champ EXCP contrôle les mécanismes de détection d'exception et de trappes.
51
52
CHAP V
CHAP V : Exeptions et Interruptions
EXCEPTIONS ET INTERRUPTIONS
L’espace mémoire est découpé en 2 segments identifiés par le bit de poids fort de l’adresse :
 adr 31 = 0 ==> segment utilisateur
 adr 31 = 1 ==> segment système
Quand le processeur est en mode superviseur, les 2 segments sont accessibles. Quand le processeur est en mode utilisateur, seul le segment utilisateur est accessible. Le processeur part en exception si une instruction essaie d'accéder à la mémoire avec une adresse correspondant au segment système alors que le processeur est en mode utilisateur.
Il existe quatre types d’évènements qui peuvent interrompre l’exécution "normale" d’un programme:




les exceptions
les interruptions
les appels système (instructions SYSCALL et BREAK)
le signal RESET
Dans tous ces cas, le principe général consiste à passer la main à une procédure logicielle spécialisée qui s’exécute en mode superviseur, à qui il faut transmettre les informations minimales lui permettant de traiter le problème.
1. Exceptions
Les exceptions sont des évènements "anormaux", le plus souvent liés à une erreur de programmation,
qui empêchent l’exécution correcte de l’instruction en cours. La détection d’une exception entraîne
l’arrêt immédiat de l’exécution de l’instruction fautive. Ainsi, on assure que l’instruction fautive ne
modifie pas la valeur d’un registre visible ou de la mémoire. Les exceptions ne sont évidemment pas
masquables. Il y a 7 types d’exception dans cette version du processeur R3000 :
 ADEL : Adresse illégale en lecture : adresse non alignée ou se trouvant dans le segment système alors que le processeur est en mode utilisateur.
 ADES : Adresse illégale en écriture : adresse non alignée ou accès à une donnée dans le
segment système alors que le processeur est en mode utilisateur.
 DBE : Data bus erreur : le système mémoire signale une erreur en activant le signal BERR
à la suite d’un accès de donnée.
 IBE : Instruction bus erreur : le système mémoire signale une erreur en activant le signal
BERR à l’occasion d’une lecture instruction.
 OVF : Dépassement de capacité : lors de l’exécution d’une instruction arithmétique (ADD,
ADDI ou SUB), le résultat ne peut être représenté sur 32 bits.
 RI : Codop illégal: le codop ne correspond à aucune instruction connue (il s’agit probablement d’un branchement dans une zone mémoire ne contenant pas du code exécutable.
 CPU : Coprocesseur inaccessible: tentative d’exécution d’une instruction privilégiée (MTC0,
MFC0, RFE) alors que le processeur est en mode utilisateur.
Le processeur doit alors passer en mode superviseur, et se brancher au gestionnaire d'exceptions
qui est une routine logicielle implantée conventionnellement à l’adresse "0x80000080". Toutes les
exceptions étant fatales dans cette version du processeur R3000, il n’est pas nécessaire de sauvegarder une adresse de retour car il n’y a pas de reprise de l’exécution du programme contenant
l’instruction fautive. Le processeur doit cependant transmettre au gestionnaire d'exceptions
l’adresse de l’instruction fautive et indiquer dans le registre de cause le type d’exception détectée.
53
Lorsqu’une exception est détectée, le processeur :





sauvegarde l’adresse de l’instruction fautive dans le registre EPC
sauvegarde l’ancienne valeur du registre d’état SR
passe en mode superviseur et masque les interruptions dans SR
écrit le type de l’exception dans le registre CR
branche à l’adresse "0x80000080".
2. Interruptions
Les requêtes d’interruption matérielles sont des évènements asynchrones provenant généralement
de périphériques externes. Elles peuvent être masquées. Le processeur possède 6 lignes
d’interruptions externes qui peuvent être masquées globalement ou individuellement. L’activation
d’une de ces ligne est une requête d’interruption. Elles sont inconditionnellement écrites dans le registre CR, et elles sont prises en compte à la fin de l’exécution de l’instruction en cours si elles ne
sont pas masquées. Cette requête doit être maintenue active par le périphérique tant qu’elle n’a pas
été prise en compte par le processeur.
Le processeur passe alors en mode superviseur et se branche ici encore au gestionnaire d'exceptions. Comme il faut reprendre l’exécution du programme en cours à la fin du traitement de
l’interruption, il faut sauvegarder une adresse de retour.
Lorsqu’une requête d’interruption non-masquée est détectée, le processeur:





sauvegarde l’adresse de retour (PC + 4) dans le registre EPC
sauvegarde l’ancienne valeur du registre d’état SR
passe en mode superviseur et masque les interruptions dans SR
écrit qu’il s’agit d’une interruption dans le registre CR
branche à l’adresse "0x80000080".
En plus des 6 lignes d’interruption matérielles, le processeur R3000 possède un mécanisme
d’interruption logicielle: Il existe 2 bits dans le registre de cause CR qui peuvent être écrits par le
logiciel au moyen de l’instruction privilégiée MTC0. La mise à 1 de ces bits déclenche le même traitement que les requêtes d’interruptions externes, s’ils ne sont pas masqués.
3. Appels système: instructions SYSCALL et BREAK
L’instruction SYSCALL permet à une tâche (utilisateur ou système) de demander un service au système d’exploitation, comme par exemple effectuer une entrée-sortie. Le code définissant le type de
service demandé au système, et un éventuel paramètre doivent avoir été préalablement rangés dans
des registres généraux. L’instruction BREAK est utilisée plus spécifiquement pour poser un point
d’arrêt (dans un but de déverminage du logiciel): on remplace brutalement une instruction du programme à déverminer par l’instruction BREAK. Dans les deux cas, le processeur passe en mode
superviseur et se branche au gestionnaire d'exceptions. Ces deux instructions sont exécutables en
mode utilisateur. Elles effectuent les opérations suivantes :





sauvegarde de l’adresse de retour (PC + 4) dans le registre EPC
sauvegarde de l’ancienne valeur du registre d’état SR
passage en mode superviseur et masquage des interruptions dans SR
écriture de la cause du déroutement dans le registre CR
branchement à l’adresse "0x80000080".
4. Signal RESET
54
Le processeur possède également une ligne RESET dont l’activation, pendant au moins un cycle,
entraîne le branchement inconditionnel au logiciel d’initialisation. Cette requête est très semblable à
une septième ligne d’interruption externe avec les différences importantes suivantes :
 elle n’est pas masquable.
 il n’est pas nécessaire de sauvegarder une adresse de retour.
 le gestionnaire de reset est implanté à l’adresse "0xBFC00000".
Dans ce cas, le processeur :
 passe en mode superviseur et masque les interruptions dans SR
 branche à l’adresse "0xBFC00000".
5. Retour d’interruption
Avant de reprendre l’exécution d’un programme qui a effectué un appel système (instructions SYSCALL ou BREAK) ou qui a été interrompu, il est nécessaire d’exécuter l’instruction RFE. Cette
instruction effectue la restitution de l’état précédent dans le registre SR
6. Gestion du registre d’état SR
Le registre d’état contient l’état courant du processeur, défini par le bit de mode KUC et par le
bit de masque global des interruptions IEC. La valeur 00 pour les bits KUC et IEC correspond à
l’état superviseur et interruptions masquées. Le registre SR contient aussi l’état précédent (bits KUP
et IEP) et l’état antérieur (bits KUO et IEO). Il constitue donc une petite pile matérielle capable
d’empiler 3 états successifs du processeur. Le registre SR contient par ailleurs 6 bits MIRQ(5:0)
permettant de masquer individuellement les 6 interruptions externes et 2 bits MSWI(1:0) permettant
de masquer les deux interruptions logicielles. Les 16 bits de poids fort et les deux bits 6 et 7 du registre SR ne sont pas utilisés: On récupère la valeur 0 en lecture et ils ne sont pas modifiés par les
écritures.
La figure suivante montre le format du registre d’état SR:
Lors d’un appel au gestionnaire d'exception, la sauvegarde de l’ancien état et le passage
dans l’état "superviseur avec interruptions masquées" peuvent s’effectuer en une seule opération par
décalage de deux bits vers la gauche des six bits de poids faible du registre SR (les 8 bits MIRQ et
MSWI ne sont pas modifiés) :
55
La restitution de l’ancien état, réalisée par l’instruction RFE, est obtenue par un simple décalage de deux bits vers la droite des six bits de poids faible du registre SR (les 8 bits MIRQ et MSWI
ne sont pas modifiés) :
7. Gestion du registre de cause CR
Le registre CR contient trois champs. Les 4 bits du champs XCODE(3:0) définissent la cause de
l’appel au gestionnaire d'exceptions. Les 6 bits du champs IRQ(5:0) représentent l’état des lignes
d’interruption externes au moment de l’appel au gestionnaire d'exception. Les 2 bits SWI(1:0) représentent les requêtes d’interruption logicielle.
La figure suivante montre le format du registre de cause CR :
Les codes d’exceptions sont les suivants :
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
INT
Inutilisé
Inutilisé
Inutilisé
ADEL
ADES
IBE
DBE
SYS
BP
RI
CPU
OVF
Inutilisé
Inutilisé
Inutilisé
Interruption
Adresse illégale en lecture
Adresse illégale en écriture
Bus erreur sur accès instruction
Bus erreur sur accès donnée
Appel système (SYSCALL)
Point d'arrêt (BREAK)
Codop illégal
Coprocesseur inaccessible
Overflow arithmétique
56
CHAP VI
CHAP VI: Pipline
Pipeline
1. Introduction
Dans la microarchitecture d'un processeur, un pipeline est une technique de conception des
processeurs où l'exécution des instructions est découpée en étages, et où à un instant donné, chaque
étage peut exécuter une instruction.
Dans une architecture sans pipeline, il faut un certain nombre d’étapes pour exécuter une instruction.
Exemple 1 :
Etapes :
1.
2.
3.
4.
5.
6.
Exemple 2:
Etapes :
1.
2.
3.
4.
5.
6.
7.
Exemple 3:
Etapes :
1.
2.
3.
4.
5.
6.
Exemple 3:
Etapes :
1.
2.
3.
4.
Add
Rd, Rs, Rt
Lire l'instruction
Décoder l'instruction
Extraire les opérandes
Effectuer le calcul : Add
Mettre le résultat dans Rd
Calcul de l'adresse de l'instruction suivante
Lw
Rt, I(Rs)
Lire l'instruction
Extraire les opérandes Rt, Rs, I
Effectuer le calcul I(Rs)
Accès mémoire : lecture
Résultat dans Rt
Adresse suivante
Sw
Rt, I(Rs)
Lire l'instruction
Extraire les opérandes Rt, Rs, I
Effectuer le calcul I(Rs)
Accès mémoire : écriture
Adresse suivante
Jr
Rs
Lire l'instruction
Extraire l'opérande
Adresse suivante
On en tire alors un schéma d'exécution général pour le R3000:
1.
Lire l'instruction
2.
3.
Extraire les opérandes
4.
Effectuer une opération
5.
Accès mémoire
6.
Ecriture du résultat
7.
Calcul de l'adresse suivante
57
CHAP VI: Pipline
2. Définition
Pour MIPS, le processeur est divisé en 5 étages
1. IF (Instruction Fetch) charge l'instruction à exécuter dans le pipeline.
2. ID (Instruction Decode) décode l'instruction et adresse les registres.
3. EX (Execute) exécute l'instruction (par la ou les unités arithmétiques et logiques).
4. MEM (Memory), dénote un transfert depuis un registre vers la mémoire dans le cas d'une
instruction du type STORE (accès en écriture) et de la mémoire vers un registre dans le cas
d'un LOAD (accès en lecture).
5. WB (Write Back) stocke le résultat dans un registre. La source peut être la mémoire ou bien
un registre.
En supposant que chaque étape met 1 cycle d'horloge pour s'exécuter, il faut normalement 5
cycles pour exécuter une instruction, 15 pour 3 instructions :
Séquençage des instructions dans un processeur sans pipeline. Il faut 15 cycles pour exécuter
3 instructions.
Si l'on insère des registres tampons (pipeline registers) entre chaque unité à l'intérieur du processeur, celui ci peut alors contenir plusieurs instructions, chacune à une étape différente.
Les 5 instructions s'exécuteront en 9 cycles, et le processeur sera capable de terminer une instruction par cycle à partir de la cinquième, bien que chacune d'entre elles nécessite 5 cycles pour
s'exécuter complètement.
Séquençage des instructions dans un processeur doté d'un pipeline à 5 étages. Il faut 9 cycles
pour exécuter 5 instructions. À t = 5, tous les étages du pipeline sont sollicités, et les 5 opérations ont
lieu en même temps.
Au 5e cycle, tous les étages sont en cours d'exécution.
3. Règles du pipeline
1.
2.
3.
4.
Les étages du pipeline doivent être équilibrés
Calibrer l'horloge sur l'étage le plus long
Les étages doivent être séparés par des registres
Le matériel doit être spécifique à l'étage
58
CHAP VI: Pipline
4. Problèmes
Les pipelines provoquent de nouveaux problèmes, en particulier d'interdépendance, ils ne sont pas
tous listés ci dessous, juste deux cas simples sont abordés.
 Interdépendance des données
Une instruction ne peut récupérer le résultat de la précédente car celui-ci n'est pas encore disponible. Ainsi, la séquence:
 add
 sw
$at, $v0, $v1
$at, 1000($zero)
//
//
$at = $v0 + $v1
(1000) = $at
Ne stocke pas à l'emplacement mémoire 1000 la valeur de $at contenant la somme $v0 + $v1,
mais la valeur de $at contenue avant l'instruction ADD. Pour résoudre ce problème particulier, il est
parfois possible de créer des courts-circuits pour amener le résultat de l'étape précédente vers l'unité
qui en a besoin directement, sans passer par les registres de pipeline.
 Interdépendance procédurale
Se pose le même problème avec les sauts:
 lw
$ra, 1000($zero)
// $ra = 1000
 Jr
$ra
// Saut inconditionnel
$ra ne contient pas encore la valeur 1000 au moment où l'instruction de saut va s'exécuter.
Une solution possible à ces deux problèmes est d'insérer une instruction entre les deux qui sont interdépendantes. Prenons par exemple la séquence suivante :
1:
2:
3:
add
add
add
$t0, $t1, $t2
$t3, $t0, $t2
$t4, $t3, $t1
qui comporte une dépendance directe simple, $t0 ne pouvant être disponible pour la partie droite de
la seconde instruction.
 la première solution, triviale, est d'insérer des NOP (No Operation), c'est ce que font les compilateurs quand on ne précise pas d'option d'optimisation du code :
1:
1b:
2:
3:
add
NOP
add
add
$t0, $t1, $t2
$t3, $t0, $t2
$t4, $13, $t1
 la seconde solution consiste à réarranger les instructions. Dans cet exemple, l'opération de la
ligne 3 n'a aucune interdépendance avec les deux précédentes. Le code modifié sera:
1:
add
$t0, $t1, $t2
2:
add
$t4, $13, $t1
3:
add
$t3, $t0, $t2
59
60
CHAP VI: Pipline
Travaux dirigés
Travaux dirigés
CHAP I
Codage de l’Informations
1.
Codification des nombres entiers naturels
• Codifier sur 8 bits lorsque cela est possible: (56) 10 ; (127) 10 ; (255) 10 ; (256) 10
(10100) 2 (101000) 2 (101000101) 2 (011000101) 2 ; 28−1;
28
• Codifier sur 16 bits si cela est possible: (1024) 10 ; (65535) 10 ; (5FE) 16 ; 216−1 ; 216; 220
• Effectuer sur 8 bits les opérations binaires suivantes:
76H+64H; 4AH+DEH ; 8CH+9AH ; 37H - 4BH ; 6EH - BOH; B4H - 95H
Préciser s'il y a retenue et s'il y a dépassement de capacité
2.
Entiers Signés
•
Donnez le codage sur 8 et 16 bits des nombres suivants:
(-1010) 2 ; (-AC) 16 ; (-183) 10
•
Donnez la valeur en base 10 des nombres binaires 0101 0101;
•
Effectuer sur 8 bits les opérations binaires suivantes:
76H+64H; 4AH+DEH ; 8CH+9AH ; 47H -3BH ; 6EH - BOH; B4H - 95H
1001 0001.
Préciser si le nombre est nul, s'il est négatif, s'il y a retenue et s'il y a dépassement de capacité.
•
3.
4.
Calculez l’opposé des nombres relatifs codés sur 16 bits : ABCDH, FFFFH, 5A72H en base 16
et en base 2. Trouvez une autre règle de conversion.
Flottants
Donnez le codage IEEE des nombres suivants: 1.0; 2; 4; 8; −1; 0.5; −2; 96.875;
−544.0625; 299892; 5.5;
19.6;
-1/3
Donnez la valeur du nombre suivant stocké et codé selon la norme IEEE: C8 80 00 00 00
Faire l'addition des nombre IEEE suivants: C8 80 00 00 + C8 00 00 00
Donnez pour les nombres stockés et codés selon la norme IEEE:
• Le plus grand et le plus petit nombre normalisé représentable (en valeur absolue ou non).
• Le codage du zéro
• Le codage du résultat d'une division par zéro
-126
-126
• Le résultat de la soustraction suivante: (1,1) 2 * 2
– (1,0) 2 * 2
Ecrire des fonctions en C pour :
1. Vérifier si un nombre est valable dans un système de numération à base B
2. Transformer un nombre entier d’une base B en nombre entier sur 16 bits
3. Ecrire un nombre entier 16 bits dans une base B
Le nombre entier est lu sous forme de chaîne de caractères (pour les bases > 10, on utilise les
chiffres A, B, C, D, E, F )
61
Travaux dirigés
Machine Von Neumann
Exercice 1:
1. Quelle est la fonction de la mémoire principale?
2. Quelle est la fonction du processeur centrale?
3. Qu’est ce qu'un programme?
4. Donner un schéma général d’un ordinateur.
5. Que fait le processeur pour chaque exécution d’une instruction?
Exercice 2:
1. Donner une relation entre le Bus Adresse et la taille de la MP.
Si la taille de d’une mémoire principale est de 1 Go, quelle est la largeur du bus d’adresse?
Donner la taille de cette mémoire en mot mémoire si un mot mémoire = (16 bits, 32 bits, 64 bits) .
62
CHAP II
Travaux dirigés
Microprocesseur MIPS R3000
Architecture externe
Exercice 1:
a. Initialiser le registre $a1 à 0
b. Initialiser le registre $a1 à 0x4567 (valeur 16 bits)
c. Initialiser le registre $a1 à 0x4567ABCD (valeur 32 bits)
Exercice 2:
Programmez en assembleur MIPS la fonction F = 2*X + 2*Y - Z .
On suppose que la variable X se trouve dans le registre $t0, la variable Y dans $t1, la variable Z
dans $t2 et que le résultat de la fonction F se trouve dans le registre $v0.
Exercice 3:
1. Ecrire une séquence d’instructions assembleur pour permuter le contenu de 2 registres, On utilisera
un registre intermédiaire.
2. Permuter deux registres sans utiliser un registre intermédiaires (penser à XOR).
3. Ecrire une séquence d’instructions assembleur qui permute le contenu de 2 variables 32 bits. Même
chose pour deux variables 16 bits, puis 8 bits.
Exercice 4:
1.
2.
3.
4.
Programmez en assembleur MIPS les expressions (variables à 32 bits):
x = y+z–2*t
S = a* x2 + b * x + c
S = a2 + b2 + c2
(x + 5 - y) * 35 / 3
Exercice 5:
a. Supposez que $a0 = 0x1234 et $a1 = 0x3.
l’exécution du programme MIPS suivant ?
add
$t0, $zero, $zero
toto:
add
$t0, $t0, $a0
addi
$a1, $a1, -1
bne
$a1, $zero, toto
srl
$t0, $t0, 4
Quelle est la valeur du registre $t0
après
b. Supposez le code MIPS suivant, qui reçoit deux entrées dans les registres $t2 et $t3 et produit
une sortie dans le registre $s4.
add
$t1, $zero, $zero
lo:
beq
$t3, $zero, fin
add
$t1, $t1, $t2
subi
$t3, $t3, 1
j
lo
fin:
addi
$t1, $t1, 100
add
$s4, $t1, $zero
a) Décrivez en une phrase la fonction du programme.
b) Quelle est la valeur de $s4 à la fin du programme, si $t2 = 4 et $t3 = 6 au début du programme?
63
Travaux dirigés
Exercice 6: Opérations logiques bit à bit.
Pour chaque question, donner la réponse en langage machine MIPS.
1- Multiplier $t0 par 8.
2- Inverser le bit 4 de $t0.
3- Si $t0 est pair, $t0 = 0, sinon $t0 = 1.
4- Mettre à un le bit 7 de $t0.
Exercice 7:
Programmez en assembleur MIPS les fonctions suivantes:
a)
PGCD(A, B) =
=
b)
PPCM(A, B) = PPCM(A’, B’) = A'
= PPCM(A' + A, B')
= PPCM(A', B'+ B)
au départ A' = A , B’ = B
si
si
si
c)
Fn
si n = 0 ou n = 1
si n > 1
d)
A*B =
=
=
e)
Ab
=
=
B
PGCD(B , A mod B )
1
Fn-1 + Fn-2
0
(2*A) * ( B div 2)
(2*A) * ( B div 2) + A
si A mod B = 0
sinon
A' = B'
A' < B'
B' < A'
si B = 0
si B est pair
si B est impair
= 1
= A(b div 2) * A(b div 2)
= A(b div 2) * A(b div 2) * A
si
si
si
b = 0
b est pair
b est impair
Exercice 8:
Ecrire des fonctions en MIPS pour :
1. Vérifier si un nombre est valable dans un système de numération à base B
2. Transformer un nombre entier d’une base B en nombre entier sur 16 bits
3. Ecrire un nombre entier 16 bits dans une base B
Le nombre entier est lu sous forme de chaîne de caractères (pour les bases > 10, on utilise les
chiffres A, B, C, D, E, F )
Exercice 9:
Programmez en assembleur MIPS un programme qui lit une phrase terminée par un ‘.’ au
clavier et qui et qui affiche (en pascal) le nombre de mots.
Exercice 10:
Programmez en assembleur MIPS un programme qui lit une phrase terminée par un ‘.’ au
clavier et qui et qui affiche (en pascal) le nombre de mots qui se termine par la lettre ‘s’.
Exercice 11 :
Programmer la fonction copy une chaine de caractères d’un emplacement mémoire à un autre.
64
CHAP III
La programmation structurée
Exercices :
Traduire en assembleur MIPS les programmes C suivants
1. int pgcd(int a, int b )
{
while (a != b )
if (a < b)
b = b-a;
else
a = a-b;
return( a ) ;
}
void main() {
int a , b ;
printf(" entrer a ");
scanf("%d", &a) ;
printf(" entrer b ");
scanf("%d", &b) ;
printf(" pgcd = %d ",pgcd(a,b) );
}
2. int pgcd(int a , int b)
{
if ( !b ) return a ;
return pgcd(b , a mod b ) ;
}
3. int mul (int a , int b)
{
if ( !b ) return 0 ;
if ( ! (b & 1 ) ) return mul( a << 2 , b >> 2 );
return( a + mul(a << 2 , b >> 2 ) ;
}
4. int combi(int n , int p)
{
If ( !p || p == n || !n ) return 1 ;
return combi(n-1 , p ) + combi( n-1 , p-1 ) ;
}
65
Travaux dirigés
CHAP IV
Travaux dirigés
Conception du jeu d'instructions
d'un processeur
Exercice 1 : Codez sous forme de hexadécimale les instructions MIPS suivantes :
1. Utilisation de données immédiates :
sltiu
lui
2.
$v0, $s7, -1
$t1, 0xA5A5
Instructions registres/registres :
srlv
nor
$t0, $t9, $s8
$t4, $v0, $v0
3. Adressage mémoire en mode indirect registre (le seul supporté par le MIPS) :
lh
sb
$a2, 0xFF($a0)
$a3, 12($s0)
Exercice 2 : nous supposerons pour l’exemple suivant que l’instruction à coder se trouve en
$pc=0x00400020, et que les étiquettes auxquelles on saute se trouvent en plus = 0x0040003C, et
moins = 0x00400018.
jalr
j
bne
bltz
$ra, $k1
plus
$v0, $v1, plus
$v1, moins
syscall
mfc0
$ra, $13
Décodage :
0x00031880
0x00021080
0x3C16FFFF
0x00A21026
0x80E30006
0xAE2200C8
66
Registres
Nom
$0
$zero
$1
$at
$2
$v0
$3
$v1
$4,$5,$6,$7 $a0 … $a3
$8, … , $15 $t0 … $t7
$16, … , $23 $s0 … $s7
$24, $25
$t8, $t9
$26, $27
$k0, $k1
$28
$gp
$29
$sp
$30
$s8
$31
$ra
HI
LO
PC
SR
CR
EPC
BAR
Description
vaut zéro en lecture, non modifié par écriture
Réservé à l’assembleur pour les macros. Ne doit pas être utilisé
Utilisé pour les valeurs de retour des fonctions
Utilisé. pour les appels systèmes. Contient le numéro d'appel de la fonction système syscall.
Utilisés par le compilateur pour optimiser les appels de fonctions pour contenir les arguments
Registres de sauvegardes d'usage universel
Réservés aux procédures noyau.
Pointeur global. Constant pour tout processus .
Pointeur de pile
Pointeur sur la zone des variables globales (section data)
Contient l’adresse de retour d’une fonction
Registres spéciaux
Poids fort du résultat d’une multiplication sur 64 bits ou reste de division.
Poids faible du résultat d’une multiplication sur 64 bits ou quotient de division.
Registre compteur de programme (Program Counter).
Registres protégés
Registre d’état (Status Register).
Registre de cause (Cause Register).
Registre d’exception (Exception Program Counter). Il contient l’adresse de retour (PC+4)
Registre d’adresse illégale, il contient la valeur de l’adresse illégale. (registre numéro 8)
Quelques notations:
Mem[ad]
||
Bn
X p..q
:
:
:
:
Contenu de la mémoire d’adresse ad
Concaténation entre deux chaînes de bits
Réplication du bit B n fois dans une chaîne de bits
Sélection des bits p à q dans une chaîne de bits X
Categorie
Arithmétique
Logique
Décalages
Instruction
Exemple
Signification
addition
add
$1 = $2 + $3
soustraction
sub
$1,$2,$3
$1 = $2 - $3
addition immédiate
addi
$1,$2,100
$1 = $2 + 100
Addition non signée
addu
$1,$2,$3
$1 = $2 + $3
Soustraction non signée
subu
add immediat non signée
addiu $1,$2,100
$1 = $2 + 100
Multiply signed
Mult
LO = ($1 *$2)31..0 HI =($1 *$2)63..32
Multiply unsigned
Multu
Divide signed
Div
Divide unsigned
Divu
$1 , $2
Move from coprocessor register
mfc0
$1,$epc
$1 = $epc
and
and $1,$2,$3
$1 = $2 & $3
or
or
$1 = $2 | $3
and immediate
andi $1,$2,100
$1 = $2 & 100
or immediate
or i $1,$2,100
$1 = $2 | 100
xor
xor
$1 = $2 ⊕ $3
xor immediate
xori $1,$2,100
$1 = $2 ⊕ 100
nor
nor $1,$2,$3
$1 = $2 nor $3
shift left logical variable
sllv
$1, $2, $3
$1 = $2 << $3
shift right logical variable
srlv
$1, $2, $3
$1 = $2 >> $3
shift right arithmetical variable
srav
$1, $2, $3
$1 = $2 >>* $3
shift left logical
sll
$1,$2,10
$1 = $2 << 10
shift right logical
srl
$1,$2,10
$1 = $2 >> 10
shift right arithmetical
sra
écrire un entier :
li
$4, 1234567
ori $2, $0, 1
syscall
lire une chaîne de caractères :
read_str: .space
256
la $4, read_str
ori $5, $0, 255
ori
$2, $0, 8
syscall
$1,$2,$3
$1,$2,$3
$1 , $2
$1 , $2
$1 , $2
$1,$2,$3
$1,$2,$3
lire un entier :
ori
$2, $0, 5
syscall
quitter :
ori
$2, $0, 10
syscall
$1, $2, 10
$1 = $2 - $3
LO = ($1 *$2)31..0 HI =($1 *$2)63..32
$1 = $2 >>* 10
écrire une chaîne de caractères :
la
$4, str
ori $2, $0, 4
syscall
transfert
branchements
Conditionnels
branchements
inconditionnel
load word
lw
$1,(100)$2
$1 = Memory[$2+100]
store word
sw
$1,(100)$2
Memory[$2+100] = $1
load half word signed
lh
$1,(100)$2
$1 = Memory[$2+100]
load half word unsigned
store half word
lhu $1,(100)$2
sh $1,(100)$2
$1 = Memory[$2+100]
Memory[$2+100] = $1
load byte signed
lb
$1,(100)$2
$1 = Memory[$2+100]
load byte unsigned
lb
$1,(100)$2
$1 = Memory[$2+100]
store byte
sb
$1,(100)$2
Memory[$2+100] = $1
Move from HI
mfhi
$1
$1 = HI
Move from LO
mflo
$1
$1 = LO
Move to HI
mthi
$1
HI = $1
Move to LO
mtlo
$1
LO = $1
load upper immediate
lui
branch on equal
beq
$1,$2, label
if ($1 == $2) go to label
branch on not equal
bne
$1,$2, label
if ($1 != $2) go to label
Branch if greater or equal zero
bgez $1, label
Branch if greater than zero
bgtz $1, label
if ($1 > 0 ) go to label
Branch if less or equal zero
blez
if ($1 <= 0 ) go to label
Branch if less than zero
bltz
Branch if greater or equal zero and
link
bgezal
$1, label
$31 = PC + 4;
Branch if less than zero and link
gltzal
$1, label
$31 = PC + 4;
jump
j
label
goto
jump and link
jal
label
$31 = PC + 4; go to label
jump register
jr
$31
PC = $31
set on less than
slt
$1,$2,$3
if ($2 < $3) $1 = 1; else $1 = 0
set less than immediate
slti
$1,$2,100
if ($2 < 100) $1 = 1; else $1 = 0
set less than unsigned
sltu $1,$2,$3
if ($2 < $3) $1 = 1; else $1 = 0
set less than immediate unsigned
sltiu $1,$2,100
if ($2 < 100) $1 = 1; else $1 = 0
$1,100
$1, label
$1, label
$1 = 100 * 216
label
( i.e. return)
31
25
20
15
OPCOD
RS
RT
OPCOD
RS
RD
OPCOD
10
RD
5
SH
0
FUNC
IMD16
Format R
Format I
IMD26
Format J
DECODAGE OPCOD
000
001
000 SPECIAL BCOND
001
ADDI
010
COPRO
ADDIU
010
J
011
JAL
100
BEQ
101
BNE
110
BLEZ
111
BGTZ
SLTI
SLTIU
ANDI
ORI
XORI
LUI
LBU
LHU
011
100
LB
LH
LW
101
SB
SH
SW
110
111
OPCOD = SPECIAL (INS 5:0)
000
SLL
001
000
001
JR
JALR
010
MFHI
MTHI
MFLO
MTLO
011
MULT
MULTU
DIV
DIVU
100
ADD
ADDU
SUB
SUBU
SLT
SLTU
101
110
111
010
SRL
011
SRA
100
SLLV
101
SYSCALL
BREAK
AND
OR
110
SRLV
111
SRAV
XOR
NOR
31
25
20
15
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RS
RT
RT
RT
RT
RT
RT
RT
RT
RT
RT
RT
RT
RT
RT
1
1
1
1
RS
RS
RS
RS
0
1
16
17
0
0
RS
0
2
3
4
5
6
7
RT
RT
RT
RT
RT
RT
10
5
RD
RD
RD
RD
RD
RD
0
RD
SA
SA
SA
0
0
0
RD
0
RD
0
0
0
0
0
0
0
0
RD
RD
RD
RD
RD
RD
RD
RD
RD
RD
0
0
0
0
0
0
0
0
0
0
offset
offset
offset
offset
Adresse mot
Adresse mot
RS
RS
RS
RS
RT
RT
0
0
offset
offset
offset
offset
0
0
2
3
4
6
7
8
9
12
13
16
17
18
19
24
25
26
27
32
33
34
35
36
37
38
39
42
43
Instr
sll
srl
sra
sllv
srlv
srav
jr
jalr
syscall
break
mfhi
mthi
mflo
mtlo
mult
multu
div
divu
add
addu
sub
subu
and
or
xor
nor
slt
sltu
bltz
bgez
bltzal
bgezal
j
jal
beq
bne
blez
bgtz
8
9
10
11
12
13
14
15
RS
RS
RS
RS
RS
RS
RS
RD
RD
RD
RD
RD
RD
RD
RD
Constante signée
Constante signée
Constante signée
Constante signée
Cte non signée
Cte non signée
Cte non signée
Cte non signée
addi
addiu
slti
sltiu
andi
ori
xori
lui
16
16
16
16
16
16
16
16
16
0
4
8
8
16
16
16
16
16
RD
RS
0
1
CS
CD
mfco
mtco
bcof
bcot
tlbr
tlbwi
tlbwr
tlbp
rfe
32
33
35
36
37
40
41
43
RS
RS
RS
RS
RS
RS
RS
RS
RD
RD
RD
RD
RD
RT
RT
RT
offset
offset
0
0
0
0
0
1
2
6
8
16
offset
offset
offset
offset
offset
offset
offset
offset
lb
lh
lw
lbu
lhu
sb
sh
sw

Approche vulgarisée

Transcription

Documents pareils

Exigences techniques pour la Salle de classe virtuelle de Berlitz

Installation des E-boards DGT

RegistryBooster

Êtes-vous loueur professionnel

Règlement ERP - Code du travail - ISBN : 978-2-35505-221-7

Comment savoir quelle version de windows 7 est installée sur mon

Loi n° 95-44 du 2 mai 1995, relative au registre du commerce

Institut National de la Normalisation

LES REGISTRES DE LANGUE

EasyCleaner - accueil Sos informatique 44