Vous êtes sur la page 1sur 9

Devoir surveillé Examen Session : Principale Contrôle

Niveau d’Etude : 3SE Semestre : 1


Matière : Architectures avancées des processeurs Date : 3/12/2020 Heure : 8h30
Nombre de pages : 3 Durée : 1h30
Enseignants responsables : Z. Ben Azouz Documents : non autorisés

N.B :
• Calculatrices non autorisées (vous n’en avez pas besoin)
• Les réponses non justifiées ne seront pas prises en compte

Exercice 1 : Processeur MIPS (13 points )


On propose d’étudier un processeur implémentant un sous ensemble du jeu d’instructions
MIPS. Il contient 32 registres de 32 bits. Le registre $0 est câblé à 0. Toutes les instructions
sont codées sur 32 bits selon l’un des formats suivants :

Format \bits 31 - 26 25 - 21 20 – 16 15 – 11 10 - 6 5-0


RR op rs rt rd sa func
RI op rs rt imm16
J op imm26

On propose d’étudier l’exécution de la séquence d’instructions donnée par la figure 1. Le


processeur utilise une mémoire centrale qui est adressable par octet et de type Gros boutiste.
La première instruction de cette séquence est sauvegardée à l’adresse 0x04000000.

add $9, $0, $0


ori $8, $0, 0x0008
lw $10, 0x0B0C($0)
etiq1 lw $7, 0x0B00($8)
and $3, $7, $10
beq $3, $0, etiq2
sub $7, $0, $7
sw $7, 0x0B00($8)
addi $9, $9, 1
etiq2 addi $8, $8, -4
bne $8, $0, etiq1
sw $9, 0x0B00 ($0)

Figure 1 : séquence d’instructions MIPS

1
1. En utilisant le tableau 1, déterminer en hexadécimal, le contenu de la mémoire
centrale à partir de l’adresse 0x04000014 jusqu’à l’adresse 0x04000023. (7 points)

Tableau 1: Un sous ensemble d’instructions MIPS

Instruction Opération Code op func

add rd, rs, rt rd ← rs+rt 0x00 0x20


sub rd, rs, rt rd← rs – rt 0x00 0x22
and rd, rs, rt rd← rs and rt 0x00 0x24
or rd, rs, rt rd← rs or rt 0x00 0x25
xor rd, rs, rt rd← rs xor rt 0x00 0x26
slt rd, rs, rt Si rs < rt alors 0x00 0x2A
rd =1 sinon rd = 0
srlv rd, rt, rs rd= rt >> rs 0x00 0x06
srl rd, rt, sa rd= rt >> sa 0x00 0x02
sll rd, rt, sa rd= rt << sa 0x00 0x00
addi rt, rs, imm16 rt ← rs + Sign 0x08 non défini
extend(Imm)
16
andi rt, rs, imm rt← rs and Zero 0x0C non défini
extend(Imm)
16
ori rt, rs, imm rt← rs or Zero 0x0D non défini
extend(Imm)
16
xori rt, imm rt← rs xor Zero 0x0E non défini
extend(Imm)
16
lw rt, imm (rs) load word 0x23 non défini
sw rt, imm16(rs) store word 0x2B non défini
beq rs, rt, imm16 branch if rs = rt 0x04 non défini
bne rs, rt, imm16 branch if rs ≠ rt 0x05 non défini
J imm26 Jump 0x02 non défini

Le contenu de la mémoire en question correspond aux instructions suivantes :


(0x 04000014) beq $3, $0, etiq2
(0x 04000018) sub $7, $0, $7
(0x 0400001C) sw $7, 0x0B00($8)
(0x 04000020) addi $9, $9, 1

2
beq $3, $0, etiq2

En code machine, etiq2 est remplacée par le nombre de saut à faire pour se rendre à
l’instruction devant laquelle il y a l’étiquette etiq2. Sachant que l’incrémentation du PC
se fait automatiquement après la lecture de n’importe quelle instruction, le saut sera
calculé par rapport à l’instruction suivant beq. Dans de cas etiq0 est remplacée par 3 (0x
0003).

beq $3, $0, 3

Op Rs Rt imm
0x04 3 0 0x0003
000100 00011 00000 0x0003
0001 0000 0110 0000 0x0003
1 0 6 0 0 0 0 3 en hexa

sub $7, $0, $7

Op Rs rt rd 0 0x22
0 0 7 7 0 0x22
000000 00000 00111 00111 00000 100010
0000 0000 0000 0111 0011 1000 0010 0010
0 0 0 7 3 8 2 2 en hexa

sw $7, 0x0B00($8)

Op rs rt imm
0x2B 8 7 0x0B00
101011 01000 00111 0x0B00
1010 1101 0000 0111 0x0B00
A D 0 7 0 B 0 0 en hexa

addi $9, $9, 1

Op rs rt imm
0x08 9 9 0x 0001
001000 01001 01001 0x 0001
0010 0001 0010 1001 0x 0001
2 1 2 9 0 0 0 1 en hexa

Le contenu de la mémoire à partir de l’adresse 0xAAE4 et 0xAAF7


est :
3
@ mémoire en Contenu
hexa
0x 04000014 10
60
00
03
0x 04000018 00
07
38
22
0x 0400001C AD
07
0B
00
0x 04000020 21
29
00
0x 04000023 01

2. Le tableau 2 représente le contenu d’une partie de la mémoire centrale avant


l’exécution des instructions de la figure 1. Déterminer le contenu de cette partie de
la mémoire (en hexadécimal) après l’exécution. Justifier bien vos réponses, en
fournissant le résultat de l’exécution de chaque instruction. Déduire l’objectif de
cette séquence d’instructions. (6 points)

add $9, $0, $0 $9 = 0


ori $8, $0, 0x0008 $8 = 0x008
lw $10, 0x0B0C($0) $10 = 80000000
etiq1 lw $7, 0x0B00($8) $7 = B0FFF800
and $3, $7, $10 $3 = 80000000
beq $3, $0, etiq2 pas de saut
sub $7, $0, $7 $7 = 4F000800
sw $7, 0x0B00($8) Mem[0x0B08]= 4F000800
addi $9, $9, 1 $9 = 1
etiq2 addi $8, $8, -4 $8 = 4
bne $8, $0, etiq1 saut à etiq1
sw $9, 0x0B00 ($0)

4
etiq1 lw $7, 0x0B00($8) $7 = 6EFFE70E
and $3, $7, $10 $3 = 00000000
beq $3, $0, etiq2 saut etiq2
etiq2 addi $8, $8, -4 $8 = 0
bne $8, $0, etiq1 pas de saut
sw $9, 0x0B00 ($0) Mem[0x0B00]=0x00000001

Contenu après exécution du programme

@mémoire (hexa) Contenu (hexa) @mémoire(hexa) Contenu (hexa)


00000B00 00 00000B08 4F
00000B01 00 00000B09 00
00000B02 00 00000B0A 08
00000B03 01 00000B0B 00
00000B04 6E 00000B0C 80
00000B05 FF 00000B0D 00
00000B06 E7 00000B0E 00
00000B07 0E 00000B0F 00

Tableau 2 : contenu de la mémoire de l’adresse 0x0B00 jusqu’à l’adresse 0x0B0F

@mémoire (hexa) Contenu (hexa) @mémoire(hexa) Contenu (hexa)


00000B00 E0 00000B08 B0
00000B01 FD 00000B09 FF
00000B02 3C 00000B0A F8
00000B03 1E 00000B0B 00
00000B04 6E 00000B0C 80
00000B05 FF 00000B0D 00
00000B06 E7 00000B0E 00
00000B07 0E 00000B0F 00

Exercice2 : Processeur ARM (7 pts)


On propose d’étudier le jeu d’instruction ARM. Le format des instructions arithmétiques et
logiques est :

Avec :
• Cond est le code op d’une condition (tableau 4).
• I=1 si l’opérande 2 est une valeur immédiate et 0 sinon.
• S = 1 si le registre flag doit être mis à jour et 0 sinon.

5
• n : numéro du registre opérande 1.
• d : numéro du registre destination
• operand2 : deuxième opérande. Trois formats sont possibles :

o opérande registre, décalage éventuel spécifié par une constante :


11 10 9 8 7 6 5 4 3 2 1 0
#décalage Sh 0 Rm

▪ #décalage : nombre de positions de décalage


▪ Sh : type de décalage (LSL = 00, LSR= 01 , ASR=10, ROR=11)
▪ Rm : numéro du registre à décaler
o opérande registre, décalage éventuel spécifié par un registre :

11 10 9 8 7 6 5 4 3 2 1 0
Rs 0 Sh 1 Rm

▪ Rs : numéro du registre contenant le nombre de positions de décalage


▪ Sh : type de décalage (LSL = 00 , LSR= 01 , ASR=10, ROR=11)
▪ Rm : numéro du registre à décaler
o Opérande2 est une valeur immédiate qui est définie par deux variables binaires
( k et Val). La valeur immédiate est obtenue par la rotation à droite de Val par
(2k).

11 10 9 8 7 6 5 4 3 2 1 0
k Val

Les codes des différentes opérations sont donnés par la figure 2.

Figure 2 : Codes des opérations arithmétiques logique pour le processeur ARM.

Tableau 3 : codage du champ condition

6
Soit à étudier l’exécution de la séquence d’instructions donnée par la figure 3. On suppose
que la mémoire est adressable par octet, qu’elle est gros-boutiste et que la première
instruction est sauvegardée à partir de l’adresse 0xF000.

SUBS r4, r6, r5 ASR #1


Instruction 2
Instruction 3
Instruction 4

Figure 3 : Séquence d’instructions ARM


1) Déduire les instructions 2, 3 et 4 à partir du tableau 4. (5 points)
Tableau 4 : Contenu d’une mémoire d’instruction.
Adresse mémoire Contenu
(en hexa)
F004 E3
F005 84
F006 71
F007 02
F008 C0
F009 87
F00A 62
F00B 36
F00C B1
F00D C7
F00E 62
F00F E6

7
E3847102

1110 0011 1000 0100 0111 0001 0000 0010


1110 00 1 1100 0 0100 0111 0001 0000 0010
Cond 00 I Code S Rn Rd Opérande 2
op
Sans Opér ORR Pas R4 R7 k val
conditi ande de 0001 0000 0010
on 2 = mis
Imm e à
jour Imm = val (sur 32bits) après ROR
du de 2 bits
flag Imm = 0x8000000
L’instruction 2 est :
ORR R7, R4, # 0x80000000

Val sur 32bits = 0000 0000 0000 0000 0000 0000 0000 0010
Après rotation à droite de 2 bits Imm =1000 0000 0000 0000 0000 0000 0000 0000
= 0x 80000000

C0876236

1100 0000 1000 0111 0110 0010 0011 0110


1100 00 0 0100 0 0111 0110 0010 0011 0110
Cond 00 I Co op S Rn Rd Opérande 2
GT Opér ADD Pas R7 R6 Rs 0 sh 1 Rm
ande de
2 = mis 0010 0 01 1 0110
regist e à
re jour R2 LSR R6
du
flag

L’instruction 3 est :
ADDGT R6, R7, R6 LSR R2

8
B1C762E6

1011 0001 1100 0111 0110 0010 1110 0110


1011 00 0 1110 0 0111 0110 0010 1110 0110
Cond 00 I Co op S Rn Rd Opérande 2
LT Opér BIC Pas R7 R6 décalage sh 0 Rm
ande de
2 = mis 00101 11 0 0110
regist e à
re jour 6 ROR R6
du
flag

L’instruction 4 est :
BICLT R6, R7, R6 ROR #5

2) Si on suppose que le contenu du registre r5 est le double de celui du registre r6, donner
le résultat de la séquence d’instructions de la figure 3. Fournir le résultat de chaque
instruction. (2points)

SUBS r4, r6, r5 ASR #1 Un décalage à droite de R5 divise son


contenu par deux.
R5 est le double de R6 donc après décalage
R4 = 0
ORR R7, R4, # 0x80000000 R7 = 0x 80000000

ADDGT R6, R7, R6 LSR R2 Cette instruction ne sera exécutée que si la


dernière instruction qui a mis à jour le
registre flag a généré un résultat
strictement positif et sans overflow. Donc
ADDGT ne sera pas exécutée car la
dernière instruction qui a mis à jour le
registre flag est l’instruction SUBS. Celle-
ci a généré un résultat nul.
BICLT R6, R7, R6 ROR #5 Cette instruction ne sera exécutée que si la
dernière instruction qui a mis à jour le
registre flag a généré un résultat
strictement négatif et sans overflow. Donc
BICLT ne sera pas exécutée car la
dernière instruction qui a mis à jour le
registre flag est l’instruction SUBS. Celle-
ci a généré un résultat nul.

Vous aimerez peut-être aussi