Académique Documents
Professionnel Documents
Culture Documents
Microprocesseur RISC
débuts en 1985, gamme de processeurs :
R2000 / R3000 / R4000 / R8000 / R10000
Équipe de nombreux types de machine
Playstation, Nintendo 64, stations Silicon Graphics (dédiées à la 3D),
société MIPS filiale de SGI
machine à chargement/rangement
machine à registres généraux
Application de l'approche RISC
Performances d'un processeur sur l'exécution de plusieurs
instructions :
approche CISC : plusieurs cycles pour une instruction.
Instruction simple
Instruction complexe
Application de l'approche RISC
Utilisation intéressante du temps : instructions simples effectuées
en peu de cycles, instructions complexes en plus de cycles (le
nombre de cycles nécessaires).
Mais complique énormément une gestion de pipelines éventuels,
car les instructions n'ont pas le même format ni la même
séquence d'exécution.
Approche RISC : toute instruction s'exécute de manière
similaire, en suivant un chemin de données bien défini : Fetch,
UAL , Mémoire, Résultat.
cycle 1 cycle 2 cycle 3 cycle 4
Fetch Opération Accès Ecriture
instruction UAL Mémoire Résultat
Exécution en pipeline
Amélioration potentielle du nombre d'instructions par cycle en
utilisant un pipeline :
chaque cycle de l'instruction utilise une partie du processeur. A
chaque cycle, on choisit de commencer le traitement d'une
nouvelle instruction :
F UAL M R
F UAL M R
F UAL M R
Flot
F UAL M R
d'instructions
cycle
Exécution en pipeline
Suppose que le pipeline contienne toujours des instructions utiles
et qu'il n'y ait pas besoin de rajouter des cycles vides pour
synchronisation.
Exemple d'un pipeline CISC, utilisé sur 6 instructions
4 cycles
8 cycles
Exécution en pipeline
Sans pipeline : en tout 44 cycles pour 6 instructions : 7,33
cycles/instruction. Avec pipeline : cycles de délai lorsqu'une
ressource n'est pas utilisable, matérialisé par :
29 cycles
Exécution en pipeline
Avec pipeline, même s'il y a du remplissage : 29 cycles, soit 4,83
cycles/instruction .
Gain contrebalancé par :
gestion du pipeline pour tenir compte des cycles vides,
des instructions de longueur variable : compliqué
évènements qui perturbent le déroulement séquentiel du
programme : sauts conditionnels, interruptions
compilateur a du mal à ordonner les instructions pour
tirer le meilleur parti du pipeline.
Machine à chargement/rangement
Efficacité du découpage si les 4 phases F, UAL, M, R
consomment une quantité de temps à peu près comparable.
Or les accès mémoire sont longs :
calcul de l'adresse, accéder aux opérandes en mémoire,
les traiter, les ranger.
Choix d'une architecture à chargement/rangement (instructions
LOAD et STORE). Seules ces instructions permettent un accès à
la mémoire.
Gain en terme de bande passante (réduction des accès)
Jeu d'instructions plus simple
Optimisation de l'utilisation des registres par compilateur
Machine à chargement/rangement
Chargement retardé (delayed LOAD).
Lors d'une opération de chargement, la donnée à charger dans un
registre n'est pas disponible immédiatement pour l'instruction
suivante si l'on utilise un pipeline :
LOAD F UAL M R
F UAL M R
F UAL M R
F UAL M R
Machine à chargement/rangement
Chargement retardé (delayed LOAD).
Solution : insérer des cycles d'attente lors de l'exécution de
l'instruction 2, entre les phases F et UAL :
lors de la phase UAL, l'instruction 2 peut avoir besoin de la
donnée de l'instruction 1.
Technique simple : faire apparaître cette dépendance au
compilateur, toute instruction de chargement à un délai de
latence de 1 cycle, qui correspond au début de traitement d'une
nouvelle instruction.
L'instruction suivant une instruction de chargement est dite dans
la fenêtre ou intervalle de retard de chargement.(Load delay
slot)
Machine à chargement/rangement
Si cela apparaît au niveau du compilateur : pas de dépendance
dans le pipeline entre l'instruction de chargement et celle qui est
dans son load delay slot.
Il existe une instruction qui n'a aucune dépendance avec les
autres : NOP !
Pas besoin de faire un contrôle matériel du pipeline. Mais
utilisation du NOP augmente la taille du code, augmente le délai
d'exécution sans faire de tâche utile !
Autre solution : utiliser une instruction utile dans le load delay
slot, optimisation faite par un compilateur.
Machine à chargement/rangement
Exemple : code pour C=A+B; F=D
Load R1,A
Load R2,B dans le load delay slot de Load R1,A : pas de dépendance
Add R3,R1,R2 dans le load delay slot de Load R2,B : dépendance à R2 : attente
Load R4,D
autre version :
Load R1,A
Load R2,B dans le load delay slot de Load R1,A : pas de dépendance
Load R4,D dans le load delay slot de Load R2,B : pas de dépendance
Add R3,R1,R2 dans le load delay slot de Load R4,D : pas de dépendance
Branchements retardés
Les instructions de branchement/sauts introduisent aussi des délais
dans le pipeline car il faut calculer l'adresse de destination avant de
procéder à la phase F (Fetch) de l'instruction suivante.
Lorsqu'un accès à la mémoire d'instructions nécessite un cycle
entier, et que l'instruction de saut correspondante indique l'adresse
de destination, il est impossible de faire tout de suite la phase F de
l'instruction suivante sans insérer un délai d'un cycle
SAUT F UAL M R
F UAL M R
CPU
données @
Cache
d'instructions
Cache de
données
données @
Mémoire principale
Le système de gestion de mémoire
Système de gestion de la mémoire de type MMU (Memory
Management Unit) intégré au coprocesseur CP0 (contrôle, pas
arithmétique)
selon le mode utilisé (utilisateur ou noyau), adresses référencées
sont ou non traduites en adresses physiques à l'aide d'un TLB
(buffer de traduction d'adresse virtuelle vers physique).
Invisible la plupart du temps pour le programmeur, mais une
mauvaise utilisation d'adresses (mauvaises valeurs) peut provoquer
des erreurs du TLB.
Ce ne sont pas des erreurs de bus ou d'alignement !
Le MIPS
Respecte entièrement la philosophie RISC
registres : 32 registres de 32 bits
instructions : toutes codées sur 32 bits, découpage cohérent pour un
traitement rapide
registre PC et adresses codées sur 32 bits
la mémoire est adressable par octet, transferts de 8, 16 ou 32 bits
possibles
mémoire maximale adressable : 232 octets = 22.210.210.210 octets = 4
Go
Le MIPS
Constitué de deux parties distinctes
le CPU : registres généraux
registres HI et LO
UAL
PC
le CP0 : processeur de contrôle système intégrant
TLB pour la gestion de mémoire virtuelle
registres de gestion mémoire
registres de traitement des exceptions
registres d'état
Le MIPS
Registres généraux :
nommage particulier :
$0 à $31
$0 : vaut toujours 0 (câblage)
$31 : utilisé par certaines instructions comme sauvegarde
ne pas utiliser $31 comme un registre général
autre convention de nommage, plus pertinente mais contredit le
caractère général des registres
Format des instructions MIPS
Toutes les instruction du R2000 sont des instructions 32 bit, et il y a
3 formats d'instruction différents, cela pour simplifier le décodage et
utiliser un séquenceur câblé.
Les opérations plus complexes peuvent être simulées grâce à une
suite d'instructions simples, on les trouvera sous la forme de pseudo-
instructions.
Exemple : un transfert de registre à registre n'est pas implémenté,
mais la pseudo-instruction move réalise cette opération.
Lorsque l'on écrit move Rsource,Rdest, en fait on réalise
l'instruction MIPS : add Rdest,Rsource,$0
Format des instructions MIPS
On distingue 3 formats d'instructions :
• les instructions de type I : opérande de type valeur
immédiate;
• les instructions de type R, les opérandes sont des registres
• les instructions de type J, (Jump, saut), l'opérande est
l'adresse choisie
Ces formats ne correspondent pas aux différentes catégories
d'instructions
Catégories des instructions MIPS
répartition en 6 catégories :
• Load/Store
• calculatoires : arithmétiques, logiques, décalages/rotations
• sauts et branchements
• instructions du coprocesseur arithmétique (R2010 FPA)
• instructions du coprocesseur de contrôle CP0 (gestion de
la mémoire virtuelle, gestion des interruptions et exceptions)
• instructions spéciales : appels système, points d'arrêt
Retour sur les formats d'instruction
Type I
op rs rt immediate
Type J
op target
Type R
op rs rt rd shamt funct
Retour sur les formats d'instruction
Avec : op : opcode sur 6 bits
rs : n° de registre source sur 5 bits
rt : n° de registre de transit sur 5 bits
rd : n° de registre de destination sur 5 bits
immediate : valeur immédiate 16 bits
target : adresse cible sur 26 bits
shamt : valeur de décalage sur 5 bits (pour les instructions de
décalage, rotations)
funct : champ de fonction sur 6 bits
Le langage Assembleur
En fait, leS langageS d'assemblage. A chaque architecture son
langage (dommage).
Produit le code réputé le plus efficace en rapidité d'exécution
proche de la machine (quoique…)
donc hélas éloigné du programmeur
productivité plus faible en assembleur qu'en C
code produit par les compilateurs de plus en plus sophistiqués.
Utilité pour certaines applications (temps réel)
Le langage Assembleur
Au départ : traduction quasi-directe en langage machine
(traduction 'à la main' en hexadécimal, en binaire, en trous ! avec des
tables de conversion)
des programmes :
Instructions du Instructions en
Code + opérandes
microprocesseur assembleur
en hexadécimal
Le langage Assembleur
Aujourd'hui, langage assembleur traduit en langage machine de
manière plus complexe :
existence de pseudo-instructions (qui ne sont pas comprises par tous
les assembleurs MIPS).
Piège pour l'évaluation de performances, en nombre de
cycles/instructions :
cycles / instructions en langage machine, et non cycles / instructions
en assembleur !
En général, pseudo-instructions très bien traduites : utilisation
naturelle, pas de précaution à prendre pour leur emploi.
Le langage Assembleur
Pas de typage fort des données : emploi sans contrôle des octets ou
groupes de 16 ou 32 bits selon les besoins
Pas de protection du code vis-à-vis des données :
localisation mémoire différente (explicite)
mais accès indifférent
code auto-modifiable
un programme peut écrire dans la zone mémoire où sont stockées ses
instructions !
(très simple en MIPS !)
Le langage Assembleur
Connaissance du "modèle de la mémoire" du processeur ou de
l'assembleur.
Attention aux différences possibles entre :
• Simulation d'un processeur : interprétation du code binaire ou
des instructions assembleur
• Exécution du programme en code binaire sur une cible
(processeur + carte)
adresses
DYNAMIC (heap)
DATA
STATIC
0x10000000
TEXT
0x00400000
Réservé
Modèle des registres
Noms associé à un rôle que jouent les registres lors de programmes
comportant plusieurs langages source (C et ASM le plus souvent)
exemple de directives :
.text indique que les lignes suivantes seront rangées dans le
segment TEXT
.data indique que les lignes suivantes seront rangées dans le
segment DATA
.byte 6 stocke la valeur 6 dans un octet de la mémoire
Écrire un programme
Exemple avec un programme affichant "hello world !"
.data
hello: .asciiz "hello world\n"
directives
.text
.globl main
main:
li $v0,4
la $a0,hello instructions
syscall
j $ra
labels
Écrire un programme
Les lignes indispensables : programme minimal
donnera en mémoire :
[0x10010000] 0xa5a5a5a5 0xb6b7a5a5 0xfb0c0c0c 0x000000fb
Les constantes à virgule
Écriture des nombres en virgule flottante, formats .float et .double : on
utilise une notation scientifique
exemples :
.data
.float 1.1
.float -1.1e-24
donnera en mémoire
[0x10010000] 0x3f8ccccd 0x97aa377d
$t0 : 00000001
$t1 : ffffffff
$t2 : 00000001
$t3 : 000000ff
Instructions de base et exemples
Instruction lh/lhu
syntaxe : lh destination, adresse
même principe que l'instruction lb pour les extensions de signe, les
valeurs transférées sont des valeurs 16 bits situées à des adresses
paires.
En cas d'adressage à une adresse impaire pou lh/lhu : erreur
d'adressage (exception), fait planter le programme
instruction lw : load word, chargement de 32 bits suivant le même
principe
syntaxe : lw destination, adresse
l'adresse donnée en opérande doit être multiple de 4.
Instructions de base et exemples
Instructions de chargement avec des valeurs non alignées en
mémoire :
lwl : load word left : charge les x octets de plus haut numéro d'un mot
mémoire dans les 24 bits de poids fort d'un registre.
lwr : load word right : charge les x octets de numéro le plus bas d'un
mot mémoire dans l'octet de poids faible d'un registre.
Utilité : charger des mots non alignés en 2 étapes. La numérotation des
octets lus en mémoire se fait en fonction de la représentation gros ou
petit-boutiste de la machine concernée.
Instructions de base et exemples
Autres affectations qui ne sont pas des chargements (pas de référence
en mémoire)
lui : load upper immediate
syntaxe : LUI destination, immédiate (16 bits)
stocke la valeur immédiate 16 bit dans les 16 bits de poids fort
du registre destination, les 16 bits de poids faible sont mis à 0.
Ex : lui $t0,0x1234
$t0 12 34 00 00
Instructions de base et exemples
Autres affectations qui ne sont pas des chargements (pas de référence
en mémoire)
li : load immediate (pseudo-instruction)
réalisé par : lui : pour charger les 16 bits de poids fort du registre,
li $v0,10
syscall
Adressage indirect avec déplacement
Pour les instructions de chargement, l'adressage indirect est utilisé
lorsque l'adresse est donnée sous forme d'un registre noté entre
parenthèses.
Exemple :
lhu $t0,($t1)
charge dans le registre $t0 le mot 16 bits (sans extension de signe)
situé à l'adresse "pointée" par le registre $t1.
On peut faire précéder cette notation d'une constante numérique (notée
en décimal ou en hexadécimal) indiquant un offset ou déplacement à
appliquer au contenu du registre avant de lire la mémoire.
Il faut toujours que le registre utilisé comme registre d'adresse soit
initialisé !
Adressage indirect avec déplacement
Exemples :
.data
samples:
.word 0x12345678
.word 0xfedbca98
.text
.globl main
main:
la $t1,samples # la : load address : adressage direct et immédiat
lw $t0,($t1) # lw : load word :adressage direct et indirect
lw $t2,4($t1) #lw : adressage direct et indirect avec déplacement
li $v0,10
syscall
offset = 4
.data
samples:
.word 0x12345678
.word 0xfedbca98
.text
.globl main
main:
la $a1,samples # la : load address : adressage
direct et immédiat
lw $t0,($a1) # lw : load word :adressage
direct et indirect
lw $t2,offset($a1)
li $v0,10
syscall
Instructions de rangement
Permettent de transférer le contenu de registres vers des octets, mots
16 bits ou mots 32 bits.
Instructions de base :
sb (store byte), sh, sw
syntaxe :
SB registre,adresse : concerne les 8 bits de poids faible du registre
SH registre, adresse : concerne les 16 bits de poids faible du registre
SW registre, adresse : concerne tout le registre
attention : la représentation little ou big endian ne concerne pas les
registres, mais seulement les mots mémoire !
Instructions de rangement
L'alignement des adresses doit être respecté :
sb à toutes les adresses
sh seulement à des adresses paires
sw seulement à des adresse multiples de 4
dans le cas contraire : erreur d'adressage, le programme plante.
Il est possible, comme pour les chargements, d'utiliser l'adressage
indirect avec déplacement (même syntaxe) pour ranger une valeur en
mémoire.
Instructions de rangement
Exemple : ranger en mémoire, à l'adresse 0x2000, les 16 bits de poids
faible du registre $t6.
On utilise les registres $t2 et $s3 comme registres d'adresse (on peut
utiliser n'importe lequel, à l'exception de $0), pour montrer deux
manières différentes d'arriver au même résultat
.text
.globl main
main: li $t6,0xfedcba98 # initialisation de $t6
la $s3,0x2000 # adressage direct et immédiat
la $t2,0x1000 # adressage direct et immédiat
sh $t6,($s3) # adressage direct et indirect
sh $t6,0x1000($t2) # adressage direct et indirect
j $ra
Instructions de rangement
Il n'est par contre pas possible de ranger en mémoire des valeurs
immédiates avec une instruction. Pour cela, on utilisera 2 instructions :
chargement d'un registre avec la valeur immédiate concernée
rangement du contenu du registre en mémoire.
Il est possible, par contre de stocker 64 bits situés dans deux registres
consécutifs grâce à la pseudo-instruction Store Doubleword.
Syntaxe : SD registre_n°_n,adresse
stocke les valeurs des registres numéro n et n+1 dans les cellules
mémoires situées à l'adresse mentionnée.
Autres affectations
Réalisation de transferts de registre à registre.
Syntaxe :
move destination,source (pseudo-instruction)
transfère sur 32 bits le contenu du registre source vers le registre
destination.
Réalisée en faisant une addition entre le registre source et le registre
$0, addition dont le résultat est rangé dans le registre destination.
main: li $t0,-1
sll $t1,$t0,12
srl $t2,$t1,1
li $t4,6
srlv $t1,$t0,$t4
fin: li $v0,10
syscall
Instructions AL
Décalages arithmétiques :
lors d'un décalage arithmétique à droite, les bits entrants sont égaux au
bit de signe du registre à décaler
syntaxe :
SRA destination, source, shamt
ou
SRAV destination, source, décalage
fin: li $v0,10
syscall
Branchements
Possibilités de branchements avec des instructions de type I, R ou J
(J : Jump).
Adresse de destination de saut donnée par :
registre
immédiat 16 bits (décalage)
immédiat 26 bits (instructions de type J)
4 variantes pour cette instruction Jump
Branchements
Saut absolu à une adresse donnée sur 26 bits :
Jump, Jump And Link.
Syntaxe :
J target
JAL target
effet : saut à l'adresse spécifiée en opérande.
Transformation de cette opérande de 26 bits 32 bits : décalage de 2
bits vers la gauche, complétion des 4 bits de poids fort en recopiant
ceux du registre PC.
Branchements
Instruction J : saut simple vers la destination spécifiée : équivalent de
GOTO.
Instruction JAL : Link : lien avec l'instruction de saut. Possibilité de
revenir à l'instruction suivante.
Principe : lorsqu'un saut est effectué, sauvegarde de l'adresse à
laquelle se situe l'instruction suivante. Possibilité de sous-programme
réutilisable à partir de plusieurs appels :
réalisation de fonctions.
Effet de JAL : sauvegarde de l'adresse de retour dans le registre $ra
(qui est le registre $31).
Système simpliste et mal adapté aux fonctions.
Branchements
Saut avec registres :
JR rs : saut à l'adresse contenue dans le registre rs.
JALR rd, rs :saut à l'adresse contenue dans le registre rs. De plus,
l'adresse de l'instruction suivante est placée dans le registre rd pour
offrir une possibilité de retour de fonction/sous-programme.
Exemples : sauts avec Jump
.text
.globl main
main : j suite
fin : li $v0,10
syscall
suite : j fin
Branchements
Exemples (suite) : Jump And Link
.data
message : .asciiz "coucou"
.text
.globl main
main : la $a0,message
jal affiche
la $a0,message+2
jal affiche
li $v0,10
syscall
affiche: li $v0,4
syscall
jr $ra
Branchements
Exemples (suite) : Jump Register (sans link)
.data
message : .asciiz "coucou"
.text
.globl main
main : la $a0,message
la $a1,affiche
jr $a1
fin: li $v0,10
syscall
affiche: li $v0,4
syscall
la $a1,fin
jr $a1
Branchements
Exemples (suite) : Jump And Link register
.data
message : .asciiz "coucou"
.text
.globl main
main : la $a0,message
la $a1,affiche
jalr $a2,$a1
la $a0,message+2
jalr $a2,$a1
fin: li $v0,10
syscall
affiche: li $v0,4
syscall
jr $a2
Branchements
Sauts relatifs et sauts conditionnels : utilisation de l'instruction branch
et de ses variantes.
La valeur du saut effectué correspond toujours à un offset ou décalage
par rapport à la valeur du registre PC indiquant l'adresse de
l'instruction en cours de traitement.
Peu d'instructions de branchement conditionnels (approche RISC), se
basent sur deux tests : égalité et nullité.
6 instructions à retenir (6 codes de conditions pour les branchements)
Branchements
Branch on EQual :
BEQ source1,source2,offset
effectue : offset décalé de deux bits à gauche et étendu sur 32 bits
PC PC+offset si source1=source2
BNE source1,source2,offset
effectue le saut si source1 source2
BLEZ source,offset : effectue le saut si source 0
BGTZ source,offset : effectue le saut si source 0
BLTZ source,offset : effectue le saut si source 0
BGEZ source,offset : effectue le saut si source 0
Branchements
Saut conditionnel et lien :
BGEZAL : BGEZ And Link (registre $ra)
BLTZAL : BLTZ And Link (registre $ra)
Réalisation de saut inconditionnel :
BEQ $0,$0,offset
Branchements
Réalisation de boucles avec les sauts conditionnels.
While condition
{
instructions
}
La traduction d'une boucle for se fait en notant qu'une boucle for est
strictement équivalente à une boucle while : on reprend donc la
traduction de la première boule while.
Appels SYSCALL
Sur le simulateur : mini système d'exploitation permettant d'appeler
des services 'minimaux' pour les entrées/sorties de base : affichages et
saisies.
Il faut sélectionner le service que le système va rendre et indiquer les
éventuels paramètres à fournir, appeler le système, puis
éventuellement récupérer le résultat.
Principe : le registre $v0 doit contenir le numéro du service. Selon la
valeur de $v0, c'est une saisie ou un affichage qui sera fait; avec un
certain format de données : entier, nombre à virgule, chaîne de
caractères.
Appels SYSCALL
Opération effectuée Service code d’appel arguments retour
Afficher un entier print_int 1 $a0 : entier
Afficher un float print_float 2 $f12 : float
Afficher un double print_double 3 $f12 : double
Afficher une chaîne print_string 4 $a0 : chaîne
Saisir un int read_int 5 Entier dans $v0
Saisir un float read_float 6 Float dans $f0
Saisir un double read_double 7 Double dans $f0
Saisir une chaîne read_string 8 $a0 : buffer, $a1 :longueur
Allocation dynamique sbrk 9 $a0 : nb d’octets Adresse de la zone dans $v0
.data
hello: .asciiz "hello\n" # asciiz ajoute un octet nul en mémoire pour repérer la fin de
chaîne
.text
.globl main
main:
li $v0,4 # code : affiche une chaîne
la $a0,hello # $a0 pointe sur le début de chaîne
syscall # appel système : demande d'affichage de chaîne
jr $ra
.text
.globl main
main: lw $a0,donnee
li $v0,1
syscall
jal convert
la $a0,str_hex
li $v0,4
syscall
li $v0,10
syscall
Affichage en HEXA
convert :
addi $sp,$sp,-4 # déplacer pointeur de pile
sw $ra,($sp) # empilement adresse de retour
SWCz registre,adresse
range la valeur du registre de la FPU à l'adresse fournie
stratégie b)
main: la $a0,valeur_pi
lwc1 $f12,($a0)
li $v0,2
syscall
j $ra
Opérations avec la FPU
Utilisation pour des calculs en virgule flottante : instructions
spécifiques, avec :
un opcode
un format (s ou d)
des opérandes
explication :
le simulateur utilise un morceau de programme pour interfacer
l'assembleur avec le langage C, et appelle le programme principal
(label main).
Les appels aux sous-programmes
Principe de l'appel de sous-programme :
deux syntaxes :
JALR registre : saut à l'adresse donnée par le registre, adresse
de retour sauvegardée dans $ra
JALR registre de lien, registre de saut : saut à l'adresse
donnée par le registre de saut, sauvegarde de l'adresse de retour dans le
registre de lien
Accès à la pile simple, grâce à un registre qui est prévu à cet effet :
c'est le registre $sp ($29 pour l'assembleur).
Pas obligatoire, possibilité d'avoir une autre pile, une pile est juste une
zone de mémoire !
Adresse de bas
$sp de zone
Taille en bits(8 ou 16 ou 32)
Exemple
0x00400000 : instructions insérées par le simulateur
0x00400014 : appel au prog : jal main
0x00400018 : nop
0x0040001c : li $v0,10
0x00400020 : syscall
0x00400024 : main : addi $sp,$sp,-4 # ici $ra contient 0x00400018
0x00400028 : sw $ra,($sp)
$sp 0x00400018
0x7fffeffc
32 bits
$ra 0x00400018
Exemple (suite)
0x00400028 :la $a0,text_acc
0x0040002c: jal aff_text
0x00400030: li $v0,6
0x00400034: syscall
# calculs
$sp 0x00400018
0x7fffeffc
32 bits
$ra 0x00400030
Exemple (suite)
0x0040007c: aff_text: li $v0,4
0x00400080: syscall
0x00400084: j $ra
$sp 0x00400018
0x7fffeffc
32 bits
$ra 0x00400030
li $v0,2
Exemple (fin)
syscall
lw $ra,($sp)
addi $sp,$sp,4
j $ra
0x00400018
$sp 0x7fffeffc
32 bits
$ra 0x00400018
Passage de paramètres
Structuration : pas de variables globales.
Utiliser des registres pour transmettre des valeurs : prendre le risque
de modifications dans les sous-programmes !
A: addi $sp,$sp,-4
sw $ra,($sp) Registres empilés dans l'ordre :
addi $sp,$sp,-4 $ra, $v0, $t2, $s4, $a0, $a2
sw $v0,($sp)
….
lw $v0,($sp)
addi $sp,$sp,4 Registres dépilés dans l'ordre :
lw $ra,($sp) $ra, $v0, $t2, $s4, $a0, $a2
addi $sp,$sp,4
jr $ra
Indépendance des registres
Illustration : soit le sous-programme FOO qui modifie le registre $v0.
.data
donnee : .word 35
.text
.globl main
main: li $v0,3 lw $v0,($sp)
jal FOO addi $sp,$sp,4
li $v0,10 lw $ra,($sp)
syscall addi $sp,$sp,4
jr $ra
FOO : addi $sp,$sp,-4
sw $ra,($sp)
addi $sp,$sp,-4
sw $v0,($sp)
lw $v0,donnee
syscall
Indépendance des registres
Empilement 1
$sp $ra
32 bits
Empilement 2
$sp $v0
$ra
32 bits
Indépendance des registres
Cas général
$sp registre
1 cellule mémoire
par registre sauvegardé
registre
$ra
32 bits
Les paramètres
Etape b) : utiliser des paramètres et non des registres pour
communiquer.
Ne dispense pas de l'étape a) car dans le sous-programme, il peut y
avoir des calculs, des transferts, qui ne se font qu'avec des registres et
non des 'variables' : les variables sont des cellules mémoires et donc
peu manipulables avec le MIPS !
jal sous_prog
État de la pile
sous-prog : addi $sp,$sp,-4
sw $ra,($sp)
# autres instructions
$sp $ra
Adresse de a : 0x10010180
Valeur de b : 62
32 bits
L'allocation dynamique
Appel système avec $v0=9 permet de réserver de la mémoire
dynamiquement dans la zone de tas pour les applications ayant au fur
et à mesure des besoins en mémoire.