Couche d’architecture du jeu

d’instructions
Instruction Set Architecture - ISA
M34
GE, ENSA Marrakech

1
Définition
Une architecture de jeu d'instructions (ISA) fait partie du modèle
d’abstraction d'un ordinateur qui définit la façon dont le processeur est
contrôlé par le logiciel. L'ISA agit comme une interface entre le matériel
et le logiciel, spécifiant à la fois ce que le processeur est capable de faire
et comment il est fait.

2
Organisation d’un ordinateur

Trois composantes principales d'un ordinateur: processeur, mémoire et

entrées/sorties (ou I/Os)

 datapath +
control =
processor
(CPU)

3
Aperçu de l’architecture de MIPS

• Catégorie d’instructions
– Load/Store
– Computational R0 - R31
– Jump and Branch
– Floating Point (co-processeur)

PC
HI
LO
3 Instruction Formats, 32 bits wide
OP rs rt rd sa funct

OP rs rt immediate
OP jump target
4
Niveaux de représentation

temp = v[k];
High Level Language
Program v[k] = v[k+1];
v[k+1] = temp;
Compiler
lw $15, 0($2)
Assembly Language lw $16, 4($2)
Program sw $16, 0($2)
sw $15, 4($2)

Assembler

0000 1001 1100 0110 1010 1111 0101 1000

Machine Language
1010 1111 0101 1000 0000 1001 1100 0110
Program 1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
Machine Interpretation

Control Signal
Specification
°
°
5
Cycles d’exécution

Instruction
Fetch
Obtenir l’instruction de la mémoire du programme

Instruction
Décoder l’instruction et déterminer les actions requises
Decode

Operand Localiser et obtenir les données des opérandes

Fetch

Execute Calculer le résultat ou l’état

Result
Stocker le résultat pour une utilisation ultérieure
Store

Next
Instruction
Déterminer l'instruction suivante

6
Les instructions arithmétiques MIPS

 Instructions arithmétiques en MIPS

add $t0, $s1, $s2

sub $t0, $s1, $s2

 Chaque instruction arithmétique performe une opération

 Chacune spécifie 3 opérandes qui sont dans les registres ($t0, $s1, $s2)
destination  source1 op source2

 Format d’instruction (R) (ex. Sub)

0 17 18 8 0 0x22

7
Champs d’instructions MIPS

op rs rt rd shamt funct

op 6-bits opcode spécifie l’opération

rs 5-bits adresse du registre du premier opérande source
rt 5-bits adresse du registre du deuxième opérande source
rd 5-bits adresse du registre de l’opérande destination
shamt 5-bits shift amount (pour les instructions de décalage)
funct 6-bits Code de la fonction (function) précisant l’opcode

8
Les opérandes des registres

 Les instructions arithmétiques utilisent les opérandes registres

 MIPS a un fichier registre de 32 × 32-bit
 Utilisé pour les données fréquemment utilisés
 Numérotés de 0 à 31
 Un mot (word) est de 32 bit

 Noms des registres en assembleur

 $t0, $t1, …, $t9
 $s0, $s1, …, $s7

 Registres vs mémoires (quand c’est plus petit c’est plus rapide)

9
Fichier registre MIPS
32
 Contient 32 registres à 32 bits Register File locations
32 bits
32 src1
 2 ports pour lecture src1 addr
5 data
 1 port pour écriture 5
src2 addr

dst addr 5
src2
32 32 data
write data

write control

 L’accès aux registres est beaucoup plus rapide que l’accès à la

mémoire principale

10
Exemple d’utilisation des opérandes

 Code C:
f = (g + h) - (i + j);
 On considère que g,h,i,j sont déjà dans $s1, …,
$s4, et le résultat f va être déposé dans $s0
 Code compilé en MIPS:

add $t0, $s1, $s2

add $t1, $s3, $s4
sub $s0, $t0, $t1

11
Opérandes immédiats

 Données constante spécifiées dans l’instruction

addi $s3, $s3, 4
 Pas d’instruction de soustraction immédiate
 Le registre 0 ($zero) est la constante 0. Sa valeur ne peut pas être
changée
• Utile dans plusieurs opération comme déplacer des valeurs entre
registres
add $t2, $s1, $zero

12
Instructions immédiates MIPS

 Les petites constantes sont souvent utilisées dans les

programmes

addi $sp, $sp, 4 #$sp = $sp + 4

slti $t0, $s2, 15 #$t0 = 1 if $s2<15
 Format machine (I) (ex: slti)
0x0A 18 8 0x0F

 La constante est dans l'instruction elle-même!

 Le format immédiat limite les valeurs dans la plage +215–1 à -215

13
Constantes larges
 Si on veut transférer une constante de 32 bit (qui dépasse
16 bits) dans un registre; on le fait en deux étapes: Soit la
constante large: 0xAAAABBBB
 Utiliser l’instruction "load upper immediate"
lui $t0, 1010101010101010

 Par après on charge les 16 bits moins significatifs en utilisant

ori $t0, $t0, 1011101110111011

14
Opérations de décalage

 sll et srl décalent les bits d'un mot à gauche ou à droite

respectivement
sll $t2, $s0, 4 #$t2 = $s0 << 4 bits
srl $t2, $s0, 4 #$t2 = $s0 >> 4 bits
 Format de l’instruction (ex. sll)

0 16 10 4 0x00

 Ces opérations sont logiques logiques car après décalage

on met des 0 dans les places vidées.

15
Opérations logiques
 Il existe un certain nombre d'opérations logiques sur les bits
and $t0, $t1, $t2 #$t0 = $t1 & $t2
or $t0, $t1, $t2 #$t0 = $t1 | $t2
nor $t0, $t1, $t2 #$t0 = not($t1 | $t2)

 Format de l’instruction (R)

andi $t0, $t1, 0xFF00 #$t0 = $t1 & ff00

ori $t0, $t1, 0xFF00 #$t0 = $t1 | ff00

 Format de l’instruction (I)

16
Instructions d'accès à la mémoire MIPS

 MIPS a deux instructions de transfert de données de base pour accéder à

la mémoire
lw $t0, 4($t1) #charger la donnée de la mémoire
sw $t0, 8($t1) #stocker la donnée en mémoire

19
Exemple de load et store
lw $t0, 4($t1)
sw $t0, 8($t1)

20
Instruction lw en langage machine
 Load(I):

lw $t0, 24($s3)

35 19 8 2410

Memory
2410 + $s3 = 0xf f f f f f f f

. . . 0001 1000 0x120040ac

$t0
+ . . . 1001 0100
. . . 1010 1100 = $s3 0x12004094

0x120040ac
0x0000000c
0x00000008
0x00000004
0x00000000
data word address (hex)
21
Exemple d’opération impliquant la mémoire

 Code C:

g = h + A[8];
 g dans $s1, h dans $s2, adresse de base de A dans $s3
 Code MIPS compilé:
 l’indice 8 correspond à un offset de 32 bytes (4 bytes par mot)

lw $t0, 32($s3) # load word

add $s1, $s2, $t0

22
Exemple

 Code C:
A[12] = h + A[8];
 h dans $s2, adresse de base de A dans $s3

23
Exemple

 Code c:
A[12] = h + A[8];
 h dans $s2, adresse de base de A dans $s3
 Code MIPS compilé:

lw $t0, 32($s3) # load word

add $t0, $s2, $t0
sw $t0, 48($s3) # store word

24
chargement et stockage des Bytes

 MIPS fournit des instructions spéciales pour transférer des

Bytes
lb $t0, 1($s3) #charger le byte de la mémoire

sb $t0, 6($s3) #stocker le byte dans la mémoire

 Format machine (I) (ex: sb)

0x28 19 8 16 bit offset

25
Les opérations des sauts

 Saut à une instruction étiquetée (L1) si une condition est vrai

 sinon, continuer séquentiellement
 beq rs, rt, L1
 si (rs == rt) saut à l’instruction L1;
 bne rs, rt, L1
 si (rs != rt) saut à l’instruction L1;

 j Label1
 saut inconditionnel à l'instruction Label1

26
Compilation de l’instruction If

 Code C:
if (i==j) f = g+h;
else f = g-h;
 f, g, h, i, j … dans $s0, $s1, $s2, $s3, $s4…
 Code compilé (manuellement) en MIPS :
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit: …

27
Spécification des destinations du saut conditionnel
 Utilisation du registre PC pour calculer l’adresse du destination
du saut

28
Instruction jump
 L’instruction j correspond à un saut inconditionnel:

j label #go to label

 Format de l’instruction (J):

0x02 26-bit address

29
Exemple

Loop: sll $t1, $s3, 2 80000 0 0 19 9 2 0

add $t1, $t1, $s6 80004 0 9 22 9 0 32

lw $t0, 0($t1) 80008 35 9 8 0

bne $t0, $s5, Exit 80012 5 8 21

addi $s3, $s3, 1 80016 8 19 19 1

j Loop 80020 2

Exit: … 80024

30
Compilation des instructions d’une boucle

Code C:
while (save[i] == k) i += 1;
 i dans $s3, k dans $s5, adresse de save dans $s6
Code compilé (manuellement) en MIPS :
Loop: sll $t1, $s3, 2
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
Exit: …

31
Compilation des instructions d’une boucle

 Code C:
while (save[i] == k) i +=
1;
 i dans $s3, k dans $s5, adresse
de save dans $s6
 Code compilé (manuellement) en
MIPS :
Loop: sll $t1, $s3, 2 add $t1, $zero, $s6
add $t1, $t1, $s6 lw $t0, 0($t1)
lw $t0, 0($t1) j test
bne $t0, $s5, Exit Loop: addi $t1, $t1, 4
addi $s3, $s3, 1 lw $t0, 0($t1)
j Loop Test: beq $t0, $s5, Loop
Exit: …

32
Autres instructions pour les sauts
 En plus de beq, bne, il y a autres types de sauts
 L’instruction slt (set less then) :
slt $t0, $s0, $s1 # if $s0 < $s1 then
# $t0 = 1 else
# $t0 = 0
 Format de l’instruction (format R):

 Il y a aussi
slti $t0, $s0, 25 # if $s0 < 25 then $t0=1 ...

sltu $t0, $s0, $s1 # if $s0 < $s1 then $t0=1 ...
sltiu $t0, $s0, 25 # if $s0 < 25 then $t0=1 ...

33 2
Pseudo-instructions pour les sauts
 On peut utiliser slt, beq, bne, et la valeur $zero pour créer
d’autres conditions
 less than blt $s1, $s2, Label

slt $at, $s1, $s2 #$at set to 1 if

bne $at, $zero, Label #$s1 < $s2

 less than or equal to ble $s1, $s2, Label

 greater than bgt $s1, $s2, Label
 great than or equal to bge $s1, $s2, Label

 blt, ble, bgt et bge sont des pseudo-instructions. Elles sont

reconnues par l’assembleur
 C'est pourquoi le registre ($at) est réservé pour l'assembleur.

34
Instructions pour l’accès aux procédures
 Instruction d’appel de la procédure :

jal ProcedureAddress #jump and link

 Sauvegarde PC+4 dans le registre $ra pour avoir un lien à la
prochaine instruction lors du retour de la procédure
 Format machine (format J):
0x03 26 bit address

 La procédure retourne avec l’instruction

jr $ra #return
 Format machine (format R):
0 31 0x08
35
3 étapes dans l’exécution de la procédure

1. La routine principale (l’appelant) place les paramètres dans $a0 - $a3

pour que la procédure appelée accède à ces paramètres et va avoir le
contrôle après (jal dest)

2. La procédure appelée réserve les ressources nécessaires, exécute la

tâche demandée et puis retourne la valeur du résultat dans:$v0 - $v1

3. La procédure appelée retourne le contrôle à l’appelant (jr $ra)

Règles:

- La procédure appelée doit sauvegarder les registres $s0-$s7 si besoin

36
Exemple de Procédure
 Code C: ProcEx:
int ProcEx (int g, h, i, j) addi $sp, $sp, -4
{ int f;
f = (g + h) - (i + j); sw $s0, 0($sp)
return f;
}
add $t0, $a0, $a1
 Arguments g, …, j dans
$a0, …, $a3 add $t1, $a2, $a3
 f dans $s0 sub $s0, $t0, $t1
 Résultat dans $v0
add $v0, $s0, $zero
lw $s0, 0(sp)
addi $sp, $sp, 4
jr $ra

37