Chap2 2mipsisa

Le jeu d’instructions MIPS
Nous allons voir le langage de la machine :

Les opérations du matériel de l’ordinateur
Les opérandes du matériel de l’ordinateur
La représentation des instructions dans
l’ordinateur
Des instructions pour prendre des décisions
19/10/2012 12:39 I.Abdesslem 1

les instructions. 1
Les opérations du matériel de l’ordinateur
Tout ordinateur doit être capable d’effectuer des

opérations arithmétiques.
La notation MIPS
add a,b,c
chaque instruction arithmétique MIPS doit toujours

avoir trois variables.
19/10/2012 12:39 I.Abdesslem 2

les instructions. 2
Les opérandes des instructions arithmétiques doivent

provenir d’un nombre limité d’emplacements particuliers
appelés registres.
La taille d’un registre dans l’architecture MIPS est de 32
bits
MIPS possède 32 registres, notés $0, $1, ...,$31
Les registres sont plus rapide que la mémoire
Les registres sont plus facile à utiliser pour le compilateur
Les registres peuvent contenir des variables
Réduction trafic mémoire
19/10/2012 12:39 I.Abdesslem 3

les instructions. 3
230 octet mémoire

31 registres 32 bits + R0=0
HI, LO, CP
R0 0
R1
…
R31
CP
LO
HI
19/10/2012 12:39 I.Abdesslem 4
les instructions. 4
Les registres du MIPS
Le MIPS comporte 32 registres généraux interchangeables, sauf

:
le registre zéro qui vaut toujours 0, même après une écriture.
Le registre ra, utilisé implicitement par certaines instructions
pour sauver l'adresse de retour avant un saut.
Les autres registres ont des utilisations préférentielles, mais

cela n'est strict que pour communiquer avec d'autres
programmes(exemple: utiliser des programmes en librairies).
19/10/2012 12:39 I.Abdesslem

5
les instructions. 5
Les registres du MIPS
Nom Numéro Usage

zero 0 Zéro (toujours)
at 1 Réservé par l'assembleur
v0 .. v1 2 .. 3 Retour de valeurs
a0 .. a3 4 .. 7 Passage d'arguments
t0 .. t7 8 .. 15 Temporaires non sauvegardés
s0.. s7 16 .. 23 Temporaires sauvegardés
t8.. t9 24 .. 25 Temporaires non sauvegardés
k0.. k1 26 .. 27 Réservés par le système
gp 28 Global Pointer
sp 29 Stack Pointer
fp 30 Frame Pointeur
ra 31 Return Address
19/10/2012 12:39 I.Abdesslem

6
les instructions. 6
Exemple
f=(g+h)-(i+j);
Les variables f,g,h,i et j peuvent être

assignées aux registres $16, $17,… $20.
C’est au compilateur que revient cette
tâche délicate.
add $8,$17,$18 #Registre $8 contient g+h

add $9,$19,$20 #Registre $9 contient i+j
sub $16,$8,$9 # f reçoit $8-$9, ou (g+h)-(i+j)
19/10/2012 12:39 I.Abdesslem 7

les instructions. 7
Beaucoup de programmes ont plus de variables que

les machines n’ont de registres. Par conséquent, le
compilateur cherche à conserver dans les registres les
variables les plus souvent utilisées et place le reste en
mémoire.
Les structures de données comme les tableaux sont

donc stockées en mémoire
19/10/2012 12:39 I.Abdesslem 8

les instructions. 8
Les opérations arithmétiques n’ont lieu que dans

les registres. MIPS doit donc disposer
d’instructions qui transfèrent les données entre la
mémoire et les registres.
Load
Processeur Mémoire
Store
19/10/2012 12:39 I.Abdesslem 9

les instructions. 9
Depuis 1980 toutes les machines utilisent des

adresses au niveau de l’octet (8 bits)
Adresse Donnée
0 10
4 45
Processeur 8 8456666
12 0
... ...
Puisque on peut lire un mot de 32 bits comme 4 octets

en un seul coup, comment ces octets sont ranger dans le
mot ?
19/10/2012 12:39 I.Abdesslem 10
les instructions. 10
Big-endian: l’adresse de l’octet le plus significatif

est l’adresse du mot
Numéro d’octet
3 2 1 0 Motorolla, MIPS, SPARC
Little-endian: l’adresse l’octet le moins

significatif est l’adresse du mot
Numéro d’octet
Intel 8086, VAX, Alpha
0 1 2 3
19/10/2012 12:39 I.Abdesslem 11

Transfert de donnée
Chargement mot :
lw $1,100($2)
$1 = Mémoire[$2+100]
Rangement mot :
sw $1,100($2)
Mémoire[$2+100] = $1
19/10/2012 12:39 I.Abdesslem 12

Exemple
T[i]=h+T[i] ;
T est un tableau d’entiers.

On suppose que la variable h est dans
$18. $19 contient la valeur i, et que le
tableau débute à l’adresse Tstart
muli $19,$19,4 #i=i*4

lw $8,Tstart($19) #reg temporaire $8 reçoit T[i]
add $8,$18,$8 #reg temporaire $8 reçoit h+T[i]
sw $8,Tstart($19) #on recopie h+T[i]dans T[i]
19/10/2012 12:39 I.Abdesslem 13

Branchement conditionnel
branchement si égal
beq $1,$2,L
si ($1==$2) aller en L
branchement si non égal :

bne $1,$2,L
si ($1!=$2) aller en L
Exemple
if (i==j)
f=g+h;
else
f=g-h;
f,g,h,ietj correspondent aux registres $16 à $20
bne $19,$20,Else # aller en Else si i¹j

add $16,$17,$18 # f=g+h
j Exit # aller en Exit
Else:sub $16,$17,$18 # f=g-h
Exit:
Exemple
While (stock[i]==k)
i=i+j;
i,j et k correspondent aux registres $19 à $21,

le tableau stock débute à Sstart,
le registre $10 contient la valeur 4;
loop : mult $9,$19,$10 #reg temporaire $9=i*4

lw $8,Sstart($9) #reg temporaire $8=stock[i]
bne $8,$21,Exit #aller en Exit si stock[i]¹k
add $19,$19,$20 #i=i+j
j Loop #aller en Loop
Exit:
Le format des instructions
31-26 25-21 20-16 15-11 10-6 5-0

0p rs rt rd decval fonct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
Nous donnons des noms aux champs MIPS pour faciliter leur
description
• op : opération correspondant à l’instruction
• rs : le premier registre opérande source
• rt : le second registre opérande source
• rd : le registre opérande destination ; il reçoit le résultat de
l’opération
• decval : valeur du décalage
• fonct : fonction ; ce champ détermine la variante de
l’opération décrite dans le champ op
Instruction de type R
31-26 25-21 20-16 15-11 10-6 5-0
0 rs rt rd decval fonct
Exemples :
add $1,$2,$3 signification $1=$2+$3

0 2 3 1 0 32
Sub $1,$2,$3 signification $1=$2-$3
0 2 3 1 0 34
Instruction de type I
Instruction de chargement ou de rangement
31-26 25-21 20-16 15-0
35ou43 rs rt adresse
6 bits 5 bits 5 bits 16 bits
Exemples :
lw $1,100($2) signification : $1=Mémoire($2+100)
35 2 1 100
Sw $1,100($2) signification : Mémoire($2+100)=$1
43 2 1 100
Instruction de branchement
31-26 25-21 20-16 15-0
4 ou 5 rs rt adresse
Exemples :
beq $1,$2,100 signification : si ($1=$2) aller en 100
4 1 2 100
bne $1,$2,100 signification : si ($1¹$2) aller en 100

5 1 2 100
• Instruction type J
op adresse
6 bits 26 bits
Exemple : J 2000
2 2000
6 bits 26 bits
Différents formats d’instructions MIPS
31 26 21 16 11 6 0
R-type op rs rt rd decval funct add, sub
I-type op rs rt immediate ori, lw, sw, beq
J-type op Address destination j, jal
Modes d’adressage
1. Adressage par registre
31 26 21 16 11 6 0
op rs rt rd decval funct
registre
Opérande est un registre Add $4,$2,$3
2. Adressage indexé
op rs rt adresse
registre
+ Mémoire
lw $1,100($2)
Opérande se trouve à
l’emplacement mémoire
Modes d’adressage
3. Adressage immédiat
op rs rt immédiat
6 bits 5 bits 5 bits 16 bits
Opérande constante addi $1,$2,100
4. Adressage relatif à CP
op rs rt adresse
CP
bne $1,$2,100 + Mémoire
Nombre de mots qui séparent l ’instruction

de branchement de l ’instruction cible
L’utilisation de la mémoire
Conventions adoptées sur un système MIPS :
Segment de texte (détient les instructions du
programme)
Segment de données
Segment de pile
Il se situe au sommet de l’espace adressable.
Lorsque le programme dépose des valeurs sur la
pile, le système d’exploitation étend le segment
de pile vers le bas.
L’utilisation de la mémoire
7fffffff
Segment de pile
Segment de
données
10000000
Segment de texte
00400000 Réservé
Traitement des procédures
Procédure A
0: procédure A
Éditeur
Procédure B de 64: procédure B
liens
112:procédure C
Procédure C
Appel de procédure.
Retour à l’instruction qui suit l’appel.
Passage des paramètres
Imbrication des procédure
Traitement des procédures
Instruction jal (saut avec lien)

jal AdresseProcedure
Ä L’Adresse de retour est rangé dans $31.
Le retour est effectue par l’instruction : jr $31
$31 CP: compteur de programme
Cas plus compliqué lorsque une procédure appelle une

autre procédure
Ä Vidée les registre $31 dans la mémoire

Les appels de procédures
Void procB(){
procC();
}
Void procA(){
procB();
}
Appels et retours
procA procB procC
Retour
Retour
Les appels de procédures
Void procB(){
procC();
}
Void procA(){
procB();
}
jal AdresseProcedure :
Affecte un saut à une adresse donnée en
sauvegardant l’adresse de l’instruction suivante dans
le registre $31
jr $31
Instruction qui fait un saut de retour
Sauvegarde et restitution de l’adresse de retour
procA:...
... $31
Mémoire
jal procB
...
procB:... $29
...
addi $29,$29,-4
sw $31,0($29)
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Après que procA ai appelé procB
procA:...
... $31
Mémoire
jal procB ad ret procB
...
procB:... $29
...
addi $29,$29,-4
sw $31,0($29)
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Juste avant que procB n’appelle procC
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
sw $31,0($29)
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Juste avant que procB n’appelle procC
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
sw $31,0($29) ad ret procB
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Appel
procA:...
... $31
Mémoire
jal procB ad ret procC
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Après que procB ait appelé procC
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Juste avant que procB ne retourne
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Juste avant que procB ne retourne
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
Retour à procA
procA:...
... $31
Mémoire
...
procB:... $29
...
addi $29,$29,-4
jal procC
lw $31,0($29)
addi$29,$29,4
...
jr $31
procC:...
...
jr $31
instructions arithmétiques
Instruction Exemple signification
add add $1,$2,$3 $1 = $2 + $3 exception possible
sous sub $1,$2,$3 $1 = $2 – $3 exception possible
add immediate addi $1,$2,100 $1 = $2 + 100 exception possible
add non signé addu $1,$2,$3 $1 = $2 + $3 pas d’exception
sous non signé subu $1,$2,$3 $1 = $2 – $3 pas d’exception
add imm. non sig addiu $1,$2,100 $1 = $2 + 100 pas d’exception
mul mult $2,$3 Hi, Lo = $2 x $3
Mul non signé multu$2,$3 Hi, Lo = $2 x $3
div div $2,$3 Lo = $2 ÷ $3, Lo = quotient
Hi = $2 mod $3 Hi = reste
div non signé divu $2,$3 Lo = $2 ÷ $3,
Hi = $2 mod $3
Move from Hi mfhi $1 $1 = Hi
Move from Lo mflo $1 $1 = Lo les instructions. 41
instructions logiques
Instruction Exemple Signification
and and $1,$2,$3 $1 = $2 ET $3
or or $1,$2,$3 $1 = $2 OR $3
xor xor $1,$2,$3 $1 = $2 XOR $3
nor nor $1,$2,$3 $1 = $2 NOR $3
and immediat andi $1,$2,10 $1 = $2 ET 10
or immediat ori $1,$2,10 $1 = $2 OU 10
xor immediat xori $1, $2,10 $1 = $2 XOR 10
shift left logical sll $1,$2,10 $1 = $2 << 10
shift right logical srl $1,$2,10 $1 = $2 >> 10
shift right arithm. sra $1,$2,10 $1 = $2 >> 10
shift left logical sllv $1,$2,$3 $1 = $2 << $3
shift right logical srlv $1,$2, $3 $1 = $2 >> $3
shift right arithm. srav $1,$2, $3 $1 = $2 >> $3
instructions de transfert de données
Instruction Comment
sw $3, 500($4) enreg. D’un mot en mémoire
sh $3, 502($2) enreg. D’un demi-mot
sb $2, 41($3) enreg. D’un octet
lw $1, 30($2) chargement d’un mot

lh $1, 40($3) chargement d’un demi mot
lhu $1, 40($3) chargement d’un demi-mot non signé
lb $1, 40($3) chargement d’un octet
lbu $1, 40($3) chargement d’un octet non signé
lui $1, 40 Load Upper Immediate (16 bits shifted left par 16)
LUI $1 0040
$1 0040 0000 … 0000

Comparaison et branchement
Instruction Exemple Signification
branch on equal beq $1,$2,100 Si ($1 == $2) go to CP+4+100
branch on not eq. bne $1,$2,100 Si ($1!= $2) go to PC+4+100
set on less than slt $1,$2,$3 Si ($2 < $3) $1=1; else $1=0
set less than imm. slti $1,$2,100 Si ($2 < 100) $1=1; else $1=0
set less than uns. sltu $1,$2,$3 Si ($2 < $3) $1=1; else $1=0
set l. t. imm. uns. sltiu $1,$2,100 Si ($2 < 100) $1=1; else $1=0
jump j 10000 go to 10000 saut à une adresse
jump register jr $31 go to $31 retour de procédure
jump and link jal 10000 $31 = PC + 4; go to 10000
appel de procédure
Langage machine et langage assembleur
Le langage assembleur attribue des noms

symboliques aux instructions, aux registres, et aux
adresses constantes.
Le langage machine est une suite de mots, qui
peuvent représenter des données ou des
instructions.
L’assembleur (pour nous, SPIM) est un programme
qui traduit le langage assembleur en langage
machine.
C’est quoi le SPIM ?
SPIM n’est que le mot MIPS écrit à l’envers.

SPIM est un simulateur logiciel qui exécute des
programmes écrits pour les processeurs MIPS
R2000/R3000.
SPIM permet de déboguer plus facilement avec
les Breakpoints et l’exécution pas à pas .
Machine virtuelle = jeu d’instructions

plus riche que le matériel réel.
19/10/2012 12:39 I.Abdesslem 46
1-Instructions et pseudo-instructions
Les instructions (RISC) étant très élémentaires, on
ajoute des pseudo-instructions, qui n’existent pas
réellement pour le processeur, mais sont traduites
vers une suite d’instructions réelles par l’assembleur.
Par exemple,
blt $t0, $t1, address

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

bne $at, $zero, address
1.Instructions et pseudo-instructions
Ou encore,
l i $t0,0xA400020
est expansée en
lui $at,0x0A40
ori $t0, $at,0x0020
2.Les commentaires :
Un commentaire sera toujours précédé par un ‘#’ .
# <commentaire>
Exemple :
#################
#-----Programme-----#
#################
19/10/2012 12:39 I.Abdesslem 49
3.Les chaines de caractères :
Une chaine de caractère sera déclarée entre “ “.
Exemple :
.asciiz “Hello world !\n”
On peut utiliser quelques caractères spéciaux

compatible avec le langage C :
newline(retour-chariot) \n
tabulation \t
19/10/2012 12:39 I.Abdesslem 50
4.Les directives de SPIM :
Définition : ce sont des instructions qui vont dire à

l’assembleur (SPIM) comment traduire un programme.
Les directives ne produisent pas des

instructions machine.
Format d’une directive : .directive
19/10/2012 12:39 I.Abdesslem 51
4.Les directives de SPIM :(Suite)
Exemples :
.data : déclaration du segment de données.
.text : déclaration du segment de code.
.ascii “ str“ :déclaration de chaines de caractères.
.asciiz “ str“ :déclaration de chaines de caractères se

terminant avec le caractère nul.
.space n : Alloue n octets d’espace mémoire dans le

segment de données.
19/10/2012 12:39 I.Abdesslem 52
4.Les directives de SPIM :(Suite)
.word w1, …, wn : Enregistre les n quantités 32 bits

dans des mots consécutive en mémoire
. half h1, ..., hn : Enregistre les n quantités 16 bits

dans des mots consécutive en mémoire
. byte b1, …, bn : Enregistre les n quantités d’octets

sucessivement en mémoire
.globl sym :déclare une étiquette ou variable globale

c.-à-d. pouvant être appelé depuis un autre fichier.
19/10/2012 12:39 I.Abdesslem 53
5.Les appels système :
$v0
$a0-$a3 syscall
$a0
$v0
•v0 (2) : Ce registre doit contenir le code de l’appel système .

•a0-a3 (4 -7) : pour les arguments en cas de manipulation de
print_int , print_string .
•v0 (2): résultat cas des services : read_int
19/10/2012 12:39 I.Abdesslem 54
4.Les appels système ( Suite ) :
Nom No Effet
print_int 1 imprime l'entier contenu dans a0
print_string 4 imprime la chaîne en a0 jusqu'à '\000'
read_int 5 lit un entier et le place dans v0
Lecture d’une chaîne
read_string 8 L’adresse du buffer en a0
La longeur de la chaîne en a1
exit 10 arrêt du programme en cours d'exécution
19/10/2012 12:39 I.Abdesslem 55
Un exemple complet 1: Factorielle (itératif)
.data
str1: .asciiz " Entrez un entier :"
str2: .asciiz "Sa factorielle est «
.text
main: li $v0 , 4 # system call code for print_str
la $a0 , str1 # address of string to print
syscall # print the string
li $v0 , 5 # system call code for read_int

syscall # read int , result in $v0
li $3 , 1 # initialisation du resultat
loop: blt $v0,1,sortie # Si $v0 <1, on sort
mul $3,$v0,$3
sub $v0,$v0,1
b loop # sinon , $3=$3*$v0 , $v0 =$v0 -1
sortie:li $v0 , 4 # system call code for print_str

li $v0,1 # system call code for print_int
move $a0,$3 # integer to print
syscall # print the integer
li $v0,10 # on sort proprement du programme

syscall
Fonctions récursives
voici une fonction C récursive.
int f (int n)
{
if (n<= 0)
return 1;
else
return n*f(n − 1);
}
Fonctions récursives
• Parce que fact est récursive, plusieurs appels imbriqués
peuvent être actifs simultanément :
a0 a0 – 1
a0 a0 – 1
fact fact
v0 a0 x v0
v0 a0 x v0
L’appel récursif modifie a0 . en fait, il en détruit le contenu.
Or, celui-ci est utilisé après l’appel.
Il faut donc sauvegarder le contenu de a0 avant l’appel, puis
le restaurer après l’appel. (Et de même pour $ra.)
La pile
• Par convention, la pile grandit dans le sens des adresses
décroissantes. Le registre $sp pointe vers le sommet de la
pile, c’est-`a-dire vers le dernier mot alloué.
On sauvegarde le contenu de a0 sur la pile comme ceci :
sub $sp, $sp, 4 # alloue un mot sur la pile
sw $a0, 0($sp) # copie $a0 vers le sommet de la pile
On restaure le contenu de a0 depuis la pile comme cela :
lw $a0, 0($sp) # copie le sommet de la pile vers $a0
add $sp, $sp, 4 # d´esalloue un mot sur la pile
Factorielle (récursive)
. data
str1 : . asciiz " Entrez un entier :"
str2 : . asciiz "Sa factorielle est "
. text
main : li $v0 , 4 # system call code for print_str
li $v0 , 5 # system call code for read_int
syscall # read int , result in $v0
move $a0,$v0
jal fact
sortie : move $16,$v0
li $v0 , 4 # system call code for print_str
li $v0 ,1 # system call code for print_int
move $a0 ,$16 # integer to print
syscall # print the integer
li $v0 ,10 # on sort proprement du programme
les instructions.
Syscall 62
Factorielle (récursive)
fact : blez $a0, fact 0 # si a0 <= 0 saut a fact 0
sub $sp, $sp, 8 # reserve deux mots en pile
sw $ra, 0( $sp) # sauve l'adresse de retour
sw $a0, 4($sp) # et la valeur de a0
sub $a0, $a0, 1 # decrement a0
jal fact # appel recursif (a0-1)
lw $a0, 4($sp) # recupere a0
mul $v0, $v0, $a0 # v0 a0 x v0
lw $ra, 0( $sp) # recupere l' adresse de retour
add $sp, $sp, 8 # libere la pile
j $ra # retour a l ' appelant
fact 0 : li $v0, 1 # v0 1
j $ra # retour a l ' appelant

Chap2 2mipsisa

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chap2 2mipsisa

Uploaded by

Copyright:

Available Formats

Le jeu d’instructions MIPS

Nous allons voir le langage de la machine :

19/10/2012 12:39 I.Abdesslem 1

Tout ordinateur doit être capable d’effectuer des

chaque instruction arithmétique MIPS doit toujours

19/10/2012 12:39 I.Abdesslem 2

Les opérandes des instructions arithmétiques doivent

19/10/2012 12:39 I.Abdesslem 3

230 octet mémoire

Le MIPS comporte 32 registres généraux interchangeables, sauf

Les autres registres ont des utilisations préférentielles, mais

19/10/2012 12:39 I.Abdesslem

Nom Numéro Usage

19/10/2012 12:39 I.Abdesslem

Les variables f,g,h,i et j peuvent être

add $8,$17,$18 #Registre $8 contient g+h

19/10/2012 12:39 I.Abdesslem 7

Beaucoup de programmes ont plus de variables que

Les structures de données comme les tableaux sont

19/10/2012 12:39 I.Abdesslem 8

Les opérations arithmétiques n’ont lieu que dans

19/10/2012 12:39 I.Abdesslem 9

Depuis 1980 toutes les machines utilisent des

Puisque on peut lire un mot de 32 bits comme 4 octets

Big-endian: l’adresse de l’octet le plus significatif

Little-endian: l’adresse l’octet le moins

19/10/2012 12:39 I.Abdesslem 11

19/10/2012 12:39 I.Abdesslem 12

T est un tableau d’entiers.

muli $19,$19,4 #i=i*4

19/10/2012 12:39 I.Abdesslem 13

branchement si non égal :

f,g,h,ietj correspondent aux registres $16 à $20

bne $19,$20,Else # aller en Else si i¹j

i,j et k correspondent aux registres $19 à $21,

loop : mult $9,$19,$10 #reg temporaire $9=i*4

31-26 25-21 20-16 15-11 10-6 5-0

add $1,$2,$3 signification $1=$2+$3

bne $1,$2,100 signification : si ($1¹$2) aller en 100

Différents formats d’instructions MIPS

I-type op rs rt immediate ori, lw, sw, beq

J-type op Address destination j, jal

Opérande constante addi $1,$2,100

bne $1,$2,100 + Mémoire

Nombre de mots qui séparent l ’instruction

Instruction jal (saut avec lien)

Le retour est effectue par l’instruction : jr $31

$31 CP: compteur de programme

Cas plus compliqué lorsque une procédure appelle une

Ä Vidée les registre $31 dans la mémoire

procA procB procC

lw $1, 30($2) chargement d’un mot

$1 0040 0000 … 0000

Le langage assembleur attribue des noms

SPIM n’est que le mot MIPS écrit à l’envers.

Machine virtuelle = jeu d’instructions

19/10/2012 12:39 I.Abdesslem 46

blt $t0, $t1, address

slt $at, $t0, $t1

19/10/2012 12:39 I.Abdesslem 49

Une chaine de caractère sera déclarée entre “ “.

On peut utiliser quelques caractères spéciaux

19/10/2012 12:39 I.Abdesslem 50