Cours-Architecture-Des-Ordinateurs - PDF Version 1

Architecture des Ordinateurs 2eme année LMD Informatique CHAP I : Rappels
CHAP 0 Révision:
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 em-
ploie 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
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 con-
vertir 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 Donc 44 = (101100)2.
 1383 = ( ? )8
1383 ÷ 8 = 172 reste 7
172 ÷ 8 = 21 reste 4
21 ÷ 8 = 2 reste 5
2 ÷ 8 = 0 reste 2 1383 = (2547) 8
 31838 = ( ? )16
31838 ÷ 16 = 1989 reste 14 = EH
1989 ÷ 16 = 124 reste 5
124 ÷ 16 = 7 reste 12 = CH
7 ÷ 16 = 0 reste 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 a-1 = 0
0.5 * 2 = 1.0 a-2 = 1
0.0 * 2 = 0.0 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 = ( ? )8
0.6953125 * 8 = 5.5625
0.5625 * 8 = 4.5
0.5 * 8 = 4.0 0.6953125 = (0.544)8
 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ésen-
ter 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
De même, chaque chiffre octal représente 3 bits.

 (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
II. 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 infor-
mation 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 in-
terne 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 cor-
respond à 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 ma-
chine à l'autre (8, 16, 24, 32, 64 bits) la longueur des mot-mémoires est une caractéristique impor-
tante dans l'architecture d'un ordinateur.
4
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'effec-
tuer 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'effec-
tuer 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
 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ébor-
dement, 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 ra-
tionnels
• virgule flottante
 Virgule flottante
e
Un nombre réel x = ± m* b est représenté par un signe, une mantisse m, un exposant e, et une
base b.
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 : (−1) S *1, M * 2 E −127

S Exposant E Mantisse M
1 bit 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 Vérifier!
6
 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 configu-
ration 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 corres-
pondants se retrouvent en code excédent-3.
7
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 dispari-
tion) 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, utili-
sant 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 8 9 A B C D E F
0 NUL SOH STH ETH EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
1 DLE DC1 CD2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
2 spc ! " # $ % & ‘ ( ) * + , - . /
3 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
4 @ A B C D E F G H I J K L M N O
5 P Q R S T U V W X Y Z [ \ ] ^ _
6 ` a b c d e f g h i j k l m n o
7 p q r s t u v w x y z { | } ~ 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 élec-
trique. 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
de la validité des données est nécessaire pour certaines applications (professionnelles, bancaires, in-
dustrielles, confidentielles, relatives à la sécurité, ...). C'est pourquoi il existe des mécanismes per-
mettant 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 vali-
dité 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 (horizon-
tal), 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 cor-
riger 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
Architecture des Ordinateurs 2eme année LMD Informatique CHAP I : Modèle de Von Neumann
CHAP I Modèle de Von Neumann

Dans cette partie, nous décrivons rapidement l’architecture de base d’un ordinateur et les prin-
cipes 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 automa-
tique.
I. Modèle de Von Neumann
L’architecture, dite architecture de Von Neu-

mann, 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 im-
plicite dans ce modèle.
C’est la première description d’un ordinateur dont

le programme est stocké dans sa mémoire.
1. L’architecture de Von Neumann décompo-

sait l’ordinateur en quatre parties distinctes
a) 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 impor-
tants, 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 hexa-
décimal.
La capacité (taille) de la mémoire est le nombre d'emplacements, exprimé en général en kilo-
octets 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'empla-
cement 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 posi-
tionne 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'indi-
cateur de zéro ( Z ) sera mis à 1. Ces indicateurs sont re-
groupé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 pro-
gramme, 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 pos-
sibles.
• 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 à conce-
voir, 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 proces-
seur (CPU), de mémoire (RAM et ROM), et de composants périphériques (Clavier, port série, con-
trô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 adres-
sables, 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 con-
tenant 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 con-
tiennent 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 fonctionne-
ment 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 à ef-
fectuer (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
Architecture des Ordinateurs 2eme année LMD Informatique CHAP II : Microprocesseur MIPS R3000
CHAP II 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 pro-
cesseurs 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 re-
gistres 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 exten-
sions 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 por-
tent 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 uti-
lisateur, 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 convention-
nellement à l’adresse 0x00400000. Sa taille est fixe et calculée lors de l’assemblage. La prin-
cipale 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 glo-

bales manipul.es par le programme utilisa- 0xFFFFFFFF
teur. Elle est implantée conventionnelle- Réservé
ment à l’adresse 0x10000000. Sa taille est 0xFFFFF000
fixe et calculée lors de l’assemblage. Les 0xFFFFEFFF
.kstack
valeurs contenues dans cette section peu-
Segment
vent être initialisées grâce à des directives Système
contenues dans le programme source en (noyau) .kdata
langage d’assemblage. 0xC0000000
3. la section stack contient la pile 0xBFFFFFFF
d’exécution du programme utilisateur. Sa .ktext
taille varie au cours de l’exécution. Elle 0x80000000
0x7FFFFFFF
est implantée conventionnellement à
Réservé
l’adresse 0x7FFFF000. La pile s’étend 0x7FFFF000
vers les adresses décroissantes. 0x7FFFEFFF
.stack
Trois sections sont également définies dans le
segment noyau (kernel):
1. la section ktext contient le code exécu- Segment
.data
utilisateur
table en mode noyau. Elle est implantée 0x10000000
conventionnellement à l’adresse 0x0FFFFFFF
0x80000000. Sa taille est fixe et calculée .text
0x00400000
lors de l’assemblage.
0x003FFFFF
2. la section kdata contient les données glo-
Ré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 ins-
tructions, 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 re-
gistres sont définies. Ces conventions sont particulièrement nécessaires lors des appels de fonctions.
18
Registres Nom Description

$0 $zero vaut zéro en lecture, non modifié par écriture
$1 $at Réservé à l’assembleur pour les macros. Ne doit pas être utilisé
$2 $v0 Utilisé pour les valeurs de retour des fonctions
$3 $v1 Utilisé. pour les appels systèmes. Contient le numéro d'appel de la
fonction système syscall.
$4,$5,$6,$7 $a0 … $a3 Utilisés par le compilateur pour optimiser les appels de fonctions
pour contenir les arguments
$8, … , $15 $t0 … $t7 Registres de travail utilisable par le code utilisateur
$16, … , $23 $s0 … $s7 Registres de sauvegardes d'usage universel
$24, $25 $t8, $t9 Registres de travail utilisable par le code utilisateur
$26, $27 $k0, $k1 Réservés aux procédures noyau.
$28 $gp Pointeur global. Constant pour tout processus .
$29 $sp Pointeur de pile
$30 $s8 Pointeur sur la zone des variables globales (section data)
$31 $ra Contient l’adresse de retour d’une fonction
Registres spéciaux
HI Poids fort du résultat d’une multiplication sur 64 bits ou reste de
division.
LO Poids faible du résultat d’une multiplication sur 64 bits ou quotient
de division.
PC 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 pro-
gramme 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 plu-
sieurs 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 $v1, $v0, $at # équivalent à $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 suf-
fixé 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:
.data
message: .asciiz "Ceci est une chaîne de caractères...\n"
.text
20
_start:
lui $a0, message >> 16
ori $a0, $a0, message & 0xFFFF # adresse de la chaîne dans $a0
ori $v0, $zero, 4 # 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 $t4, 13($t2) # $t4 ← Mem[$t2 + 13]
sw $s4, -60($s6) # 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 effec-
tuent un simple transfert entre un registre général et la mémoire, sans aucun traitement arith-
mé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
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

Addu Addition registre registre non-signée

Syntaxe : addu $rr, $ri, $rj
Description : rr ← ri + rj
Exception: pas d’exception
Addiu Addition registre immédiat non-signée

Syntaxe : addiu $rr, $ri, imm
rr ← (imm 15 16 || imm 15..0 ) + ri
Subu Soustraction registre registre non-signée

Syntaxe : subu $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
Exemple 5: Donner l’instruction ou la suite des instructions MIPS pour effectuer les actions sui-
vantes
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
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)
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: - Adresse dans le segment noyau alors que le processeur est en mode utilisateur.
Lbu Lecture d’un octet non-signé en mémoire

Syntaxe : lbu $rr, imm($ri)
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 $ri et $rj.
Le résultat est placé dans le registre $rr.
rr ← ri and rj
Exception : pas d’exception
Andi 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
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 z = w + y;

la $t10, w # put address of w into $t10
lw $s0, 0($t10) # put contents of w into $s0
la $t1, y # put address of y into $t1
lw $s1, 0($t1) # put contents of y into $s1
add $s2, $s0, $s1 # add w + y, put result in $s2
la $t2, z # put address of z into $t2
sw $s2, 0($t2) # put contents of $s2 into z
Mult Multiplication signée

Syntaxe : mult $ri, $rj
Description : Le contenu du registre $ri est multiplié par le contenu du registre $rj, le con-
tenu 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.
lo ← (ri x rj) 31..0 et hi ← (ri x rj) 63..32
Exception: pas d’exception.
Multu Multiplication non-signée
Div Division entière signée

Syntaxe : div $ri, $rj
Description : Le contenu du registre $ri est divisé par le contenu du registre $rj, le conte-
nu 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
Divu Division entière non-signée
Mfhi Move From HI

Syntaxe : mfhi $ri # $ri ← hi
25
Mflo Move From LO

Syntaxe : mflo $ri # $ri ← lo
Mthi Move to HI
Syntaxe : mfti $ri # hi ← $ri
Mtlo 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
repéré par la directive .text. La première instruction à exécuter (point d’entrée du programme)
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
directive .data. D’autres directives sont disponibles pour déclarer et initialiser des variables.
L’ordre des zones instructions et données n’a pas d’importance.
Exemple 7: Un programme qui calcule S = a + b (32 bits)

.data # début de la section données en mémoire
a: .word 15
b: .word 20
s: .word 0
.text # début de la section instructions (code) en mémoire

__start:
la $a1, a # première instruction du programme
lw $t10, 0($a1) # $t10  a
la $a1, b
lw $t1, 0($a1) # $t1  b
add $t4 , $t10 , $t1 # $t4  a + b
la $a1, s
sw $t4 , 0($a1) # s  $t4
ori $v0, $zero, 10 # appel système N°10

syscall # 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
.data # début de la section données en mémoire
a: .word 15
b: .word 20
c: .word 30
26
x: .word 40
s: .word 0
.text # début de la section instructions (code) en mémoire

__start:
la $a1, x # première instruction du programme
lw $t10, 0($a1) # $t10  x
la $a1, a
lw $t1, 0($a1) # $t1  a
la $a1, b
lw $t2, 0($a1) # $t2  b
la $a1, c
lw $t3, 0($a1) # $t3  c
mult $t1 ,$t10

mflo $t4 # $t4  a* x
add $t4 , $t4 , $t2 # $t4  a* x + b
mult $t4 , $t10
mflo $t4 # $t4  (a* x + b)* x
add $t4 , $t4 , $t3 # $t4  (a *x + b) *x + c
la $a1, s
sw $t4 , 0($a1) # s  $t4
ori $v0, $zero, 10 # 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
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 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
Jr 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 Programme assembleur
.data
void main() x: .word -5
{ val_abs : .word 0
.text
int x = -5;
__start :
int val_abs; la $a0, x
val_ abs = x; lw $a0, 0($a0)
if (x <= 0) bgtz $a0, suite
val_abs = -x; sub $a0, $zero, $a0
exit(0); suite :
} la $a1, val_abs
sw $a0, 0($a1)
ori $v0, $zero, 10
syscall
Exemple 11: Un autre programme.

.data
x: .word -5
void main() val_abs : .word 0
{ .text
int x = -5; __start :
int val_abs; la $a0, x
lw $a0, 0($a0)
if (x <= 0)
bgtz $a0, vrai
val_abs = -x; sub $a0, $zero, $a0
else j suite
val_abs = x; vrai :
exit(0); add $a0, $a0, $zero
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

strlen:
addi $v1, $zero, 0 # $v1 = 0
int strlen(char *s )
loop:
{
lb $a2, 0 ($a1)
int i = 0;
beq $a2, $zero, end
while (*s != 0)
addi $v1, $v1, 1 # $v1 = $v1 + 1
{
addi $a1, $a1, 1
i ++ ;
J loop
s ++ ;
end:
}
add $v0, $v1, $zero
return( i ) ;
Jr $ra # 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
char *maj(char *s ) maj:
{ addi $v1, $a1, 0 # $v1 = $a1
char *c ; loop:
c=s; lb $a2, 0 ($v1)
while (*s != ‘\0’) beq $a2, $zero, end
{ andi $a2, $a2, 0xDF # $a2 = $a2 and 11011111b
*s = *s & 0xDF; sb $a2, 0($v1)
s++ ; addi $v1, $v1, 1
} J loop
return(c) ; end:
} Jr $ra # Retour Fonction
Exemple 14: Calcul PGCD(a, b)

pgcd(0, b) = b si a = 0
pgcd(a, b) = pgcd(|a-b|, min(a,b) ) (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

pgcd :
while :
int pgcd(int a, int b )
beq $a0, $zero, endwihe
{ sub $t10, $a0 , $a1
while (a) bgez $t10, else
if (a < b) sub $a1, $a1 , $a0
b = b-a; j endif
else else :
a = a-b; sub $a0, $a0 , $a1
endif :
return( b) ;
j while
}
endwhile :
add $v0,$a1, 0
Jr $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
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
int nb_un(long int a) nb_un :

{ ori $a0, $zero, 0
int i = 0 ; ori $a2, $zero, 0x80000000
unsigned long int masque = 0x80000000; do :
do { and $a3, $a1, $a2
if (a & masque) beq $a3, $zero, finsi
i++ ; addi $a0, $a0,1
masque = masque >> 1 ; finsi:
} srl $a2, $a2, 1
while (masque != 0) ; bne $a2, $zero , do
return( i ) ; Jr $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 inconditionnelle-
ment 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 # met 123 dans l’argument
ori $v0, $zero, 1 # code de ’print_int’
syscall # 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 # code de ’read_integer’
syscall # $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 sys-
tème numéro 4 pour l’afficher.
str:
.asciiz "Chaîne à afficher\n"
…
la $a0, str # charge le pointeur dans $a0
ori $v0, $zero, 4 # code de ’print_string’
syscall # 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 256
la $a0, read_str # charge le pointeur dans $a0
ori $a1, $zero, 255 # charge longueur max dans $a1
ori $v0, $zero, 8 # code de ’read_string’
syscall # lit la chaîne
 quitter :
L’appel système numéro 10 effectue l’exit du programme au sens du langage C.
ori $v0, $zero, 10 # indique l’appel à exit
syscall # quitte pour de bon!
Exemple 16:

.data
main() s1 : .asciiz "Donner un entier\n"
{ s2 : .asciiz "L’entier est "
int n ; .text
main :
printf("Donner un entier\n");
la $a0, s1
scanf("%d", &n); ori $v0, $zero, 4
syscall
printf("L’entier est %d\n", n);
ori $v0, $zero, 5
exit(0); syscall
add $a1, $v0, $zero
}
la $a0, s2
ori $v0, $zero, 4
syscall
add $a0, $a1, $zero
ori $v0, $zero, 1
syscall
ori $v0, $zero, 10
syscall
33
Catégorie Instruction Exemple Signification

addition add $1,$2,$3 $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 $1,$2,$3 $1 = $2 - $3
Arithmétique add immédiat non signée addiu $1,$2,100 $1 = $2 + 100
Multiply signed Mult $1 , $2 LO = ($1 *$2) 31..0 HI =($1 *$2) 63..32
Multiply unsigned Multu $1 , $2 LO = ($1 *$2) 31..0 HI =($1 *$2) 63..32
Divide signed Div $1 , $2 L0 = Quotient , HI = reste
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
or or $1,$2,$3 $1 = $2 | $3
and immediate andi $1,$2,100 $1 = $2 & 100

Logique
or immediate ori $1,$2,100 $1 = $2 | 100
xor xor $1,$2,$3 $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
Décalages 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 $1, $2, 10 $1 = $2 >>* 10
34
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 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]
transfert 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 $1,100 $1 = 100 * 216
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 if ($1 >= 0 ) go to label
Branch if greater than zero bgtz $1, label if ($1 > 0 ) go to label
branchements
Conditionnels Branch if less or equal zero blez $1, label if ($1 <= 0 ) go to label
Branch if less than zero bltz $1, label if ($1 < 0 ) go to label
Branch if greater or equal zero and $ra = PC + 4;
bgezal $1, label
link if ($1 >= 0 ) go to label
$ra = PC + 4;
Branch if less than zero and link gltzal $1, label
if ($1 < 0 ) go to label
jump j label goto lable
branchements
jump and link jal label $ra = PC + 4; go to label
inconditionnel
jump register jr $ra PC = $ra ( i.e. return)
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
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 instruc-
tions, macro-instructions ou directives qui les suivent. Sur ces six directives, deux sont dynamique-
ment 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 Passage dans la section text dans le segment utilisateur.
 .data Passage dans la section data dans le segment utilisateur.
 .stack Passage dans la section stack dans le segment utilisateur.
 .ktext Passage dans la section text dans le segment noyau.
 .kdata Passage dans la section data dans le segment noyau.
 .kstack 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 -1, -1000, -100000, 1, 1000, 100000
 .half Positionne des demi-mots successifs aux valeurs des expressions.

.half expression, [expression,] : : :
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 0 , 1024
 .byte Positionne des octets successifs aux valeurs des expressions.

.byte expression, [expression,] : : :
La valeur de chacune des expressions est tronquée à 8 bits, et les valeurs ainsi obtenues sont pla-
cées à des adresses successives de la section active.
Exemple 19
table:
.byte 1, 2, 4, 8, 16, 32, 64, 32, 16, 8, 4, 2, 1
 .align 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, demi-
mots et mots.
Exemple 22
.align 2
.byte 12
.align 2
.byte 24
 .ascii Déclare et initialise une chaîne de caractères

.ascii 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 "Bonjour, Maître!\n\0"
 .asciiz Déclare et initialise une chaîne de caractères, en ajoutant un zéro binaire à la fin.
.asciiz 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 "Bonjour, Maître!\n"
 .space Reserve expression octets, et les mets à zéro

.space 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: .word 3, 6, 8, 9, 2
37
Exemple 23 :

void main() .data
{ tab : .word 3, 6, 8, 9, 2
int i = 5; .text
int tab[5] = {3,6,8,9,2}; main :
int somme = 0; ori $a0, $zero, 0 #somme
do ori $a1, $zero, 5 #taille
somme += tab[ --i ]; la $a2, tab
while ( i ) ; bcl:
printf(" %d ",somme); lw $a3, 0($a2)
exit(0); add $a0, $a0, $a3
} addui $a2, $a2, 4
$a0 ≡ somme ; addui $a1, $a1, -1
$a1 ≡ i ; bne $a1, $zero, bcl
$a2 ≡ tab ; ori $v0, $zero, 1
syscall
ori $v0, $zero, 10
syscall
38
Architecture des Ordinateurs 2eme année LMD Informatique 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éve-
loppent et se rétrécissent. Si la taille combinée des segments excède l'espace disponible leurs fron-
tiè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 Libre
$sp - 4 Libre
$sp Push Pop
Tout au début le registre de pile $sp est initialisé à 0x7FFF0000 (l'adresse juste au-dessus du seg-
ment .stack).
Push (empiler)
Pour notre pile de données 4-octets, ajouter un article signifie soustraire quatre de $sp et stoc-
ker l'article dans cette adresse. Cette opération s'appelle : empiler
Exemple : Empiler le contenu du registre $t0
subu $sp, $sp, 4 # Mettre à jour $sp ,
sw $t0, ($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 $t0, ($sp) # Copie le sommet dans $t0.
addu $sp, $sp,4 # $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 appe-
lé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 ins-
tructions 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 re-
gistre $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 appe-
lé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 appe-
lant. 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 uti-
lisé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 argu-
ments, 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 argu-
ment à 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 ins-
truction 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 com-
mence 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éces-
saires ainsi que les variables locales stockées dans la pile, puis écrit la valeur de retour dans le re-
gistre $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 fonc-
tion 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
A(na-1)
Zone des argu- … • A(i) : ième argument
ments A(1)
A(0) • R(i) : ième registre
$ra
• V(i) : ième variable locale
Zone de sauve- R(0)
garde des re- R(1) • na: nombre d’arguments
gistres …
R(nr-1) • nr: nombre de registres
V(0)
Zone des va- V(1) • nv: nombre de variables locales
riables locales
…
V(nv-1) 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:

.stack 4 val_abs:
int val_abs(int n) .text addiu $sp, $sp, -8
{ main : sw $ra, 4($sp)
if (n < 0) ori $a0, $zero, -5 sw $a0, 0($sp)
return -n; addiu $sp, $sp, -4 lw $a0, 8($sp)
else sw $a0, 0($sp) add $v0, $a0, $zero
return n; jal val_abs bgez $a0, suite
} addiu $sp, $sp, 4 sub $v0, $zero, $a0
main() or $a0, $v0, $zero suite :
{ ori $v0, $zero, 1 lw $ra, 4($sp)
printf("%x", syscall lw $a0, 0($sp)
val_abs(-5)); ori $v0, $zero, 10 addiu $sp, $sp, 8
exit(0); syscall jr $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 va-
leurs
 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:

.data echange:
void echange (int * a, var1 : .word 8 addiu $sp, $sp, -20
int * b) var2 : .word 5 sw $ra, 16($sp)
{ .stack 4 sw $a0, 12($sp)
.text sw $a1, 8($sp)
int tmp;
main : sw $a2, 4($sp)
tmp = *a; la $a0, var1 sw $a3, 0($sp)
*a = *b; la $a1, var2 lw $a0, 20($sp)
*b = tmp; addiu $sp, $sp, -8 lw $a1, 24($sp)
} sw $a0, 0($sp) lw $a2, 0($a0)
main() sw $a1, 4($sp) lw $a3, 0($a1)
{ jal echange sw $a3, 0($a0)
addiu $sp, $sp, 8 sw $a2, 0($a1)
int a = 8, b = 5;
lw $a0, 0($a0) lw $ra, 16($sp)
echange(&a, &b); ori $v0, $zero, 1 lw $a0, 12($sp)
printf("%d %d",a, b); syscall lw $a1, 8($sp)
exit(0); lw $a0, 0($a1) lw $a2, 4($sp)
} ori $v0, $zero, 1 lw $a3, 0($sp)
syscall addiu $sp, $sp, 20
ori $v0, $zero, jr $ra
10
syscall
Exemple 3 : fonctions récursives
factorial:
bgtz $a0, doit
int fact ( int n ) ori $v0, $zero, 1 # cas 0! = 1
{ jr $ra
if ( n <= 0 ) return (1) ; doit:
return ( n * fact (n − 1) ); subi $sp, $sp, 8 #
}; sw $s0, ($sp) #
sw $ra, 4($sp) # adresse
 n dans $a0 ori $s0, $a0 ,0 # sauver l’argument

subi $a0, $a0, 1 # n-1
jal factorial # $v0 = (n-1)!
mult $v0,$s0 # n*(n-1)!
mflo $v0
lw $s0, ($sp) # restaurer les registres

lw $ra, 4($sp)
addi $sp, $sp, 8
jr $ra
44
Architecture des Ordinateurs 2eme année LMD Informatique CHAP IV : Conception du jeu d’instruction
CHAP IV 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 permet-
tent 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 pro-
cesseur:
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 lon-

gueur 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 uti-
lisant 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 010 011 100 101 110 111
000 SPECIAL BCOND J JAL BEQ BNE BLEZ BGTZ
001 ADDI ADDIU SLTI SLTIU ANDI ORI XORI LUI
010 COPRO
011
100 LB LH LW LBU LHU
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
000 001 010 011 100 101 110 111
000 SLL SRL SRA SLLV SRLV SRAV
001 JR JALR SYSCALL BREAK
010 MFHI MTHI MFLO MTLO
011 MULT MULTU DIV DIVU
100 ADD ADDU SUB SUBU AND OR XOR NOR
101 SLT SLTU
110
111
Lorsque le code opération a la valeur BCOND, il faut analyser les bits 20 et 16 de l'instruction. Lors-
que 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 lo-
giques 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 format R
 ADDI : rd ← rs op IMD format I
L’opérande immédiat 16 bits est signé pour les opérations arithmétiques et non signé pour les opéra-
tions 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 or-
dinal 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 20 15 10 5 0 Instr
0 0 RT RD SA 0 sll 8 RS RD Constante signée addi
0 0 RT RD SA 2 srl 9 RS RD Constante signée addiu
0 0 RT RD SA 3 sra 10 RS RD Constante signée slti
0 RS RT RD 0 4 sllv 11 RS RD Constante signée sltiu
0 RS RT RD 0 6 srlv 12 RS RD Cte non signée andi
0 RS RT RD 0 7 srav 13 RS RD Cte non signée ori
0 RS 0 8 jr 14 RS RD Cte non signée xori
0 RS 0 RD 0 9 jalr 15 RD Cte non signée lui
0 numéro 12 syscall
16 0 RD CS mfco
0 numéro 13 break
16 4 RS CD mtco
0 0 RD 0 16 mfhi
16 8 0 offset bcof
0 RS 0 17 mthi
16 8 1 offset bcot
0 0 RD 0 18 mflo
16 16 0 1 tlbr
0 RS 0 19 mtlo
16 16 0 2 tlbwi
0 RS RT 0 24 mult
16 16 0 6 tlbwr
0 RS RT 0 25 multu
16 16 0 8 tlbp
0 RS RT 0 26 div
16 16 0 16 rfe
0 RS RT 0 27 divu
0 RS RT RD 0 32 add 32 RS RD offset lb
0 RS RT RD 0 33 addu 33 RS RD offset lh
0 RS RT RD 0 34 sub 35 RS RD offset lw
0 RS RT RD 0 35 subu 36 RS RD offset lbu
0 RS RT RD 0 36 and 37 RS RD offset lhu
0 RS RT RD 0 37 or 40 RS RT offset sb
0 RS RT RD 0 38 xor 41 RS RT offset sh
0 RS RT RD 0 39 nor 43 RS RT offset sw
0 RS RT RD 0 42 slt
0 RS RT RD 0 43 sltu
1 RS 0 offset bltz
1 RS 1 offset bgez
1 RS 16 offset bltzal
1 RS 17 offset bgezal
2 Adresse mot j
3 Adresse mot jal
4 RS RT offset beq
5 RS RT offset bne
6 RS 0 offset blez
7 RS 0 offset bgtz
48
4. Interface du Processeur
L'interface entre le processeur et la mémoire est réalisé par les
signaux ADR[31:0], DATA[31:0], RW[2:0], FRZ, BERR. Les RW REQUETE
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
faible de ADR n'est pas pris en compte). 1** RW lecture d'un mot
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 proces-
seur 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 proces-
seur 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écom-
pose en une partie opérative et une partie contrôle. La
partie opérative (PO) contient les registres et les opéra-
teurs. 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 par-
tie 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 com-
mande 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 pro-
cesseur possède 3 registres internes:
• IR Registre instruction qui mémorise l'instruc-
tion 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 par-
tie contrôle.
Le processeur possède deux bus opérandes X et Y
et une seule "boîte à opérations" capable d'effec-
tuer des opérations logiques, arithmétiques, mais
aussi des opérations de comparaison, ou des déca-
lages 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éra-
tions 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éra-
tive est capable d'effectuer deux transferts élémen-
taires à chaque cycle: un transfert interne (qui uti-
lise 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, calcu-
lé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 consti-
tuent 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 ci-
dessous :
- 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
Architecture des Ordinateurs 2eme année LMD Informatique CHAP V : Exeptions et Interruptions
CHAP V 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 proces-
seur est en mode utilisateur, seul le segment utilisateur est accessible. Le processeur part en excep-
tion si une instruction essaie d'accéder à la mémoire avec une adresse correspondant au segment sys-
tè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écia-
lisée qui s’exécute en mode superviseur, à qui il faut transmettre les informations minimales lui per-
mettant 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 sys-
tè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 probable-
ment 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 sauvegar-
der 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 re-
gistre 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'excep-
tions. 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
 é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 trai-
tement 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 sys-
tè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 pro-
gramme à 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 :
 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 SYS-
CALL 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 re-
gistre 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éca-
lage 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) re-
pré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 INT Interruption
0001 Inutilisé
0010 Inutilisé
0011 Inutilisé
0100 ADEL Adresse illégale en lecture
0101 ADES Adresse illégale en écriture
0110 IBE Bus erreur sur accès instruction
0111 DBE Bus erreur sur accès donnée
1000 SYS Appel système (SYSCALL)
1001 BP Point d'arrêt (BREAK)
1010 RI Codop illégal
1011 CPU Coprocesseur inaccessible
1100 OVF Overflow arithmétique
1101 Inutilisé
1110 Inutilisé
1111 Inutilisé
56
Architecture des Ordinateurs 2eme année LMD Informatique CHAP VI: Pipline
CHAP VI 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 ins-
truction.
Exemple 1 : Add Rd, Rs, Rt
Etapes :
1. Lire l'instruction
2. Décoder l'instruction
3. Extraire les opérandes
4. Effectuer le calcul : Add
5. Mettre le résultat dans Rd
6. Calcul de l'adresse de l'instruction suivante
Exemple 2: Lw Rt, I(Rs)

Etapes :
3. Extraire les opérandes Rt, Rs, I
4. Effectuer le calcul I(Rs)
5. Accès mémoire : lecture
6. Résultat dans Rt
7. Adresse suivante
Exemple 3: Sw Rt, I(Rs)
Etapes :
3. Extraire les opérandes Rt, Rs, I
4. Effectuer le calcul I(Rs)
5. Accès mémoire : écriture
6. Adresse suivante
Exemple 3: Jr Rs
Etapes :
3. Extraire l'opérande
4. Adresse suivante
On en tire alors un schéma d'exécution général pour le R3000:

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
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 pro-
cesseur, 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 ins-
truction 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. Les étages du pipeline doivent être équilibrés
2. Calibrer l'horloge sur l'étage le plus long
3. Les étages doivent être séparés par des registres
4. Le matériel doit être spécifique à l'étage
58
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 dis-
ponible. Ainsi, la séquence:
 add $at, $v0, $v1 // $at = $v0 + $v1
 sw $at, 1000($zero) // (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 inter-
dépendantes. Prenons par exemple la séquence suivante :
1: add $t0, $t1, $t2
2: add $t3, $t0, $t2
3: add $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 com-
pilateurs quand on ne précise pas d'option d'optimisation du code :
1: add $t0, $t1, $t2
1b: NOP
2: add $t3, $t0, $t2
3: add $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
Architecture des Ordinateurs 2eme année LMD Informatique 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; 1001 0001.
• Effectuer sur 8 bits les opérations binaires suivantes:
76H+64H; 4AH+DEH ; 8CH+9AH ; 47H -3BH ; 6EH - BOH; B4H - 95H
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é.
• 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.
3. 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
4. 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
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 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:
Programmez en assembleur MIPS les expressions (variables à 32 bits):
1. x = y+z–2*t
2. S = a* x2 + b * x + c
3. S = a2 + b2 + c2
4. (x + 5 - y) * 35 / 3
Exercice 5:
a. Supposez que $a0 = 0x1234 et $a1 = 0x3. Quelle est la valeur du registre $t0 après
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
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
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 si A mod B = 0
= PGCD(B , A mod B ) sinon
b) PPCM(A, B) = PPCM(A’, B’) = A' si A' = B'

= PPCM(A' + A, B') si A' < B'
= PPCM(A', B'+ B) si B' < A'
au départ A' = A , B’ = B
c) Fn = 1 si n = 0 ou n = 1
= Fn-1 + Fn-2 si n > 1
d) A*B = 0 si B = 0
= (2*A) * ( B div 2) si B est pair
= (2*A) * ( B div 2) + A si B est impair
e) Ab = 1 si b = 0
= A(b div 2) * A(b div 2) si b est pair
= A(b div 2) * A(b div 2) * A si 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
CHAP IV 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 $v0, $s7, -1
lui $t1, 0xA5A5
2. Instructions registres/registres :
srlv $t0, $t9, $s8
nor $t4, $v0, $v0
3. Adressage mémoire en mode indirect registre (le seul supporté par le MIPS) :
lh $a2, 0xFF($a0)
sb $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 $ra, $k1

j plus
bne $v0, $v1, plus
bltz $v1, moins
syscall
mfc0 $ra, $13
Décodage :
0x00031880
0x00021080
0x3C16FFFF
0x00A21026
0x80E30006
0xAE2200C8
66
Registres Nom Description
$0 $zero vaut zéro en lecture, non modifié par écriture
$1 $at Réservé à l’assembleur pour les macros. Ne doit pas être utilisé
$2 $v0 Utilisé pour les valeurs de retour des fonctions
$3 $v1 Utilisé. pour les appels systèmes. Contient le numéro d'appel de la fonction système syscall.
$4,$5,$6,$7 $a0 … $a3 Utilisés par le compilateur pour optimiser les appels de fonctions pour contenir les arguments
$8, … , $15 $t0 … $t7 Registres de travail utilisable par le code utilisateur
$16, … , $23 $s0 … $s7 Registres de sauvegardes d'usage universel
$24, $25 $t8, $t9 Registres de travail utilisable par le code utilisateur
$26, $27 $k0, $k1 Réservés aux procédures noyau.
$28 $gp Pointeur global. Constant pour tout processus .
$29 $sp Pointeur de pile
$30 $s8 Pointeur sur la zone des variables globales (section data)
$31 $ra Contient l’adresse de retour d’une fonction
Registres spéciaux
HI Poids fort du résultat d’une multiplication sur 64 bits ou reste de division.
LO Poids faible du résultat d’une multiplication sur 64 bits ou quotient de division.
PC Registre compteur de programme (Program Counter).
Registres protégés
SR Registre d’état (Status Register).
CR Registre de cause (Cause Register).
EPC Registre d’exception (Exception Program Counter). Il contient l’adresse de retour (PC+4)
BAR Registre d’adresse illégale, il contient la valeur de l’adresse illégale. (registre numéro 8)
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
Categorie Instruction Exemple Signification
addition add $1,$2,$3 $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 $1,$2,$3 $1 = $2 - $3

Arithmétique add immediat non signée addiu $1,$2,100 $1 = $2 + 100
Multiply signed Mult $1 , $2 LO = ($1 *$2)31..0 HI =($1 *$2)63..32
Multiply unsigned Multu $1 , $2 LO = ($1 *$2)31..0 HI =($1 *$2)63..32
Divide signed Div $1 , $2 L0 = Quotient , HI = reste
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
or or $1,$2,$3 $1 = $2 | $3
and immediate andi $1,$2,100 $1 = $2 & 100

Logique
or immediate or i $1,$2,100 $1 = $2 | 100
xor xor $1,$2,$3 $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

Décalages 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 $1, $2, 10 $1 = $2 >>* 10
écrire un entier : écrire une chaîne de caractères :

lire un entier :
li $4, 1234567 la $4, str
ori $2, $0, 5
ori $2, $0, 1 ori $2, $0, 4
syscall
syscall syscall
lire une chaîne de caractères :
read_str: .space 256
quitter :
la $4, read_str
ori $2, $0, 10
ori $5, $0, 255
syscall
ori $2, $0, 8
syscall
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 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]
transfert 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 $1,100 $1 = 100 * 216
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 if ($1 >= 0 ) go to label
Branch if greater than zero bgtz $1, label if ($1 > 0 ) go to label
branchements
Conditionnels Branch if less or equal zero blez $1, label if ($1 <= 0 ) go to label
Branch if less than zero bltz $1, label if ($1 < 0 ) go to label
Branch if greater or equal zero and bgezal $1, label $31 = PC + 4;

link if ($1 >= 0 ) go to label
Branch if less than zero and link gltzal $1, label $31 = PC + 4;
if ($1 < 0 ) go to label
jump j label goto label
branchements
jump and link jal label $31 = PC + 4; go to label
inconditionnel
jump register jr $31 PC = $31 ( i.e. return)
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
31 25 20 15 10 5 0
OPCOD RS RT RD SH FUNC Format R
OPCOD RS RD IMD16 Format I
OPCOD IMD26 Format J
DECODAGE OPCOD
000 001 010 011 100 101 110 111
000 SPECIAL BCOND J JAL BEQ BNE BLEZ BGTZ
001 ADDI ADDIU SLTI SLTIU ANDI ORI XORI LUI
010 COPRO
011
100 LB LH LW LBU LHU
101 SB SH SW
110
111
OPCOD = SPECIAL (INS 5:0)

000 001 010 011 100 101 110 111
000 SLL SRL SRA SLLV SRLV SRAV
001 JR JALR SYSCALL BREAK
010 MFHI MTHI MFLO MTLO
011 MULT MULTU DIV DIVU
100 ADD ADDU SUB SUBU AND OR XOR NOR
101 SLT SLTU
110
111
31 25 20 15 10 5 0 Instr
0 RS RT RD SA 0 sll
0 RS RT RD SA 2 srl 8 RS RD Constante signée addi
0 RS RT RD SA 3 sra 9 RS RD Constante signée addiu
0 RS RT RD 0 4 sllv 10 RS RD Constante signée slti
0 RS RT RD 0 6 srlv 11 RS RD Constante signée sltiu
0 RS RT RD 0 7 srav 12 RS RD Cte non signée andi
0 RS 0 8 jr 13 RS RD Cte non signée ori
0 RS 0 RD 0 9 jalr 14 RS RD Cte non signée xori
0 12 syscall 15 RD Cte non signée lui
0 13 break
16 0 RD CS mfco
0 0 RD 0 16 mfhi
16 4 RS CD mtco
0 RS 0 17 mthi
16 8 0 offset bcof
0 0 RD 0 18 mflo
16 8 1 offset bcot
0 RS 0 19 mtlo
16 16 0 1 tlbr
0 RS RT 0 24 mult
16 16 0 2 tlbwi
0 RS RT 0 25 multu
16 16 0 6 tlbwr
0 RS RT 0 26 div
16 16 0 8 tlbp
0 RS RT 0 27 divu
16 16 0 16 rfe
0 RS RT RD 0 32 add
0 RS RT RD 0 33 addu 32 RS RD offset lb
0 RS RT RD 0 34 sub 33 RS RD offset lh
0 RS RT RD 0 35 subu 35 RS RD offset lw
0 RS RT RD 0 36 and 36 RS RD offset lbu
0 RS RT RD 0 37 or 37 RS RD offset lhu
0 RS RT RD 0 38 xor 40 RS RT offset sb
0 RS RT RD 0 39 nor 41 RS RT offset sh
0 RS RT RD 0 42 slt 43 RS RT offset sw
0 RS RT RD 0 43 sltu
1 RS 0 offset bltz
1 RS 1 offset bgez
1 RS 16 offset bltzal
1 RS 17 offset bgezal
2 Adresse mot j
3 Adresse mot jal
4 RS RT offset beq
5 RS RT offset bne
6 RS 0 offset blez
7 RS 0 offset bgtz

Cours-Architecture-Des-Ordinateurs - PDF Version 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours-Architecture-Des-Ordinateurs - PDF Version 1

Transféré par

Droits d'auteur :

Formats disponibles

Architecture des Ordinateurs 2eme année LMD Informatique CHAP I : Rappels

3. Ecriture des nombres entiers

4. Ecriture des nombres fractionnaires

6. Passage d'une base quelconque à la base 10

7. Passage de la base 10 vers une base quelconque

1 ÷ 2 = 0 reste 1 a5 = 1 Donc 44 = (101100)2.

 0.3 = (0.2 3146 3146 3146) 8

De même, chaque chiffre octal représente 3 bits.

II. Codage de données

2. Codification des nombres entiers

Sur 8 bits on peut donc représenter les nombres:

 Opération arithmétique et débordement (Overflow):

3. Représentation des nombres réels (norme IEEE)

Sur 32 bits : (−1) S *1, M * 2 E −127

4. Décimaux codés binaire

 CODE DCB Décimal Codé Binaire :

5. Représentation des caractères

ASCII US défini par la norme iso-646

III. Protection contre les erreurs

CHAP I Modèle de Von Neumann

I. Modèle de Von Neumann

L’architecture, dite architecture de Von Neu-

C’est la première description d’un ordinateur dont

1. L’architecture de Von Neumann décompo-

Dans une mémoire de taille N, on a N emplacements mémoires, numérotés de 0 à N-1. Chaque

Sélecteur d’adresse (décodeur) c’est un circuit à n entrées et 2n sorties. Il permet de déterminer

c) L’unité de contrôle (commande). L'unité de contrôle organise le fonctionnement interne de la

d) Unité d’entrées-sorties : dispositifs qui permettent de communiquer avec le monde extérieur.

5. Exécution d'une instruction

Calcul de l’adresse des opérandes

Positionnement des indicateurs

CHAP II Microprocesseur MIPS R3000

2.1. Organisation de la mémoire

Un programme utilisateur utilise généralement trois sous-segments (appelés sections) dans le

2. la section data contient les données glo-

Question : Calculer l’espace de chaque section de la mémoire

2.2. Registres visibles du logiciel

Registres Nom Description

• PC Registre compteur de programme (Program Counter). Ce registre contient l'adresse de

2.3. Registres protégés

lw $t2, 0($t3) # sauve la valeur copiée dans la mémoire

Add Addition registre registre signée

Sub Soustraction registre registre signée

Addi Addition registre immédiat signée

rr ← (imm 15 16 || imm 15..0 ) + ri

Addu Addition registre registre non-signée

Addiu Addition registre immédiat non-signée

Subu Soustraction registre registre non-signée

Exemple 5: Programmez en assembleur MIPS la fonction F(X,Y,Z) = X + 2Y -3Z .

Lw Lecture d’un mot de la mémoire

Sw écriture d’un mot en mémoire

Lh Lecture d’un demi-mot signé en mémoire

Lhu Lecture d’un demi-mot non-signé en mémoire

Lb Lecture d’un octet signé en mémoire

Lbu Lecture d’un octet non-signé en mémoire

Sh Ecriture d’un demi-mot en mémoire

Sb Ecriture d’un octet en mémoire

And ET bit-à-bit registre registre

Andi ET bit-à-bit registre immédiat

Idem pour : Or , Ori , Xor, Xori , Nor

La Chargement d’une adresse dans un registre (c’est une Macro instruction! )

Exemple 6: une séquence assembleur MIPS pour calculer z = w + y;

Mult Multiplication signée

Sur 32 bits : (−1) S 1, M 2 E −127

Multiply signed Mult $1 , $2 LO = ($1 $2) 31..0 HI =($1 $2) 63..32

Multiply unsigned Multu $1 , $2 LO = ($1 $2) 31..0 HI =($1 $2) 63..32