Introduction aux systèmes Informatiques:

Interface Matériel Logiciel

(A3- 2021/2022)

Léon Mugwaneza
Polytech’ Marseille/Dépt. Informatique
(bureau A118)
leon.mugwaneza@univ-amu.fr

I. Le Langage Machine
Exemple : le MIPS R2000 (Architecture MIPS-I)
 MIPS R2000
• MIPS : Microprocessor without Interlocked Pipeline Stages
– Issu d’un projet de l’université de Stanford
! Architecture MIPS-I (1985)

• Machine 32 bits
– registres de 32 bits (mots de 32 bits)
– little endian ou big endian par configuration
– les instructions sont codées sur un mot et s’exécutent (en moyenne)
en 1 cycle ==> machine RISC

• Architecture load/store
– machine à registres adressables où seules 2 «instructions» (load et
store) accèdent à la mémoire
» le mot du MIPS est suffisamment large (et le codage suffisamment
«bien fait») pour pouvoir spécifier 3 registres dans certaines
instructions

2
 Les registres (1/2)
• 32 registres généraux, mais convention de programmation
– $0 ($zero) vaut toujours 0 (donc 31 registres généraux !)
– $1 ($at - assembler temporary) est réservé à l’assembleur
– $2 ($v0) et $3 ($v1) sont destinés à contenir les résultats des fonctions
– $4 à $7 ($a0 à $a3) sont destinés au passage des paramètres
– $8 à $15, $24 et $25 ($t0 à $t9) : temporaires non sauvegardés par les appels de
procédures
– $16 à $23, ($s0 à $s7) : temporaires sauvegardés
– $26 et $27 ($k0 et $k1) sont réservés au noyau du SE (Kernel)
– $28 ($gp) : pointeur sur les données globales (Global Pointer)
– $29 ($sp) : pointeur de pile (Stack Pointer)
– $30 ($fp) : pointeur sur l’environnement d’une fonction (Frame Pointer)
– $31 ($ra) est utilisé à l’appel d’une fonction pour sauvegarder l’adresse de
retour (Return Address)

! Les conventions de programmation sont destinées au programmeur

(et surtout au compilateur) et ne sont pas une contrainte du matériel
(pour la plupart des registres)
!Elles permettent d’utiliser des procédures compilées séparément 3
 Les registres (2/2)
• registres spécialisés
– le compteur ordinal (PC - Program Counter)
– deux registres Hi (High) et Lo (Low) utilisés (implicitement) par les
instructions de multiplication et division entre entiers
– des registres de contrôle regroupés dans le coprocesseur 0 (jusqu’à 32
pour les versions supérieures). Signalons :
» $12 : le registre d’état (status) (contient le masque d’interruptions, le mode
du processeur, … )
» $13 : le registre cause de l’exception (cause)
» $14 : le registre contenant l’adresse de l’instruction qui a causé l’exception
(EPC - Exception PC)
» $8 : le registre contenant l’adresse mémoire qui a causé une violation de
protection mémoire (BadVAddr - Bad Virtual Address)
– Les registres du coprocesseur flottants (coprocesseur 1)
» 32 registres de 32 bits ($f0 à $f31) utilisés comme 16 registres simples
précision (on n’utilise que les 16 registres de no. pairs), et 16 registres
double précision (par jeu de 2 registres)
» 1 flag code condition pour les instructions de comparaison des flottants

4
 Formats des instructions
31 26 25 21 20 16 15 11 10 6 5 0

– R op (6) rs(5) rt(5) rd(5) shamt(5) funct(6)

31 26 25 21 20 16 15 0
– I op (6) rs (5) rt (5) Immediate (16)

31 26 25 0
– J Op (6) target address (26 bits)

• Format I : utilisé pour des instructions qui manipulent des

constantes, load et store (le déplacement est une constante), et
les instructions de branchement qui utilisent un déplacement
par rapport au compteur ordinal
• Format J : utilisé pour les instructions j et jal (voir plus loin)
• Format R : utilisé pour toutes les autres instructions

5
 s
nu
Bo
Format R (1/2)
31 26 25 21 20 16 15 11 10 6 5 0
op (6) rs(5) rt(5) rd(5) shamt(5) funct(6)

• Que représente chacun des champs d’une instruction ?

– op est l’opcode : est une partie du code de l’instruction (toutes les instructions
CPU au format R ont op = 0 - pas vrai pour les instructions des coprocesseurs)

– funct : combiné avec op spécifie exactement l’opération

– …

!Pourquoi op et funct ne forment-ils pas un seul champ de 12 bits?

6
 s
nu
Bo
Format R (2/2)
31 26 25 21 20 16 15 11 10 6 5 0
op (6) rs(5) rt(5) rd(5) shamt(5) funct(6)

• Que représentent les champs d’une instruction ? (suite)

– ...
– rs (Source Register) : utilisé généralement pour spécifier le registre contenant
le premier opérande source
– rt (Target Register) : utilisé généralement pour spécifier le registre contenant le
deuxième opérande source (le nom prête à confusion ! )
– rd (Destination Register) : utilisé généralement pour spécifier le registre qui
contiendra le résultat de l’opération
– shamt (shift amount) : spécifie le nombre de décalages pour les instructions de
décalage (=0 pour les autres instructions)
• généralement signifie : «il y a des exceptions»
– par ex. mult et div rangent le résultat dans HIGH et LOW et donc le champ rd
n’est pas significatif (doit être mis à 0)

7
 Format R - exemple (1/2)
Ab
RG us d
U t [8 ] ¬ e n o
i
d ’ lis é R G t a t io
am à c [ n
b ig h a 9 ] + ( n o
u ït q u e R G r m
é f o i [ 1 0 a le m
add $8, $9, $10 # $8 ¬ $9 + $10 s q ]) en
u’ t:
il n
’y
– op = 0 (lu dans la table des codes des instructions) ap
as
– funct = 32 (lu dans table des codes des instructions)
– rs = 9 (1er opérande source)
– rt = 10 (2ème opérande source)
– rd = 8 (destination)
– shamt = 0 (ce n’est pas une instruction de décalage)

8
 Format R - exemple (2/2)
add $8, $9, $10 # $8 ¬ $9 + $10

• Représentation décimale par champs

31 26 25 21 20 16 15 11 10 6 5 0
0 9 10 8 0 32

• Représentation binaire par champs

31 26 25 21 20 16 15 11 10 6 5 0
000000 01001 01010 01000 00000 100000

• Langage Machine :
- en binaire : 00000001001010100100000000100000
- en hexadécimal : 012A4020
- en décimal : 19 546 144
9
 s
nu
Bo
Format I
31 26 25 21 20 16 15 0

op (6) rs (5) rt (5) Immediate (16)

• Seul un champ n’est pas conforme au format R et le champ op est au

même endroit
• Que représente chacun des champs ?
– op : comme pour le format R mais comme il n’y a pas de champ funct,
spécifie complètement l’opération
!Pourquoi dans le format R, op et funct ne forment-ils pas un seul champ
de 12 bits ?
– rs : spécifie le seul registre opérande source (quand il y en a un)
– rt : spécifie généralement le registre qui «contiendra» le résultat (est ce pour
cela qu’on l’appelle Target Register ?)
– immediate :
» constante sur 16 bits (représentation des nombres en complément à 2,
extension de signe avant l’opération arithmétique même pour les
opérations non signées)
» mot binaire sur 16 bits (extension avec des zéros en poids forts avant
opération logique)

10
 Format I - exemple (1/2)

addi $21, $22, -50 # $21 ¬ $22 + (-50)

– op = 8 (lu dans la table des codes des instructions)
– rs = 22 (registre contenant l’opérande)
– rt = 21 (registre contenant le résultat)
– immediate = -50 (décimal par défaut)

11
 Format I - exemple (2/2)
addi $21, $22, -50 # $21 ¬ $22 + (-50)

• Représentation décimale par champs

31 26 25 21 20 16 15 0
8 22 21 -50

• Représentation binaire par champs

31 26 25 21 20 16 15
001000 10110 10101 1111111111001110

• Langage Machine
- en hexadécimal : 22D5FFCE
- en décimal : 584 449 998
!Problème : Et les constantes qui ne tiennent
pas sur 16 bits?
" Voir instructions lui et ori plus loin
12
 Format J (1/2)
• Utilisé dans les instructions j et jal qui modifient PC en lui
affectant une adresse absolue (PC ¬ adresse cible)

31 26 25 0

Op (6) target address (26 bits)

Ex : j 1000

• Que représente chacun des champs d’une instruction ?

– op : même signification (et même localisation) que dans
les formats R et I, spécifie complètement l’opération
– target address : adresse mémoire (les autres champs qui
restent sont combinés pour spécifier une adresse «la plus
large possible »)

" Comment fabrique-t-on l’adresse sur 32 bits?

13
 Format J (2/2)
• Le champ «target address» spécifie 26 des 32 bits
• Comme les instructions sont des mots de 32 bits, on peut
supposer (imposer) qu’elles soient alignées à des frontières
de mots
# les 2 bits de poids faibles sont donc toujours à 0
– on peut donc spécifier 28 des 32 bits de l’adresse
• Où trouver les 4 bits restants ?
– MIPS a choisi de prendre les 4 bits de poids forts du registre PC
New PC = PC[31..28] & (target address) & 00
(où & est la concaténation de chaîne de bits)
# on ne peut donc pas aller n’importe où en mémoire ! (« pages » de 256M
octets)
– mais c’est suffisant 99,99% du temps : les programmes ne sont pas si
longs! (mais il faut bien positionner le début du programme)
# si on veut absolument spécifier les 32 bits de l’adresse, il est possible de
charger l’adresse dans un registre et d’utiliser les instructions jr et jalr
(voir plus loin)

14
 Modes d’adressage (1/4)
• Le MIPS a 5 modes d’adressage

op rs rt rd
1. Direct registre (register)
Registre rs

Ex : add $2, $3, $4

add $v0, $v1, $a0

2. Immédiat (immediate) op rs rt immediate

Ex : addi $2, $2, -500 nombres signés sur

ori $v0, $t0, 1000 16 bits (en binaire
complément à 2)

15
 Modes d’adressage (2/4)

3. Basé (base @ssing)

op rs rt immediate
Mémoire
Registre rs +

lw $2, 200($3) # $2 ¬ M[$3+200] (Load Word)

n’importe lequel des registres généraux

nombre signé sur 16 bits ($0 compris)
(en binaire complément à 2)

16
 Modes d’adressage (3/4)

4. Relatif PC (PC-relative)

op rs rt immediate
Mémoire
PC +

Ex : beq $2, $3, -20 # si $2=$3 alors PC ¬ PC + (-20)*4

le déplacement est en
nombre de mots

17
 Modes d’adressage (4/4)
5. Pseudo direct Mémoire

op target address
Mémoire
PC &
8 bi ts
Su r 2
Ex : j 1000 # PC ¬ PC[31..28] & (1000 * 4)

l’adresse est non signée

concaténation

ajout de deux 0 en poids faibles

! @ssage indirect registre? @ssage direct mémoire?

# avec l’@ssage basé (exercice)
18
 Les Instructions du MIPS R2000

• instructions de transfert
• instructions arithmétiques et logiques
• instructions de comparaison et branchement
• instructions d’appel de procédure
• instructions du coprocesseur flottants
• instructions d’appel système
• l’instruction nop (no operation)

19
 Instructions de transfert (1/2)
• Transfert reg. généraux - mémoire : Load et Store
– lw, sw : Load Word, Store Word

- lw $2, 200($3) # $2 ¬ M[$3+200] (Format I)

31 26 25 21 20 16 15 0
35 3 2 200 = 0x00C8

- sw $ra, -4($sp) # M[$sp-4] ¬ $ra (Format I)

($ra = $31 et $sp = $29)

31 26 25 21 20 16 15 0
43 29 31 -4 = 0xFFFC

! contrainte d’alignement pour lw et sw :

#l’adresse doit être multiple de 4
20
 Instructions de transfert (2/2)
• Octets et 1/2 mots
– lb, sb (byte)
– lbu (load byte unsigned)
– lh, sh (half word)
– lhu (load half unsigned)
• Dans le cas d’un «load» on charge les poids faibles du
registre MAIS le reste du registre (poids forts) est
également touché :
– lbu et lhu mettent les poids forts à 0
– lb et lh font l’extension de signe (mettent le «bit de signe» de
l’octet ou du 1/2 mot dans les poids forts)

! contrainte d’alignement pour lh, lhu et sh :

#l’adresse doit être multiple de 2
21
 Chargement d’une constante
• Load Upper Immediate (lui Rt, immediate)
– on ne peut spécifier qu’une constante sur 16 bits
– la constante est chargée dans les 16 bits de poids forts du registre
Rt
– les bits de poids faibles de Rt sont mis à 0
• Combiné avec ori, permet de charger une constante de 32
bits dans un registre

– comment réaliser $2 ¬ 0x1FC4A6 ?

! en deux instructions à l’aide de lui et ori
lui $2, 0x1F
ori $2, $2, 0xC4A6

• On ne peut pas utiliser l’addition à la place de ori

– addi fait toujours l’extension de signe avant l’addition
0xC4A6 devient FFFFC4A6 !

22
 s
nu
Load et store «non alignées»(1/5)
Bo

• lw et sw doivent spécifier des adresses multiples de 4

(frontières de mots)
– simplifie le matériel d’accès à la mémoire
– dans le cas de «non alignement» : il y a une erreur à l’exécution
signalée par le mécanisme d’exception (voir plus loin)

• MIPS offre la possibilité d’accéder à un mot rangé de part

et d’autre d’une frontière de mots (mais en 2 instructions)
"instructions load et store «non alignées» : lwl (Load Word Left), lwr
(Load Word Right), swl (Store Word Left) , swr (Store Word Right)

23
 s Load et store «non alignées» (2/5)
nu
Bo

• Load Word Left (lwl)

Mémoire big-endian

A B C D $24
avant
8 9 10 11
@4 4 5 6 7 $24
1 2 3 D après
@0 0 1 2 3

lwl $24, 1($0)

l’autre partie du registre

reste inchangée
24
 Load et store «non alignées» (3/5)
s
nu
Bo

• Load Word Right (lwr)

Mémoire big-endian

A B C D $24
avant
8 9 10 11
lwr $24, 4($0)
4 5 6 7 $24
A B C 4 après
0 1 2 3

l’autre partie du registre

reste inchangée

$ lwl et lwr s’utilisent conjointement

25
 s
nu
Bo
Load et store «non alignées» (4/5)
• Store Word Left (swl)

Mémoire big-endian

avant A B C D $24
8 9 10 11
@4 4 5 6 7

@0 0 1 2 3

swl $24, 2($0)

après
8 9 10 11
@4 4 5 6 7

@0 0 1 A B
26
 Load et store «non alignées» (5/5)
s
nu
Bo

• Store Word Right (swr)

Mémoire big-endian

avant A B C D $24
8 9 10 11
@4 4 5 6 7

@0 0 1 2 3

swr $24, 5($0)

après
8 9 10 11
@4 C D 6 7

@0 0 1 2 3

$ swl et swr s’utilisent conjointement

27
 Autres inst. de transfert (1/2)

• Transfert entre High/Low et les registres généraux

– move from High : mfhi Rd
– move from Low : mflo Rd
– move to High : mthi Rd
– move to Low : mtlo Rd

• Load et store des registres des coprocesseurs

– 4 coprocesseurs (0 : contrôle, 1: flottants, … )
– instructions lwcz (z = 0, 1, 2, 3)
– instructions swcz (z = 0, 1, 2, 3)

28
 Autres inst. de transfert (2/2)

• Transfert entre registres généraux et registres des

coprocesseurs
– Move From Coprocessor : mfcz Rt, Rd (z = 0, 1, 2, 3)
– Move To Coprocessor : mtcz Rt, Rd (z = 0, 1, 2, 3)

• les instructions mfc0 et mtc0 sont privilégiées

• Il n’y a pas d’instruction de transfert entre registres

généraux !
– $3 ¬ $4 se fait par add $3, $4, $0

29
 Inst. arithmétiques (1/5)

add Rd, Rs, Rt

addu Rd, Rs, Rt # add unsigned

ex : addu $2, $3, $4

31 26 25 21 20 16 15 11 10 6 5 0
0 3 4 2 0 33

• addu est l’addition non signée : pour MIPS

sans test de débordement de capacité !

30
 Inst. arithmétiques (2/5)

addi Rt, Rs, imm # add immediate

addiu Rt, Rs, imm # add immediate unsigned

ex : addiu $2, $3, 0xFFFF

31 26 25 21 20 16 15 0
9 3 2 0xFFFF

• Il y a extension de signe de l’opérande «imm» avant

addition sans test de débordement (cas addiu) ou
avec test de débordement (cas addi)

31
 Inst. arithmétiques (3/5)
sub Rd, Rs, Rt # substract
subu Rd, Rs, Rt # substract unsigned

ex : subu $2, $3, $4 # $2 ¬ $3 - $4 (sans test de débordement)

31 26 25 21 20 16 15 11 10 6 5 0
0 3 4 2 0 0x23 = 35

• Il n’y a pas de variante avec opérande immédiat pour

sub
– Pourquoi ?
# addi et addiu suffisent !
– une «pseudo instruction» existe en langage d’assemblage et
est traduite par l’assembleur

32
 Inst. arithmétiques (4/5)
mult Rs, Rt
multu Rs, Rt # multiply unsigned

ex : mult $2, $3 # Hi,Lo ¬ $2 * $3 (opérandes signées)

31 26 25 21 20 16 15 11 10 6 5 0
0 2 3 0 0 0x18=24

• Il n’y a pas de variante avec opérande immédiate pour

mult
– comment multiplier par une constante ?
" La transférer d’abord dans un registre !
– une «pseudo instruction» existe en langage d’assemblage et est
traduite par l’assembleur (en utilisant $1)
– ex : mult $2, 0x12 est traduite par addi $1, $0, 0x12
mult $2, $1

$Le résultat étant sur 64 bits, il ne peut pas y avoir de

débordement!
33
 Inst. arithmétiques (5/5)

div Rs, Rt
divu Rs, Rt # divide unsigned (opérandes non signées)
ex : div $2, $3 # Lo ¬ quotient ($2 / $3); High ¬ reste ($2 / $3)
31 26 25 21 20 16 15 11 10 6 5 0
0 2 3 0 0 0x1A=26

• Il n’y a pas de débordement

• En cas de division par zéro, le résultat n’est pas défini

34
 Instructions logiques
and Rd, Rs, Rt
andi Rs, Rt, immediate # and immediate
ex : and $2, $3, $4 # $2 ¬ $3 & $4 (Et bit à bit - Et logique sur vecteur)
31 26 25 21 20 16 15 11 10 6 5 0
0 3 4 2 0 0x24 = 36

• Autres instructions logiques :

– Ou (or Rd, Rs, Rt et ori Rs, Rt, immediate)
– Ou exclusif (xor Rd, Rs, Rt et xori Rs, Rt, immediate)
– Non Ou (nor Rd, Rs, Rt)

• Pour les inst. logiques, l’opérande immédiat sur 16 bits

est étendu sur 32 bits en mettant des 0 dans les poids
forts (the immediate operand is zero extended)
35
 Inst. de décalage (1/2)
• Déplacer (décaler), d’un nombre de bits donné, tous les bits
d’un mot vers «la droite» ou vers «la gauche»
ex: décalage à droite de 8 bits
1001 0000 0001 0010 0011 0100 0101 0110
logique
0000 0000 1001 0000 0001 0010 0011 0100
1111 1111 1001 0000 0001 0010 0011 0100

ex: décalage à gauche de 8 bits arithmétique

0001 0010 0011 0100 0101 0110 0111 1000

0011 0100 0101 0110 0111 1000 0000 0000

• Décalage arithmétique (à droite) : on copie le bit de poids
forts (division entière par une puissance de 2)
36
 Inst. de décalage (2/2)
• Nombre de bits à décaler dans l’instruction :
sll (Shift Left Logical)
srl (Shif Right Logical)
sra (Shift Right Arithmetic)

ex : sra Rd, Rt, sa

31 26 25 21 20 16 15 11 10 6 5 0
0 0 Rt Rd sa 0x03 = 3

• Nombre de bits à décaler dans un registre :

sllv (Shift Left Logical Variable)
srlv (Shif Right Logical Variable)
srav (Shift Right Arithmetic Variable)

ex : srav Rd, Rt, Rs

31 26 25 21 20 16 15 11 10 6 5 0
0 Rs Rt Rd 0 0x04 = 4
37
 Instructions de branchement (1/2)
• Saut relatif conditionnel

octets
mémoire adressée par
d’instructions,
Déplacement en nb
beq Rs, Rt, offset # Branch on EQual
bne Rs, Rt, offset # Branch on Not Equal
Ex : beq $2, $3, -20 # si $2=$3 alors PC ¬ PC + (-20)*4

Où pointe PC ?
– Sur l’instruction en cours d’interprétation ?
– Sur l’instruction suivante ?
$ Pour le MIPS : instruction suivante
$ Pour le simulateur que nous utiliserons : instruction en cours
• Comment réaliser un saut relatif inconditionnel?
Prendre Rs = Rt (ex : Beq $0, $0, offset)
• Autres instructions de saut relatif :
bgtz (>0), bgez (>= 0), bltz (< 0), blez (<=0)
(ici z signifie zéro et non numéro de coprocesseur comme dans mfcz, mtcz, ...)
38
 Instructions de branchement (2/2)

• Saut absolu inconditionnel

j target # Jump
jr Rs # Jump Register (PC ¬ Rs)

j 1000 # PC ¬ PC[31..28] & (1000 * 4)

l’adresse est non signée

concaténation
ajout de deux 0 en poids faibles

39
 Instructions de comparaison
• Comparaison signée
slt Rd, Rs, Rt # Set on Less Than
slti Rt, Rs, immediate # slt Immediate
Ex : slt $2, $3, $4 # si $3 < $4 alors $2 ¬ 1 sinon $2 ¬ 0

• Comparaison non signée

sltu Rd, Rs, Rt # Set on Less Than Unsigned
sltiu Rt, Rs, immediate # slt immediate unsigned
Ex : sltiu $2, $3, -100 # si $3 < 0xFF9C alors $2 ¬ 1 sinon $2 ¬ 0

– La comparaison est faite en considérant les opérandes comme

des entiers non signés. Pour sltiu il y a extension de signe sur
32 bits de l’opérande 16 bits avant la comparaison
(0xFF9C ==> 0xFFFFFF9C)
40
 MIPS R2000 et codes conditions

• le CPU (partie sur les entiers) du MIPS R2000 n’a pas de

code condition
• des registres généraux sont positionnés à des valeurs
particulières lors des instructions de comparaisons (ex.
slt - Set on Less Than )
• les instructions de branchement réalisent en même
temps les comparaisons et les branchements
• les débordements sont directement signalés par des
exceptions
$la partie coprocesseur flottants a un code condition

41
 Inst. d’appel de procédure (1/2)
• Branchements vs. appels de procédure

BR appel
BR Retour à
l’appelant

– branchement = modification du compteur ordinal

– appel de procédure = sauvegarde adresse de retour + branchement
(l’appel de procédure doit sauvegarder la valeur du compteur
ordinal pour pouvoir retourner à l’instruction qui suit l’appel)
– du point de vue de la partie du programme où s’effectue l’appel de
procédure, l’appel est considéré comme une instruction qui prend
«un certain temps» et qui a un «effet complexe» sur l’état de la
machine

42
 Inst. d’appel de procédure (2/2)
• Appel avec saut absolu inconditionnel
jal target # Jump And Link ($ra ¬ PC ; PC ¬ target)
jalr Rs # JAL Register ($ra ¬ PC ; PC ¬ Rs)
jalr Rd, Rs # Rd ¬ PC ; PC ¬ Rs

• Comment retourner à l’appelant ?

jr $ra (à condition de ne pas avoir modifié $ra !)

• Appel avec saut relatif conditionnel

bltzal Rs, offset # branch on less than zero and link
bgezal Rs, offset # branch on greater than or equal zero and link
– « link » signifie garder un lien avec l’appelant
– calcul de l’adresse de branch. : (voir inst. branch. Relatif)
– appel impossible au delà de 32 K instructions

43
 Inst. coprocesseur flottants (1/2)
• Instructions de « Format R »
31 26 25 21 20 16 15 11 10 6 5 0
cop1 (6) fmt(5) ft(5) fs(5) fd(5) funct(6)

" Que représentent les champs d’une instruction ?

– cop1 = 0x11 (instructions coprocesseur 1)
– fmt : format (0 : simple précision, 1 : double précision)
– fs : le «registre flottants» contenant le premier opérande
– ft : le «registre flottants» contenant le deuxième opérande
– fd : le «registre flottants» qui contiendra le résultat de l’opération
– funct : spécifie l’opération

Ex : add.s $f0, $f2, $f4 # $f0 ¬ $f2 + $f4

31 26 25 21 20 16 15 11 10 6 5 0
0x11 0 4 2 0 0

add.d $f0, $f2, $f4 # $f0,$f1 ¬ $f2,$f3 + $f4,$f5

31 26 25 21 20 16 15 11 10 6 5 0
0x11 1 4 2 0 0
44
 Inst. coprocesseur flottants (2/2)
• Autres instructions (voir doc Assemblers,
Linkers, and the SPIM Simulator )

– load, store (lwc1, stwc1)

– soustraction

Architecture MIPS32
– valeur absolue
– comparaison (positionnent un code condition)
– test du code condition et branchement
– multiplication, division
– conversion
– arrondis (floor, ceil, round, truncate, …)
– ...

45
 Instructions relatives aux exceptions
(cf 2ème partie du cours)

! Architecture MIPS-I
• Appel système «sans paramètre dans l’inst.» : syscall
31 26 25 21 20 16 15 11 10 6 5 0
0 0 0 0 0 0xC

• Appel système «avec paramètre dans l’inst. » : break <code>

31 26 25 10 9 6 5 0
0 <code> (16 bits) xxxx 0xD

• Restauration du registre d’état :

rfe (Return From Exception)
31 26 25 24 5 0
0x10 1 0 0x20
– Instruction privilégiée (ne peut être exécutée qu’en mode « kernel »)
-- cf partie O.S. 46
 L’instruction NOP
• No OPeration (instruction qui ne fait rien !)
– en fait une pseudo instruction réalisée par sll $0,$0, 0

• A quoi peut servir NOP ?

– attente active sans trop modifier l’état du processeur
– remplir les «délais» des instructions de branchement différé et
chargement différé dans certaines implantations pipelinées du jeu
d’instructions

• Pipelining ?
– Technique d’implantation matériel du processeur (du chemin de
données et du chemin de contrôle)
– Cf Cours d’Architecture

47
Fin du chapitre I

48