Contrôle « Architecture des microprocesseurs » ECE – …lysjack.free.fr/jack/ressources/68000/Correction_Controle_mars... · Contrôle « Architecture des microprocesseurs »

Contrôle « Architecture des microprocesseurs » ECE – INGE3 / PREPA MASTER Eléments de correction Durée : 2 heures - mars 2003

J. FRANCOMME [email protected] - J.M. HENRI [email protected] 1/14

É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 :

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 .

A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 CE OE WE

D0 D1 D2 D3 D4 D5 D6 D7

U1

RAM: 6132

(A0…A15)

E1

0V

A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14

CE VPP

D0 D1 D2 D3 D4 D5 D6 D7

EPROM: 2764

U2

E2

(A0…A15)

1 U3

74LS04

A15

(D0…D7)

Bus d’adresse

Bus de données



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.

A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 Combinaison la plus petite 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 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 kbits321024

4096*8= .

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élection de la RAM (U1).

A15 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 $0000 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 $0FFF

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



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 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 Combinaison la

plus petite 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 kbits256102432768*8

= .

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 1 $FFFF

$FFFF $F000

$EFFF $E000

$DFFF $D000

$CFFF $C000

$BFFF $B000

$AFFF $A000

$9FFF $9000

$8FFF

EPROM (U2)

$8000

32Ko

$7FFF $7000

$6FFF $6000

$5FFF $5000

$4FFF $4000

$3FFF $3000

$2FFF $2000

$1FFF

$1000 $0FFF RAM (U1) $0000 4ko



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 »



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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0 0 1 0 0 1 0 0 0 1 1 F F F F 9 1 2 3

ü MOVE.W 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 !).



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 sur 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.



Algorithme

Initialisations pointeurs 1. Adresse VAL ? A0 2. Adresse PAIR ? A1 3. Adresse IMPAIR ? A2 4. 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 equ $1000 VAL equ $3000 PAIR equ $3100 IMPAIR equ $3200 NBRE equ $8 org $0 dc.l $8000 dc.l START org VAL dc.b $12,$C9,$5F,$FC,$A2,$52,$3B,$FD org PAIR ds.b NBRE org IMPAIR ds.b NBRE

org DEBPROG START lea VAL,A0 (1) lea PAIR,A1 (2) lea IMPAIR,A2 (3) clr.l D0 clr.l D1 move.b #NBRE-1,D0 (4)(5) continu move.b (A0),D1 (6) lsr #1,D1 (7) bcs nbimpair (8) move.b (A0)+,(A1)+ (9A-B) jmp suite (9C) nbimpair move.b (A0)+,(A2)+ (10A-B) suite dbra D0,continu (11A-B-C) fin bra fin (12) end



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. Remarques : ü 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 MOVE.W #VAL1,D0 MOVE.W #VAL2,D1 MOVE.W D1,D5 ANDI #$0F,D5 BSR DOFOISD5 MOVE.W D6,D7 MOVE.W D1,D5 LSR.B #4,D5 ANDI.W #$0F,D5 BSR DOFOISD5 LSL.W #4,D6 BSR D6PLUSD7 FIN BRA FIN

************************************* * 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 #efface_X,CCR ABCD D7,D6 ROR.W #8,D6 ROR.W #8,D7 ABCD D7,D6 ROR.W #8,D6 RTS END



C.1.1) Complétez les documents réponses joints pages 5 et 6 en vous aidant des remarques

suivantes :

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.

3 5 * 1 1 3 5 Résultat du premier appel à la procédure D0FOISD5 3 5 . Résultat du second appel à la procédure D0FOISD5 suivi du décalage 3 8 5 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.



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) ? 3 5 * 1 2 7 0 Résultat du premier appel à la procédure D0FOISD5 3 5 . Résultat du second appel à la procédure D0FOISD5 suivi du décalage 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 aura deux additions successives. la valeur du digit étant utilisée comme compteur, il faudra un tour de plus dans la procédure D0FOISD5 pour arriver à la valeur -1 qui fait sortir de la bouc le.

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

Obtenu après le premier appel à la procédure D0FOISD5

Obtenu après le deuxième appel à la procédure D0FOISD5 puis un décalage à gauche de 4 bits.

Obtenu après l’appel à la procédure D6PLUSD7



$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



Instructions Registres

A0 A1 A2 A3 D0 PC

après

après

après

après avant après avant après avant après avant après

après

après

après

après

après

après

après

après

après

après

après

après

Instructions

après

après

après

après

après

après

après

après

après

après

après

après

après

après

après

après

MOVE.W #VAL2,D1

ANDI #$0F,D5 BSR DOFOISD5 MOVE.W D6,D7 MOVE.W D1,D5

ANDI.W #$0F,D5 BSR DOFOISD5 LSL.W #4,D6 BSR D6PLUSD7 BRA FIN

LSR.B #4,D5

CLR.W D6

Lors du premier appel de la procédure D0FOISD5

BRA NEXT ANDI #efface_X,CCR ABCD D0,D6

RTS DBF D5,SUITE

$00001000

après

après

après

après

$00001008

$0000100A

$0000100E

$00001028

$00001014

$00001016

$00001018

$0000101C

$00001028

$00001022

$00001042

$00001026

$00001028

$0000102A

$0000103C

$00001032

0

0

$00001034

0

$0000103C

//////////////////

$102E

$00001012

avant après avant après MOVE.W #VAL1,D0 $00001004

ADD.W #$0100,D6

BCC NEXT

MOVE.W D1,D5

Nom : Eléments de correction

xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx 0

FIN

Registres D0 D1 D5 D6 D7 Bit N Bit C Bit X

0 0

DOFOISD5

SUITE

NEXT

VAL1 EQU $35 VAL2 EQU $11 efface_X EQU $EF

$0011

$0035

$0011 $0001

$0035

$0035

$0011 $0001 $0001

$0035 $0350 $0385

$0000

$0000 $FFFF

$0035

$1040

Seuls les registres modifiés par l’instruction sont représentés.

$0035

$0011

$FFFF

$0385

$3500

0

0

0

0

Pas exécutée pour cet exemple.

$FFFF équivalent à « -1 »



après

après

après

après

après

après

après

après

après

après

après

après

après

après

ANDI #efface_X,CCR ABCD D7,D6 ROR.W #8,D6 ROR.W #8,D7

RTS

$00001046

0

$00001048

1

$0000104A

0

$0000104C

$0000104E

$00001050

$00001026

ROR.W #8,D6 ABCD D7,D6

D6PLUSD7

après

après

après

après

après

après

après

après

après

après

après

après

après

après

après

après

CLR.W D6

Lors du deuxième appel de la procédure D0FOISD5

BRA NEXT ANDI #efface_X,CCR

ABCD D0,D6

RTS DBF D5,SUITE

$00001028

$0000102A

$0000103C

$00001032

0

0

$00001034

0

$0000103C

/////////////////

$00001020

ADD.W #$0100,D6

BCC NEXT

DOFOISD5

SUITE

NEXT

Instructions Registres A0 A1 A2 A3 D0

PC Instructions

Registres D0 D1 D5 D6 D7 Bit N Bit C Bit X

Lors de l’appel de la procédure D6PLUSD7

Nom : Eléments de correction

$00001042

$0000

$0035

$0000 $FFFF

$0385 $8503

$3500

$8503 $0385

$102E $1040

Dans cette colonne, la valeur du compteur de programme après l’exécution de l’instruction

0

1

1

0

Ne sont indiqués que les indicateurs pris en considération dans l’instruction qui suit.



Annexe 1 – Fichier listing de l’application partie C 00000000 1 ********************************************************** 00000000 2 * ECE Mars 2003 00000000 3 * INGE3 - PREPA MASTER 00000000 4 * Contrôle Architecture des microprocesseurs 00000000 5 * J. FRANCOMME - http://francomme.fr.fm 00000000 6 * Etat initial du registre des flags : X N Z V C tous à 0. 00000000 7 ********************************************************** 00000000 9 ********************************************************** 00000000 10 * Assignations 00000000 11 ********************************************************** 00000000 =00001000 12 DEBPROG EQU $1000 00000000 =00000035 13 VAL1 EQU $35 00000000 =00000011 14 VAL2 EQU $11 00000000 =000000EF 15 efface_X EQU $EF 00000000 16 00000000 17 00000000 18 ********************************************************** 00000000 19 * Initialisation des vecteurs de démarrage 00000000 20 ********************************************************** 00000000 21 ORG $0 00000000 00008000 22 DC.L $8000 Pointeur de pile après un reset 00000004 00001000 23 DC.L DEBPROG Compteur de programme (PC) après un reset 00000008 24 00000008 25 00000008 26 ********************************************************** 00000008 27 * Programme principal 00000008 28 ********************************************************** 00001000 29 ORG DEBPROG 00001000 30 00001000 31 * Charger un registre d'adresse (A1) avec adresse de la zone des données 00001000 32 * Utilisation de l'adressage indirect pour le lecture des données 00001000 33 00001000 34 00001000 303C 0035 35 MOVE.W #VAL1,D0 00001004 323C 0011 36 MOVE.W #VAL2,D1 00001008 3A01 37 MOVE.W D1,D5 0000100A 0245 000F 38 ANDI #$0F,D5 0000100E 6100 0018 39 BSR DOFOISD5 00001012 3E06 40 MOVE.W D6,D7 00001014 3A01 41 MOVE.W D1,D5 00001016 E80D 42 LSR.B #4,D5 00001018 0245 000F 43 ANDI.W #$0F,D5 0000101C 6100 000A 44 BSR DOFOISD5 00001020 E94E 45 LSL.W #4,D6 00001022 6100 001E 46 BSR D6PLUSD7 00001026 60FE 47 FIN BRA FIN * pour éviter l'exécution des codes qui se trouvent 00001028 48 * après le programme dans la mémoire. 00001028 49 00001028 50 ********************************************************** 00001028 51 * Bibliothèques de sous-programmes 00001028 52 ********************************************************** 00001028 53 DOFOISD5 00001028 4246 54 CLR.W D6 0000102A 6000 0010 55 BRA NEXT 0000102E 023C 00EF 56 SUITE ANDI #efface_X,CCR 00001032 CD00 57 ABCD D0,D6 00001034 6400 0006 58 BCC NEXT 00001038 0646 0100 59 ADD.W #$0100,D6 0000103C 51CD FFF0 60 NEXT DBF D5,SUITE 00001040 4E75 61 RTS 00001042 62 00001042 63 D6PLUSD7 00001042 023C 00EF 64 ANDI #efface_X,CCR 00001046 CD07 65 ABCD D7,D6 00001048 E05E 66 ROR.W #8,D6 0000104A E05F 67 ROR.W #8,D7 0000104C CD07 68 ABCD D7,D6 0000104E E05E 69 ROR.W #8,D6 00001050 4E75 70 RTS 00001052 71 00001052 72 END

02 3C 00 EF CD 00 64 00 00 06 06 46 01 00 51 CD

Voilà tous les octets qu’il faut remonter pour aller à

l’étiquette essai.

Documents

Contrôle « Architecture des microprocesseurs » ECE – …lysjack.free.fr/jack/ressources/68000/Correction_Controle_mars... · Contrôle « Architecture des microprocesseurs »