Chap4 of Computer Architucture

Architecture des ordinateurs
2éme Année LMD
Mr N. Azizi 2021-2022
PRÉSENTATION DU PROCESSEUR MIPS R3000
• MIPS (de l'anglais Microprocessor without interlocked pipeline stages) a été
développée par la compagnie MIPS Computer Systems Inc., basée en
Californie.
• En 1988, la société MIPS Computer Systems, présente le MIPS R3000 qui succède
au MIPS R2000.
• Son jeu d’instructions est de type RISC.
• Le processeur MIPS R3000 est un processeur 32 bits.
• Le principal marché du MIPS: les applications embarquées, les ordinateurs de
poche, les routeurs Cisco et les consoles de jeux vidéo (Nintendo 64 et Sony
PlayStation, et PSP)…
• Il existe plusieurs réalisations industrielles de cette architecture (Siemens,
Toshiba, Philips, Silicon Graphics, etc...)
2
NOTION D’ARCHITECTURES CISC/RISC:
Deux grandes catégories de processeurs, qui se distinguent par la
conception de leurs jeux d’instructions :
• CISC (Complex Instruction Set Computer)
• jeu étendu d’instructions complexes;
• instructions proches des constructions typiques des langages de haut niveau
• Exemples : Motorola 68000, x86 Intel, AMD...
• RISC (Reduced Instruction Set Computer)
• jeu d’instructions réduit;
• toutes les instructions sont codées avec un même nombre de bits,
généralement un mot machine; Ceci facilite le décodage des instructions.
• Exemples : MIPS, PowerPC, UltraSPARC (Sun), ...
3
MODE UTILISATEUR/SUPERVISEUR:
Afin de mettre en œuvre les mécanismes de protection nécessaires pour un
système, le processeur possède deux modes de fonctionnement :
• Le mode superviseur: permet une plus grande sécurité pour le système. Quand
le processeur est en mode superviseur, l’utilisateur ne peut pas accéder à
certaines zones (ex: mémoire, registres...)
• Le mode utilisateur: Ce mode permet à l’utilisateur d’accéder uniquement aux
zones réservées aux utilisateurs. Le processeur part en exception si l’utilisateur
accède à une zone privilégiée.
Note: quand le processeur est en mode superviseur, le système peut accéder aux
zone protégées et non protégées.
4
LES REGISTRES
• Les registres sont une zone de stockage temporaire située dans le processeur.
• La valeur de certains registres peut être lue ou modifiée par les instructions.
• Selon les modes de fonctionnement du processeur, il existe deux catégories de
registres:
✓Les registres non protégés (Accessibles en mode utilisateur)

✓Les registres protégés (Accessibles en mode superviseur)
5
LES REGISTRES NON PROTÉGÉS
• Le processeur MIPS possède 32 registres de travail accessibles au programmeur.
• Chaque registre est connu par son numéro, qui varie entre 0 et 31, et est préfixé
par un $.
• Par exemple:
✓ Le registre 31 sera noté $31 dans l’assembleur.

✓ Le registre $0 est un registre particulier. Il contient toujours la valeur constante
0. L’écriture ne modifie pas son contenu.
✓Le registre $29 est le registre pointeur de pile. Il prend la notation $Sp.
6
7
Le compteur programme $PC (compteur ordinal)
Ce registre contient l'adresse de l'instruction en cours d'exécution. Sa valeur est
modifiée par toutes les instructions.
Les registres HI et LO
Ces registres à 32 bits sont utilisés pour la multiplication ou la division pour stocker
le
résultat de l’opération
8
LES REGISTRES PROTÉGÉS
• L'architecture MIPS définit 32 registres (numérotés de 0 à 31), qui ne
sont pas accessibles en mode utilisateur.
• Ils sont accessibles par les instructions privilégiées c'est à dire les
instructions qui ne peuvent être exécutées qu'en mode superviseur.
• On dit qu'ils appartiennent au "coprocesseur système".
9
LES REGISTRES PROTÉGÉS
Le registre d'état SR (Status Register)
Il contient en particulier le bit qui définit le mode : superviseur ou utilisateur, ainsi que les
bits de masquage des interruptions
Registre de cause CR (Cause Register)

En cas d'interruption ou d'exception, son contenu définit la cause pour laquelle on fait
appel au programme de traitement des interruptions et des exceptions.
Registre d'exception EPC (Exception Program Counter)

Il contient l'adresse de retour (PC + 4) en cas d'interruption. Il contient l'adresse de
l'instruction fautive (PC) en cas d'exception.
Registre d'adresse illégale BAR (Bad Address Register)

En cas d'exception de type "adresse illégale", il contient la valeur del'adresse mal formée
10
ORGANISATION DE LA MÉMOIRE (1)
Toutes les adresses émises par le processeur sont des adresses octets, ce qui signifie que
la mémoire est vue comme un tableau d'octets, qui contient aussi bien les données que
les instructions.
• Les adresses sont codées sur 32 bits.
• Les instructions sont codées sur 32 bits.
• Les échanges de données avec la mémoire se font :
• par mot (4 octets consécutifs),
• demi mot (2 octets consécutifs),
• ou par octet.
11
• L’espace mémoire est découpé en 2 segments identifiés par le bit de poids fort de
l’adresse :
adr 31 = 0 → segment utilisateur (user)
adr 31 = 1 → segment système (kernel)
• Quand le processeur est en mode superviseur, les 2 segments sont accessibles.

• Quand le processeur est en mode utilisateur, seul le segment utilisateur est accessible.
• Le processeur part en exception si une instruction essaie d'accéder à la mémoire
avec une adresse correspondant au segment système alors que le processeur est en
mode utilisateur.
12
Un programme utilisateur utilise généralement trois sous-
segments (appelés sections)
dans le segment utilisateur :
• la section .text contient le code exécutable en mode
utilisateur. Elle est implantée
conventionnellement à l’adresse 0x00400000.
• la section .data contient les données globales
manipulées par le programme utilisateur.
Elle est implantée conventionnellement à l’adresse
0x10000000.
• la section .stack contient la pile d’exécution du
programme. Sa taille varie au cours de
l’exécution. Elle est implantée conventionnellement à
l’adresse 0x7FFFEFFF. Contrairement
aux sections data et text, la pile s’étend vers les adresses
décroissantes.
13
MODE D'ADRESSAGE
• Indique comment l'architecture spécifie les adresses des objets qu'elle va
accéder dans la mémoire.
• MIPS est une architecture de chargement/rangement (load/store), ce qui
signifie que seules les instructions de chargement et de rangement peuvent
accéder à la mémoire.
• Il n’existe qu’un seul mode d’adressage, le mode indirect registre consistant à

effectuer la somme entre le contenu d'un registre général Ri, défini dans
l'instruction, et d'un déplacement qui est une valeur immédiate signée, sur 16
bits, contenue également dans l'instruction :
adresse effective = Ri + Déplacement
• Exemple : lb $t1, -100($t2)
14
MODE D'ADRESSAGE
• Le jeux d’instruction étendu (pseudo-instructions) de mips offrent les modes
d’adressage suivants pour les instructions load/store
Format Calcul d’adresse Exemple
(registre) Indirect Le contenu du registre lw $t1, ($t2)
val (registre) Indirect avec Val + Le contenu du registre lw $t1, 10($t2)
déplacement
(relatif)
Val Direct (absolu) valeur lb $t1, 0x0012
label Direct (absolu) Adresse du label lb $t1, chaine
label ± val adresse du label + ou – val lb $t1, chaine+0x0012
label ± val adresse du label + ou – (val + contenu lb $t1, chaine+ 10($t2)
(register) du registre)
15
FORMAT D’UNE INSTRUCTION:
• Toutes les instructions ont une longueur de 32 bits et possèdent un des trois
formats suivants :
• Le format R : est utilisé par les instructions nécessitant deux registres sources (RS et RT) et
un registre résultat (RD).
• Le format I: est utilisé par les instructions de lecture/écriture mémoire, par les
instructions utilisant un opérande immédiat, ainsi que par les branchements
conditionnels.
• Le format J: n’est utilisé que pour les branchements inconditionnels.
16
FORMAT D’UNE INSTRUCTION R:
17
FORMAT D’UNE INSTRUCTION R:
18
FORMAT D’UNE INSTRUCTION I:
19
FORMAT D’UNE INSTRUCTION I:
20
FORMAT D’UNE INSTRUCTION J:
21
CODE OPÉRATION
Il détermine quelle opération effectuer (6 bits de poids forts)
22
CODOP SPÉCIAL
Pour le format R, le codeOp peut être nul et c’est le champ func (6bits de poids faible )
qui détermine l’opération
23
FORMAT D’UN PROGRAMME MIPS:
Un programme Mips est composé
essentiellement de deux parties:
• Data section : contient la

déclaration de données.
• Text section : contient le code
du programme.
• Les commentaires permettent

de donner plus d’explication
sur le code
• Ils commencent par un #
et s’achèvent à la fin de la
ligne courante.
24
DÉCLARATION DE DONNÉES:
Les données (constantes et variables) doivent être déclarées dans « .Data » section.
• Les données doivent commencer par une lettre suivie des lettres, chiffres ou
caractères spéciaux.
• Le format général de la déclaration d’une donnée est:
Exemple:
25
Les données en Mips sont de différents types:
26
Déclaration des entiers :
• Une valeur entière décimale est notée 253.

• Une valeur entière hexadécimale est notée 0xFA (préfixée par zéro suivi de x).
• En hexadécimal, les lettres de A à F peuvent être écrites en majuscule ou en
minuscule.
• Les entiers sont déclarés par :
.word, .half, .byte
Exemple :
27
Les chaînes de caractères :
Les chaînes de caractères sont déclarées par:

.ascii, .asciiz
Remarque:
.asciiz termine la chaîne de caractères par NULL (0). Le but est de faire savoir au
compilateur la fin de la chaîne.
Exemple : la déclaration suivante défini une chaîne de caractères « message » de type

asciiz et qui a comme contenu « hello world ».
« \n » : est un retour à la ligne
28
Déclaration des nombres réels :
• Les nombres réels sont déclarés par :

.float, .double
Exemple :
• Les déclarations suivantes sont utilisées pour définir la variable « pi » sur 32 bits par le
type .float et l’initialiser à 3,14159.
• Et la variable « tao » qui prend le type .double et sera enregistrée sur 64 bits. Elle est
initialisée à 6,28318.
29
Déclaration des constantes:
Une constante est une valeur fixe et ne change pas durant le déroulement du
programme.
Exemple :
30
INSTRUCTIONS ET PSEUDO-INSTRUCTIONS
Certaines instructions appelées pseudo-instruction ne sont en pas implantées par le processeur,
mais traduites par l’assembleur en séquences d’instructions plus simples.
Exemple 1 :
blt $t0,$t1, adress
est expansée en : slt $at, $t0,$t1

bne $at,$0, adress
Exemple 2 :
li $t0, 400020
est expansée en : lui $at,6

ori $t0,$at,6804
31
LES INSTRUCTIONS DU LANGAGE MIPS
Pour pouvoir faire des programmes sur la machine MIPS R3000, on dispose d'un certain
nombre d'instructions qui forment le langage de la machine.
• Le jeu d'instructions est "orienté registres". Cela signifie que les instructions utilisent les
registres pour le transfert et le rangement des données.
• Le processeur possède 57 instructions qui se répartissent en 4 classes :
✓ Instructions de lecture/écriture mémoire (Load and Store)

✓ Instructions arithmétiques/logiques entre registres (calcul)
✓ Instructions de branchement (Saut)
✓ Appels système (Syscall)
32
LES INSTRUCTIONS DE LECTURE/ÉCRITURE MÉMOIRE
Ces instructions transfèrent les données entre la mémoire et les registres.
• L’opération de chargement (Load) permet de lire une donnée de la mémoire et la
charger dans un registre.
• L’opération de sauvegarde (Store) permet d’écrire le contenu d’un registre dans la
mémoire.
33
1. Les instruction de chargement: (Load)
• Lw $t0, var1 #Charge le contenu de l’adresse

mémoire var1 dans le registre $t0.
▪ Li $t0, 27 #Après l’exécution $t0=27
• La Rd, adr #Charge l’adresse de la donnée

dans le registre Rd.
34
1. Les instruction de sauvegarde: (Store)
• Sw Rs, mem #Sauvegarde le contenu du registre

source Rs dans la mémoire.
• Move Rd, Rs #Copie le contenu du registre Rs

dans le registre Rd.
35
LES APPELS SYSTÈME (SYSCALL)
• Pour exécuter certaines fonctions système, principalement les entrées/sorties (lire ou
écrire un nombre, ou un caractère), il faut utiliser des appels système.
• Pour exécuter un appel système, il faut chercher:

o L’argument dans le registre $a0 ou $a1.
o Le numéro de l’appel système est contenu dans le registre $v0
o Syscall
36
• Ecrire un entier: ( Print_int )
• Il faut mettre l’entier à écrire dans le registre $a0 et exécuter l’appel système numéro 1.
• Lire un entier : (Read_int)

• Consiste à exécuter l’appel système numéro 5 et récupérer le résultat dans le registre
$v0.
37
• Lire une chaîne de caractères : (Read_string)
Il faut:
• Adresse du début de la chaîne et la passer dans $a0
• La longueur maximum et la mettre dans $a1
• Exécuter l’appel système numéro 8.
• Ecrire une chaîne de caractères: (Print_string)

Une chaîne de caractères étant identifiée par une adresse de début de la chaîne.
• Il faut passer cette adresse dans $a0 et exécuter l’appel système numéro 4 pour
l’afficher.
38
• Quitter le programme:
• L’appel système numéro 10 effectue la sortie du programme
39
40
LES OPÉRATIONS ARITHMÉTIQUES ET LOGIQUES
Les instructions arithmétiques et logiques permettent de faire les 4 opérations de calcul
(addition, multiplication, soustraction, division) ainsi que les opérations logiques (Or, And,
xor..) et les opérations de décalage…
Les instructions arithmétique
1. add : add $rd, $rs, $rt #$rd= $rs + $rt

Les contenus des registres $rs et $rt sont ajoutés pour former un résultat qui est placé dans
le registre $rd.
2. addi : On peut aussi faire une addition avec les constante au lieu du registre $t2:
addi $t0, $t1, 5 # $t0 = $t1 + 5
3. sub : sub $rd, $rs, $rt #$rd = $rs - $rt

Le contenu du registre $rt est soustrait du contenu du registre $rs pour former un résultat
qui est placé dans le registre $rd :
41
4. mul : add $rd, $rs, $rt #$rd = $rs x $rt
Les contenus des registres $rs et $rt sont multipliés pour former un résultat qui est placé
dans le registre $rd.
5. mult : mult $rd, $rs # ($hi,$lo) = $t0 * $t1
permet de multiplier les contenus des registres $rs et $rt. Le résultat est placé dans les
registres spéciaux : hi et lo. Les 32 bits de poids fort du résultat sont placés dans le registre
$hi, et les 32 bits de poids faible dans $lo.
6. div : div $rs, $rt
Le contenu du registre $rs est divisé par le contenu du registre $rt. Le résultat de la division
est placé dans le registre $lo, et le reste dans le registre $hi.
42
7. mfhi (Move from $hi):
mfhi $rd # $rd = $hi
Le contenu du registre spécialisé $hi qui est mis à jour par l’opération de multiplication ou
de division est recopié dans le registre général $rd.
8. mflo (Move from $lo):
mflo $rd # $rd = $lo
Le contenu du registre spécialisé $lo qui est mis à jour par l’opération de multiplication ou
de division est recopié dans le registre général $rd.
43
Les instructions logiques
1. and - Et logique - : and $rd, $rs, $rt # $rd = $rs and $rt (bit à bit)
Un et bit-à-bit est effectué entre les contenus des registres $rs et $rt. Le résultat est placé
Exemple: Pour faire une copies du registre $t0 dans le registre $t1 en mettant les 6
premiers bits à zéro, on utilise l’instruction suivante: and $t1, $t0, $t8
$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

and
$t8 = 1111 1111 1111 1111 1111 1111 1100 0000
$t1 = 1000 1000 1111 0111 0001 0000 0100 0000
$t8 est utilisé pour masquer les 6 premiers bits
44
2. or - ou logique - : or $rd, $rs, $rt # $rd = $rs or $rt (bit à bit)
Un ou bit-à-bit est effectué entre les contenus des registres $rs et $rt. Le résultat est placé
Exemple: Pour faire une copies du registre $t0 dans le registre $t1 en mettant les 6
premiers bits à un, on utilise l’instruction suivante: or $t1, $t0, $t8
$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

or
$t9 = 0000 0000 0000 0000 0000 0000 0011 1111
$t1 = 1000 1000 1111 0111 0001 0000 0111 1111
45
3. xor - ou éxclusif - : xor $rd, $rs, $rt # $rd = $rs xor $rt (bit à bit)
Un ou éxclusif bit-à-bit est effectué entre les contenus des registres $rs et $rt. Le résultat
est placé dans le registre $rd.
Exemple: Pour faire une copies du registre $t0 dans le registre $t1 en inversant les 6
premiers bits, on utilise l’instruction suivante: xor $t1, $t0, $t8
$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

xor
$t9 = 0000 0000 0000 0000 0000 0000 0011 1111
$t1 = 1000 1000 1111 0111 0001 0000 0111 1011
46
4. neg - négatif - : neg $rd, $rs # $rd = -($rs) . Donne le négatif de $rs.
5. Sll - Shift Left Logical - : Décalage à gauche immédiat, est utilisé pour réalisé la
multiplication par des puissances de 2
sll $rd, $rt, val #Rd = Rt<<val
- Le registre $rt est décalé à gauche de la valeur immédiate val.

- Des zéros étant introduits dans les bits de poids faibles.
- Le résultat est placé dans le registre $rd.
Exemple:
Sll $v1, $t3, 5 # $v1 = $t3 << 5
• Supposons que $t3 contient la valeur : 0000000000011010 = 26,

• Après le décalage à gauche (Sll) le résultat 0000001101000000 est placé dans le
registre $v1.
• L’opération donne (26 * 25) = (26 * 32) = 83210
47
6. sra - Shift Right Arithmetic - : Décalage à droite arithmétique immédiat, est utilisé pour
réalisé la division par des puissances de 2
sra $rd, $rt, val
- Le registre $rt est décalé à droite de la valeur immédiate val.

- Des zéros (si le nombre et positif) ou des uns (si le nombre et négatif) étant introduits
dans les bits de poids faibles.
- Le résultat est placé dans le registre $rd.
Exemple:
sra $v1, $t3, 2
• Supposons que $t3 contient la valeur : 11111111111111111111111111100000 = -32,

• Après le décalage à droite (sra) le résultat 11111111111111111111111111111000 est
placé dans le registre $v1.
• L’opération donne (-32 / 22) = (-32 / 4) = -810
48
7. slt – set if less than - : Comparaison signée registre registre.
slt $rd, $rs, $rt # if ($rs < $r ) then $rd =1 else rd = 0
Autres instructions arithmétiques et logiques:

• addu, subu, addiu, multu, divu
• nor, ori, andi, xori
• srav (Shift right arithmetical variable), srl (shift right logical)
• sltu (Set if Less Than Unsigned)
• mthi (Move from Lo)
• mtlo (Move to Lo)
49
LES OPÉRATIONS DE SAUT (JUMP) ET DE BRANCHEMENT (BRANCH)
Les structures de contrôles comme le IF..THEN..ELSE, WHILE et FOR n’existent pas en

langage d’assemblage.
• Pour les programmer, il faut utiliser les instructions de sauts et de branchements.
• Ces instructions sont de type conditionnel ou inconditionnel.
50
Les instructions de branchement
Instruction Signification
Branch if equal
Branch if not equal
Branch if greater or equal
Branch if greater than
Branch if less or equal
Branch if less than
Branch if greater or equal zero
Branch if greater than zero
Branch if less or equal zero
Branch if less than zero
Branch if not equal zero
Branch if equal zero
51
Les instructions de saut
1. j - Jump – :
j Label #Le programme saute inconditionnellement à Label.
2. jr - Jump register – :
jr $rs #Le programme saute à l’adresse contenue dans le registre $rs.
3. jal - Jump and link - :

jal Label
Utilisé dans les appels des procédures et fonctions. L’adresse de
l’instruction suivant le jal est sauvée dans le registre ($ra).
52
IF…..THEN…..
Condition de sortie
if (num < 0) lw $t0, num

{ bgez $t0, pos
num = - num; sub $t0,$0,$t0
} sw $t0, num
pos:
# ………
53
IF…..THEN…..ELSE Jump obligatoire
avant else
if (i == j) beq $t3, $t4, true

{ sub $t0, $t1, $t2 # f=g-h(false)
f = g+h; j fin # go to fin
} else true: add $t0,$t1,$t2 # f=g+h (true)
{ fin: ….
f = g-h;
}
54
La boucle while Condition pour
sortir de la boucle
while ($a1 < $a2) loop: bge $a1, $a2, done # if $a1 >= $a2 branch to done
{ addi $a1, $a1, 1 # $a1 = $a1 + 1
$a1 = $a1 +1; subi $a2, $a2, 1 # $a2 = $a2 - 1
$a2 = $a2 -1; j loop # branch to loop
} done :
Jump pour refaire

la boucle
55
Calculer la somme de N nombres saisis au clavier jusqu’à entrer le
nombre 0.
56
La boucle for
$a0 = 0; li $a0, 0 # $a0 = 0

for ($t0 = 1; $t0 <=10 ; $t0++) li $t0, 10 # initialize loop counter to 10
{ loop: add $a0, $a0, $t0 # $a0 = $a0 + $t0
$a0 = $a0 +$t0; subi $t0, $t0, 1 # Decrement loop counter
} bgtz $t0, loop # if ($t0 > 0) branch to loop
….
57
LES TABLEAUX ET LES PILES
• Les structures de données comme les tableaux et les piles sont utilisées
en MIPS pour stocker des données les unes à la suite des autres.
• Pour les manipuler, il faut d’abord connaître comment ils sont stockés
en mémoire.
num1: .word 42
num2: .word 5.000.000
• 4210 est représentée en hexadécimal par :

0x0000002A
• 5,000,00010 est représenté en hexadécimal par
0x004C4B40.
58
LES TABLEAUX
• Un tableau est une zone mémoire dans laquelle les données sont
rangées les unes à la suite des autres;
• Il est repéré par l’adresse du premier élément;
• On accède aux différentes cases par déplacement par rapport à la
première;
• Un tableau est déclaré comme suit: .data
T : .word 3, 6, 8, 9, 2
• Cette déclaration permet l’allocation en mémoire d’un tableau de 5

éléments (mots de 32 bits) qui sont: {3,6,8,9,2}
• On peut aussi déclarer un tableaux en réservant un espace mémoire :
.data
T1: .space 20
• Cela permet de déclarer un tableau de 20 octet c-à-d 5 mots
59
LES TABLEAUX
• Le programme suivant permet de faire la somme des éléments d’un tableau:
.data
tab : .word -2, 3, 7, -6,0
.text
li $a0, 0 # somme
li $a1, 5 # taille
la $a2, tab # $a2 reçoit l'adresse du
premier élément
bcl: lw $a3, ($a2) # lire une valeur du tableau
add $a0, $a0, $a3 # ajouter la valeur lu dans $a0
addi $a2, 4 # incrémenter le pointeur du
tableau par 4
addi $a1, -1 # décrémenter le compteur de la
boucle bcl
bne $a1, $zero, bcl # si la valeur n'est pas nulle
brancher sur bcl
li $v0, 1 # appel système pour print-

int
syscall # imprimer la somme 60
LES TABLEAUX
• Exercice :
Ecrire un programme qui permet de donner la somme des nombres négatifs et la somme
des nombres positifs dans le tableau suivant:
Tab: { - 4, 5 , 8 , -1 , 6 , 7 , 13 , - 7 , - 8 }
61
LES PILES
• La pile est une structure de données, qui permet de stocker les données dans l'ordre
LIFO (Last In First Out) - Dernier Entré Premier Sorti).
• La récupération des données sera faite dans l'ordre inverse de leur insertion.
• La pile est utilisée dans la programmation

pour stocker les informations durant les
appels des procédures et des fonctions.
• Pour ajouter un élément à la pile on
utilise l’opération Push (Empiler).
• Pour retirer un élément de la pile on
utilise l’opération Pop (Dépiler).
Remarque: les opérations Push et Pop sont implémentées manuellement.

62
LES PILES
Organisation de la pile:
• La pile est stockée dans le segment .stack.
63
LES PILES
• Contrairement aux sections .data et .text, la pile s’étend vers les adresses décroissantes.
64
LES PILES
• Le sommet de la pile est pointé par le registre $sp.
• Tout les éléments empilés et dépilés de la pile sont généralement de taille 32 bits.
Exemple:
Considérons le tableau suivant, on veut le stocker dans une pile: a={7,19,37}
Les opération suivantes permettent Les opération suivantes permettent

d’empiler les éléments du tableau de dépiler les éléments de la pile
dans la pile: dans le tableau :
• empiler a[0] • dépiler a[0]

65
LES PILES
Implémentation de la pile :
Push (empiler):
• Empiler ou ajouter un élément à la pile signifie soustraire 4 du registre $sp et stocker le
résultat dans cette adresse.
Exemple :
subu $sp, $sp, 4 # Mettre à jour $sp ,
sw $t0, ($sp) # ranger $t0 au sommet de la pile .
Pop (dépiler):
• Dépiler un élément signifie qu'il est copié à un autre endroit (un registre).
• Retirer un élément de la pile signifie ajouter 4 au registre $sp.
Exemple :
lw $t0, ($sp) # copie le sommet dans $t0
addu $sp, $sp, 4 # Mettre à jour $sp ,
66
LES PILES
Exercice :
Etant donné le tableau suivant:

array: .word 1, 3, 5, 7, 9, 11, 13, 15, 17, 19
.word 21, 23, 25, 27, 29, 31, 33, 35, 37, 39
.word 41, 43, 45, 47, 49, 51, 53, 55, 57, 59
Ecrire un programme qui permet de renverser l’ordre des éléments de ce tableau en

utilisant une pile.
67
LES PROCÉDURES ET LES FONCTIONS
• Les fonctions et les procédures permettent de décomposer un
programme complexe en une série de sous-programmes plus simples.
• Le but est d’éviter de réécrire le même code plusieurs fois.
• Une fonction est une suite ordonnée d’instructions qui retourne une
valeur .
• Par contre, une procédure est un sous programme qui ne retourne pas
de valeur.
68
• Pour déclarer une procédure/fonction
en Mips on utilise: Exemple:
.text
.global main
main:
......
Jal calcul
…
.end main
#------------
.global calcul
calcul:
#code de la
fonction
La directive .global indique que ce qui suit la directive
Jr $ra
est une étiquette globale et peut être référencée à
.end calcul
partir d’autres fichiers
69
Convention d’appel
• La convention d’appel régit la communication entre appelant et
appelé lors de l’appel de procédure ou de fonction.
• Pour le MIPS, la convention proposée par le fabricant est :
• les arguments sont passés dans $a0-$a3 puis (s’il y en a plus de
quatre) sur la pile ;
• l’adresse de retour est passée dans $ra ;
• la valeur de retour est renvoyée dans $v0, $v1 ;
• les registres $t0-$t9, peuvent être modifiés par l’appelé ; l’appelant
doit donc les sauvegarder si nécessaire ; on les appelle caller-
saved
• les registres s0-s7 doivent être préservés par l’appelé; on les appelle
callee-saved.
70
• La fonction appelante passe les arguments comme suit:
• Le premier argument est passé dans le registre $a0.

• Le deuxième argument est passé dans le registre $a1.
• Le troisième argument est passé dans $a2.
• Le quatrième argument est passé dans $a3.
• Les autres arguments sont passés par la pile
71
• Pour appeler une fonction on utilise l’instruction suivante:
Jal <fonct>
• Cette instruction de saut permet de faire un saut avec lien (linkage)
• C’est-à-dire que le programme appelant fait un saut pour exécuter la

fonction ensuite un retour pour continuer l’exécution du programme.
• L’instruction Jal copie $pc dans $ra et saute à la fonction appelée.
• Quand la fonction appelée se termine on utilise : Jr $ra pour aller à

l’instruction suivante dans le programme appelant.
72
Cette exemple permet de calculer la
puissance du nombre X par Y. (XY)
• X et Y sont passées par valeur.
• La valeur du premier argument est
passé dans le registre $a0.
• La valeur du deuxième argument est
passée dans le registre $a1.
• Le résultat est mis dans la variable
answer.
• La fonction power sauvegarde le
résultat dans $v0.
• Le programme principale copie le
contenue de $v0 dans la variable
answer.
73
Cette exemple permet
de calculer la somme de
six nombres et met le
résultat dans sum
74
• Chaque appel de fonction (jal) met l’adresse de retour dans le registre $ra (31), et si
on effectue des appels de fonction imbriqués sans sauver ce registre, on perd les
adresses de retour de tous les appels sauf le dernier.
• Si on a des fonctions récursives, chaque instance de la fonction récursive exécute le
même code, et donc utilise forcément les mêmes registres, donc si on ne sauve pas
ces registres quelque part, on perd la valeur qu’ils avaient dans tous les appels, sauf
le dernier.
Donc si la fonction appelée est :

• terminale (n’appeler pas d’autres fonctions):
• empiler $s0, $s1 . . . utilisés
• non-terminale (appeler d’autres fonctions):
• empiler $ra
• empiler $a0, $a1, . . . utilisés
• empiler $s0, $s1 . . . utilisés
Exemple important de fonction non-terminale : les fonctions récursives …
75
• Une fonction récursive qui calcule la factorielle
d’un nombre donné
Tester le cas trivial
Aller vers l’adresse de

retour
Sauvegarder $ra et
• Programme principal
$a0 (empiler)
L’appel récursif
Restaurer $ra et $a0

(dépiler) n*fact(n-1)
Aller vers l’adresse de

retour
76
Le passage des paramètres:
Le passage des paramètres pour les fonctions et les procédures se fait
par valeur ou par adresse(variable, référence).
Le passage par valeur:

• les variables transmises ne changent pas de valeur lors du retour au
programme principal.
Le passage par adresse:
• Le passage de la variable se fait par l’adresse et n’ont pas par la
valeur. (utiliser l’instruction la)
• Après l’exécution de la fonction appelée les variables changent de
valeur.
• La passage par adresse est utilisé pour faire passer des tableaux par
exemple.
77

Chap4 of Computer Architucture

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap4 of Computer Architucture

Transféré par

Droits d'auteur :

Formats disponibles

Architecture des ordinateurs

2éme Année LMD

✓Les registres non protégés (Accessibles en mode utilisateur)

✓ Le registre 31 sera noté $31 dans l’assembleur.

• On dit qu'ils appartiennent au "coprocesseur système".

Registre de cause CR (Cause Register)

Registre d'exception EPC (Exception Program Counter)

Registre d'adresse illégale BAR (Bad Address Register)

• Quand le processeur est en mode superviseur, les 2 segments sont accessibles.

• Il n’existe qu’un seul mode d’adressage, le mode indirect registre consistant à

adresse effective = Ri + Déplacement

• Exemple : lb $t1, -100($t2)

• Data section : contient la

• Les commentaires permettent

• Une valeur entière décimale est notée 253.

Les chaînes de caractères sont déclarées par:

Exemple : la déclaration suivante défini une chaîne de caractères « message » de type

« \n » : est un retour à la ligne

• Les nombres réels sont déclarés par :

est expansée en : slt $at, $t0,$t1

est expansée en : lui $at,6

✓ Instructions de lecture/écriture mémoire (Load and Store)

• Lw $t0, var1 #Charge le contenu de l’adresse

▪ Li $t0, 27 #Après l’exécution $t0=27

• La Rd, adr #Charge l’adresse de la donnée

• Sw Rs, mem #Sauvegarde le contenu du registre

• Move Rd, Rs #Copie le contenu du registre Rs

• Pour exécuter un appel système, il faut chercher:

• Lire un entier : (Read_int)

• Ecrire une chaîne de caractères: (Print_string)

Les instructions arithmétique

1. add : add $rd, $rs, $rt #$rd= $rs + $rt

addi $t0, $t1, 5 # $t0 = $t1 + 5

3. sub : sub $rd, $rs, $rt #$rd = $rs - $rt

5. mult : mult $rd, $rs # ($hi,$lo) = $t0 * $t1

6. div : div $rs, $rt

mfhi $rd # $rd = $hi

8. mflo (Move from $lo):

mflo $rd # $rd = $lo

$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

$t8 est utilisé pour masquer les 6 premiers bits

$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

$t0 = 1000 1000 1111 0111 0001 0000 0100 0100

sll $rd, $rt, val #Rd = Rt<<val

- Le registre $rt est décalé à gauche de la valeur immédiate val.

• Supposons que $t3 contient la valeur : 0000000000011010 = 26,

sra $rd, $rt, val

- Le registre $rt est décalé à droite de la valeur immédiate val.

• Supposons que $t3 contient la valeur : 11111111111111111111111111100000 = -32,

slt $rd, $rs, $rt # if ($rs < $r ) then $rd =1 else rd = 0

Autres instructions arithmétiques et logiques:

Les structures de contrôles comme le IF..THEN..ELSE, WHILE et FOR n’existent pas en

• Pour les programmer, il faut utiliser les instructions de sauts et de branchements.

• Ces instructions sont de type conditionnel ou inconditionnel.

j Label #Le programme saute inconditionnellement à Label.

jr $rs #Le programme saute à l’adresse contenue dans le registre $rs.

3. jal - Jump and link - :

if (num < 0) lw $t0, num

if (i == j) beq $t3, $t4, true

Jump pour refaire

$a0 = 0; li $a0, 0 # $a0 = 0

• 4210 est représentée en hexadécimal par :

• Cette déclaration permet l’allocation en mémoire d’un tableau de 5