Correction du contrôle 2003 - Bienvenue sur la page de Jack

Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Éléments de correction Contrôle
Architecture des microprocesseurs
Durée 2 heures
Tous les documents personnels (cours, TD, TP) sont autorisés.
La machine à calculer est autorisée.
La qualité de la présentation sera prise en compte dans le barème de notation.
Les trois parties de ce contrôle sont totalement indépendantes.
Il vous est demandé de rédiger chacune des parties sur une copie séparée.
Pensez à rappeler le numéro des questions auxquelles vous répondez.
N’oubliez pas de joindre tous les documents réponses à votre copie.
Remarque concernant les éléments de correction :
Les éléments de correction font apparaître pour les exercices, plusieurs solutions
possibles ainsi que des rappels afin d’aborder ceux-ci convenablement. Il n’était pas demandé
aux étudiants d’être aussi précis dans leur démarche.
Partie A
Architecture du microprocesseur 68000 de MOTOROLA
Décodage d’adresses
Une carte micro-programmée comporte un composant RAM et un composant EPROM
câblés sur le bus d’adresse comme indiqué ci-dessous :
(A0…A15)
(A0…A15)
Bus d’adresse
U2
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
A10
A11
A12
A13
A14
U1
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
A10
A11
E1
D0
D1
D2
D3
D4
D5
D6
D7
A 15
CE
OE
WE
U3
1
74LS04
RAM: 6132
E2
D0
D1
D2
D3
D4
D5
D6
D7
CE
VPP
0V
EPROM: 2764
(D0…D7)
Bus de données
A.1. Etude du composant RAM (U1)
(3 points / 8mn)
A.1.1) Indiquer le rôle de l’entrée E1. Quel doit être l’état actif de cette entrée E pour effectuer une
écriture d’une donnée dans la RAM (U1).
L’entrée E1 est connectée sur la broche CE (Chip Enable ou validation boîtier) du
composant RAM. Celle -ci permet au composant RAM d’être sélectionné et d’avoir son
bus de donnée connecté à celui du microprocesseur. Cette entrée est active à l’état bas.
Pour pouvoir effectuer une écriture cette entrée doit être à l’état bas ainsi que l’entrée
WE .
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
1/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
A.1.2) Déterminer la capacité du composant U1 en Kbits et en Ko.
Afin de déterminer la capacité mémoire de la mémoire RAM (U1), il faut regarder le
nombre de ligne du bus d’adresse du microprocesseur connecté sur le bo îtier mémoire.
Seules les lignes A0 ? A11 sont utilisées.
Il y a donc 12 lignes qui permettent d’avoir 212 combinaisons différentes d’adresses.
A11
A10
A9
A8
A7
A6
A5
A4
A3
A2
A1
A0
Combinaison la plus petite
A15
A14
A13
A12
0
0
0
0
0
0
0
0
0
0
0
0
0
Combinaison la plus grand e
1
1
1
1
1
1
1
1
1
1
1
1
4095
De la combinaison 0 à la combinaison 4095 il y a 4096 combinaisons soit 4096
emplacements mémoires de 8 bits (octets).
Pour la conversion en Kilo -octets, il suffit de diviser par 1024 (210 ) et cela donne 4Ko.
Pour obtenir la quantité en Kbits il faut considérer que dans un octet il y a huit bits
soit
8 * 4096
= 32kbits .
1024
A.1.3) En supposant que les lignes A15, A14, A13 et A12 du bus d’adresse sont à l’état logique
bas, déterminer la plage d’adresse occupée par le composant U1.
Pour connaître la plage d’adresses occupée par le composant, il faut considérer
l’adresse de début et l’adresse de fin. Il est donné l’état des autres bits du bus
d’adresses (A12 ? A15 ), tous à l’état logique bas pour valider la sélectio n de la RAM
(U1).
A15
A14
A13
A12
0
0
0
0
0
0
0
0
A11
A10
A9
A8
A7
A6
A5
A4
A3
A2
A1
A0
0
0
0
0
0
0
0
0
0
0
0
0
$0000
1
1
1
1
1
1
1
1
1
1
$0FFF
1
1
Soit adresse de début $0000 et adresse de fin $0FFF
$FFFF
$F000
$EFFF
$E000
$DFFF
$D000
$CFFF
$C000
$BFFF
$B000
$AFFF
$A000
$9FFF
$9000
$8FFF
$8000
$7FFF
$7000
$6FFF
$6000
$5FFF
$5000
$4FFF
$4000
$3FFF
$3000
$2FFF
$2000
$1FFF
$1000
$0FFF
RAM (U1)
$0000
4ko
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
2/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
A.2. Etude du composant EPROM (U2)
(2 points / 8mn)
A.2.1) Déterminer la capacité du composant U2 en Kbits et en Ko.
De la même manière que la question précédente :
Seules les lignes A0 ? A14 sont utilisées.
Il y a donc 15 lignes qui permettent d’avoir 215 combinaisons différentes d’adresses.
A15
Combinaison la
plus petite
A14
A13
A12
A11
A10
A9
A8
A7
A6
A5
A4
A3
A2
A1
A0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Combinaison la
plus grande
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
32767
De la combinaison 0 à la combinaison 32767 il y a 32768 combinaisons soit 32768
emplacements mémoires de 8 bits (octets).
Pour la conversion en Kilo -octets, il suffit de diviser par 1024 (210 ) et cela donne 32Ko.
Pour obtenir la quantité en Kbits il faut considérer que dans un octet il y a huit bits
soit
8 * 32768
= 256 kbits .
1024
A.2.2) Sachant que le bit A15 du bus d’adresse est inversé puis connecté à l’entrée E2 du
composant U2, déterminer la plage d’adresse occupée par le composant U2
Pour que le composant mémoire U2 (EPROM) soit sélectionné, il faut que sur l’entrée
CE soit présent un état bas ou alors que le bit d’adresse A15 soit au niveau logique
haut.
A15
A14
A13
A12
A11
A10
A9
A8
A7
A6
A5
A4
A3
A2
A1
A0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
$8000
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
$FFFF
1
$FFFF
$F000
$EFFF
$E000
$DFFF
$D000
$CFFF
$BFFF
EPROM (U2)
$C000
32Ko
$B000
$AFFF
$A000
$9FFF
$9000
$8FFF
$8000
$7FFF
$7000
$6FFF
$6000
$5FFF
$5000
$4FFF
$4000
$3FFF
$3000
$2FFF
$2000
$1FFF
$1000
$0FFF
RAM (U1)
$0000
4ko
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
3/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Partie B
Programmation dans le langage assembleur du microprocesseur 68000 de
MOTOROLA
B.1. Généralités (3 points / 14mn)
B.1.1) Donnez le nom d’une mémoire volatile.
R.A.M. : Random Access Memory ou mémoire à accès aléatoire . Vous pouviez donner
le nom des mémoires dérivées : SRAM, DRAM, …
B.1.2) Quels sont les différents bits du registre de code condition ?
Le registre de code condition (CCR) est constitué de 5 bits dont l’é tat dépend de
l’instruction ayant été exécutée. Les autres bits sont à zéro.
0
0
0
X
N
Z
V
C
B.1.3) Proposez une solution permettant de mettre à zéro le cinquième bit du registre de code
condition en partant de la droite. Décrivez convenablement votre solution.
Il s’agit de mettre à zéro le bit X du registre CCR.
Le jeu d’instructions du 68000 possède l’instruction ANDI to CCR permettant de
remettre à zéro le bit voulu du registre de code condition.
Exemple : ANDI #%1110 1111, CCR
Il est rappelé que l’opé ration logique AND a pour élément absorbant la valeur 0 et
pour élément neutre la valeur 1 ; Seul le bit X sera modifié par cette opération
de masquage.
B.1.4) Convertir la valeur $EF en binaire.
$EF ? %1110 1111 : la conversion est directe. Certains peuvent toutefois préférer
passer en décimal, puis effectuer des divisions par deux successives (c’est une
mauvaise méthode qui donne quand même le bon résultat).
B.1.5) Décrire la fonction de la ligne suivante dans un programme écrit en langage assembleur
68000.
DC.L
2
C’est une directive d’assemblage « define data constant » qui permet d’enregistrer
dans la mémoire des opérandes. Le format de l’opérande pour cette ligne est
« .L » soit 32 bits. On enregistrera donc dans la mémoire la valeur « 2 » sur 32
bits soit $00000002 ou %0000 0000 0000 0000 0000 0000 0000 0010
B.1.6) Quel est le rôle du registre PC du processeur 68000 ?
Le registre PC « program counter » contient l’adresse de la prochaine instruction
devant être exécutée. Son contenu est incrémenté en fonction du nombre
d’octets de la dernière instruction exécutée. La valeur de cette adresse est
toujours paire !
B.1.7) Montrez que l’instruction, dbf est équivalente à l’instruction dbra
Info: consulter la description de l’instruction «DBcc » dans le document annexe/jeu
d’instructions.
Il faut vous servir du polycopié « annexes » dans lequel vous avez le jeu
d’instructions (page 12 instruction DBcc) ;
« DBcc » : Cette instruction réalise trois opérations différentes : test, décrémente,
branche.
Si la condition « cc » est fausse, alors décrémenter « D » le registre indiqué
dans l’instruction et brancher « B » à l’adresse indiquée également dans l’instruction.
Si le résultat de la décrémentation donne « -1 » le rebouclage se termine et
passage à l’instruction suivante.
Dans le cas qui vous est proposé « DBF », « cc » est la condition « F », soit « jamais
égal » ou « never equal »
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
4/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Pour la deuxième instruction DBRA, il n’y a pas de condition pour réaliser la
décrémentation du registre : elle est faite systématiquement.
On remarque donc que dans les deux cas, la condition est toujours considérée comme
fausse et que les seules actions réalisées effectivement sont :
. La décrémentation du registre
. Le branchement si le contenu du registre ? -1.
Ces deux instructions sont donc équivalentes.
Vous pouviez également justifier de la façon suivante :
Dans la documentation correspondant à l'instruction DBF, il est noté :
« Most assemblers accept DBRA for DBF...”
B.1.8) Indiquer de manière simplifiée les différentes étapes pour l’enregistrement d’une donnée
dans la pile.
Lors d’une opération d’écriture dans la pile, il faut utiliser le registre A7 appelé aussi
SP « Stack pointer ». Le contenu de ce registre est systématiquement
prédécrémenté lors d’un empilage «écriture dans la pile » : le nombre de
décrémentation dépend du format de la donnée que l’on écrit dans la pile : les
seules possibilités sont le mot « W » et le long mot « L ».
Exemple : MOVE.W A0,-(A7)
Le registre A7 est décrémenté de deux unités (.W) puis les 16 bits de poids
faibles contenus dans A0 sont recopiés dans la mémoire pointée par le
registre A7. La mémoire pointée par le registre A7 s’appelle la pile.
B.1.9) Décrire les modes d’adressages mis en œuvre dans les deux instructions suivantes pour
chacun des opérande s et donner le contenu de chacun des registres 32 bits et de la mémoire
après exécution :
ü MOVEA.W #$9123, A0
Placer un opérande 16 bits « .W » dans le registre A0.
Piège : Lors d’une écriture avec un registre d’adresse, il y a
systématiquement extension d’adresse. Le bit de poids fort de
l’opérande est recopié sur les bits de poids fort du registre
d’adresse. (%1001 0001 0010 0011).
Adressage immédiat pour l’opérande source « # $9123».
Adressage direct par registre d’adresse pour l’opérande
destination « A0 ».
1
1
1
F
1
1
1
1
F
1
1
1
1
F
1
1
1
1
F
ü MOVE.W
1
1
0
0
1
0
9
0
0
1
1
0
0
1
2
0
0
0
1
1
3
A0, (A0)
Placer un opérande 16 bits « .W » contenu dans le registre
d’adresse A0 dans la mémoire dont l’adresse 32 bits est donnée
dans le registre d’adresse A0.
Adressage direct par registre d’adresse pour l’opérande source
« A0 ».
Adressage indirect pour l’opérande destination « (A0).
Le registre A0 n’est pas modifié et contient toujours la valeur
précédente : $FFFF9123
A l’adresse $FFFF9123 dans la mémoire, on retrouve sur deux
octets (un mot : .W) la valeur $9123 (en espérant que ce soit de
la RAM !).
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
5/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
B.2. Création d’un programme. (5 points / 40mn)
Objectif : Ecrire un programme permettant de trier les valeurs (8 octets) d’un tableau VAL de façon à
séparer les nombres pairs des nombres impairs comme suit :
Le tableau "VAL" se situe à l’adresse $3000
Le tableau "PAIR" qui recevra les nombres pairs se situe à l’adresse $3100
Le tableau "IMPAIR" qui recevra les nombres impairs se situe à l’adresse $3200
B.2.1) En quelques mots, indiquer une méthode permettant de déterminer si un nombre est pair ou
impair en utilisant la notion de décalage.
Première méthode - il convient de faire un décalage de 1 bit vers la droite de la donnée
préalablement enregistrée dans un registre puis de tester la retenue.
Deuxième méthode - il convient de faire une opération de masquage pour ne garder
que le bit de poids faible : ce bit est à un si le résultat du masquage est différent
de 0.
B.2.2) Sur quel indicateur d’état, le test doit-il agir pour définir la parité du nombre ?
En déduire le nom en langage assembleur des 2 tests qu’il est possible de mettre en œuvre.
Le test doit agir s ur l’indicateur de retenue : carry.
Test: BCC « branch if carry clear » ou BCS « branch if carry set ».
B.2.3) Ecrire le programme en langage assembleur 68000 à partir de l’adresse $1000,
correspondant au cahier des charges décrit ci-dessus.
Vous considèrerez un tableau VAL de 8 octets défini comme suit :
VAL
DC.B
$12, $C9, $5F, $FC, $A2, $52, $3B, $FD
Vous utiliserez les registres suivants :
D0
Contient le nombre d’octet de la chaîne VAL, initialisé à la valeur 8.
D1
Contient successivement les valeurs de la chaîne VAL.
A0
Pointe la chaîne VAL.
A1
Pointe la chaîne PAIR.
A2
Pointe la chaîne IMPAIR.
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
6/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Algorithme
Initialisations pointeurs
1.
2.
3.
4.
Adresse VAL ? A0
Adresse PAIR ? A1
Adresse IMPAIR ? A2
NBRE ? D0
; La solution proposée utilise l’instruction dbra pour le comptage du nombre des éléments
traités.
; Comme la valeur finale testée est « -1 », il ne faut pas oublier de commencer avec la valeur
; maximum moins une unité soit « NBRE-1 ».
5. Décrémenter compteur de valeur (D0) (cf. remarque ci-dessus)
6. Charger la valeur courante de la table VAL dans D1 (pointée par
A0)
Ici on n’effectue pas l’incrémentation du pointeurA0.
7. Décalage à droite du registre D1 à travers la carry.
8. Si carry = 1 sauter à impair
9. Sinon pair
A. Enregistrer la valeur courante pointée par A0 (VAL) dans
la table PAIR pointée par A1
B. Incrémenter pointeur table PAIR
C. Incrémenter pointeur sur la table VAL (A0)
D. Sauter à TEST_FIN_TABLE
10. impair :
A. Enregistrer la valeur courante pointée par A0 (VAL) dans la
table IMPAIR pointée par A2.
B. Incrémenter pointeur table impair
C. Incrémenter pointeur sur la table VAL (A0)
11. TEST_FIN_TABLE :
A. Décrémenter compteur D0
B. Si D0 ? -1 alors valeur suivante (retour au début de la boucle)
C. Sinon Fin_Application
12. Fin_Application
Le programme est donné ci-dessous :
DEBPROG
VAL
PAIR
IMPAIR
NBRE
equ
equ
equ
equ
equ
$1000
$3000
$3100
$3200
$8
org
dc.l
dc.l
$0
$8000
START
org
dc.b
org
ds.b
org
ds.b
VAL
$12,$C9,$5F,$FC,$A2,$52,$3B,$FD
PAIR
NBRE
IMPAIR
NBRE
START
continu
nbimpair
suite
fin
org
lea
lea
lea
clr.l
clr.l
move.b
move.b
lsr
bcs
move.b
jmp
move.b
dbra
bra
end
DEBPROG
VAL,A0
PAIR,A1
IMPAIR,A2
D0
D1
#NBRE-1,D0
(A0),D1
#1,D1
nbimpair
(A0)+,(A1)+
suite
(A0)+,(A2)+
D0,continu
fin
(1)
(2)
(3)
(4)(5)
(6)
(7)
(8)
(9A-B )
(9C)
(10A-B)
(11A-B-C)
(12)
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
7/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Partie C
Analyse d’un programme en langage assembleur pour le microprocesseur 68000
de MOTOROLA
C.1. Compréhension d’un programme en langage assembleur 68000 (7 points / 50mn)
Le programme suivant réalise une opération sur deux opérandes de deux digits codés en BCD.
Remarque s :
ü Vous considèrerez donc pour ces deux opérandes la représentation BCD et pas
hexadécimale : Oubliez le « $ » marqué devant l’opérande mais ne l’enlevez pas.
ü Si on ne met pas le « $ », le logiciel d’assemblage fait la conversion en hexadécimal.
*************************************
* ECE Mars 2003
* INGE3 - PREPA MASTER
* Contrôle Architecture des microprocesseurs
* J. FRANCOMME - http://francomme.fr.fm
* Etat initial du registre des flags : X N Z V
C tous à 0.
*************************************
*************************************
* Assignations
*************************************
DEBPROG EQU
$1000
VAL1
EQU
$35
VAL2
EQU
$11
efface_X
EQU
$EF
*************************************
* Initialisation des vecteurs de démarrage
*************************************
ORG
$0
DC.L $8000
Pointeur de pile
après un reset
DC.L DEBPROG
Compteur de
programme (PC) après un reset
*************************************
* Programme principal
*************************************
ORG
DEBPROG
FIN
MOVE.W
MOVE.W
MOVE.W
ANDI
BSR
MOVE.W
MOVE.W
LSR.B
ANDI.W
BSR
LSL.W
BSR
BRA
*************************************
* Bibliothèques de sous-programmes
*************************************
DOFOISD5
CLR.W
D6
BRA
NEXT
SUITE ANDI
#efface_X,CCR
ABCD
D0,D6
BCC
NEXT
ADD.W
#$0100,D6
NEXT DBF
D5,SUITE
RTS
D6PLUSD7
ANDI
ABCD
ROR.W
ROR.W
ABCD
ROR.W
RTS
#efface_X,CCR
D7,D6
#8,D6
#8,D7
D7,D6
#8,D6
END
#VAL1,D0
#VAL2,D1
D1,D5
#$0F,D5
DOFOISD5
D6,D7
D1,D5
#4,D5
#$0F,D5
DOFOISD5
#4,D6
D6PLUSD7
FIN
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
8/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
C.1.1) Complétez le s documents réponses joints pages 5 et 6 en vous aidant
suivantes :
des remarques
Remarque : Seuls les registres modifiés sont notés dans le tableau pour éviter de
surcharger le document et laisser ainsi apparaître les éléments importants . Les
valeurs du registre PC sont donné es sur 32 bits, la solution où seulement 16 bits
apparaissent est aussi valable.
Aide pour compléter les documents réponses :
ü Vous remarquerez que le sous-programme D0FOISD5 est appelé deux fois et que le
sous-programme D6PLUSD7 est appelé une seule fois à la fin de l’application : pour
les valeurs choisies.
ü Vous trouverez donc le groupe d’instructions de chaque sous-programme autant de fois
que celui-ci est appelé , sur les documents réponses.
ü Après l’exécution de chaque instruction, donnez le contenu de tous les registres cités
dans le tableau, sur la même ligne ; c'est-à-dire : D0, D1, D5, D6, D7, les bits X et C
et N du registre de code condition puis le contenu du registre PC : il faut pour cela
utiliser le fichier listing.
ü Comme cela est indispensable, le fichier listing vous est fourni en annexe 1.
ü Toutes les valeurs négatives du tableau seront notées en complément à 2.
C.1.2) Après avoir complété les documents réponses joints, il vous est demandé de déduire
l’opération effectuée par cette application sur les deux opérandes : cf. documents réponses.
L’opération effectuée se compose d’additions successives et on remarque de plus que
ces additions se font en BCD. On peut en déduire que cette opération est une
multiplication en BCD. On peut remarquer aussi qu’à la fin de l’exécution de cette
application, le résultat 385 obtenu à partir des opérandes 35 et 11 (il était demandé de
ne pas tenir compte du symbole $) est bien le résultat de l’opération 35 * 11.
C.1.3) Pour vérification, posez l’opération sur votre copie et décrivez le processus pour obtenir le
résultat.
35
*
11
35
35 .
3 85
Résultat du premier appel à la procédure D0FOISD5
Résultat du second appel à la procédure D0FOISD5 suivi du décalage
Résultat du second appel à la procédure D6PLUSD7
Description :
On considère le deuxième opérande « 11 » constitué de deux digits :
D1 D0
1 1
Comme l’addition en BCD ne se fait que sur un octet (ie les huit bits de poids
faibles du registre), l’opération se fera d’abord avec le digit D0 tout seul puis
lors d’un deuxième passage avec le second digit D1 tout seul.
Pour le premier cas, il suffit de masquer tout ce qui se trouve après le
quatrième bit (masquage avec la valeur $0F).
Pour le second cas, il faudra faire d’abord un décalage à droite de quatre bits
pour ramener le digit D1 sur les bits de poids faibles puis masquer tout ce qui
se trouve après le quatrième bit.
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
9/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
C.1.4) Quelle sera la différence dans l’exécution du sous-programme D0FOISD5 si l’opérande
VAL2 = 12 (ie : nombre de boucle) ?
Obtenu après le premier appel à la
Obtenu après le
35
procédure D0FOISD5
deuxième appel à
*
12
la procédure
7 0 Résultat du premier appel à la procédure D0FOISD5
D0FOISD5 puis un
décalage à gauche
3 5 . Résultat du second appel à la procédure D0FOISD5 suivi du décalage
de 4 bits.
4 2 0 Résultat du second appel à la procédure D6PLUSD7
On remarque que lors de l’appel de la première procédure D0FOISD5, il y
Obtenu après
aura deux additions successives. la valeur du digit étant utilisée comme
l’appel à la
compteur, il faudra un tour de plus dans la procédure D0FOISD5 pour
procédure
arriver à la valeur -1 qui fait sortir de la bouc le.
D6PLUSD7
C.1.5) La procédure D6PLUSD7 est constituée d’un certain nombre d’instructions de rotation
« ROR »
C.1.5.1) Expliquez ce que fait l’instruction « ROR » sur la donnée dont le format est celui
donné dans ce sous-programme (.W).
L’instruction effectue une rotation d’un opérande sur 16 bits (.W). Il s’agit
donc d’une permutation entre l’octet de poids faible et l’octet de poids fort (cf.
schéma de rotation dans le polycopié de cours).
C.1.5.2) Indiquez la raison de cette manipulation en utilisant le rappel sur les opérations en
BCD donné ci-dessous.
L’addition en BCD ne pouvant ce faire que sur un octet, il faut faire l’opération
d’abord sur l’octet de poids faible (positionnement éventuel de la retenue
auxiliaire X dans le registre de code condition) puis après une rotation de huit
bits vers la droite sur un message de 16 bits (pour ne rien perdre du message
correspondant au résultat) on effectue l’addition sur la deuxième partie du
résultat ayant pris la place de l’octet de poids faible.
Une fois fini cette dernière opération, il ne faut pas oublier de remettre le
résultat comme il faut en refaisant une rotation à droite de 8 bits sur le message
de 16 bits.
C.1.6) Justifier la valeur $FFF0 de la ligne 103C du fichier listing donné en annexe 1.
La valeur $FFF0 correspond à la valeur du saut à effectuer car sur cette ligne
on trouve l’instruction dbf d5, suite
Cette instruction se trouve à l’adresse $103C
La valeur du saut est calculée de la façon suivante :
A l’issue du décodage du code de l’opération sur 16 bits , c'est-à-dire
$51CD, l’instruction doit retrouver juste après, la valeur du saut, soit
$FFF0 ; cette valeur pour le saut est codée en complément à deux.
Il faut donc partir de la valeur de l’adresse après le code opération du
saut soit $103C+2=$103E qu’il faut retrancher à l’adresse à laquelle on
veut arriver c'est-à-dire l’adresse indiquée par l’étiquette « SUITE »
soit $102E (le saut est donc négatif).
La soustraction donne :
$102E
- $103E en binaire
0001 0000 0011 1110
compléme nt à deux :
1110 1111 1100 0010 ($EFC2)
Puis on additionne cette dernière valeur avec l’adresse de destination
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
10/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
$1 0 2 E
$EF C 2
$FF F 0 le résultat est négatif car le bit de poids fort est à 1.
Pour pouvoir lire la valeur directement, il faut effectuer le complément
à deux de ce résultat soit :
$FFF0 en binaire
%1111 1111 1111 0000
complément à deux %0000 0000 0001 0000
On a donc un saut de 16 octets : il ne reste plus qu’à les compter.
+
Une autre démarche consiste à évaluer la différence entre les deux lignes de
commandes (correctement !), à identifier le déplacement NEGATIF à effectuer
puis à coder ce déplacement en complément à deux.
C.1.7.synthèse) Ne répondre à cette question que si vous avez répondu à toutes les questions
précédentes ;
Proposez une modification du programme donné dans cette partie C afin de pouvoir faire la
même opération sur des opérandes de 32 bits
Remarque : Le résultat tient sur un format plus grand que celui d’origine que vous
considèrerez afin de toujours obtenir un résultat valide.
Rappel : Opération sur les chiffres décimaux codés en binaire (BCD).
ABCD ? Addition décimale sur un octet utilisant le bit X (extended carry).
Syntaxe utilisée : ABCD Dy, Dx
Additionne l’opérande source et l’opérande destination avec le contenu du bit X et
enregistre le résultat dans le registre de destination.
Registre de code condition :
ü X : Positionné à la même valeur que la retenue C
ü N : Non utilisé
ü Z : Mis à zéro si le résultat est différent de zéro, sinon inchangé.
ü V : Non utilisé
ü C : Mis à un si une retenue décimale est générée, sinon mis à zéro.
That’s all Folks …
La correction de ce contrôle sera sur Internet
à l’adresse suivante http://francomme.fr.fm
dans la rubrique Informatique Industrielle, 68000, cours.
Bon courage …
Remarque inhérente à la solution programmée : la solution proposée fonctionne parfaitement
avec l’outil de simulation « Visual simulator » (IDE68K) mais provoque un mauvais résultat avec
l’outil de simulation BSVC.
Cela est dû à une mauvaise implémentation de l’instruction ABCD (addition BCD) qui lors
de l’addition BCD ne tient pas compte de l’indicateur X du registre CCR comme cela est donné
dans la documentation constructeur.
Ces deux outils sont accessibles à partir du site http://francomme.fr.fm rubrique informatique
industrielle, 68000, travaux pratiques/liens.
ü BSVC : Windows et linux / Unix
o Sous Windows NT, nécessite les droits administrateur
ü IDE68K / visual simulator : Windows uniquement
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
11/14
Nom : Eléments de correction
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
VAL1 EQU $35
VAL2 EQU $11
efface_X EQU $EF
Seuls les
registres
modifiés par
l’instruction
sont
représentés.
FIN
DOFOISD5
SUITE
NEXT
Registres Registres
A0
D0 A1D1A2 D5A3 D0
D6
D7
Instructions
MOVE.W
MOVE.W
MOVE.W
ANDI
#VAL1,D0
#VAL2,D1
D1,D5
#$0F,D5
BSR
MOVE.W
MOVE.W
LSR.B
ANDI.W
DOFOISD5
D6,D7
D1,D5
#4,D5
#$0F,D5
BSR
LSL.W
DOFOISD5
#4,D6
avant
après
après
après
après
après
après
après
après
après
avant
après
après
avant
après
après
avant
après
après
avant
après
après
xxxxxxxx
D6
NEXT
#efface_X,CCR
D0,D6
NEXT
ADD.W
DBF
RTS
#$0100,D6
D5,SUITE
xxxxxxxx
xxxxxxxx
xxxxxxxx
0
0
Bit X
0
$0035
$0011
$0011
$0001
$0035
$0035
$0011
$0001
$0001
après
$0035
après
$0350
après
BSR
D6PLUSD7
$0035
BRA
FIN
après
Lors du premier appel de la procédure D0FOISD5
CLR.W
BRA
ANDI
ABCD
BCC
xxxxxxxx
Bit N Bit C
$0385
$0011
$FFFF
$0385
$3500
0
0
0
$0000
après
après
0
après
$0035
après
0
0
après
après
après
$0000
$FFFF
0
PC
$00001000
$00001004
$00001008
$0000100A
$0000100E
$00001028
$00001014
$00001016
$00001018
$0000101C
$00001028
$00001022
$00001042
$00001026
$00001028
$0000102A
$0000103C
$00001032
$00001034
$0000103C
//////////////////
$102E
$1040
$00001012
après
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
$FFFF équivalent à « -1 »
12/14
Pas
exécutée
pour cet
exemple.
Nom : Eléments de correction
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Ne sont indiqués que les indicateurs pris en considération dans l’instruction qui suit.
Registres Registres
A0
D0 A1D1 A2 D5A3 D0
D6
D7
Instructions
PC
Bit N
Bit C
Bit X
Lors du deuxième appel de la procédure D0FOISD5
DOFOISD5
SUITE
NEXT
CLR.W
BRA
ANDI
D6
NEXT
#efface_X,CCR
après
ABCD
BCC
D0,D6
NEXT
après
ADD.W
DBF
RTS
#$0100,D6
D5,SUITE
après
$00001028
$0000
après
après
0
$0035
0
0
0
après
après
$0000
$FFFF
$00001020
après
Lors de l’appel de la procédure D6PLUSD7
D6PLUSD7
ANDI
ABCD
ROR.W
#efface_X,CCR
D7,D6
#8,D6
après
ROR.W
ABCD
ROR.W
RTS
#8,D7
D7,D6
#8,D6
après
0
après
$0385
1
après
$8503
1
1
0
0
$3500
après
$8503
après
$0385
après
$0000102A
$0000103C
$00001032
$00001034
$0000103C
/////////////////
$102E $1040
$00001042
$00001046
$00001048
$0000104A
$0000104C
$0000104E
$00001050
$00001026
Dans cette colonne, la valeur du compteur de programme après l’exécution de l’instruction
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
13/14
Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER
Eléments de correction
Durée : 2 heures - mars 2003
Annexe 1 – Fichier listing de l’application partie C
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000 =00001000
00000000 =00000035
00000000 =00000011
00000000 =000000EF
00000000
00000000
00000000
00000000
00000000
00000000
00000000 00008000
00000004 00001000
00000008
00000008
00000008
00000008
00000008
00001000
00001000
00001000
00001000
00001000
00001000
00001000 303C 0035
00001004 323C 0011
00001008 3A01
0000100A 0245 000F
0000100E 6100 0018
00001012 3E06
00001014 3A01
00001016 E80D
00001018 0245 000F
0000101C 6100 000A
00001020 E94E
00001022 6100 001E
00001026 60FE
00001028
00001028
00001028
00001028
00001028
00001028
00001028 4246
0000102A 6000 0010
0000102E 023C 00EF
00001032 CD00
00001034 6400 0006
00001038 0646 0100
0000103C 51CD FFF0
00001040 4E75
00001042
00001042
00001042 023C 00EF
00001046 CD07
00001048 E05E
0000104A E05F
0000104C CD07
0000104E E05E
00001050 4E75
00001052
00001052
1 **********************************************************
2 * ECE Mars 2003
3 * INGE3 - PREPA MASTER
4 * Contrôle Architecture des microprocesseurs
5 * J. FRANCOMME - http://francomme.fr.fm
6 * Etat initial du registre des flags : X N Z V C tous à 0.
7 **********************************************************
9 **********************************************************
10 * Assignations
11 **********************************************************
12 DEBPROG
EQU $1000
13 VAL1
EQU
$35
14 VAL2
EQU $11
15 efface_X
EQU $EF
16
17
18 **********************************************************
19 * Initialisation des vecteurs de démarrage
20 **********************************************************
21
ORG
$0
22
DC.L
$8000
Pointeur de pile après un reset
23
DC.L
DEBPROG
Compteur de programme (PC) après un reset
24
25
26 **********************************************************
27 * Programme principal
28 **********************************************************
29
ORG
DEBPROG
30
31 * Charger un registre d'adresse (A1) avec adresse de la zone des données
32 * Utilisation de l'adressage indirect pour le lecture des données
33
34
35
MOVE.W
#VAL1,D0
36
MOVE.W #VAL2,D1
37
MOVE.W D1,D5
38
ANDI
#$0F,D5
39
BSR
DOFOISD5
40
MOVE.W D6,D7
41
MOVE.W
D1,D5
42
LSR.B
#4,D5
43
ANDI.W
#$0F,D5
44
BSR
DOFOISD5
45
LSL.W
#4,D6
46
BSR
D6PLUSD7
47 FIN
BRA
FIN
* pour éviter l'exécution des codes qui se trouvent
48
* après le programme dans la mémoire.
49
50 **********************************************************
51 * Bibliothèques de sous-programmes
52 **********************************************************
53 DOFOISD5
54
CLR.W
D6
55
BRA
NEXT
02 3C 00 EF
56 SUITE
ANDI
#efface_X,CCR
57
ABCD
D0,D6
CD 00
58
BCC
NEXT
64 00 00 06
59
ADD.W
#$0100,D6
60 NEXT
DBF
D5,SUITE
06 46 01 00
61
RTS
51 CD
62
63 D6PLUSD7
64
ANDI
#efface_X,CCR
65
ABCD
D7,D6
66
ROR.W
#8,D6
Voilà tous les octets qu’il
67
ROR.W
#8,D7
68
ABCD
D7,D6
faut
remonter pour aller à
69
ROR.W
#8,D6
70
RTS
l’étiquette essai.
71
72
END
J. FRANCOMME [email protected] - J.M. HENRI [email protected]
14/14