Cours Archi 2011 Chap 5 La Petite Machine .pdf



Nom original: Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdfTitre: cours_archi_2011-2012Auteur: roussell

Ce document au format PDF 1.4 a été généré par PDFCreator Version 1.2.0 / GPL Ghostscript 9.0, et a été envoyé sur fichier-pdf.fr le 13/05/2012 à 13:54, depuis l'adresse IP 193.250.x.x. La présente page de téléchargement du fichier a été vue 1340 fois.
Taille du document: 89 Ko (32 pages).
Confidentialité: fichier public


Aperçu du document


5 Architecture d'un processeur
simple : la petite machine
5.1 Positionnement du problème
Pour réaliser ce processeur, il faut définir :
• la nature des traitements qu'il sera capable d'effectuer
• la taille et/ou le format des opérandes
• la capacité de transfert de données avec l'extérieur
Ces 3 points aboutissent à l'établissement
• du jeu d'instruction du processeur
• de la structure matérielle de la partie opérative
• de la structure matérielle de dialogue avec les circuits extérieurs
IUT Informatique
Calais

Architecture des ordinateurs

163

Le processeur est constitué de deux ensembles :
• la partie opérative
• la partie contrôle (séquenceur)
PROCESSEUR

Partie contrôle

Partie opérative

IUT Informatique
Calais

séquenceur

unité de
traitement

RI

unité de
gestion de la
mémoire

Architecture des ordinateurs

Structures d'échange
(BUS)
164

5.2 Jeu d'instruction
5.2.1 Modes d'adressage
• mnémonique
traitement à effectuer, mais il faut préciser quel est le
type des données (valeurs, adresses, registres ...)
il faut préciser "quoi" (traitement) et "où" (mode d'adressage)
• exemple : transfert d'un mot mémoire (MOVE)
1. Charger le registre R1 avec la valeur 05
MOVE #05, R1

R1

05

2. Charger la case mémoire d'adresse (8000)16 avec le contenu de R2
MOVE R2, $8000

M[8000]

(R2)

3. Additionner la valeur 05 au contenu de R1, le résultat est dans R1
ADD #05, R1

R1

(R1) + 05

• instruction : ensemble de µcommandes dépendant du mode d'adressage
IUT Informatique
Calais

Architecture des ordinateurs

165

• les traitements et les modes d'adressages sont liés à la structure
matérielle du processeur (possibilités de l'UAL, nombre et taille des
registres, ...)
• microprocesseurs 8 bits : destination généralement incluse dans le
mnémonique (ex : ADDA #05)
• microprocesseurs modernes : nombreux modes d'adressage dont
• adressage registre : le registre adressé est précisé dans l'instruction
ex : mise à zéro du registre R1, CLR1
R1
0
• adressage immédiat : l'opérande est inclus dans l'instruction
ex : addition de la valeur 34 avec R2
ADD #34, R2
R2
(R2) + 34
• adressage direct : l'adresse de l'opérande est inclus dans l'instruction
ex : transfert du contenu de la mémoire à l'adresse (87FF)16 dans R1
MOVE $87FF, R1
R1
(M[87FF])
IUT Informatique
Calais

Architecture des ordinateurs

166

• adressage indirect : le contenu d'un registre ou d'un mot mémoire
représente l'adresse de l'opérande
ex 1 : MOVE R1, *R2
M[R2]
(R1)
ex 2 : MOVE *$7AF2, R1
R1
(M[M[7AF2]])
• adressages composés : l'adresse effective de l'opérande est obtenue
par un calcul, généralement de type base + déplacement, où la base
est le contenu d'un registre
5.2.2 Jeu d'instruction de la petite machine
Celui-ci est volontairement réduit dans un but de simplicité, il comprend
un total de 19 instructions (seul le registre A est utilisable pour les
calculs)
• 5 instructions de calcul
• ADD : addition du registre A avec un opérande
• SUB : soustraction de A avec un opérande
• AND : et bit à bit de A avec un opérande
IUT Informatique
Calais

Architecture des ordinateurs

167

• OR : ou bit à bit de A avec un opérande
• EOR : ou exclusif bit à bit de A avec un opérande
• 4 instructions de transfert :
• LD : chargement de A avec un opérande
• ST : stockage du contenu de A en mémoire
• PUSHA : empilement du contenu de A
• POPA : dépilement de A
• 5 instructions de rupture de séquence :
• BRA : saut inconditionnel à une adresse donnée
• BSZ : saut si résultat nul
• BSC : saut si retenue
• BSV : saut si dépassement de capacité
• BSN : saut si résultat négatif
IUT Informatique
Calais

Architecture des ordinateurs

168

• 5 instructions de haut niveau :
• CALL : branchement à un sous-programme
• RET : retour d'un sous-programme
• ENTER : gestion des paramètres et des variables locales
• LEAVE : libère les paramètres et les variables locales
• END : termine le programme
• Les instructions ont toutes un opérande au plus noté $n ($ pour hexa)
• Le processeur dispose de 4 modes d'adressage :
• mode implicite : pas d'opérande (ex : END)
• mode immédiat : symbole # devant l'opérande (ex : ADD #$05)
• mode direct : aucun symbole devant l'opérande (ex : ADD $05)
• mode basé indexé : noté [RX + $dd] (ex : ADD [RX + $05])
IUT Informatique
Calais

Architecture des ordinateurs

169

• Les instructions, les opérandes et les adresses : 8 bits
• Les transferts processeur / mémoire : bus de 8 bits
• Remarque : une adresse de 8 bits ne code que 256 mots mémoire !
5.2.3 Structure des instructions :
• codées sur 2 octets :
• le premier contient le code opération ET le mode d'adressage (destiné
à RI)
• le second précise, selon le mode d'adressage, une valeur, une adresse
(destinée à TA) ou un index (pour faire RX+...)
adresses
une instruction

i-2
i
i+2

code op.

opérande

i-1
i+1
i+3

1 mot mémoire = 1 octet
IUT Informatique
Calais

Architecture des ordinateurs

170

Les instructions sont classées en 4 groupes fonctionnels :
• instructions de calcul selon le mode :
immédiat :
direct :
basé-indexé :

ADD #$dd
ADD $dd
ADD [RX+$dd]

A
A
A

A + dd
A + M[dd]
A + M[(RX)+dd]

A
A
A

dd
M[dd]
M[(RX)+dd]

• instructions de transfert selon le mode :
immédiat :
LD #$dd
direct :
LD $dd
basé-indexé :
LD [RX+$dd]
ST n'a pas de mode immédiat !

ST #$dd

• instructions de branchement (séquencement) selon le mode :
immédiat :
direct :
basé-indexé :

BRA #$dd
BRA $dd
BRA [RX+$dd]

CP
CP
CP

dd
M[dd]
M[(RX)+dd]

• les instructions de haut niveau et la gestion de la pile sont détaillées plus
loin
IUT Informatique
Calais

Architecture des ordinateurs

171

5.2.4 Codage des instructions
• Le premier octet d'une instruction peut être divisé en 2 champs :
7 6 5 4 3 2 1 0

champ opération
INST<6:1>

champ d'adressage
INST<7+0>

7 6 5 4 3 2 1 0

instruction

IUT Informatique
Calais

groupe

Architecture des ordinateurs

172

mode d’adressage
7 6 5 4 3 2 1 0

instruction

groupe

Bits 7 et 0 :

00
01
10
11

mode immédiat
mode direct
mode basé indexé
mode implicite

Bits 2 et 1 :

00
01
10
11

instruction de haut niveau
instruction de calcul
instruction de transfert
instruction de rupture de séquence

IUT Informatique
Calais

Architecture des ordinateurs

173

Bits 6 à 3 :

IUT Informatique
Calais

0001
0010
0100
1000
0011

ADD
SUB
AND
OR
EOR

0001
0010
0100
1000

LD
ST
PUSHA
POPA

0001
0010
0100
1000
0011

BRA
BSC
BSZ
BSV
BSN

0001
0010
0100
1000
0011

CALL
RET
ENTER
LEAVE
END

Architecture des ordinateurs

174

Exemple : ADD #$05
• adressage immédiat : bits 7 et 0 : 00
• instruction de calcul : bits 2 et 1 : 01
• addition : bits 6 à 3 : 0001
mode d’adressage
7 6 5 4 3 2 1 0
0 0 0 0 1 0 1 0

instruction
Codage final :

IUT Informatique
Calais

7 6 5 4 3 2 1 0
0 0 0 0 0 1 0 1

groupe

0A 05

Architecture des ordinateurs

175

Exemple : BRA [RX+$2A]
• adressage basé-indexé : bits 7 et 0 : 10
• instruction de rupture de séquence : bits 2 et 1 : 11
• saut inconditionnel : bits 6 à 3 : 0001
mode d’adressage
7 6 5 4 3 2 1 0
1 0 0 0 1 1 1 0

instruction
Codage final :

IUT Informatique
Calais

7 6 5 4 3 2 1 0
0 0 1 0 1 0 1 0

groupe

8E 2A

Architecture des ordinateurs

176

ADD
SUB
AND
OR
EOR
LD
ST
PUSHA
POPA
BRA
BSC
BSZ
BSV
BSN
CALL
RET
ENTER
LEAVE
END
IUT Informatique
Calais

Implicite
-------A5
C5
------91
-C1
99

Immédiat
0A
12
22
42
1A
0C
---0E
16
26
46
1E
08
-20
---

Architecture des ordinateurs

Direct
0B
13
23
43
1B
0D
15
--0F
17
27
47
1F
09
-----

Basé-indexé
8A
92
A2
C2
9A
8C
94
--8E
96
A6
C6
9E
88
----177

Présentation de la petite machine à l’aide du logiciel …
5.3 Programmation de la petite machine
5.3.1 Saisie et exécution d’un programme simple
Additionner les nombres 21 et 13 et mettre le résultat à l’adresse $80.
LD #$15

chargement de 21 dans A

ADD #$0D

additionner 13 au registre A

ST $80

stocker A à l’adresse $80

END

fin du programme

Effectuer l’opération (17 + 08) OU (24 – 14) et stocker le résultat à
l’adresse $80 …
IUT Informatique
Calais

Architecture des ordinateurs

178

5.3.2 Codage
Les nombres sont codés en complément à 2 sur 8bits donc de -128 à 127 :
$00=0, $01=1, …, $7F=127, $80=-128, $81=-127, …, $FE=-2, $FF=-1
0000 0000

0111 1111

5.3.3 Test

1000 0000

10 :

si condition alors
action 1
sinon
action 2

1111 1111

BS[C,N,V,Z] #$30

12…26 :action 2
28 :

BRA #$46

30…44 :action 1
46 :

… suite du programme

fin si
Comparer les nombres 38 et 69 et mettre le plus grand à l’adresse $80 …
IUT Informatique
Calais

Architecture des ordinateurs

179

5.3.4 Boucle
10…2A:action

faire
action
tant que condition

2C :

BS[C,N,V,Z] #$10

2E :

… suite du programme

• D'autre boucle peuvent être réalisée : tant que ... faire (exemple ci-dessous),
pour i de x à y faire (TD-TP).
• Mettre 0 à l’adresse $80, 16 à l’adresse $81 et 3 à l’adresse $82.
tant que M[$81] > 0 faire
M[$80] = M[$80] + 1
M[$81] = M[$81] - M[$82]
fin tant que
IUT Informatique
Calais

Architecture des ordinateurs

180

5.3.5 Notations à utiliser en DS
• Nombres en hexadécimal ($dd) et codés en complément à 2
• Utilisation d’étiquettes au lieu d’adresses pour les sauts. Les étiquettes sont
définies en début de ligne (finsi : , sizéro : , …)
• Des variables sont utilisées au lieu de leurs adresses (i=$81, ADD i, …)
Variables :

x = $81
res = $80

(variable x lue et stockée à l’adresse $81)
(variable res lue et stockée à l’adresse $80)

Programme : LD #$06 (# : mode immédiat donc registre A = 6)
ADD #$12 (# : mode immédiat donc registre A + 18)
ST x
(x=6+18)
LD #$18
(# : mode immédiat donc registre A = 24)
SUB x
(mode direct donc registre A = A – x)
BSZ sizéro (saut à l’étiquette sizéro si le résultat est 0)
LD #$01
ST res
BRA finsi (saut inconditionnel à l’étiquette finsi)
sizéro : LD #$FF
ST res
finsi : END
IUT Informatique
Calais

Architecture des ordinateurs

181

5.3.6 Appel à un sous-programme
• Utilisation des instructions de haut niveau CALL, RET, ENTER et
LEAVE
• CALL permet d'appeler un sous-programme (selon le mode) :
immédiat :

CALL #$dd

direct :
basé-indexé :

CALL $dd
CALL [RX+$dd]

appelle le sous-programme
se trouvant à l'adresse dd
... à l'adresse M[dd]
... à l'adresse M[(RX)+dd]

• RET permet de revenir au programme appelant lorsque le sousprogramme est terminé :
mode implicite : RET

IUT Informatique
Calais

Architecture des ordinateurs

182

• Exemple :
00
...
2E
30
...
...
...
40
42
44
...
...
...
5A
5C

...
...
CALL #$42
...
...
...
...
...
ADD #$23
...
...
...
...
RET


CP = 00+1+1=2
CP = CP+1+1= …
CP = CP+1+1= 30

CP = 42+1+1=44
CP = CP+1+1= 46
CP = CP+1+1= …

CP = CP+1+1= 5C
CP = 30

Problème : comment se rappeler que c’est à l’adresse 30 qu’il faut revenir ?
IUT Informatique
Calais

Architecture des ordinateurs

183

• Gestion de l’adresse de retour : utilisation d’une pile (pointée par SP)
• Lorsque l’instruction CALL est appelée, l’adresse de retour est empilée.
CALL #$dd

:

M[SP]
SP
CP

CP
SP-1
dd

empiler $30
saut à $42

• À la fin du sous-programme, lorsque RET est appelé, l’adresse est
récupérée sur la pile
dépiler $30
RET
:
SP
SP+1
dans CP donc
CP
M[SP]
saut à $30
• L’utilisation de la pile permet l’imbrication de plusieurs appels à des
sous-programmes
• Visualisation des appels avec la petite machine …

IUT Informatique
Calais

Architecture des ordinateurs

184

5.3.7 Passage de paramètres et variables locales à un sous-programme
• Les paramètres sont passés aux sous-programmes en les mettant sur la pile
• De même les variables locales sont allouées aux sous-programmes en les
mettant sur la pile
• L’accès aux paramètres et aux variables locales d’une fonction se fait
impérativement en utilisant le mode basé-indexé ([RX+dd]) : RX indique
l’endroit sur la pile correspondant au sous-programme en cours
• Les paramètres sont empilés avant l’appel au sous-programme à l’aide de
l’instruction PUSHA et dépilés après l’appel à l’aide de l’instruction POPA
• Exemple :

IUT Informatique
Calais

00
02
04
06
08
0A
0C
0E

LD #$42
PUSHA
LD #$A5
PUSHA
CALL #$16
ST $80
POPA
POPA

Architecture des ordinateurs

variable res=$80
étiquette f à l’adresse $16
res:=f(66,165)

185

• Les variables locales sont allouées à l’aide de l’instruction ENTER :
ENTER est la première instruction d’un sous-programme et permet de
choisir le nombre de variables locales.
Le registre RX est la base du mode basé-indexé : comme les variables
locales et les paramètres sont sur la pile, RX doit contenir le sommet de la
pile pour y accéder en mode basé-indexé
mode implicite : ENTER #$dd M[SP]
(dd indique le nombre de
SP
variables locales désirées)
RX
SP

RX
empiler RX courant
SP – 1
: RX=sommet de pile
SP
SP - dd : réserver dd cases sur la pile

• Les variables locales sont libérées (enlevées de la pile) et l’ancien
contenu de RX (avant l’appel) récupéré à l’aide de l’instruction LEAVE :
mode implicite : LEAVE

IUT Informatique
Calais

SP
SP
RX

récupérer ancien som. de pile
RX
SP + 1 dépiler RX pour récupérer
M[SP]
son ancienne valeur

Architecture des ordinateurs

186

• État de la pile suite à un appel à un sous-programme ayant deux
paramètres et deux variables locales :
SP
RX (base du mode
basé-indexé)

RX + 3

variable locale 2

Y

FA

variable locale 1

X

FB

RX

00

CP (adresse de retour)

0A

adresses FC
croissantes FD

paramètre 2

A5

FE

paramètre 1

42

FF

Pile
IUT Informatique
Calais

Architecture des ordinateurs

187

• Dans un sous-programmes les paramètres sont toujours accessibles aux
adresses [RX+3] et suivantes :
[RX+3]
[RX+4]
[RX+5]

dernier paramètre empilé
avant dernier paramètre empilé


• Dans un sous-programmes les variables locales sont toujours
accessibles aux adresses RX et précédentes :
[RX+0]
[RX-1]
[RX-2]

variable 1
variable 2 (attention [RX+FF] en C2)


• Si le sous-programme est une fonction, on supposera que le résultat est
stocké dans A avant de retourner au programme appelant
• Exemple : appel à un sous-programme exécutant la somme de 2
nombres puis leur différence et retournant le plus grand des deux
résultats. Le résultat final sera stocké à l’adresse 80.
IUT Informatique
Calais

Architecture des ordinateurs

188

5.3.8 Récursivité
• Un sous-programme récursif est un sous-programme qui s'appelle luimême.
Exemple : une suite d'entiers naturels

 un = un −1 + 3

u0 = 1
fonction suite (entier n) : entier
début
si (n=0) alors
retourner (1)
sinon
retourner (suite(n-1) + 3)
fin si
fin
IUT Informatique
Calais

Architecture des ordinateurs

189

• Pour utiliser la récursivité avec la petite machine il suffit, à l'intérieur du
sous-programme, de l'appeler lui-même en faisant un CALL sur sa propre
adresse de début de sous-programme :
10
12
14
...
26
...
3A
3C

...
ENTER ...
...
...
CALL #$12
...
LEAVE
RET

(début du sous-programme)

(appel récursif)

(fin du sous-programme
retour au programme
appelant)

• Vérifiez toujours le cas d'arrêt de votre sous-programme récursif
• ATTENTION : sauvegardez toujours votre programme avant de
l'exécuter car si la récursivité est trop longue ou ne s'arrête pas, la pile
déborde et écrase toute le mémoire !
IUT Informatique
Calais

Architecture des ordinateurs

190

5.4 Limites de la petite machine

• Elle ne dispose que d'un registre utilisateur : A
• toutes les opérations passent par ce registre
• de nombreuses opérations de transfert supplémentaires nécessaires

• Les opérations de l'UAL sont limitées
• pas de multiplication / division
• pas de gestion des nombres réels
• travail sur des données de 8 bits

IUT Informatique
Calais

Architecture des ordinateurs

191

• Mais la principale limite est le mode indirect qui n'est pas géré :
• Mode immédiat : valeur 3 utilisée par l’instruction
ADD #$03

A

A + 03

variable i (d’adresse 3)
• Mode direct :
contenant la valeur 7
ADD $03
A
A + M[03]
exemple :

A

A + 07

Le mode direct permet de gérer des variables
variable i (d’adresse 3) contenant
• Mode indirect : l’adresse de la variable j (d’adresse 7)
contenant la valeur 2C

ADD *$03
exemple : A

A

mémoire

A + M[M[03]]

A + M[07] : A

A + 2C

00
01
02
i 03
04
05
06
j 07
08
09
0A

...
...
...
07
...
...
...
2C
...
...
...

La variable se trouvant à l'adresse 03 contient une adresse :
cette variable est un pointeur
IUT Informatique
Calais

Architecture des ordinateurs

192

• Utilité du mode indirect :
• permet d'effectuer des calculs sur des adresses mémoire, c'est à dire
des pointeurs
• grâce au mode indirect il devient possible de gérer des tableaux, des
listes chaînées …
exemple : additionner les nombres d'un tableau de 10 entiers situés
entre les adresses $81 et $8A (le résultat est stocké à l'adresse $8B)
somme = 0
pour i de 1 à 10 faire
somme = somme + tab[i]
fin pour
3 variables :
$8B = somme
$79 = compteur (i)
$78 = adresse de l'élément de tab
IUT Informatique
Calais

00 LD #$00
02 ST $8B
04 LD #$0A
06 ST $79
08 ADD #$00
0A BSZ #$20
0C LD #$80
0E ADD $79
10 ST $78

Architecture des ordinateurs

12 LD *$78
14 ADD $8B
16 ST $8B
18 LD $79
1A SUB #$01
1C ST $79
1E BRA #$0A
20 END
193

5.5 Conclusion
• Ce chapitre vous a décrit le fonctionnement complet d'un processeur :
• organisation interne des circuits (registres, bus, UAL, ...)
• pilotage du processeur par le séquenceur (association de chaque
instruction à un cycle de microcommandes)
• définition et utilisation des instructions dans différents programmes
en langage machine (codes) et assembleur (mnémoniques)
• fonctionnement au niveau le plus proche du processeur des
concepts de base de la programmation : test, boucle, sousprogramme, passage de paramètres, variables locales, pile
d'exécution, pointeurs

IUT Informatique
Calais

Architecture des ordinateurs

194


Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 1/32
 
Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 2/32
Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 3/32
Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 4/32
Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 5/32
Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf - page 6/32
 




Télécharger le fichier (PDF)


Cours_Archi_2011_-_Chap_5_-_La_Petite_Machine.pdf (PDF, 89 Ko)

Télécharger
Formats alternatifs: ZIP



Documents similaires


cours archi 2011 chap 5 la petite machine
tp 1
chapitre 1
corrigeds1
hh struct machine
notions de structure machine

Sur le même sujet..