Vous êtes sur la page 1sur 58

Amphi 4 : Introduction au

langage d’assemblage MIPS


(suite)

I. Codage des instructions :


Format, adressage
II. Désassemblage

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 1


Représentation des instructions

2. Représentation des instructions


3. Format pour les opérations registre-
registre
4. Format pour les immédiats et
adressage relatif
5. Format pour les sauts et adressage
absolu

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 2


Le concept de “Stored-Program”
• Les ordinateurs sont construits selon 2 principes
clés :
1) Les instructions sont représentées par des
nombres.
2) Par conséquent, les programmes peuvent
être stockés en mémoire comme des données
(d’où la possibilité de les lire et d’y écrire).
• Cela simplifie la technologie SW/HW :
– Les mêmes circuits sont utilisés pour tout ce
qui est stocké en mémoire

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 3


Conséquence 1 : tout a une adresse
• Puisqu’instructions et données sont également
stockées en mémoire comme des nombres, tout a
une adresse mémoire.
– Les branchements et les sauts les utilisent
• Rappel : les pointeurs (en C) ne sont rien d’autre
que des adresses mémoire : ils peuvent “pointer”
n’importe quel octet stocké en mémoire
– Un usage non contraint des adresses peut mener à des
bogues sournoises
• Un registre conserve l’adresse de l’instruction en
cours d’exécution : “Program Counter” (PC)
– Tout simplement un pointeur (cf le nom utilisé par Intel :
Instruction Address Pointer)
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 4
Conséquence 2: compatibilité binaire
• Les programmes sont distribués sous forme
binaire
– Ils sont liés à des jeux d’instructions spécifiques
– Versions différentes pour Macintosh et PC
• On souhaite pouvoir exécuter les anciens
programmes sur les machines récentes
• Cela influe sur l’évolution des jeux d’instructions
• Par exemple, le choix d’Intel 8086 en 1981 pour le
1er PC IBM est la principale raison pour laquelle les
PC les plus récents (Pentium 4) utilisent un jeu
d’instructions de la famille 80x86
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 5
Codage numérique des instructions (1/2)
• Jusqu’à présent, toutes les données sont
codées dans des mots (blocs de 32 bits) :
– Chaque registre accueille un mot.
– lw et sw transfèrent un mot à la fois.
• Comment représenter les instructions?
– Rappel : la machine ne reconnaît que des
suites de 0 et de 1.
– MIPS recherche la simplicité : puisque les
données sont des mots, on adopte le
même format pour les instructions
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 6
Codage numérique des instructions (2/2)
• 1 mot = 32 bits, on divise donc chaque mot-
instruction en champs (fields).
• Chaque champ donne à la machine une
information sur l’instruction.
• On pourrait définir des champs différents pour
chaque instruction, mais le choix de la
simplicité pousse à se restreindre à
seulement 3 formats de base :
– Format R
– Format I
– Format J
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 7
Formats d’instructions
• Format I : utilisé pour les instructions utilisant
des immédiats, pour lw et sw (car l’offset
compte comme un immédiat), et pour les
branchements (beq et bne),
– (mais pas pour les décalages)
• Format J : utilisé pour j et jal
• Format R : utilisé pour toutes les autres
instructions

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 8


Instructions de format R (1/5)
• On partitionne le mot-instruction en champs de
longueurs respectives : 6 + 5 + 5 + 5 + 5 + 6 = 32
6 5 5 5 5 6

• Chaque champ porte un nom


opcode rs rt rd shamt funct

• Important : chaque champ est traité comme


un entier non signé.
– Par exemple, les champs de 5 bits peuvent
représenter tout entier compris entre 0 et 31 (et les
champs de 6 bits tout entier compris entre 0 et 63)
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 9
Instructions de format R (2/5)
• Que nous disent ces champs ?
– opcode: détermine partiellement l’instruction
• N.B. : vaut 0 pour toutes les instructions R.
– funct: en combinaison avec l’ opcode, ce
nombre détermine complètement l’instruction
– Question : pourquoi ne fusionne-t-on pas
opcode et funct en un unique champ de 12
bits ?
• Réponse : plus tard.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 10


Instructions de format R (3/5)
• Les autres champs :
– rs (pour Source Register): en général,
utilisé pour spécifier le registre contenant le
1er opérande
– rt (pour Target Register): en général,
utilisé pour spécifier le registre contenant le
2e opérande (N.B. Le nom est trompeur)
– rd (pour Destination Register): en général,
utilisé pour spécifier le registre destiné à
accueillir le résultat du calcul

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 11


Instructions de format R (4/5)
• Remarques sur les champs registres :
– Chaque champ registre a exactement 5 bits, il peut
donc représenter un entier non signé entre 0 et 31.
– Sur la diapo précédente, on a utilisé “généralement”
à cause des exceptions (voir plus tard). E.g.,
• mult et div ne codent rien d’important dans le
champ rd puisque les registres destinataires sont
hi et lo
• mfhi et mflo ne codent rien d’important dans les
champs rs et rt puisque la source est
déterminée par l’instruction (cf. P&H p. 264)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 12


Instructions de format R (5/5)

• Champ shamt (pour shift amount):


– Ce champ code l’amplitude du décalage.
Décaler un mot de 32 bits de plus de 31
positions est inutile, le champ shamt a
donc seulement 5 bits, ce qui permet de
représenter tous les entiers entre 0 et 31.
– Ce champ vaut 0 pour toutes les
instructions sauf les décalages.
• Pour tous les détails, cf. le “green insert card”
de P&H, COD 3e

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 13


Format R : exemple (1/2)
• Instruction MIPS :
add $8,$9,$10

opcode = 0
funct = 32
rd = 8 (destination)
rs = 9 (1er opérande)
rt = 10 (2e opérande)
shamt = 0 (ce n’est pas un décalage)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 14


Format R : exemple (2/2)
• Instruction MIPS :
add $8,$9,$10
Représentation décimale de chaque champ :
0 9 10 8 0 32
Représentation binaire de chaque champ :
000000 01001 01010 01000 00000 100000
hex
Représentation hex de l’instruction : 012A4020hex
(Représentation décimale de l’instruction : 19,546,144ten)

– C’est une instruction en langage machine


Oct. 2009 Archi INFO1 Ch. T. Amphi 4 15
Instructions de format I (1/4)
• Que faire pour les instructions qui manient des
immédiats ?
– Un champ de 5 bits ne peut représenter que
32 valeurs différentes : c’est très insuffisant
pour les immédiats
– Idéalement, MIPS aurait un seul format, mais
il est nécessaire de faire des compromis
• On définit un nouveau format d’instruction qui
est partiellement cohérent avec le format R :
– On remarque d’abord qu’une instruction qui
manie un immédiat utilise au plus 2 registres.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 16
Instructions de format I (2/4)
• On partitionne le mot-instruction en champs de
longueurs respectives : 6 + 5 + 5 + 16 = 32
6 5 5 16
• Chaque champ a un nom :
opcode rs rt immediate

• Points clés : seul un champ ne correspond à


aucun champ du format R ; le champ opcode
est toujours au même endroit.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 17


Instructions de format I (3/4)
• Que nous disent ces champs ?
– opcode: même signification que pour le format R, mais
suffit à déterminer complètement l’instruction (il n’y pas
de champ funct dans le format I)
– Cela explique aussi pourquoi le format R a 2 champs
de 6 bits (au lieu d’un champ de 12 bits) pour
déterminer l’instruction : on garantit ainsi une certaine
cohérence des formats.
– rs: spécifie le n° de l’unique registre opérande (s’il y en
a un)
– rt: spécifie maintenant le n° du registre qui recueille le
résultat du calcul (d’où le nom de target register)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 18


Instructions de format I (4/4)
• Le champ immediate :
– Pour addi, slti, sltiu, le signe de
l’immédiat est étendu aux 16 bits de plus
haut poids. L’immédiat est donc traité
comme un entier signé.
– 16 bits  on peut donc représenter 216
valeurs différentes
– C’est suffisant pour traiter l’offset d’une lw
ou sw typique, ainsi que la majorité des
valeurs utilisées dans un slti.
• N.B. Si l’immédiat est trop grand : cf. plus tard

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 19


Format I : exemple (1/2)
• Instruction MIPS :
addi $21,$22,-50

opcode = 8
rs = 22 (opérande)
rt = 21 (registre cible)
immediate = - 50

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 20


Format I : exemple (2/2)

• Instruction MIPS :
addi $21,$22,-50
Représentation décimale des valeurs de champs :
8 22 21 -50

Représentation binaire des valeurs de champs :


001000 10110 10101 1111111111001110
Représentation hex de l’instruction : 22D5 FFCEhex
(Représentation décimale de l’instruction: 584,449,998ten)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 21


Format I : deux problèmes (1/4)
• Problème 1 : un nombre non signé qui subit une extension
de signe ?
– addiu, sltiu, étendent le signe de leur immédiat.
• Justification
– addiu permet d’additionner sans test d’overflow
– sltiu doit pouvoir utiliser le même HW
• Cela signifie-t-il qu’on obtient des réponses fausses?
• Non, mais l’assembleur doit traiter tout immédiat non
signé 215 ≤ n < 216 (i.e., avec un 1 en position 15 et
des 0 dans les deux octets de plus haut poids) de la
même façon que des nombres trop grands …

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 22


Format I : deux problèmes (2/4)
• Problème 2 :
– Les instructions addi, lw, sw et slti
opèrent le plus souvent sur des immédiats
assez petits pour tenir dans le champ
immediate…
– …mais si l’immédiat est trop grand ?
– Il faut un moyen de traiter des immédiats
de 32 bits.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 23


Format I : deux problèmes (3/4)
• Solutions envisagées pour le problème 2 :
– Le traiter au niveau software et ajouter une
instruction
– Ajouter une instruction d’assemblage (sans
changer les instructions existantes)
• Nouvelle instruction :
lui register, immediate
– lui pour Load Upper Immediate
– place un immédiat de 16 bits dans les deux
octets de plus haut poids du registre spécifié
– les autres bits sont mis à 0.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 24
Format I : deux problèmes (4/4)
• Qu’apporte lui ?
– Exemple:
addi $t0,$t0, 0xABABCDCD
devient:
lui $at, 0xABAB
ori $at, $at, 0xCDCD
add $t0,$t0,$at
– Toute instruction de format I a un champ
immediate de 16 bits.
– L’assembleur peut-il faire ce genre de
transformation automatiquement ?
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 25
Branchements: adressage relatif (1/5)
• On utilise le format I pour les branchements :
opcode rs rt immediate
• L’opcode différencie beq de bne
• rs et rt codent les n° des registres à comparer
• Que peut représenter le champ immediate ?
– Immediate n’a que 16 bits
– PC (pour Program Counter) contient l’adresse
mémoire de l’instruction en cours d’exécution; c’est
un pointeur de 32 bits (en français, CP)
– Le champ immediate ne peut donc pas spécifier
absolument l’adresse de branchement.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 26
Branchements: adressage relatif (2/5)
• Quelle est l’utilisation normale des branchements ?
– Compilation de if-else, while, for
– Les boucles sont généralement “petites” :
typiquement moins de 50 instructions
– Les appels de fonctions et les branchements
inconditionnels sont compilés en utilisant les
instructions de saut (j and jal), pas des
branchements.
• Conclusion : on peut souhaiter se brancher
n’importe où en mémoire, mais généralement un
branchement modifie peu la valeur du CP.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 27
Branchements: adressage relatif (3/5)
• Une solution : l’adressage relatif (PC-
Relative Addressing)
• On décide de considérer le champ de 16 bits
immediate comme un entier signé en
complément à deux à ajouter à la valeur du
CP.
• On peut maintenant se brancher à une
distance de ± 215 octets du contenu du CP, ce
qui devrait suffire pour traiter les boucles.
• Peut-on faire mieux ?

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 28


Branchements: adressage relatif (4/5)
• On sait que les instructions sont des mots ;
elles sont donc alignées (l’adresse mémoire,
en octets, est toujours un multiple de 4).
– Le nombre d’octets à ajouter au contenu du
CP sera donc toujours un multiple de 4.
– On peut donc considérer que le champ
immediate compte des mots.
• On peut maintenant se brancher à une
distance de ± 215 mots du contenu du CP (ou
± 217 octets), et traiter des boucles 4 fois plus
grosses.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 29
Branchements: adressage relatif (5/5)
• Calcul de l’adresse de branchement :
– Si la condition de branchement n’est pas
respectée : CP = CP + 4
(CP+4 = adresse en octets de l’instruction suivante)
– Si la condition de branchement est
respectée: CP = (CP + 4) + (immediate * 4)
– Observations
1 Le champ Immediate spécifie le nombre de mots à
sauter, c’est-à-dire le nombre d’instructions.
2 Le champ Immediate peut être positif ou négatif.
3 Pour des raisons matérielles, on ajoute immediate à
(CP+4)
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 30
Branchement : exemple (1/3)
• Code MIPS :
Loop: beq $9,$0,End
add $8,$8,$10
addi $9,$9,-1
j Loop
End:
•beq est au format I :
opcode = 4
rs = 9 (1er opérande)
rt = 0 (2e opérande)
immediate = ???
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 31
Branchement : exemple (2/3)
• Code MIPS :
Loop:beq $9,$0,End
addi $8,$8,$10
addi $9,$9,-1
j Loop
End:
• Valeur du champ immediate =
Le nombre d’instructions à ajouter (ou
soustraire) au CP, en commençant à
l’instruction qui suit le branchement.
– Dans le cas du beq supra, immediate = 3
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 32
Branchement : exemple (3/3)
• Code MIPS :
Loop:beq $9,$0,End
addi $8,$8,$10
addi $9,$9,-1
j Loop
End:

Représentation décimale des champs :


4 9 0 3
Représentation binaire des champs :
000100 01001 00000 0000000000000011
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 33
Instructions de format J (1/5)
• Pour les branchements, on a supposé qu’on
ne chercherait pas à se brancher trop loin ; on
s’est limité à spécifier le changement du CP.
• En revanche, pour des sauts (j et jal), on
doit pouvoir sauter à n’importe quelle adresse
de la mémoire.
• Idéalement, on souhaiterait pouvoir spécifier
une adresse mémoire de 32 bits.
• Malheureusement, on ne peut pas faire tenir
un opcode de 6 bits et une adresse de 32 bits
dans un seul mot.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 34
Instructions de format J (2/5)
• On définit deux champs de 6 + 26 = 32 bits :

6 bits 26 bits
• Comme d’habitude, les champs ont un nom
opcode target address

• Remarques clés
– Le champ opcode ne change pas par
rapport aux formats R et I : cohérence.
– On réunit tous les autres champs pour faire
de la place pour de “grandes” adresses.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 35
Instructions de format J (3/5)
• On peut ainsi spécifier 26 des 32 bits d’une
adresse.
• Optimisation liée à l’alignement :
– Comme pour les branchements, les sauts
n’ont pour cible que des adresses word-
aligned (les deux derniers bits sont donc
toujours 00, en binaire).
– On peut considérer cela comme
systématiquement acquis.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 36


Instructions de format J (4/5)
• On peut ainsi spécifier 28 des 32 bits d’une
adresse.
• Comment obtenir les 4 bits manquants ?
– Par convention, on prend les 4 bits de plus
haut poids du PC.
– Techniquement, cela signifie qu’on ne peut
sauter à n’importe quelle adresse mémoire,
mais cela suffit dans 99.9999…% des cas
(longueur des programmes < 256 Mo)
– N.B. s’il faut absolument une adresse de 32 bits, on
peut la placer dans un registre et utiliser un jr.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 37
Instructions de format J (5/5)
• Résumé :
PC actualisé = { PC[31..28], target address, 00 }
• N.B. : { , , } représente une concaténation
{ 4 bits , 26 bits , 2 bits } = adresse de 32 bits
• Par exemple,
{ 1010, 11111111111111111111111111, 00 }
= 10101111111111111111111111111100
– N.B. cette notation est celle de Verilog

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 38


Récapitulatif sur les formats
• MIPS Machine Language Instruction:
32 bits représentant une instruction unique
R opcode rs rt rd shamt funct
I opcode rs rt immediate
J opcode target address

• Les branchements utilisent l’adressage relatif


au CP, les sauts utilisent l’adressage absolu.
• Le désassemblage est facile et commence par
le décodage de l’opcode.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 39


II. Désassemblage

1. Désassemblage
2. Pseudo-instructions et variétés
de langages d’assemblage
(TAL vs MAL)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 40


Décodage du langage machine
• Comment “traduire” du code binaire en code C ?
• Pour chaque mot de 32 bits :
– Regarder l’opcode: 0 correspond au format R,
2 ou 3 au format J, les autres valeurs au
format I.
– Utiliser le type pour déterminer les champs.
– Écrire le code MIPS, en traduisant
convenablement chaque champ (en nom, n°
de registre, nombre binaire/hex).
– Traduire ce code MIPS en code C valide. Est-
ce toujours possible ? Unique?
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 41
Décodage : exemple (1/7)
• Voici 6 instructions en langage machine (en
hexadécimal) :
00001025hex
0005402Ahex
11000003hex
00441020hex
20A5FFFFhex
08100001hex
• On suppose que la 1re instruction se trouve à
l’adresse 4.194.304ten (0x00400000hex).
• 1re étape : on convertit l’hex en binaire
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 42
Décodage : exemple (2/7)
• Les 6 instructions en binaire:
00000000000000000001000000100101
00000000000001010100000000101010
00010001000000000000000000000011
00000000010001000001000000100000
00100000101001011111111111111111
00001000000100000000000000000001
• 2e étape : identifier l’opcode et le format
R 0 rs rt rd shamt funct
I 1, 4-63 rs rt immediate
J 2 ou 3 target address
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 43
Décodage : exemple (3/7)
• On examine les 6 premiers bits pour
déterminer le format :
Format:
R 00000000000000000001000000100101
R 00000000000001010100000000101010
I 00010001000000000000000000000011
R 00000000010001000001000000100000
I 00100000101001011111111111111111
J 00001000000100000000000000000001
• Décodage de l’opcode:
0 correspond au format R, 2 et 3
correspondent au format J, les autres valeurs
au format I.
• 3e étape : séparation des champs
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 44
Décodage : exemple (4/7)
• On sépare les champs (en utilisant l’opcode)
Format:
R 0 0 0 2 0 37
R 0 0 5 8 0 42
I 4 8 0 +3
R 0 2 4 2 0 32
I 8 5 5 -1
J 2 1,048,577

• 4e étape : traduire (“désassembler”) en


instructions d’assemblage MIPS
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 45
Décodage : exemple (5/7)
• Code assemblage MIPS (1re mouture) :
Adresses : Instructions d’assemblage :
0x00400000 or $2,$0,$0
0x00400004 slt $8,$0,$5
0x00400008 beq $8,$0,3
0x0040000c add $2,$2,$4
0x00400010 addi $5,$5,-1
0x00400014 j 0x100001
• On peut faire mieux : on traduit en utilisant des
instructions MIPS plus “parlantes” (on ajoute
des étiquettes, etc.)
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 46
Décodage : exemple (6/7)
• Code assemblage MIPS (2e mouture):
or $v0,$0,$0
Loop: slt $t0,$0,$a1
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop
Exit:
• 5e étape : traduire en code C (faire
preuve d’imagination !)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 47


Décodage : exemple (7/7)
Départ Hex : Arrivée code C (cf. associations infra)
$v0: produit
00001025hex
$a0: multiplicande
0005402Ahex
11000003hex $a1: multiplicateur
00441020hex produit = 0;
20A5FFFFhex while (multiplicateur > 0) {
08100001hex produit += multiplicande;
or $v0,$0,$0 multiplicateur -= 1;}
Loop: slt $t0,$0,$a1 La grande idée : les
beq $t0,$0,Exit instructions sont des
add $v0,$v0,$a0 nombres, le code est traité
addi $a1,$a1,-1 comme des données
j Loop
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 48
Exit:
Retour sur lui
• Rappel : à quoi lui sert-elle ?
– Exemple: addi $t0,$t0, 0xABABCDCD
devient : lui $at, 0xABAB
ori $at, $at, 0xCDCD
add $t0, $t0, $at
• L’assembleur pourrait-il faire cela
automatiquement ?
• Si l’immédiat ne tient pas sur 16 bits, alors
remplacer automatiquement addi par la
séquence lui, ori, add

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 49


“True Assembly Language” (1/3)
• Pseudo-instruction: une instruction MIPS qui
ne correspond pas à une instruction en langage
machine, mais à plusieurs instructions MIPS
• Comment traiter les pseudo-instructions?
– Elles sont décomposées par l’assembleur en
plusieurs “véritables” instructions MIPS.
– Qu’est-ce qu’une “véritable” instruction MIPS ?
Réponse infra
• D’abord quelques exemples

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 50


Pseudo-instructions : exemples (1/3)
• Register Move
move reg2,reg1
correspond à :
add reg2,$zero,reg1
• Load immediate
li reg,valeur
Si la valeur tient sur 16 bits :
addi reg,$zero,value
Sinon :
lui reg, bits 31-16 de valeur
ori reg, $zero, bits 15-0 de valeur

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 51


“True Assembly Language” (2/3)
• Problème :
– Pour décomposer une pseudo-instruction,
l’assembleur peut avoir besoin d’un registre
supplémentaire.
– S’il utilise un registre ordinaire, il écrasera ce
que le programme y a écrit.
• Solution :
– On réserve un registre ($1, appelé $at pour
assembler temporary) pour cette tâche.
– Comme l’assembleur peut l’utiliser à tout
moment, il est sage de le laisser de côté pour
coder.

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 52


Pseudo- instructions : exemples (2/3)
• Instruction Rotate Right
ror reg, value
décomposée en :
srl $at, reg, valeur 0
sll reg, reg, 32-valeur
or reg, reg, $at 0

• Instruction No Operation
nop
Décomposée en :,
sll $0, $0, 0 (= 0ten)

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 53


Pseudo-instructions : exemples (3/3)
• Opérande erroné pour l’instruction
addu reg,reg,valeur # addiu attendu

Si valeur tient sur 16 bits, l’instruction ci-dessus


est changée en :
addiu reg,reg,valeur
Sinon elle est changée en :
lui $at, bits 31-16 de valeur
ori $at,$at,bits 15-0 de valeur
addu reg,reg,$at

• Comment éviter la confusion ?

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 54


“True Assembly Language” (3/3)
• MAL (pour MIPS Assembly Language) : le
jeu d’instructions qu’un prorammeur peut
utiliser pour coder en MIPS ; cela inclut les
pseudo-instructions
• TAL (pour True Assembly Language):
ensemble des instructions qui peuvent
effectivement être traduites en une unique
instruction machine (un mot de 32 bits)
• Tout programme doit être traduit de MAL
en TAL avant la traduction en binaire.
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 55
Traitement des pseudo-instructions
• Question :
– Comment MIPS reconnaît-il les pseudo-
instructions ?
• Réponse :
– Il cherche les pseudo-instructions
“officielles”, comme ror ou move
– Il cherche les cas spéciaux (opérandes ne
correspondant pas à l’opération) et cherche
à les traiter adéquatement

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 56


Exemple : récrire du TAL en MAL

• TAL:
or $v0,$0,$0
Loop: slt $t0,$0,$a1
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop
Exit:

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 57


Exemple : récrire du TAL en MAL
• TAL : or $v0,$0,$0
Loop: slt $t0,$0,$a1
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop

• MALExit:
: li $v0,0
Loop: bge $zero,$a1,Exit
add $v0,$v0,$a0 sub
$a1,$a1,1 j Loop
Exit:

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 58