poly sba

REPUBLIQUE ALGERIENNE DEMOCTRATIQUE ET POPULAIRE
DJILLALI UNVERSITE DJILLALI LIABES DE SIDI BEL-ABBES
FACULTE DES SCIENCES EXACTES
DEPARTEMENT INFORMATIQUE
ASSEMBLEUR MIPS R3000
avec un recueil
d'exercices Corrigés
PR GAFOUR ABDELKADER
ANNÉE UNIVERSITAIRE 2020-2021
Langage Machine
0000 0010 1011 0110 0100 1000 0010 0000
MARS 4.4
Langage Assembleur
ADD A ,B ,C
Langage de Haut niveau
C := A+ B
La programmation en information est un art très passionnant qui permet
entre autres de comprendre le principe de fonctionnement d'un ordinateur
en général et le rôle du processeur en particulier.
Comme le langage d'assemblage appelé communément l'assembleur est le
langage le plus proche de la machine, il est impératif que tout
informaticien doive étudier au moins un assembleur dans son cursus
universitaire.
Dans ce polycopié j'ai relaté la représentation de l'information en
mémoire du MIPS R 3000, son architecture externe en terme de registres
et de zone mémoire accessibles à l'utilisateur, son jeu d'instructions ses
pseudo_instructions, ses directives et certaines fonctions d'appel système
pour les entrées- sorties de données. En outre il contient un recueil
d'exercices corrigés, il est bien illustré de beaucoup d'exerces types pour
permettre aux usagers "d'apprendre par l'exemple".
Il est scindé en trois parties, dans la première partie est exposée
La représentation de l'information en mémoire, la deuxième partie
englobe l'architecture externe du MIPS R3000, son jeu d'instruction,
certaines de ses directives et fonctions systèmes utiles à la
programmation enfin la troisième partie vient enrichir ce dernier avec un
recueil d'exercices corrigés.
2
I- Introduction
7
II- Représentation de l’information en mémoire
8
II.1 Les unités de mesure en Informatique
8
II.2 Représentation des nombres signés et non signés
10
II.2.1 Représentation des nombres en binaire pur
10
II.2.2 Les intervalles de représentations des nombres entiers
signés et non signés
13
II.2.3 Intervalle de représentation sur format 10 BITS
13
II.3 Représentation des réels en Virgule Flottante
15
II.4 Représentation des caractères
17
III Hiérarchie des langages de programmation
18
III.1 Notion d’architecture RISC et CISC
19
III.2 L’architecture RISC
19
III.3 Différences entre L’architecture RISC et CISC
19
IV Processeur MIPS R3000
20
IV.1 Introduction
20
IV.2 Architecture Externe
20
IV.3 Registres visibles Ou Accessibles par
21
Instruction(non protégés)
IV.4 Registres protégés
22
IV.5 Organisation de la Mémoire
23
3
IV.6 Langage d’Assemblage : L’Assembleur MIPS
24
IV.6.1 Format D’Instruction en ASSEMBLEUR
24
IV.6.2 Les directives
24
IV.6.3 Directive de réservation d’espace mémoire
24
IV.6.4 Directive d’Initialisation de Zone Mémoire
24
IV.6.5 Les Pseudo-Instruction en ASSEMBLEUR
28
IV.6.6 Le Jeu d’Instruction du MIPS R3000
30
IV.6.7 Les Instruction de Lecture/Ecriture
30
IV.6.8 Les Instruction de Logique
33
IV.6.9 Les Instructions de Décalage
35
IV.6.10 Les Instructions de Branchement
37
IV.6.11 Traduction en Assembleur des
actions de test et des boucles
39
IV.6.12 Structure d’un Programme en Assembleur
42
IV.6.13 Les fonctions Appel Système (SYSCALL)
43
IV.6.14 Programmation en Assembleur
52
IV.6.15 Rappel de la Structure d’un Programme en Assembleur 52
IV.6.16 Exemple 1 sans Procédures Système sans Directives
52
IV.6.17 Exemple 2 : Avec Procédure Système
52
IV.6.18 Exemple 3 : Avec Procédures Système & Directives
53
IV.6.19 Exemple 4 :
53
Calcul du PGCD et PPMC
IV.6.20 Exemple 5 : Calcul de l'inverse
d'un nombre de 2 chiffres
56
4
IV.6.21 Exemple 6 : Calcul de Factoriel N = N!= 1.2.3….N
57
IV.6.22 Les directives relatives au réels( les flottants)
58
IV.6.23 Le Jeu d’Instruction sur les Réels du MIPS R3000
58
IV.6.24 Exemple: Equation AX2 + BX + C = 0
60
IV.7 Les Sous-Programmes en Assembleur
61
IV.7.1 EXEMPLE d’algorithme avec Fonction
61
IV.7.2 PROCEDURES & LES FONCTIONS
63
RÉCURSIVES
IV.7.2.1 Définition de Fonction Récursive
63
IV.7.2.2 Exemple
63
de Fonction Récursive
IV.7.2.3 Rappel de fonction d’appel à
un sous programme
64
IV.7.2.4 Structures dynamiques
65
IV.7.2.5 Gestion de la file d’attente
65
IV.7.2.6 Gestion de la PILE
65
IV.7.2.7 Exemple de Gestion de la PILE
66
IV.8 ASSEMBLAGE & DESASSEMBLAGE
IV.8.1 Organisation de la Mémoire du MIPS
IV.8.2 Codage ou Assemblage d’Instruction
IV.8.3 Exemple de Codage d’une instruction au format R
68
69
70
75
IV.8.4 Exemple de Codage d’une instruction au format I
76
IV.8.5 Exemple de Codage d’une instruction au format J
77
5
IV.8.6 Décodage ou Désassemblage d’Instruction:
IV.8.7 Exemple de Décodage ou Désassemblage
77
78
V
Conclusion
79
VI
Bibliographie
80
VII Annexe
81
VIII Recueil d’Exercices Corrigés
90
6
La hiérarchie des langages de programmation est schématisée selon la
pyramide ci-dessous où on distingue les trois niveaux
- du plus difficiledu point vue hard ou plus bas niveau ( ou langage
machine)
- jusqu’au plus aisé pour l’usagerou niveau haut dit évolué ( plus
loin de la machine)
- en passant par le niveau intermédiaire regroupant les langages
d’assemblage connus communément sous les noms d’Assembleur
.
Il est à noter :
- Qu’il faut connaitre toute l’ architecture d’une machine pour
travailler en langage machine
- Qu’il faut connaitre le minimum architectural d’une machine à
savoir les registres et la zone de travail mémoire pour travailler en
assembleur
- Par contre l’usager ne soucie guère de l’architecture d’une machine
pour travailler en un langage de haut niveau ( Pascal,C, Fortran etc)
7
II.1- Les unités de mesure en Informatique
On rappelle les unités internationales et leurs notations qui sont utilisés
en sciences physiques et chimie etc.
K = KILO
= 103 = 1000
M = MÉGA = 106 = 1 000 000
G = GIGA
= 109 = 1000 000 000
T = TÉRA
= 1012 = 1000 000 000 000
Puisque l'information se trouve stockée sur un support physique tels que
le disque dur, disquette, CD, DVD, Mémoire, il est judicieux de
quantifier ces support en terme de quantité d'information qu'ils peuvent
contenir.
Pour cela la même notation internationale est maintenue à la différence
Des valeurs :
K = KILO
M = MÉGA
G = GIGA
T= TERA
=
=
=
=
210 = 1024
220 = 1 024* 1024
230 = 1 024* 1024*1024
240 = 1 024* 1024*1024*1024
Remarque:
La valeur 210 = 1024 est choisie du fait que 2 reflète le système binaire
par contre 1024 est plus proche de 1000, voire 512=29 < 1000 < 1024.
8
Exemple 1: Un Livre de 64 Pages
De 32 lignes par Page
De 60 Caractères par ligne
Chaque caractère tient sur 8 Bits (1 Octet ou Byte).
Ce livre a pour taille:
Taille du fichier en Bits = 60 caractères x8 Bitsx32 lignes x64 Pages =
983040 Bits
Taille du fichier en Octets = 60 caractères x32 lignes x64 Pages =
122880 Octets =983040 Bits/8
Taille du fichier en K Bits = 983040 Bits/ 1024 = 960 Kbits
Taille du fichier en K Octets = 122880 Octets/ 1024 = 120= 960Kbits/8
Taille du fichier en M Bits est :
983040 Bits/ (1024*1024) = 0.9375 M Octets = 0.9375 M Bytes
Le nombre de livres qu'on peut stocker sur un DVD simple face:
4.38*23 0 *8 /983040= =38273
38273 romans Sont contenus dans un seul DVD:
Le DVD: il est composé de deux faces et de deux couches par face. Sa
capacité est de 17 Go (environ 17*10 9 Octets) ou 15,8 Gio(15.8*230) .
17 000 000 000
15.8*1024*1024*1024 =16965120819.2
Si on suppose qu'une librairie contient 10000 Livres. Le nombre de
librairies qu'on peut caser dans un DVD Double face Double couche est :
15.8x230 *8/(1000* 983040)
14 Librairies
Exemple 2 :
Taille du disque dur = 1 Téra Octets =240 O = 1 099 511 627 776 =1012 O
Taille du journal El Watan au format PDF = 3 Méga Octets=3145728 O
9
Le nombre de numéro qu'on peut stocker sur ce disque:
240/3 145 728 =349525
En nombres d'années : 349525/365 =957 ans 220 Jours
365 *957 =349305
; 349525 – 349305= 220 = 7 mois 10 Jours
En nombres d'années : 349525/365 =957 ans 7 Mois 10 Jours
II.2- Représentation des nombres signés et non signés:
Comme l'attribut d'une information peut être un nombre entier signé ou
non tels que l'âge , la taille et la température etc.
Pourquoi l'âge, la taille, la température reflètent au mieux l'information?
La réponse est très simple : lorsqu'on affecte des valeurs à ces
informations qu'on nommera communément données.
Il a l'âge de 6 ans.
L'information =il s'agit d'un enfant
Il a l'âge de 17 ans.
L'information =il s'agit d'un adolescent
Il a l'âge de 70 ans.
L'information =il s'agit d'un vieux
Il fait -5 degrés .
L'information =il fait froid
Il fait 45 degrés .
L'information =il fait Chaud
Sa taille est de 1 mètre. L'information =il est de petite taille
Sa taille est de 2 mètres 10. L'information =il est de grande taille.
II.2.1- Représentation des nombres en binaire pur
Les nombres entiers non signés (0 et les nombres positifs) sont
représentés en système binaire selon un format de N Bits.
Exemple:
56 est représenté sur un format de 8 Bits en binaire pur par:
On convertit d'abord 56 en une configuration en binaire ensuite selon un
format on la représente en mémoire.
10
Pour la conversion en binaire on procède soit par :
- La méthode des divisions entières successives d'un nombre par 2 jusqu'à
annulation du quotient en considérant les restes dans le sens inverse;
56 2
0 28 2
0 14 2
0 7 2
1
3
1
2
1 2
1 0
l'annulation du quotient est le processus
d'arrêt
( 56 )10 = ( 1 1 1 0 0 0 )2
56 en décimal est équivalent à 111000 en Binaire
Si on veut le représenter en mémoire sur un format de 8 bits on le cadre à
droite.
0
0
1
1
1
0
0
0
- La méthode des soustractions successives d'un nombre par des
puissances de 2 qui lui sont inférieures dans le sens décroissant jusqu'à
obtenir une soustraction nulle(= 0 ) ;
56 -32 = 24 0n a effectué 56-25 on met 1
24-16= 8 0n a effectué 24-24 on met
1
3
8-8= 0 0n a effectué 8-2 on met
1
On n'a fait la soustraction par 22 On met 0
On n'a fait la soustraction par 21 On met 0
On n'a fait la soustraction par 20 On met 0
Exemple: Conversion du décimal vers le binaire des puissances de 2:
Décimal
1=20
2=21
4=22
8=23
16=24
…
X=2N
1
Binaire
1
10
100
1000
10000
…
000…000
N zéros
11
Exemple:
Conversion du décimal vers le binaire des puissances de 2 -1:
Décimal
1=21 – 1
3=22 – 1
7=23 - 1
15=24 – 1
31=25 -1
…
X=2N – 1
Binaire
1
11
111
1111
11111
…
1 1 1 …1 1 1
N uns
127 = 27 -1 est représenté sur un format de 8 Bits en binaire pur par:
0
1
1
1
1
1
1
1
128 = 27 est représenté sur un format de 8 Bits en binaire pur par:
1
0
7
0
0
0
0
0
0
6
192 =2 + 2 est représenté sur un format de 8 Bits en binaire pur par:
1
1
0
0
0
0
0
0
255=28 -1 est représenté sur un format de 8 Bits en binaire pur par:
1
1
1
1
1
1
1
1
On ne peut pas représenter 256=28 car il tient sur 9 Bits
1
0
0
0
0
0
0
0
0
12
II.2.2- Les intervalles de représentations des nombres entiers signés
et non signés
Le premier bit de fort poids est réservé au signe
0 pour les nombres positifs 0 y compris,
1 pour les nombre négatifs.
Les nombres positifs sont représentés en binaire
Les nombres négatifs sont représentés en complément à 2.
II.2.3- Intervalle de représentation sur un format de 10 BITS:
L'intervalle des nombres négatifs est: [ -29 , -1] =[ -512 , -1 ]
L'intervalle des nombres positifs est: [ 0 , 29 - 1] =[ 0 , 511 ]
-512 est représenter par:
1
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
0
0
0
0
0
0
0
1
1
1
1
1
1
1
-1 est représenté par:
1
1
1
0 est représenter par:
0
0
0
511 est représenté par:
0
1
1
Exemple :
Le Codage sur un format de 10 Bits de 255
255=256-1=28 -1 , est représenté par:
0
0
1
1
1
1
1
1
1
1
0
0
0
0
0
0
1
1
1
0
0
-255 est représenté par:
1
1
0
300 =256+32+16+8+4 est représenté par:
0
1
0
0
1
1
-300 est représenté par:
13
1
0
1
1
0
0
0
1
0
0
511 =256+32+16+8+4 est représenté par:
0
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
1
-511 est représenté par:
1
0
0
On ne peut pas représenter 512 car il n'appartient à l'intervalle voire il
tient sur 11 Bits;
-512 est représenter par:
1
0
0
0
0
0
0
0
0
0
On ne peut pas représenter -520 car il n'appartient à l'intervalle voire il
tient sur 11 Bits;
Exemple : L'équivalent décimal de configurations binaires en mémoire :
La configuration ci-dessous
0
0
0
1
0
1
0
1
1
1
1
0
Correspond à : + ( 64+16+4+2+1 ) = + 87 en décimal;
La configuration ci-dessous
0
0
0
0
1
1
1
1
Correspond à : + ( 63 - 1 ) = (32 + 16 + 8 + 4 + 2) = + 62 en décimal;
La configuration ci-dessous
1
1
1
1
1
1
1
1
1
1
Correspond à : - 1 en décimal; car le complément à 2 C2 est:1
14
II.3- Représentation des réels en Virgule Flottante:
Les réels sont représentés selon le format de la norme JEEE 360
de 32 bits en simple précision et 64 bits en double précision :
S
E +127: Exposant biaisé
M: PseudoMantisse
S E E E E E E E E M
1 Bit
8Bits
M
23 Bits
Dans ce format, il faut d'abord faire la conversion en binaire d'un nombre
puis le transformer en écriture scientifique N=Mantisse* 2exposant ensuite
Selon la norme JEEE 360 N = 1.mantisse *2Exposant enfin le représenter
S E E E E E E E E M
(Exposant+127)2
M
Remarque : Le 1 n'est pas représenté et on parle de bit masqué. On peut
représenter également les entiers car ils sont inclus dans l'ensemble des
réels. S=0 pour Nombre > = 0 & S=1 pour Nombre < 0
Exemple:
N=1, N=2018 , N=-2018, N=40.625,
N= (1)10 = (1)2 = 1.0 *20
Exposé biaisé : (0+127)10=( 1 1 1 1 1 1 1 )2
Pseudo-Mantisse=0 ;
0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
N= (2018)10 = (11111100010)2 = ( 1. 1111100010) *210
Pseudo-Mantisse=1111100010;
Exposant biaisé : (10+127)10=(1010 + 1 1 1 1 1 1 1 )2 =(1 0 0 0 1 0 0 1 )2
0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
N= (-2018)10 = -(11111100010)2 = -( 1. 1111100010) *210
Pseudo-Mantisse=0 ; Exposant biaisé : (0+127)10=( 1 1 1 1 1 1 1 )2
1 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
N= (-2018)10 = -(11111100010)2 = -( 1. 1111100010) *210
15
N= (40.625)10 = (40+0.625)10 =(101000.101) 2
(40)10 = (101000)2 ; (0.625)10 = (0.5+0.125)10 = (0.101)2
N= (40.625)10 =(101000.101) 2 =(1.01000101) 2 *25
Pseudo-Mantisse=01000101 ;
Exposant biaisé : (5+127)10=( 101+1 1 1 1 1 1 1 )2=(1 0 0 0 0 1 0 0)2
0 1 0 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
16
2.4 Représentation des caractères:
Le code ASCII est utilisé pour représenter les caractères en mémoire
ASCII est l'acronyme de
L'American Standard Code for Information Interchange (Code américain
normalisé pour l'échange d'information), plus connu sous l'acronyme
ASCII([aski ]), est une norme informatique de codage de caractères
apparue dans les années 1960.
C'est la norme de codage de caractères la plus influente à ce jour.
La table ASCII
Exemple:
Bonjour en ASCII correspond à :
En Hexadécimal : 42 6 F 6E 6A 6F 75 72
Binaire : 01000010 0110 1111 0110 1110 0110 1010 01101111 01110101 01110010
En Décimal:
66 111 110 106 111 117 114
17
III Hiérarchie des langages de programmation
On distingue :
- Les langages de bas niveau communément appelés langages
machine qui sont compréhensibles par la machine et ils sont
transcrits en binaire pur,
- Les Langages d'assemblages appelés Assembleur,
- Les langages évolués ou de haut niveau .
Le schéma ci-dessous illustre cette hiérarchie.
-
+
Place en mémoire
Temps d'exécution
Langage de Haut Niveau : Pascal
+
Assembleur
Langage d'Assemblage
Langage Machine
-
18
III.1 Notion d’architecture RISC et CISC
Actuellement l’architecture des microprocesseurs se compose de deux grandes
familles :
- L’ architecture CISC (Complex Instruction Set Computer)
-L’ architecture RISC (Reduced Instruction Set Computer)
I.1 L’architecture CISC
C’est une architecture où le format des d’instructions est variable.
Le microprocesseur doit exécuter des tâches complexes par instruction unique mais
chacune nécessite un plus grand nombre de cycles d’horloge. Le code machine de ces
instructions varie d’une instruction à l’autre et nécessite donc un séquenceur
complexe.
III.2 L’architecture RISC
C’est une architecture où le format des d’instructions est fixe et le jeu d’instruction
est réduit.
III.3 Différences entre L’architecture RISC et l’architecture CISC
19
IV.1- Introduction:
Le processeur MIPS R3000 est un processeur de 32 Bits c.-à-d. les données traitées
tiennent sur un format de 32 Bits pour les nombres relatifs (entiers signés et non
signés) par contre son coprocesseur1 traite les nombres flottants(réels positifs et
négatif) sur 32 Bits en simple précision et 64 Bits en double précision selon la norme
IEEE754 .
Son jeu d’instructions est de type RISC les instructions sont donc de même longueur
de 32 Bits et possèdent l’un des 3 Formats suivants:
IV.2- Architecture Externe:
On entend par architecture externe tout ce qui est visible ou accessible par instruction
à savoir Les registres et Les Segments de mémoire.
20
IV.3 Registres visibles Ou Accessibles par Instruction(non protégés):
Le processeur MIPS R3000 possède entre autres 35 Registres manipulés par
instructions Standard. Tous ces registres ont une Longueur de 32 Bits.
*) Ri : i = 0 , 1 , 2 , … , 31
Ces 32 registres sont directement adressés par les instructions et permettent de stocker
des résultats de calculs intermédiaires.
Remarque 1 : Le registre R0 est un registre particulier qui contient toujours
la valeur 0 même Si vous chargez une autre valeur
0.
( R0 ) = ( 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) 2
= ( 0 0 0 0 0 0 0 0 ) 16 = ( 0 ) 10
Remarque 2 : Le registre R31 est utilisé par les instructions d’appel à un
sous-programme pour sauvegarder l’adresse de retour au Programme Principal.
*) Le PC ( Program Counter )
C’est le compteur de programme ou d’instruction, il contient toujours l’adresse de
l’instruction en cours d’exécution et sa valeur est modifiée par toutes les instructions.
PC
( PC ) + 4
Ou
PC
( PC ) + Déplacement
*) Les deux registres HI (higher) & LO ( lower)
Utilisés quant on manipule la multiplication et la division entière:
Ri
de 32 BITS
*
Rj
HI de 32 Bits
de 32 BITS
LO de 32 Bits
La division entière:
Ri
Reste
Rj
Quotient
Exemple :
Ri
de 32 BITS
:
Rj
de 32 BITS
21
Reste
HI de 32 Bits
Quotient
LO de 32 Bits
En programmation assembleur on utilisera par la suite les noms symboliques des
registres au lieu de leur nombre.
IV.4 Registres protégés:
L'architecture MIPS définit d'autres registres qui ne sont accessibles que par les
instructions privilégiées ( mode superviseur). En pratique le MIPS R3000 en utilise 4
registres pour la gestion des interruptions et des exceptions.
*SR : Registre d'état ( Status Register : N° 12 ).
Il contient en particulier le bit qui définit le mode: Superviseur ou utilisateur.
*CR : Registre de cause ( Cause Register : N° 13 ).
En cas d'interruption ou d'exception, son contenu définit la cause pour laquelle on fait
appel au programme de traitement et des exceptions.
*EPC : Registre d'éxecption (Exception Program Counter : N° 14 ).
Il contient l'adresse de retour( PC+4) en cas d'interruption. Il contient l'adresse de
l'instruction fautive en cas d'exception (PC).
*BAR : Registre d'adresse illégale( Bad Adresse Register : N° 8 ).
En cas d'exception de type adressse illégale, il contient la valeur de l'adresse mal
formée.
22
III.5 Organisation de la Mémoire:
La mémoire est partagée en 2 parties:
Une partie pour contenir le système et l’autre réservée aux programmes
de l’utilisateur comme suit:
K pour Kernel
c’est le noyau du système.
Stack étant la pile utilisateur
KStack étant la pile Système.
L’adresse mémoire tient sur 32 Bits soit 8 positions hexadécimales. Cette
mémoire a pour Capacité : 232 Octets = 4* 230 Octets=4 Giga Octets
Une adresse est une valeur entière positive comprise entre
0 et la taille -1(232 -1). La longueur du mot est de 1 octet (8bits).
Pour stocker de l’information en mémoire à partir d’une certaine adresse,
Le MIPS adopte :
La disposition LITTLE ENDIAN : où l’octet de faible poids est écrit à la
basse adresse ,
Contrairement à la disposition BIG ENDIAN : où l’octet de fort poids
est écrit à la basse adresse;
comme illustré sur le schéma suivant:
Exemple : Stocker 0X BACFAC01 à partir de l’adresse 0X000010D
0X 0000010D
0X 0000010E
0X 0000010F
0X 00000110
Little Endian(Octet)
Big Endian(Octet)
01
AC
CF
BA
BA
CF
AC
01
Remarque : Une donnée en mémoire est toujours stockée dans des
adresses consécutives selon l'une des Disposition little ou Big endian
23
IV.6 Langage d’Assemblage : L’Assembleur MIPS
IV.6.1 Format D’Instruction en ASSEMBLEUR :
[ Etiquette :]
Mnémonique
adresses opérande
# Commentaire
ou Symbolique
Remarque :
Généralement, en assembleur l’étiquette commence à partir de la première colonne.
Au moins un blanc séparera les différentes parties. En assembleur du MIPS l'étiquette
peut commencer à partir de n'importe quelle colonne et se termine par:
IV.6.2 Les directives :
Une directive est une instruction non exécutable.
On distingue entre autres les directives d’initialisation d’une zone mémoire, les
directives de réservation d’espace Mémoire.
Remarque: en pratique toutes les directives et instructions sont écrites en minuscule.
Mais pour des raisons de clarté, dans ce polycopié elles sont écrites en majuscule.
IV.6.3 Directive de réservation d’espace mémoire :
La syntaxe est la suivante :
Résultat:
. SPACE
N
# Cette réservation a pour effet de
# réserver N octets à partir de l’adresse affectée à Résultat.
Exemple : Zone :
@ zone
. SPACE
0
4
# Cette à pour effet de réserver 4 octets.
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
IV.6.4 Directive d’Initialisation de Zone Mémoire :
La syntaxe pour les octets est la suivante :
Etiquette:
. BYTE
V1,V2, …
# Cette directive a pour effet
# d’initialiser un octet par la valeur de V1
# L’octet suivant par V2 etc. à partir de
# L’adresse mémoire affectée à l’étiquette
Remarque :
Si une valeur Vi est supérieure à 255 alors elle est tronquée sur un format de 8 Bits
Exemple :
24
TableUnOcctet :
. BYTE
25, -1 , 19, 10
# Cette Directive à pour effet :
# d'initialiser une zone mémoire avec les valeurs 25, -1, ,19, 10 chacun sur un octet.
@TableUnOctet
0
0
1
0
@TableUnOctet + 1
…
TableUnoctet :
0
0
1
0
. BYTE
0
0
1
0
0
1
1
1
1
0
1
1
0
0
1
0
257, -1 , 19, 10
1
1
1
0
0
1
1
1
10
19
-1
25
# Cette Directive à pour effet :
# d'initialiser une zone mémoire avec les valeurs 257, -1, ,19, 10 chacun sur 1 octet.
@TableUnOctet
0
0
1
0
@TableUnOctet + 1
…
0
0
1
0
0
0
1
0
0
1
1
0
1
0
1
0
0
0
1
0
1
1
1
0
0
1
1
1
10
19
-1
257
La valeur (257)10 = ( 1 0 0 0 0 0 0 0 1 )2
Tronquée à gauche sur 8 bits ça devient: (0000 0001)
La syntaxe pour les demi-mots (2 octets) est la suivante :
[Etiquette:]
. HALF
V1,V2,… # Cette directive a pour effet
# d’initialiser 2 octets par la valeur de V1, Les 2 octets suivants par V2 ..
# à partir l’adresse mémoire affectée à l’étiquette
Remarque :
Les valeurs respectives à V1 et V2 sont tronquées sur un format de 16 Bits
Exemple :
TableDemiMots:
. HALF
@ TableDemiMots
@ TableDemiMots+2
@ TableDemiMots+4
@ TableDemiMots+6
1
1
0
0
0
0
0
0
25, -1 , 19 ,10
1
1
0
0
0
0
0
0
1
1
0
0
0
0
0
0
1
1
0
1
0
0
0
1
# Cette à pour effet :
1
1
0
1
0
1
0
0
1
1
0
0
0
0
0
0
1
1
0
0
0
1
0
1
1
1
0
1
0
0
0
1
-1
25
10
19
25
La syntaxe pour les mots (4 octets) est la suivante :
[Etiquette:]
. WORD
V1,V2,… # Cette directive a pour effet :
# d’initialiser 4 octets par la valeur V1, Les 4 octets suivants par V2
# à partir de L’adresse mémoire affectée à l’étiquette
Remarque :
Les valeurs respectives à V1 et V2 sont tronquées sur un format de 32 Bits
Exemple :
TableMots:
. HALF
25, -1 , 19 ,10
# Cette à pour effet :
25 sur 4 Octets(32 Bits), -1 sur 4 Octets, 19 sur 4 Octets , 10 sur 4 Octets
@ TableMots
@ TableMots+4
@ TableMots+8
@ TableMots+12
0
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
1
0
0
0
0
1
0
0
1
0
0
0
0
1
0
0
1
0
0
0
0
25
-1
19
10
INITIALISATION de Zone Mémoire avec une chaine de caractères
On distingue deux directives: ASCII
& ASCIIZ
La syntaxe d’initialisation de ASCII est comme suit :
[Etiquette:]
. Ascii
"chaine"
# Cette directive a pour effet
# d’initialiser des octets par le code ASCII des caractères
# à partir de l’adresse mémoire affectée à Etiquette
Remarque: La chaine peut contenir des séquences d’échappement du
(comme en LANGAGE C \n ) et doit être terminée par le Zéro Binaire si
elle est utilisée lors d'un appel système qu'on verra par la suite.
26
Exemple
Le Code ASCII de A = ( 0100 0001)2 =(41) 16 =( 65 )10
Le code ASCII de zéro 0 = ( 0011 0000)2 =(30) 16 =( 48 )10
Le code ASCII de blanc (espace)= ( 0010 0000)2 =(20) 16 =( 32 )10
Le code ASCII de LF (\n) line feed= ( 0000 1010)2 =(0a) 16 =( 10)10
Tchaine:
. ASCII " BAC 2017 " # en hexadécimal 42 41 43 20 32 30 31 37
# Cette directive a pour effet d'initialiser chaque 8 bits avec le code ASCII du
# caractère selon la disposition little endian( pour chaque 4 caractères).
@Tchaine
…
0
0
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
1
0
1
1
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
0
0
0
1
0
0
1
1
1
0
0
Bespace
AC
CA
espaceB
27
01
10
72
La syntaxe d’initialisation de ASCIIZ est comme suit :
Etiquette:
. Asciiz
"chaine"
# Cette directive a pour effet
# d’initialiser des octets par le code ASCII des caractères
# de chaine à partir de l’adresse mémoire affectée à Etiquette
Remarque: Cette directive ajoute un zéro binaire en fin de chaine
Exemple :
TchaineZ:
@TchaineZ
. Asciiz
0
0
0
0
0
0
0
0
0
" BAC FAC\n" # Cette directive a pour effet:
1
1
1
0
1
1
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
1
0
1
0
1
0
1
1
0
0
1
1
0
0
1
1
0
0
B
A
C
espace
F
A
C
\n
0 zéro terminal
27
IV.6.5 Les Pseudo-Instruction en ASSEMBLEUR :
Une pseudo instruction est une séquence écrite moyennant les instructions de base de
l’assembleur du MIPS reconnue par son compilateur. Elles sont très utiles en pratique.
Pseudo-Instruction de chargement Immédiat:
LI : Load Immediat
La syntaxe est la suivante :
LI
RT , V
# Cette Instruction a pour effet de
# Charger la Valeur en binaire de Vdans le Registre RT.
Exemple 1 :
LI $ T1 , 2015
# Cette Instruction a pour effet de
# charger la valeur (2015)10 =(11111011111)2 dans le registre T1.
Le contenu de T1 après exécution est:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 1 1 1 1
Exemple 2 :
LI
$ T1 , -2016
# Cette Instruction a pour effet de charger
# -2015 en Complément à 2 dans le registre T1.
Le contenu de T1 après exécution est:
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 0 0 0 0 1
Pseudo-Instruction de chargement Adresse.
LA: Load Adress
La syntaxe est la suivante :
LA
RT , Etiquette
# Cette Instruction a pour effet de charger
# l’adresse affectée par le compilateur à Etiquette dans RT.
Exemple :
LA $ T2 , Boucle
# on suppose que l’adresse de boucle =2048
2048 = 211 = ( 1 0 0 0 0 0 0 0 0 0 0 0 )2
( OU LA $T2 , 2048 )
Le contenu de T2 après exécution est:
0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
28
Pseudo-Instruction de transfert de Registre à Registre.
Move:
La syntaxe est la suivante :
MOVE
RD , RS
# Cette Instruction a pour effet de charger
# Le Contenu de RS dans RT.
Exemple :
LI
$T1 , 5
LI
$ T2 , 63
Move $ T1 , $ T2
Le contenu de T1 après l’exécution est:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
Ensuite il contient:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1
Pseudo-Instruction de Multiplication
MUL:
La syntaxe est la suivante :
MUL
RD , RS , RT
# Cette Instruction a pour effet de faire
# La Multiplication entre les Contenus de RS et RT : le résultat est forcé dans RD.
Exemple :
LI
$ T2 , 63
LI
$ T1 , 8
MUL $ T3 , $ T1 , $ T2
Le contenu de T2 après exécution est:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1
Le contenu de T1 après exécution est:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
Le contenu de T3 après exécution est:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0
Remarque: Dans l'annexe vous trouverez d'autres pseudo-instructions utiles à la
programmation.
29
IV.6.6 Le Jeu d’Instruction de L’ ASSEMBLEUR MIPS R3000:
Le processeur possède plus de 150 Instructions qui se répartissent en 4 Classes :
-
instructions arithmétiques et Logiques entre Registres,
ADD, SUB, MULT, AND , OR , XOR, SLL, SRL, SRA ….
-
Instructions de Branchement,
BNE , BEQ, BGTZ , BGEZ , BLEZ, BLTZ, J , JAL ,JR ….
-
Instructions de Lecture/Ecriture c-à-d Chargement/Rangement.
LW , SW , LB, LBU , LH , LHU, SB, SH
-
Instructions d’appel aux procédures (ou routines) système :
Dans tout ce qui suit seules les instructions les plus utilisées seront explicitées
IV.6.7 Les Instruction de Lecture/Ecriture
ou Chargement et Rangement:
Le processeur possède entre autres 8 Instructions de Lecture/Ecriture à savoir.
LW , SW , LH, LHU , SH , LB, LBU, SB
Où La Lecture correspond à un chargement d’une donnée de la mémoire Vers un
registre. Par contre l’écriture correspond à un rangement d’une donnée d’un registre
en mémoire.
On distingue 3 instructions de Rangement:
SW: Store Word : Rangement d’un mot de 4 Octets en mémoire
Où la Syntaxe est:
SW RT , I ( RS ) # ( RT )
@: (RS)+I
I est un déplacement, si I=0 on peut l'omettre.
SH: Store Half : Rangement d’un demi-mot de 2 Octets en mémoire
Où la Syntaxe est:
SH RT , I ( RS )
# Les 2 octets de faible poids de ( RT )
@ : (RS)+I
SB: Store Byte : Rangement d’un Byte (1 Octet) en mémoire
Où la Syntaxe est:
SB RT , I ( RS )
# l’ octet de faible poids de ( RT )
@: (RS)+I
30
EXEMPLE:
( 1029 )10 = ( 1024 +5 )10 = ( 1 0 0 0 0 0 0 0 1 0 1 )2
Contenu de T0
LI
$ T0 , 1029
# ( T0 ) =00000000 00000000 00000100 00000101
En Mémoire on aura après exécution :
LA $ T2 , RESULT #@ RESULT
0
0
0
0
0
1
0
1
SW $ T0 , ( $T2 )
0
0
0
0
0
1
0
0
SH S T0 , 4 ( $T2 )
SB S T0 , 6 ( $T2 )
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
0
0
0
0
0
1
0
1
On distingue, entre autres, 5 instructions de Chargement:
LW: Load Word : Chargement d’un mot de 4 Octets de la mémoire vers un
registre
Où la Syntaxe est:
LW RT , I ( RS ) # ( RT )
((RS)+I)
Effet de l'instruction:
Les 4 octets à partir de l'adresse (RS)+1 est chargé dans le registre RT
LH: Load Half : Chargement d’un demi-mot de 2 Octets de la mémoire
Vers un Registre avec Extension du Signe.
Où la Syntaxe est:
LH RT , I ( RS )
# RT
((RS)+I)
Effet de l'instruction:
Les 2 octets à partir de l'adresse (RS)+1 est chargé dans le registre RT
LB: Store Byte : Chargement d’un Byte (1 Octet) de la mémoire
Vers un Registre avec Extension du Signe.
Où la Syntaxe est:
LB RT , I ( RS ) #
RT
((RS)+I)
Effet de l'instruction:
L'octet d'adresse (RS)+1 est chargé dans le registre RT
LHU: Load Half Unsigned : Chargement d’un demi-mot de 2 Octets de la
mémoire Vers un Registre sans Extension du Signe.
Où la Syntaxe est:
LHU RT , I ( RS )
#
RT
((RS)+I)
LBU: Load Byte Unsigned: Chargement d’un Byte (1 Octet) de la mémoire
Vers un Registre sans Extension du Signe.
Où la Syntaxe est:
LBU RT , I ( RS )
#
RT
((RS)+I)
31
EXEMPLE 1:
on suppose qu’en mémoire à l'adresse Zone on a les
informations suivantes:
@Zone
image du contenu mémoire
1
1
0
1
0
LA
LW
0
0
0
0
0
$ T3 , Zone
$ T0 , ( $T3 )
0
0
0
1
0
0
0
0
0
0
#
0
0
0
0
0
1
1
0
0
1
0
0
0
0
0
équivalent héxa
1
0
0
0
0
85
84
00
contenu de T0 après execution:
A
0
0
0
8
4
8
5
1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1
LH
S T1 , ( $T3)
# contenu de T1 après execution avec extension
# du signe 1 car les 2 octets 8485=(1000 0100 1000 0101)2
F
F
F
F
8
4
8
5
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1
LB
S T2 , 4( $T3 )
# contenu de T2 après execution:
# avec extension du signe 0 car l'octet 04=(0000 0100)2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
LHU
S T4 , ( $ T3 )
0
0
0
# contenu de T4 après execution:
# sans extension du signe
0
8
4
8
5
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1
LBU
S S2 , ( $ T3 )
0
0
#
0
contenu de S2 après execution:
# sans extension du signe
0
0
0
8
5
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1
32
IV.6.8 Les Instruction de Logique :
Le processeur possède 7 Instructions de Logique:
OR , AND , XOR , NOR , ORI , ANDI , XORI
Rappel: On distingue plusieurs opérateurs entre autres :
Le OU ( OR) , Le ET ( AND), Le OUX ( OU Exclusif , XOR),
Le Non ET (NAND ), Le Non OU ( NOR ).
La table de Vérité ci-dessous définit ces opérateurs
pour 2 données A et B de 1 Bit chacune :
A
B
A AND B
A XOR B
A OR B
A NOR B
A NAND B
0
0
0
0
0
1
1
0
1
0
1
1
0
1
1
0
0
1
1
0
1
1
1
1
0
1
0
0
OR : Cette Instruction Fait Le OU Logique entre 2 Registres Bit à Bit
Où la Syntaxe est:
OR RD , RS , RT # RD
(RS) OR (RT)
AND : Cette Instruction Fait Le ET Logique entre 2 Registres
Où la Syntaxe est:
AND RD , RS , RT # RD
(RS) AND (RT)
XOR : Cette Instruction Fait Le OU exclusif entre 2 Registres
Où la Syntaxe est:
XOR RD , RS , RT # RD
(RS) XOR (RT)
NOR : Cette Instruction Fait Le Non OU logique entre 2 Registres
Où la Syntaxe est:
NOR RD , RS , RT # RD
(RS) NOR (RT)
ORI : Fait Le OU Logique entre un Registre et une valeur non signée
Où la Syntaxe est:
ORI RD , RS , I # RD
(RS) OR I
ANDI : Fait Le ET Logique entre un Registre et une valeur non signée
Où la Syntaxe est:
ANDI RD , RS , I # RD
(RS) ANDI I
33
EXEMPLE 1 : Soit La Séquence Suivante:
LI
$ T0 , 1039
LI
$ T1 , 147
AND $T2 , $T0 , $T1
OR $T3 , $T0 , $T1
XOR $T4 , $T0 , $T1
ANDI $T5 , $T0 , 1 # 1= (00000000000000000000000000000001)2
ANDI $T6 , $T0 , -1 # -1= (11111111111111111111111111111111)2
Après exécution de cette séquence on aura :
Dans T0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1
Dans T1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 1
Dans T2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
Dans T3
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 1 1 1 1
Dans T4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 1 1 0 0
Dans T5
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
Dans T6
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1
EXEMPLE 3: Addition en assembleur: Soit La Séquence Suivante:
LI
$ T0 , 1039
ADDI $T1 , $T0 , - 35
Avant exécution de cette séquence on aura :
Dans T0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1
-35 en complément à 2 sur 32 BITS
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1
Après exécution de cette séquence on aura :
Dans T1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 1 0 0
Remarque: On ne tient pas compte de la retenue générée au-delà de 32 Bits lors de
L’addition du Complément à 2,
34
IV.6.9 Les Instructions de Décalage :
Le MIPS possède entre autres 6 instructions de décalage :
SLLV , SRLV , SRAV , SLL, SRL , SRA
S: Shift (Décalage) L:Logical(Logique) L:Left (à Gauche) R:Rigth(à Droite)
A:Arithmetical (Arithmétique) V: Variable
sll $t1,$t2,10 Shift left logical : Set $t1 to result of shifting $t2 left by number
of bits specified by immediate
sllv $t1,$t2,$t3 Shift left logical variable : Set $t1 to result of shifting $t2 left
by number of bits specified by value in low-order 5 bits of $t3
sra $t1,$t2,10 Shift right arithmetic : Set $t1 to result of sign-extended shifting
$t2 right by number of bits specified by immediate
srav $t1,$t2,$t3 Shift right arithmetic variable : Set $t1 to result of signextended shifting $t2 right by number of bits specified by value in low-order 5
bits of $t3
srl $t1,$t2,10 Shift right logical : Set $t1 to result of shifting $t2 right by
number of bits specified by immediate
srlv $t1,$t2,$t3 Shift right logical variable : Set $t1 to result of shifting $t2
right by number of bits specified by value in low-order 5 bits of $t3
Ces instructions sont de 2 types:
*) Décalage Arithmétique à droite variable avec extension du signe,
S:Shift R:right A:arithmetic V:variable
SRAV Rd , Rt , Rs # Rd
( Rt ) >> 5Bits de faible poids de Rs
# avec extension du signe
Le registre Rt est décalé à droite avec extension du signe. Le nombre de décalage est
contenu dans les 5 bits de faible poids du registre Rs. Le résultat est stocké dans Rd
Pourquoi le nombre de décalage se trouve dans 5 bits de faible poids de Rs?
Car il est égal au maximum à (31)10 (registre de 32 bits – le bit de signe) qui est
équivaut à en binaire (11111)2
SRA Rd , Rt , Sh # Rd
( Rt ) >> valeur de Sh
Le registre Rt est décalé à droite avec extension du signe. Le nombre de décalage est
la valeur Sh. Le résultat est stocké dans Rd
Exemple 1:
On suppose que le registre T1 contient la valeur suivante:
T1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
LI
$T0, 6
SRAV $T2 , $T1, $T0
après exécution de ces 2 instructions on aura:
Dans T2
1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1
35
On suppose que le registre T1 contient la valeur suivante:
T1
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
LI
$T0, 6
SRAV $T2 , $T1, $T0
après exécution de ces 2 instructions on aura:
Dans T2
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1
Exemple 2: On suppose que le registre T1 contient la valeur suivante:
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
SRA $T2 , $T1, 8
après exécution de cette instruction on aura:
Dans T2
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
On suppose que le registre T1 contient la valeur suivante:
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
SRA $T2 , $T1, 8
après exécution de cette instruction on aura:
Dans T2
1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
**) Décalage Logique à droite et à gauche sans extension du signe,
SLLV
Rd , Rt , Rs
# Rd
( Rt ) << 5Bits de faible poids de Rs
SRLV
Rd , Rt , Rs
# Rd
( Rt ) >> 5Bits de faible poids de Rs
SLL
Rd , Rt , Sh
# Rd
( Rt ) << Valeur de Sh
SRL
Rd , Rt , Sh
# Rd
( Rt ) >> Valeur de Sh
Remarque : Pour toutes ces instructions on injecte des 0 dans les places libres.
36
Exemple 1:
On suppose que le registre T1 contient la valeur suivante:
T1
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
LI
$T0, 6
SRLV $T2 , $T1, $T0
après exécution de ces 2 instructions on aura:
Dans T2
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1
Exemple 2: On suppose que le registre T1 contient la valeur suivante:
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
SRL $T2 , $T1, 8
après exécution de cette instruction on aura:
Dans T2
0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
Exemple 3: On suppose que le registre T1 contient la valeur suivante:
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
LI
$T0, 6
SLLV $T2 , $T1, $T0
après exécution de ces 2 instructions on aura:
Dans T2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0
Exemple 4: On suppose que le registre T1 contient la valeur suivante:
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0
SLL $T2 , $T1, 8
après exécution de cette instruction on aura:
Dans T2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0
IV.6.10 Les Instructions de Branchement :
Les Mips possède entre autres 8 instructions de branchements:
BEQ , BNE , BGTZ , BGEZ, BLTZ , BLEZ, J , JR , JAL
B: Branch (Branchement)
E:Equal(Egal)
L:Less (Inférieur)
G:greater( Supérieur)
J: Jump ( Saut )
JR : Jump Register
JAL: saut vers un sous-Programme
37
*) Branchements si les contenus de 2 registres sont égaux:
BEQ
Rs , Rt , Label
# Si (Rs) = ( Rt) on se branche à label
# SiNon on continue en séquence
Exemple1 : Cas où il n’y a pas de Branchement
Boucle:
LI
$T1 , 10
LI
$T2 , 20
BEQ $T1 , $T2, Boucle
ADD $S1, $T1 , $T2
Exemple2 : Cas de Branchement où on boucle indéfiniment (à éviter )
Boucle:
LI
$T1 , 10
ADDI
$T2 , $T1 , 0
BEQ $T1 , $T2, Boucle
ADD $S1, $T1 , $T2
**) Branchement si 2 registres sont différents:
BNE
Rs , Rt , Label
# Si (Rs) ( Rt) on se branche à label
# SiNon on continue en séquence
Exemple1 : Cas ou il n’y a pas de Branchement
Boucle:
LI
$T1 , 10
LI
$T2 , 10
BNE $T2 , $T1, Boucle
ADD $S1, $T1 , $T2
Exemple2 : Cas de Branchement où on boucle indéfiniment (à éviter)
Boucle:
LI
$T1 , 10
ADDI
$T2 , $T1 , 1
BNE $T2 , $T1, Boucle
ADD $S1, $T1 , $T2
***) Branchement si le contenu d’un registre est supérieur à 0 :
BGTZ Rs , Label
# Si (Rs) > 0 On se branche à Label
# SiNon on continue en séquence
Exemple1 :
Boucle:
LI
$T1 , 10
LI
$T2 , 0
ADD
$T2 , $T2 , $T1
ADDI $T1 , $T1 , -1
BGTZ $T1 , Boucle
38
****) Branchement si le contenu d’un registre est supérieur ou égal à 0 :
BGEZ Rs , Label # Si (Rs) >= 0 On se branche à Label
# SiNon on continue en séquence
Exemple2 :
LI
$T1 , 10
LI
$T2, 0
Boucle:
ADD
$T2 , $T2 , $T1
ADDI
$T1, $T1 , -1
BGEZ $T1 , Boucle
…..
*****) Branchement si le contenu d’un registre est inférieur à 0 :
BLTZ Rs , Label # Si (Rs) < 0 On se branche à Label
# SiNon on continue en séquence
******) Branchement si le contenu d’un registre est inférieur ou égal à 0 :
BLEZ Rs , Label # Si (Rs) <= 0 On se branche à Label
# SiNon on continue en séquence
IV.6.11 Traduction en Assembleur des actions de test et des boucles:
a) Traduction de l’action :
Si Condition Alors action ;
Suite : …
On Fait d’abord la négation du test comme suit:
Si Non(Condition) Alors aller à suite ;
Action ;
Suite: …
Exemple :
Si T1 = T2 Alors T3
T1+T2 ;
Suite : ….
Devient:
Si T1 T2 Alors Allerà Suite ;
T3
T1+T2 ;
Suite : ….
En Assembleur on aura :
Suite:
BNE $T1 , $T2 , Suite
ADD $T3 , $T2, $T1
…
39
b) Traduction de l’action :
Suite :
Si Condition Alors Action1
SiNon Ation2 ;
…
On Fait d’abord la négation du test comme suit:
Si Non (Condition) Alors Allerà suite ;
Action1;
Allerà Fin;
Suite:
Action2
Fin:….
Exemple :
Si T1= T2 Alors T3
SiNon T3
T1;
Suite : ….
T1+T2
Devient:
Suite :
Fin:
Si T1 T2 Alors Allerà Suite ;
T3
T1+T2 ;
Allerà Fin;
T3
T1;
…
Traduction en Assembleur
BNE $T1 , $T2, Suite
ADD $T3, $T1, $T3
J
FiN
Suite: Move $T3 , $T1
FIN: ….
c) Traduction de l’action :
Tant Que Condition Faire Début Action1 ; Action2; … Fin;
Suite : …
On Fait d’abord la négation de la condition avec une action Si …
Comme suit:
TantQue: Si Non ( Condition) Alors Allerà suite
Action1;
Action2;
…
Allerà TantQue;
Suite:
…
40
Exemple :
Suite :
T1
10;
T2
0;
Tant Que T1 > 0 Faire
Début
T2
T2 + T1 ;
T1
T1 - 1 ;
Fin;
….
Devient:
T1
10;
T2
0;
TantQue: Si T1 < = 0 Alors Allerà Suite ;
T2
T2 + T1 ;
T1
T1 – 1;
Allerà TantQue;
Suite:
…
Traduction en Assembleur
TantQue:
Suite:
LI
$T1 , 10
LI
$T2 , 0
BLEZ $T1 , Suite
ADD $T2, $T2, $T1
ADDI $T1, $T1, -1
J
TantQue
…
41
IV.6.12 Structure d’nn Programme en Assembleur:
.data
Section des directives
.text
Section Instructions
Li
$V0 , 10
SYSCALL
# Fin de programme on fait appel à une procédure
# Système
Voici un premier programme qui permet de calculer la somme:
S= 1+2+3+4 … + 100
Et de stocker en mémoire cette somme S.
Traduction en Assembleur
Résultat:
TantQue:
Suite:
.data
.
.space
4
.text
li
$t1 , 10
li
$t2 , 0
blez $t1 , Suite
add $t2 , $t2 , $t1
addi $t1 , $t1 , -1
j
TantQue
la
$t3 , Résultat
stw $t2 , ( $t3)
li
$v0 , 10
syscall
42
IV.6. 13 Les fonctions Appel Système (SYSCALL) :
Ces fonctions appel système ( Syscall) sont des routines système utilisées pour la
lecture des données à partir du clavier, d'un fichier, d'une boite de dialogue et
également pour l'affichage des résultats sur écran, leurs écritures dans un fichier ou
sur une boite de dialogue.
On distingue une trentaine de procédures qui sont explicitées dans le tableau suivant:
CODE
ARGUMENTS
Affichage d'un Entier
1
A0
Affichage d'un Réel
2
F12
Affichage d'un Réel
Double
Affichage d'une Chaine
de caractères
Lecture d'un Entier
3
F12
Service
Lecture d'un Réel
Lecture d'un Réel double
Lecture d'une Chaine de
Caractères
V0
4
5
6
7
8
Réel
Réel
Double précision
A0
l'adresse
Symbolique de chaine
Affichage d'un Caractère
Lecture d'un Caractère
Affichage d'un Entier en
Hexadécimal
Affichage d'un Entier en
Binaire
Affichage d'un Entier
non Signé en Décimal
Confirmation
De
Dialogue
10
11
12
34
35
A0
l'adresse où
mettre la chaine
Longueur Max
A0
Caractère
A0
Entier
A0
Entier
A0
A0
Entier
Adresse de la
chaine de dialogue
de l'utilisateur
Entier Lu
F0
Réel Lu
F0
Réel D Lu
La chaine lue est stockée à
l'adresse qui se trouve dans
A0
Affichage du Caractère
V0
36
50
Affichage du Nombre
entier
Affichage du
Nombre Réel
Affichage du Réel en
double précision
Affichage de l'entier
V0
A1
Fin De Programme
Entier
RÉSULTAT
Caractère Lu
Affichage de l'entier en
Hexa sur 8 positions
Affichage de l'entier en
Binaire sur 32 positions
Affichage de l'entier en
Décimal
A0 contient la réponse:
A0
0 OUI
A0
1 NON
A0
2 ANNULER
43
Service
V0
CODE
ARGUMENTS
Entrée d'un Entier
Par Boite
51
A0
Adresse de la
chaine de dialogue
de l'utilisateur
52
A0
Adresse de la
chaine de dialogue
de l'utilisateur
54
A0
Adresse de la
chaine de dialogue de
l'utilisateur
A1
l'adresse où
mettre la chaine
A2
Longueur Max
A0
Adresse de la
chaine de dialogue de
l'utilisateur
A1
l'entier à
afficher
De Dialogue
Entrée d'un Réel
Par Boite
De Dialogue
Entrée d'une Chaine
De Caractères Par Boite
De Dialogue
Affichage d'un Entier
56
Sur une Boite
De Dialogue
Affichage d'un Réel
A0
Adresse de la
chaine de dialogue de
l'utilisateur
F12
le réel à
afficher
Affichage de la valeur
réelle qui se trouve dans
le registre F12 sur une
boite de dialogue
57
A0
Adresse de la
chaine de dialogue de
l'utilisateur
A1
la chaine à
afficher
Affichage de la chaine qui
se trouve dans le registre
A1 sur une boite de
dialogue
De Dialogue
De Caractères sur une
BoiteDe Dialogue
A0
Entier Entré
A1 contient le Statut :
A1
0 OK
A1
-1 Entrée Erronée
A1
-2 Annuler
A1
-3 OK sans entier
F0
Réel Entré
A1 contient le Statut :
A1
0 OK
A1
-1 Entrée Erronée
A1
-2 Annuler
A1
-3 OK sans Réel
A1 contient le Statut :
A1
0 OK
A1
-2 Annuler
A1
-3 OK sans la
chaine ( non entrée)
A1
-4 Dépassement de
longueur ( troncature )
Affichage de l'entier qui se
trouve dans le registre A1
sur une boite de dialogue
57
Sur une Boite
Affichage d'une Chaine
RÉSULTAT
44
Exemple : Application des procédures Appel Système : SYSCALL:
a) Programme de Lecture d'un nombre entier à partir du clavier
et de son affichage sur écran
.text
li $v0, 5
syscall
move $a0,$v0
li $v0,1
syscall
# Lecture d'un entier à partir du clavier,
# le système met l'entier lu dans le registre v0
# Transfert de l'entier lu dans le registre A0
# Affichage de l'Entier lu sur Ecran
b) Programme de Lecture d'un nombre réel à partir du clavier
et de son affichage sur écran
.text
li
$v0 , 6
syscall
# Lecture d'un réel à partir du clavier
# le système met l'entier lu dans le registre f0
Mov.s $f12 , $f0 # Transfert du réel lu dans le registre f12
li
$v0 , 2
syscall
# Affichage du réel lu sur Ecran
c) Programme de Lecture d'une chaine de caractère de longueur 16 à partir
du clavier, son stockage à l'adresse chaine et de son affichage sur écran
Chaine:
.data
.space
16 # Réservation de 10 Octets
.text
li $v0, 8
la $a0, Chaine
li $a1 , 16
syscall
# Lecture d'une chaine à partir du clavier
la $a0 , Chaine
li $v0 , 4
syscall
# Affichage de la chaine lue sur écran
li $v0, 10
syscall
# Fin de Programme
45
d) Programme de Lecture d'un nombre entier à partir d'une boite de dialogue
et de son affichage sur écran avec instruction de fin programme:
.data
message:
.asciiz
"Entrez une valeur entière: "
.text
li $v0 , 51
la $a0, message
syscall
# Lecture
# d'un entier à partir d'une boite de dialogue
li $v0 , 1
syscall
# Affichage de l'Entier lu sur Ecran
li $v0 , 10
syscall
# Fin de programme
# Remarque : Si vous tapez un entier incorrect et OK Ou/Et vous tapez
# annuler, vous aurez 0 sur écran.
# Par contre Si vous tapez une valeur entière correcte et OK elle sera affichée.
e) Programme de Lecture d'un nombre réel à partir d'une boite de dialogue
et de son affichage sur écran avec instruction de fin programme
.data
message:
.asciiz
"Entrez une valeur réelle:"
.text
li $v0 , 52
la $a0 , message
syscall
mov.s $f12 , $f0
li $v0 , 2
syscall
# Affichage du réel lu sur Ecran
li $v0 , 10
syscall
# Fin de programme
# Remarque : Si vous tapez un réel incorrect et OK Ou/Et vous tapez
# annuler, vous aurez 0.0 sur écran.
# Par contre Si vous tapez une valeur réelle correcte et OK elle sera affichée.
46
g) Programme de Lecture d'une chaine de 20 caractères au Maximum à partir
d'une boite de dialogue et de son affichage sur écran
.data
message:
.asciiz "Entrez une chaine de caractères:"
Zone:
.space 20
.text
li $v0 , 54
la $a0 , message
la $a1 , Zone
li $a2 , 20
syscall # Lecture d'une Chaine de caractères à partir d'une boite de dialogue
la $a0 , Zone
li $v0 , 4
syscall
# Affichage de la chaine lue sur Ecran
li $v0,10
syscall # Fin de programme
# Remarque : Si vous tapez une chaine Ou/Et vous tapez annuler,
# vous aurez une chaine vide (rien) sur écran.
# Par contre Si vous tapez une Chaine et OK elle sera affichée.
h) Programme de Lecture d'un nombre entier d'une boite de dialogueet de son
affichage sur une boite de dialogue avec instruction de fin programme:
.data
message:
.asciiz
"Entrez une valeur entière: "
Sortie:
.asciiz
" Voici l'entier lu :\n"
.text
li $v0 , 51
la $a0, message
syscall
# Lecture
# d'un entier à partir d'une boite de dialogue
li $v0 , 56
move $a1, $a0
la $a0,Sortie
syscall
# Affichage de l'Entier sur une boite de dialogue
li $v0 , 10
syscall
# Fin de programme
.
47
i) Programme de Lecture d'un nombre réel d'une boite de dialogue et de son
affichage sur une boite de dialogue avec instruction de fin programme:
.data
message:
Sortie:
.asciiz
"Entrez une valeur réelle:"
.asciiz
" Voici la valeur Lue de la boite de dialogue:\n"
.text
li $v0 , 52
la $a0 , message
syscall
mov.s $f12 , $f0
li $v0 , 57
la $a0 , Sortie
syscall
# Affichage
# du réel lu sur une boite de dialogue
li $v0 , 10
syscall
# Fin de programme
g) Programme de Lecture d'une chaine de caractère d'une boite de dialogue et
de son affichage sur une autre boite de dialogue :
.data
message:
Sortie:
Zone:
.asciiz "Entrez une chaine de caractères:"
.asciiz " Voici la chaine lue :\n"
.space 20
.text
li $v0 , 54
la $a0 , message
la $a1 , Zone
li $a2 , 50
syscall # Lecture d'une Chaine de caractères à partir
#d'une boite de dialogue
la $a0 , Sortie
la $a1 , Zone
li $v0,59
syscall
# Affichage de la chaine lue sur boite de dialogue
li $v0,10
syscall # Fin de programme
Les Macro-Instructions: Elles servent à remplacer une suite d'instructions de
base par une seule macro.
48
$a0 contains value of
user-chosen option
$a0 = address of null-terminated string
0: Yes
ConfirmDialog 50
that is the message to user
1: No
2: Cancel
h) Programme de confirmation de dialogue :
Message:
.data
.asciiz
.text
" Voulez-vous Continuer ?Tapez Oui"
Début:
la $a1 , Message
li $v0,50
syscall
# Affichage de la boite de confirmation de dialogue
blez $a0 , Début
li $v0,10
syscall # Fin de programme
49
MessageDialog
.data
Message0:
Message1:
Message2:
Message3:
$a0 = address of null-terminated string that is the message to user
$a1 = the type of message to be displayed:
0: error message, indicated by Error icon
55 1: information message, indicated by Information icon
2: warning message, indicated by Warning icon
3: question message, indicated by Question icon
other: plain message (no icon displayed)
.asciiz
.asciiz
.asciiz
.asciiz
.text
"
"
"
"
N/A
Erreur: Division par zéro!"
La donnée doit être entière!"
Attention: il s'agit d'une division entière"
Voulez-vous quitter"
la $a0 , Message0
li $v0,55
li $a1,0
syscall
la $a0 , Message1
li $a1,1
syscall
la $a0 , Message2
li $a1,2
syscall
la $a0 , Message3
li $a1,3
syscall
li $v0,10
syscall # Fin de programme
50
Les Macros
Exemple:
Soit à remplacer la procédure suivante:
li $v0,10
syscall # Fin de programme
par Fin
on aura:
.data
.macro Fin
li $v0 , 10
syscall
# Fin de programme
.end_macro
.text
….
Fin
51
VI.6.14 Programmation en Assembleur:
VI.6.15 rappel de la Structure d’un Programme en Assembleur:
.DATA
Section des directives
.TEXT
Section Instructions
LI
$V0 , 10
SYSCALL
# Fin de Programme
VI.6.16 Exemple 1 sans Procédures Système sans Directives :
Comment traduire cette affectation C = A + B
En assembleur
.text
li
li
add
$t0 , 2000
$t1 , 18
$t3 , $t0 , $t1
avec A=2000 et B=18
Le registre t0 contient 2000
Le registre t1 contient 18
Le registre t3 contient 2018
# après exécution
VI.6.17 Exemple 2 Avec Procédure Système :
C = A + B . On lit la valeur de A à partir du clavier et on le met dans T0 puis on
lit la valeur de B et on la met dans T1 ensuite on calcule la somme de (T0 )+(T1) et
on la stocke dans T3 . Enfin on affiche le résultat ( la valeur de C ) sur Ecran.
.text
li $v0 , 5
syscall
# Lecture de la Première valeur.
move $t0 , $v0
# T0 contient la première valeur.
li $v0 , 5
syscall
# Lecture de la Deuxième valeur.
move $t1 , $v0
# T1 contient la deuxième valeur.
add $t3 , $t0 , $t1 # T3 contient l : (T0) + (T1).
move $a0 , $t3
li $v0 , 1
syscall
# Affichage du Résultat sur écran.
li $v0 , 10
syscall
# Fin de Programme.
52
VI.6.18 Exemple 3 Avec Procédures Système & Directives:
C:
.data
.asciiz " C= A+B= "
.text
li $v0 ,5
syscall
# Lecture de la Première valeur.
move $t0,$v0
# T0 contient la première valeur de A.
li $v0 ,5
syscall
# Lecture de la Dexième valeur.
move $t1,$v0
# T1 contient la dexième valeur B.
add $t3,$t0,$t1 # T3 contient (T0) + (T1) Valeur de C.
li $v0,4
la $a0,C
syscall
# Ecriture ou Affichage de C=A+B=
move $a0,$t3
li $v0 ,1
syscall
# Affichage de La valeur de C sur écran.
li $v0 ,10
syscall
# Fin de Programme.
VI.6.19 Exemple 4 : Calcul du PGCD et PPMC de deux entiers A et B
A et B différents de Zéro
0ù les données sont lues à partir du clavier et les résultats sont affichés sur écran
Algorithme
PGDC-PPMC ;
Variables
A , B , PGDC , PPMC , R , Q : Entier;
Début
Lire(A , B );
PPMC
A * B;
R
A MOD B ;
TANT_QUE R < > 0 FAIRE Début
A
B; B
R;
R
A MOD B ;
Fin ;
PGDC
B;
PPMC
PPMC DIV B ;
Afficher (' Le PGDC = ', PGDC, ' Le PPMC = ', PPMC);
Fin.
53
lectureA:
lectureB:
ecritureA:
ecritureB:
saut:
Reponse:
.data
.asciiz
.asciiz
.asciiz
.asciiz
.asciiz
.asciiz
" Tapez une Valeur : A= \n"
" Tapez une Valeur : B= \n"
" Le PGDC de A et B est = "
" et Le PPMC de A et B est = "
"\n"
" Voulez-Vous continuer? tapez OUI"
.text
main:
li $v0 , 4
la $a0 , saut
syscall
li $v0 , 4
la $a0 , lectureA
syscall
li $v0 , 5
syscall
# Lecture de la valeur de A
move $t1 , $v0
# T1 contient la valeur de A
li $v0,4
la $a0, lectureB
syscall
li $v0,5
syscall
# Lecture de la valeur de B
move $t2 , $v0
# T2 contient la valeur de B
mul $t4 , $t1 , $t2
rem $t3 , $t1 , $t2
boucle: blez $t3,fin
move $t1 , $t2
move $t2 , $t3
rem $t3 , $t1 , $t2
j boucle
Fin:
li $v0 , 4
la $a0 , ecritureA
syscall
li $v0 , 1
move $a0 , $t2
syscall
div $t4 , $t4 , $t2
li $v0 , 4
la $a0 , ecritureB
syscall
li $v0 , 1
move $a0 , $t4
syscall
li $v0 , 50
la $a0 , reponse
syscall
blez $a0 , main
li $v0 , 10
syscall
# Fin de Programme
54
Exemple 4 : Calcul du PGCD et PPMC de deux entiers A et B
A et B différents de Zéro
0ù les données sont lues à partir d'une boite de dialogue et les résultats sont
affichés sur boite de dialogue. Avec Contrôle sur les données et la boite de dialogue
lectureA:
lectureB:
ecritureA:
ecritureB:
reponse:
.data
.asciiz
.asciiz
.asciiz
.asciiz
.asciiz
.text
" Tapez une Valeur entière de A"
" Tapez une Valeur ent ière de B"
" Le PGDC de A et B est \n "
" Le PPMC de A et B est \n "
" Voulez-Vous continuer? Tapez OUI "
Début:
li $v0 , 51
la $a0 , lectureA
syscall
bltz $a1 , Début
# (a1)=-1 ou -2 ou -3 erreur Sur A
beq $a0 , $zero , Début # Erreur si A=0
move $t1,$a0
RelireB: li $v0 , 51
la $a0 , lectureB
syscall
bltz $a1 , RelireB
# (a1)=-1 ou -2 ou -3 erreur Sur B
beq $a0 , $zero , RelireB # Erreur si B=0
move $t2 , $a0
mul $t4 , $t1 , $t2
rem $t3 , $t1 , $t2
boucle: blez $t3 , fin
move $t1 , $t2
move $t2 , $t3
rem
$t3 , $t1 , $t2
j
boucle
fin:
li $v0 , 56
la $a0 , ecritureA
move $a1 , $t2
syscall
div $t4 , $t4 , $t2
la
$a0 , e critureB
move $a1 , $t4
syscall
li $v0 , 50
la $a0 ,r eponse
syscall
blez $a0 , Début
li
$v0 , 10
syscall
55
IV.6.20 Exemple 5 : Calcul de l'inverse d'un nombre de 2 chiffres
0ù la donnée est lue à partir d'une boite de dialogue et le résultat est saffiché sur
boite de dialogue. Avec Contrôle sur la donnée et la boite de dialogue
.data
entrée: .asciiz
" Donner un Nombre de deux chiffre au
maximum\n"
sortie: .asciiz
" le no mbre inverse est :\n "
reponse: .asciiz "Voulez-vous continuer? Tapez OUI"
.text
#
li $v0,55
#
la $a0,message
#
li $a1,0
#
syscall
debut: li
$v0,51
la
$a0,entrée
syscall
move $t1,$a0
move $t4,$a0
a ddi
$t2,$t1,-9
blez
$t2,debut
div
$t2,$t1,100
bgtz
$t2,debut
div
$t2,$t1,10
rem
$t3,$t1,10
be q
$t3,$t1 suite
mul
$t4,$t3,10
j
continue
suite: add
$t4,$t4,$t3
continue: add
$t4,$t4,$t2
li
$v0,56
la
$a0,sortie
move
$a1,$t4
syscall
li
$v0,50
la
$a0,reponse
syscall
blez $a0,debut
li
$v0,10
syscall
56
VI.6.21 Exemple 6 : Calcul de Factoriel N = N!= 1.2.3….N
0ù la donnée est lue à partir d'une boite de dialogue et le résultat est affiché sur boite
de dialogue. Avec Contrôle sur les données et la boite de dialogue.
.data
message: .asciiz
" Donner une valeur de N >= 2 \n"
sortie: .asciiz
" Factoriel de N = N!= "
reponse: .asciiz "Voulez-vous continuer? tapez Oui"
.text
debut: li
$v0,51
la
$a0,message
syscall
move
$t1,$a0
bltz
$t1,debut
bltz
$a1,debut
li
$t2,1
sub
$t3,$t1,$t2
blez
$t3,fin
move
$t2,$t1
a ddi
$t1,$t1,-1
boucle: mul
$t2,$t2,$t1
a ddi
$t1,$t1,-1
bgtz
$t1, boucle
fin:
li
$v0,56
la
$a0,sortie
move
$a1,$t2
syscall
li
$v0,50
la
$a0,reponse
syscall
blez $a0,debut
li
$v0,10
syscall
57
VI.6.22 Les directives relatives au réels ( les flottants) :
Directive d’initialisation d’une zone mémoire avec des réels 32 Bits:
La syntaxe est la suivante :
Etiquette:
. FLOAT
V1,V2,…Vn
# Cette directive a pour effet d’initialiser la zone d’adresse Etiquette
# par les valeurs réelles V1,V2,…Vn chacune sur 32 Bits .
Exemple :
Entrée :
. float
1 , 2 # Cette directive a pour effet :
@Entrée
Directive d’initialisation d’une zone mémoire avec des réels 64 Bits:
La syntaxe est la suivante :
Etiquette:
. DOUBLE
V1,V2,…Vn
# Cette directive a pour effet d’initialiser la zone d’adresse Etiquette
# par les valeurs réelles V1,V2,…Vn chacune sur 64 Bits .
Exemple :
Entrée :
. double
2 # Cette directive a pour effet :
@Entrée
VI.6.23 Le Jeu d’Instruction sur les Réels ASSEMBLEUR MIPS :
Le coprocesseur possède 32 registres (F0,F1, …., F31) et manipule plusieurs
Instructions de base et Pseudo-Instructions telles que:
- L’Instruction de base d’addition
ADD.S
$F0 , $F1, $F2
# F0
( F1) + ( F2)
# F0
( F1) / ( F2)
- L’Instruction de base de division
DIV.S $F0 , $F1, $F2
- L’Instruction de base de multiplication
MUL.S
$F0 , $F1, $F2
# F0
( F1) * ( F2)
58
- L’instruction de base de transfert
MFC1
$T1 , $F1
# T1
(F1)
MTC1
$T1 , $F1
# T1
(F1)
# F0
( F1 )
# F0
Racine Carrée de (F1)
MOV.S $F0 , $F1
-
Calcul de racine carrée
SQRT.S
$F0 , $F1
L’Instruction de base de soustraction
SUB.S
$F0 , $F1, $F2
# F0
( F1) - ( F2)
- Pseudo-Instruction de chargement dans un registre
L.S $F0 , ($T1)
# F0
(( T1) )
L.S $F0 , Etiquette
# F0
( Etiquette)
LWC1
$F0 , ($T1)
LWC1 $F0 , Etiquette
- Pseudo-Instruction de rangement en mémoire
S.S
$F0 , ($T1)
S.S $F0 , Etiquette
# ( F0 )
( T1)
# ( F0 )
Etiquette
SWC1 $F0 , ($T1)
SWC1 $F0 , Etiquette
59
VI.6.24 Exemple: Résolution de l'équation : AX2 + BX + C = 0
0ù les données sont lues à partir d'une boite de dialogue et les résultats spnt
affichés sur boite de dialogue. Avec Contrôle sur les données et la boite de dialogue
.data
LectureA: .asciiz
" Tapez une Valeur : A= "
LectureB: .asciiz
" Tapez une Valeur : B= "
LectureC: .asciiz
" Tapez une Valeur : C= "
Ecriture0S: .asciiz
" Delta négat ive : pas de solut ions dans R\n "
Ecriture1S: .asciiz
" Racine double: X1 = X2 = -B/(2*A)= \n"
Solution1: .asciiz
" 2 Racines distinctes\n X1 = "
Solution2: .asciiz
" 2 Racines distinctes\n X2 = "
delta:
.asciiz
" delta = "
quatre:
.float
4
Résultat: .asciiz
" Résultat :\n"
reponse: .asciiz
" Voulez-Vous continuer? Tapez Oui"
.text
main: li
$v0,52
la
$a0,LectureA
syscall
mov.s $f1,$f0
la
$a0,LectureB
syscall
mov.s $f2,$f0
la
$a0,LectureC
syscall
mov.s $f3,$f0
mul.s $f4,$f2,$f2
mul.s $f5,$f1,$f3
la
$t1,quatre
l.s $f6,($t1)
mul.s $f5,$f5,$f6
sub.s $f4,$f4,$f5
la
$a0,delta
li
$v0,57
mov.s $f12,$f4
syscall
mfc1 $t5,$f4
bltz $t5,inf0
bgtz $t5,sup0
add.s $f1,$f1,$f1
mtc1 $t5,$f12
sub.s $f12,$f12,$f2
div.s $f12,$f12,$f1
li
$v0,57
la
$a0,Ecriture1S
syscall
j
fin
inf0:
li
$v0,59
la
$a1,Ecriture0S
la
$a0,Résultat
60
VI.7 Les Sous-Programmes en Assembleur :
Définition: Un sous-programme est une routine qui se trouve au début ou à la fin
d'un programme et qui est appelée dans ce dernier.
On fait recours à un sous programme pour deux raisons principales:
- La maintenance d'un long programme
- la redondance
Dans les langages de haut niveau un sous-programme est transcrit en une fonction ou
procedure
VI.7.1 EXEMPLE d’algorithme avec Fonction:
Le calcul de Factoriel N:
N! = 1 * 2 * 3 * 4 * … * N
Algorithme Factoriel;
Variable
N, I, Fact :Entier;
Fonction F(N:Entier):Entier;
Variable P : Entier;
Début
P
1;
Si N = 0 Alors F
P
SiNon Pour I Variant de 1
F
N Faire
P
P*I;
P
Fin;
Début
Lire ( N );
Fact
F(N) ;
Ecrire ( N , ’!= ‘ , Fact );
Fin.
61
Rappel de fonction d’appel à un sous programme:
JAL
LABEL
Appel de fonction inconditionnel immédiat.
Description :
L’adresse de l’instruction suivant l’instruction
JAL est stockée dans le registre $31(Ra). Le programme saute
inconditionnellement vers l’adresse associée à l’étiquette .
Ra= R31
PC + 4
PC
adresse associée à label
Rappel de fonction d’appel à un sous programme:
JALR $Ri Ou JALR $Rj , $Ri
Appel de fonction inconditionnel Registre.
Description :
Le programme saute à l’adresse contenue dans le registre Ri.
L’adresse de l’instruction suivant l’instruction JALR est
Sauvée dans le registre Rj.
Si le registre Rj n’est pas spécifié alors le registre 31(Ra) est
utilisé par défaut.
Ra= R31 Ou Rj
PC + 4
PC
(Ri)
Programme Assembleur de FACT ( N ) Simple:
.DATA
Message: ASCIIZ ’’ Donnez une valeur entière de N >= 0 \n’’
Sortie : ASCIIZ ’’ Factoriel de N= ’’
.TEXT
Main: LI $V0 , 51
LA $A0, Message
SYSCAL
# Lecture de N
MOVE $T1 , $A0
# ( T1 ) = N
BLTZ
$T1 , Main
# Si N< 0 se brancher vers main
# pour une relecture de N
LI
$T2 , 1
# ( T2 )=1
SUB
$T3 , $T1 , $T2
# T3 = ( T1 ) – (T2)
BLEZ $T3 , FIN
# Si ( T1 ) = 1 Alors Écrire N!=1!=1
# Si ( T1 ) = 0 Alors Écrire N!=0!=1
MOVE $T2 , $T1
# ( T2 ) =N
ADDI $T1 , $T1 , -1
# T1 = ( T1 ) - 1
Boucle: MUL $T2 , $T2 , $T1 # T2 = ( T2 ) *( T1 )
ADDI $T1 , $T1 , -1
# T1 = ( T1 ) - 1
BGTZ $T1 , Boucle
# Tant que ( T1 ) > 0 On Boucle
Fin:
LI
$V0 , 56
LA
$A0 , Sortie
MOVE
$A1, $T2
62
Programme Assembleur de FACT ( N ) avec s/Programme:
.DATA
Message: ASCIIZ ’’ Donnez une valeur entière de N >= 0 \n’’
Sortie : ’’ Factoriel de N= ’’
.TEXT
Main: LI $V0 , 51
LA $A0, Message
SYSCAL
# Lecture de N
MOVE $T1 , $A0
# ( T1 ) = N
BLTZ
$T1 , Main
# Si N< 0 se brancher vers main
# pour une relecture de N
LI
$T2 , 1
# ( T2 )=1
SUB
$T3 , $T1 , $T2
# T3 = ( T1 ) – (T2)
BLEZ $T3 , FIN
# Si ( T1 ) = 1 Alors Écrire N!=1!=1
# Si ( T1 ) = 0 Alors Écrire N!=0!=1
JAL FACT
Fin:
LI
$V0 , 56
LA
$A0 , Sortie
MOVE
$A1, $T2
SYSCALL
# Écriture de « Factoriel de N = »
LI
$V0 , 10
SYSCALL
# Fin de programme
FACT: MOVE $T2 , $T1
# ( T2 ) =N
ADDI $T1 , $T1 , -1
# T1 = ( T1 ) - 1
Boucle: MUL $T2 , $T2 , $T1 # T2 = ( T2 ) *( T1 )
ADDI $T1 , $T1 , -1
# T1 = ( T1 ) - 1
BGTZ $T1 , Boucle
# Tant que ( T1 ) > 0 On Boucle
JR
$Ra
VI.7.2 LES PROCEDURES & LES FONCTIONS RÉCURSIVES
VI.7.2.1 Définition de Fonction Récursive:
Une Fonction est dite récursive si elle fait appel à elle même.
VI.7.2.2 Exemple de Fonction Récursive:
La fonction Factorielle de N:
F(N)= N ! = 1*2*3*4* … *(N-2)*(N-1) * N
= [ 1*2*3*4* … *(N-2)*(N-1) ]* N
= F(N-1)* N
F(N-1) = F(N-2)* (N-1) …
F(2)
= F(1)*2
63
F(1)
=1
Algorithme FACTO;
Variables I, N,Fact : Entier ;
Fonction F(N:Entier): Entier;
Début
SI N < 2 ALORS F
1
SINON F
F(N-1)*N
Fin;
Début
Ecrire ( ‘ Donner une valeur entière de N’);
Ecrire ( ‘ N= ‘); Lire(N)
Fact
F(N);
Ecrire (N, ‘ ! = ’ , Fact);
FIN.
IV.7.2.2 Rappel de fonction d’appel à un sous programme:
*) Appel de fonction inconditionnel immédiat.
JAL
LABEL
Ra= R31
(PC) + 4
PC
adresse associée à label
*) Appel de fonction inconditionnel Registre
JALR
$Ri Ou JALR $Rj , $Ri
Ra= R31 Ou Rj
PC
(PC) + 4
(Ri)
64
IV.7.2.4 Structures dynamiques :
La pile et la file d’attente sont deux structures dynamiques particulières Où leurs
gestions sont différentes par rapport aux structures Statiques.
En pratique on utilisera les pointeurs pour implémenter de Telles structures.
IV.7.2.5 Gestion de la file d’attente:
La stratégie de gestion adoptée d’une file d’attente est la Stratégie FIFO( First IN First
OUT) où le premier arrivé dans la file sera le premier servi.
IV.7.2.6 Gestion de la PILE:
La stratégie de gestion adoptée à une pile est la
Stratégie LIFO( Last IN First OUT) où le dernier arrivé dans
la Pile sera le premier servi.
Au niveau de la pile on dispose de deux opérations:
- Mettre un élément dans la pile ou Empiler un élément,
-Prendre un élément de la pile ou Dépiler un élément
La pile est gérée moyennant de deux adresses :
L’adresse du sommet de pile
@I
& L’adresse de fond de pile
@I-1
Où par convention la pile
grossit vers les adresses
décroissantes
65
IV.7.2.7 Exemple de Gestion de la PILE:
C’est le registre 29( $ SP: Stack pointer) du MIPS qui est utilisé
Comme pointeur de pile.
*) Pour sauver un registre Ri sur la pile, on alloue un mot(espace)
D’abord ensuite on écrit(stocke ou empile) sur le sommet de pile:
8 Bits
ADDI $SP, $SP,-4
SW $Ri , 0 ( $SP)
*) Pour restaurer(dépiler ou charger) un mot de la pile,
on lit d’abord le mot qui se trouve au sommet de pile,
puis on désalloue l’espace de la pile
8 Bits
LW
$Ri , 0 ( $SP)
ADDI $SP, $SP,4
66
Programme Assembleur de FACT ( N ) avec s/Programme récursif:
.DATA
Message: ASCIIZ ’’ Donnez une valeur entière de N >= 0 \n’’
Sortie : ’’ Factoriel de N= ’’
.TEXT
Main: LI $V0 , 4
LA $A0, Message
SYSCALL
# Écriture du Message « … »
LI $V0 , 5
SYSCALL
# Lecture de N
MOVE $T1 , $V0
# ( T1 ) = N
BLTZ
$T1 , Main # Si N< 0 se brancher vers main
# pour une relecture de N
LI
$T2 , 1
# ( T2 )=1
SUB
$T3 , $T1 , $T2
# T3 = ( T1 ) – (T2)
BLEZ $T3 , FIN
# Si ( T1 ) = 1 Alors Écrire N!=1!=1
# Si ( T1 ) = 0 Alors Écrire N!=0!=1
JAL
Fin:
FACT
LI
$V0 , 4
# @128
LA
$A0 , Sortie
SYSCALL
# Écriture de « Factoriel de N = »
MOVE $A0 , $T2
LI
$V0 , 1
SYSCALL
# Écriture du résultat qui se trouve dans T2
LI
$V0 , 10
SYSCALL
# Fin de programme
FACT: BLEZ $T1 , Fact_0
# Si ( T1 ) <= 0 saut à Fact_0
ADDI $SP , $SP , -8
# Réservation de 2 mots en pile
SW
$RA , 0($SP)
# Sauvegarde de l’adresse de retour
SW
$T1 , 4($SP)
# & la valeur de (T1)
ADDI $T1 , $T1 , -1
# Décrémentation de (T1)
JAL
FACT
# appel récursif avec l’argument (T1)-1
@256 LW
$T1 , 4($SP)
# Récupération de la valeur de (T1)
MUL
ST2 , $T2 , $T1
LW
$RA , 0($SP)
# Récupérer l’adresse de retour
ADDI $SP , $SP , 8
# Libération de la pile
J
$RA
# Retour à l’appelant
Fact_0: LI
$T2 , 1
J
$RA
67
IV.8 ASSEMBLAGE & DESASSEMBLAGE
L’assemblage correspond au codage ou traduction des instructions en langage
machine ( en binaire) selon l’un des 3 formats suivants:
Format R : il est utilisé par les instructions arithmétiques
CODEOP
RS
RT
RD
SH
FUNC
et logiques nécessitant 3 registres
Format I: Il est utilisé par les instructions de rangement, de
CODEOP
RS
RT
Immédiat 16 Bits
Chargement, avec opérande immédiat et saut à courte distance
Format J : Il est utilisé par les instructions de branchement à
CODEOP
Immédiat 26 Bits
longue distance (inconditionnels)
Par contre le désassemblage correspond à l’opération inverse c-à-d
à partir d’un code en binaire pur retrouver l’instruction source.
L’assemblage:
Instruction
Binaire (langage machine)
Le Désassemblage
Langage machine( Binaire)
Instruction source
V.8.1 Organisation de la Mémoire du MIPS
Lorsqu’on assemble un Programme, il sera ensuite chargé en mémoire dans sa propre
zone pour être exécuté. Cette mémoire à pour capacité 232 Octets ( Bytes )
Où une adresse tient sur 32 Bits et elle organisée comme suit:
68
Organisation de la Mémoire entre le Noyau système( Kernel ) et l’utilisateur
Mémoire
Plage d'Adresses
Zone Réservée
SEGMENT
SYSTEME
Zone Système
.KSTACK du noyau
0X FFFEFFF
0X FFFF000
0X FFFEFFF
Zone Système
.KTEXT du noyau
Zone Système
.KTEXT du noyau
0X C0000000
0X BFFFFFFF
0X 80000000
0X 7FFFFFFF
Zone Réservée
SEGMENT
UTILISATEUR
Zone utilisateur
.PILE
0X 7FFFF000
0X 7FFFEFFF
Zone utilisateur
.DATA
Zone utilisateur
.TEXT
0X 10000000
0X 0FFFFFFF
0X 00400000
0X 003FFFFF
Zone Réservée
0X 00000000
On remarques les zones de données et de piles sont variables d'une part, d'autre part le
Bit de fort poids d'une adresse utilisateur en binaire commence par 0,et le Bit de fort
poids d'une adresse système en binaire commence par 1.
En effet ( sans les zones réservées) :
En Hexadécimal
en binaire sur 32 bits
Zone
0X 7FFFEFFF 0111 1111 1111 1111 1110 1111 1111 1111
Utilisateur
0X 00400000
0000 0000 0100 0000 0000 0000 0000 0000
Zone
0X 80000000
1000 0000 0100 0000 0000 0000 0000 0000
système
0X FFFEFFF
1111 1111 1111 1111 1110 1111 1111 1111
69
IV.8.2 Codage ou Assemblage d’Instruction:
On devra suivre les étapes ci-dessous pour assembler correctement une ou plusieurs
instructions. Ce rôle est en fait le travail d’un compilateur.
1-Voir le type de format : R , I , J
CODE OP
RS
RT
RD
SH
FUNC
R
CODE OP
RS
RT
IMMEDIAT 16 Bits
I
CODE OP
IMMEDIAT 26 Bits
J
70
2- Consulter le code opération dans sa table respective
71
Le codage des instructions est défini principalement par les 6 Bits du champ code
opération de l’instruction ( les Bits 31 30 29 28 27 26 de l'instruction)
Cependant 3 valeurs particulières relatives à ce champ Définissent
3 familles d’instructions: Ces codes particuliers sont:
0 0 0 0 0 0 : Code Spécial
0 0 0 0 0 1 : Code BCOND
0 1 0 0 0 0 : Code COPRO
Les 3 formats sur 32 Bits
31
26 25
21 20
16 15
11 10
CODE OP
RS
RT
RD
SH
31
26 25
CODE OP RS
21 20
RT
65
0
FUNC
16 15
IMMEDIAT 16 Bits
0
31
26 25
CODE OP IMMEDIAT 26 Bits
Pour le code spécial 0 0 0 0 0 0 on consultera la table suivante :
31
26 25
21 20
16 15
11 10
000000
RS
RT
RD
SH
65
0
FUNC
Pour coder les 6 Bits du champ Func de l’instruction ( INS 5:0)
72
Pour le code BCOND 0 0 0 0 0 1 on consultera la table suivante
Pour coder les Bits 20 et 16 de l’instruction ( INS 20 e t16 )
31
26 25
000001
20
X
16
X
0
Pour le code COPRO 0 1 0 0 0 0 on consultera la table suivante :
Pour coder les Bits 25 et 23 de l’instruction( INS 25 et 23)
31
26 25 23
010000 X
X
0
73
Par contre les autres instructions qui n’ont pas de code particulier,
on utilisera la table suivante:
Pour coder les 6 Bits 31: 26 de l’instruction( INS 31 : 26)
31 30 29 28 27 26
X X X X X X
3- Codage des Registres : Puisqu’on dispose de 32 registre (R31 : R0 ) , ils sont
sur 5 Bits en Binaire pur.
R0 = Zéro a pour code 0 0 0 0 0 et
R31 = Ra
R1 = AT a pour code 0 0 0 0 1 et
R29 = SP a pour code 1 1 1 0 1
R2 = Vo
a pour code 0 0 0 1 0 et
R3
= V1
a pour code 0 0 0 1 1
R4 = Ao
a pour code 0 0 1 0 0 et
R5
= A1
a pour code 0 0 1 0 1
R6 = A2
a pour code 0 0 1 1 0 et
R7
= A3
a pour code 0 0 1 1 1
R8
= To a pour code 0 1 0 0 0 et
R9
a pour code 1 1 1 1 1
= T1 a pour code 0 1 0 0 1
R10 = T2 a pour code 0 1 0 1 0 et
R11 = T3 a pour code 0 1 0 1 1
R12 = T4 a pour code 0 1 1 0 0 et
R13 = T5 a pour code 0 1 1 0 1
R14 = T6 a pour code 0 1 1 1 0 et
R15 = T7 a pour code 0 1 1 1 1
R16 = So a pour code 1 0 0 0 0 et
R17 = S1 a pour code 1 0 0 0 1
R18 = S2 a pour code 1 0 0 1 0 et
R19 = S3 a pour code 1 0 0 1 1
R20 = S4 a pour code 1 0 1 0 0 et
R21 = S5 a pour code 1 0 1 0 1
R22 = S6 a pour code 1 0 1 1 0 et
R23 = S7 a pour code 1 0 1 1 1
R24 = T8 a pour code 1 1 0 0 0 et
R25
= T9 a pour code 1 1 0 0 1
74
4- Codage des Valeurs Immédiates:
Les valeurs immédiates positives sont codées en binaire pur soit sur un format
De 26 Bits , 16 Bits, 5 Bits .
31
26 25
21 20
16 15
11 10
CODE OP
RS
RT
RD
SH
31
26 25
CODE OP
RS
21 20
16 15
RT
31
26 25
CODE OP
65
0
FUNC
0
IMMEDIAT 16 Bits
IMMEDIAT 26 Bits
IV.8.3 Exemple de Codage d’une instruction au format R :
ADD
$T1 , $S5 , $S6
ADD
RD , RS , RT
RD T1 R9 0 1 0 0 1 || RS S5 R21 1 0 1 0 1 || RT S6 R22 1 0 1 1 0
31
26 25
21 20
16 15
11 10
CODE OP
RS
RT
RD
SH
65
0
FUNC
Le champ SH n’est pas utilisé de facto il est codé à 0 0 0 0 0
L’instruction en binaire est :
0 0 0 0 0 0 1 0 1 0 1 1 0 1 1 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0
Code en Binaire est: 0000 0010 1011 0110 0100 1000 0010 0000
Soit en hexadécimal = 0
2
B
6
4
8
2
0
75
IV.8.4 Exemple de Codage d’une instruction au format I :
XORI
$T4 , $T8 , 12
XORI
RT , RS ,
I
RT T4 R12 0 1 1 0 0 || RS T8 R24
31
26 25
CODE OP RS
21 20
RT
1 1 0 0 0 || I 12 0000000000001100
16 15
IMMEDIAT 16 Bits
0
31
26 25
21 20
16 15
0
001110 11000 01100
000000000000 1 100
L’instruction en binaire est codée alors:
0011 1011 0000 1100 0000 0000 0000 1100
Soit en hexadécimal = 3
B
0
C
0
0
0
C
76
IV.8.5 Exemple de Codage d’une instruction au format J :
( PC )=Ox 00400078
J
Boucle
J
Label
PC
PC 31:28 || I*4
il faut connaître les adresses de Boucle et du PC Pour en déduire I.
On suppose que ( PC )=0x 00400078 et @ de Boucle 0x 0040005C
(0040005C)16 = (0000 0000 0100 0000 0000 0000 0101 1100) =I*4
I=PC DIV 4 = 0000 0000 0100 0000 0000 0000 0101 11
31
26 25
COP OP
IMMEDIAT 26 BITS
0
31
26 25
0
000010
000001000000000000000101 11
L’instruction en binaire est codée Par :
0000 1000 0001 0000 0000 0000 0001 0111
Soit En Hexadécimal:
0
8
1
0
0
0
1
7
IV.8.5 Décodage ou Désassemblage d’Instruction:
On devra suivre les étapes ci-dessous pour désassembler correctement une
configuration de 32 Bits.
1- Prendre les 6 bits de forts poids de la configuration
Code opération
77
2- Retrouver le symbolique de l’instruction dans les tables
des codes,
3- Prendre ce symbolique et consulter les tables d’instructions pour retrouver le
format ( R , I Ou J)
4-Scinder la configuration binaire en zones selon le format trouvé,
5- Désassembler chaque zone séparément
6- Ecrire l’instruction.
IV.8.6 Exemple de Décodage ou Désassemblage :
Soit la configuration (en Hexadécimal) suivante : Ox 2129FFFF
2
1
2
9
F
F
F
F
En binaire 0010 0001 0010 1001 1111 1111 1111 1111
CODEOP
RS
RT
001000 01001 01001
ADDI
$T1
Immédiat 16 Bits
1111 1111 1111 1111
,
$ T1
,
-1
78
Il faut retenir primo que chaque machine possède son propre
assembleur à moins que les machines soient identiques,
Secundo la programmation en ASSEMBLEUR nécessite les pré-requis
En algorithmique et la connaissance d’au moins un langage de
programmation de haut niveau tel que le pascal , le C .
79
Université Pierre et Marie Curie Licence Informatique Processeur MIPS R3000
Langage d'assemblage septembre 2004
Université Pierre et Marie Curie Licence Informatique Processeur MIPS R3000
Architecture Externe septembre 1999
Cours personnel d’architecture des ordinateurs LMD SI 2ième année
80
Le langage de simulation MARS 4.4 sous Windows
Le jeu d instruction :
1- Les instructions de Base
add $t1,$t2,$t3 Addition with overflow : set $t1 to ($t2 plus $t3)
add.d $f2,$f4,$f6 Floating point addition double precision : Set $f2 to double-precision floating
point value of $f4 plus $f6
add.s $f0,$f1,$f3 Floating point addition single precision : Set $f0 to single-precision floating
point value of $f1 plus $f3
addi $t1,$t2,-100 Addition immediate with overflow : set $t1 to ($t2 plus signed 16-bit
immediate)
addiu $t1,$t2,-100 Addition immediate unsigned without overflow : set $t1 to ($t2 plus signed
16-bit immediate), no overflow
addu $t1,$t2,$t3 Addition unsigned without overflow : set $t1 to ($t2 plus $t3), no overflow
and $t1,$t2,$t3 Bitwise AND : Set $t1 to bitwise AND of $t2 and $t3
andi $t1,$t2,100 Bitwise AND immediate : Set $t1 to bitwise AND of $t2 and zero-extended 16bit immediate
beq $t1,$t2,label Branch if equal : Branch to statement at label's address if $t1 and $t2 are equal
81
bgez $t1,label Branch if greater than or equal to zero : Branch to statement at label's address if
$t1 is greater than or equal to zero
bgezal $t1,label Branch if greater then or equal to zero and link : If $t1 is greater than or equal to
zero, then set $ra to the Program Counter and branch to statement at label's address
bgtz $t1,label Branch if greater than zero : Branch to statement at label's address if $t1 is greater
than zero
blez $t1,label Branch if less than or equal to zero : Branch to statement at label's address if $t1 is
less than or equal to zero
bltz $t1,label Branch if less than zero : Branch to statement at label's address if $t1 is less than
zero
bltzal $t1,label Branch if less than zero and link : If $t1 is less than or equal to zero, then set $ra
to the Program Counter and branch to statement at label's address
bne $t1,$t2,label Branch if not equal : Branch to statement at label's address if $t1 and $t2 are not
equal
div $t1,$t2 Division with overflow : Divide $t1 by $t2 then set LO to quotient and HI to
remainder (use mfhi to access HI, mflo to access LO)
div.d $f2,$f4,$f6 Floating point division double precision : Set $f2 to double-precision floating
point value of $f4 divided by $f6
div.s $f0,$f1,$f3 Floating point division single precision : Set $f0 to single-precision floating
point value of $f1 divided by $f3
divu $t1,$t2 Division unsigned without overflow : Divide unsigned $t1 by $t2 then set LO to
quotient and HI to remainder (use mfhi to access HI, mflo to access LO)
j target Jump unconditionally : Jump to statement at target address
jal target Jump and link : Set $ra to Program Counter (return address) then jump to statement at
target address
jalr $t1 Jump and link register : Set $ra to Program Counter (return address) then jump to
statement whose address is in $t1
jalr $t1,$t2 Jump and link register : Set $t1 to Program Counter (return address) then jump to
statement whose address is in $t2
jr $t1 Jump register unconditionally : Jump to statement whose address is in $t1
lb $t1,-100($t2) Load byte : Set $t1 to sign-extended 8-bit value from effective memory byte
address
lbu $t1,-100($t2) Load byte unsigned : Set $t1 to zero-extended 8-bit value from effective
memory byte address
lh $t1,-100($t2) Load halfword : Set $t1 to sign-extended 16-bit value from effective memory
halfword address
lhu $t1,-100($t2) Load halfword unsigned : Set $t1 to zero-extended 16-bit value from effective
memory halfword address
lw $t1,-100($t2) Load word : Set $t1 to contents of effective memory word address
mfc0 $t1,$8 Move from Coprocessor 0 : Set $t1 to the value stored in Coprocessor 0 register $8
mfc1 $t1,$f1 Move from Coprocessor 1 (FPU) : Set $t1 to value in Coprocessor 1 register $f1
mfhi $t1 Move from HI register : Set $t1 to contents of HI (see multiply and divide operations)
mflo $t1 Move from LO register : Set $t1 to contents of LO (see multiply and divide operations)
mov.d $f2,$f4 Move floating point double precision : Set double precision $f2 to double
precision value in $f4
mov.s $f0,$f1 Move floating point single precision : Set single precision $f0 to single precision
value in $f1
82
mtc0 $t1,$8 Move to Coprocessor 0 : Set Coprocessor 0 register $8 to value stored in $t1
mtc1 $t1,$f1 Move to Coprocessor 1 (FPU) : Set Coprocessor 1 register $f1 to value in $t1
mthi $t1 Move to HI registerr : Set HI to contents of $t1 (see multiply and divide operations)
mtlo $t1 Move to LO register : Set LO to contents of $t1 (see multiply and divide operations)
mul $t1,$t2,$t3 Multiplication without overflow : Set HI to high-order 32 bits, LO and $t1 to
low-order 32 bits of the product of $t2 and $t3 (use mfhi to access HI, mflo to access LO)
mul.d $f2,$f4,$f6 Floating point multiplication double precision : Set $f2 to double-precision
floating point value of $f4 times $f6
mul.s $f0,$f1,$f3 Floating point multiplication single precision : Set $f0 to single-precision
floating point value of $f1 times $f3
mult $t1,$t2 Multiplication : Set hi to high-order 32 bits, lo to low-order 32 bits of the product of
$t1 and $t2 (use mfhi to access hi, mflo to access lo)
multu $t1,$t2 Multiplication unsigned : Set HI to high-order 32 bits, LO to low-order 32 bits of
the product of unsigned $t1 and $t2 (use mfhi to access HI, mflo to access LO)
neg.d $f2,$f4 Floating point negate double precision : Set double precision $f2 to negation of
double precision value in $f4
neg.s $f0,$f1 Floating point negate single precision : Set single precision $f0 to negation of
single precision value in $f1
nop Null operation : machine code is all zeroes
nor $t1,$t2,$t3 Bitwise NOR : Set $t1 to bitwise NOR of $t2 and $t3
or $t1,$t2,$t3 Bitwise OR : Set $t1 to bitwise OR of $t2 and $t3
ori $t1,$t2,100 Bitwise OR immediate : Set $t1 to bitwise OR of $t2 and zero-extended 16-bit
immediate
round.w.d $f1,$f2 Round double precision to word : Set $f1 to 32-bit integer round of doubleprecision float in $f2
round.w.s $f0,$f1 Round single precision to word : Set $f0 to 32-bit integer round of singleprecision float in $f1
sb $t1,-100($t2) Store byte : Store the low-order 8 bits of $t1 into the effective memory byte
address
sh $t1,-100($t2) Store halfword : Store the low-order 16 bits of $t1 into the effective memory
halfword address
sll $t1,$t2,10 Shift left logical : Set $t1 to result of shifting $t2 left by number of bits specified by
immediate
sllv $t1,$t2,$t3 Shift left logical variable : Set $t1 to result of shifting $t2 left by number of bits
specified by value in low-order 5 bits of $t3
slt $t1,$t2,$t3 Set less than : If $t2 is less than $t3, then set $t1 to 1 else set $t1 to 0
slti $t1,$t2,-100 Set less than immediate : If $t2 is less than sign-extended 16-bit immediate, then
set $t1 to 1 else set $t1 to 0
sltiu $t1,$t2,-100 Set less than immediate unsigned : If $t2 is less than sign-extended 16-bit
immediate using unsigned comparison, then set $t1 to 1 else set $t1 to 0
sltu $t1,$t2,$t3 Set less than unsigned : If $t2 is less than $t3 using unsigned comparision, then
set $t1 to 1 else set $t1 to 0
sqrt.d $f2,$f4 Square root double precision : Set $f2 to double-precision floating point square
root of $f4
sqrt.s $f0,$f1 Square root single precision : Set $f0 to single-precision floating point square root
of $f1
sra $t1,$t2,10 Shift right arithmetic : Set $t1 to result of sign-extended shifting $t2 right by
number of bits specified by immediate
srav $t1,$t2,$t3 Shift right arithmetic variable : Set $t1 to result of sign-extended shifting $t2
right by number of bits specified by value in low-order 5 bits of $t3
srl $t1,$t2,10 Shift right logical : Set $t1 to result of shifting $t2 right by number of bits specified
by immediate
83
srlv $t1,$t2,$t3 Shift right logical variable : Set $t1 to result of shifting $t2 right by number of
bits specified by value in low-order 5 bits of $t3
sub $t1,$t2,$t3 Subtraction with overflow : set $t1 to ($t2 minus $t3)
sub.d $f2,$f4,$f6 Floating point subtraction double precision : Set $f2 to double-precision
floating point value of $f4 minus $f6
sub.s $f0,$f1,$f3 Floating point subtraction single precision : Set $f0 to single-precision floating
point value of $f1 minus $f3
subu $t1,$t2,$t3 Subtraction unsigned without overflow : set $t1 to ($t2 minus $t3), no overflow
sw $t1,-100($t2) Store word : Store contents of $t1 into effective memory word address
syscall Issue a system call : Execute the system call specified by value in $v0
trunc.w.d $f1,$f2 Truncate double precision to word : Set $f1 to 32-bit integer truncation of
double-precision float in $f2
trunc.w.s $f0,$f1 Truncate single precision to word : Set $f0 to 32-bit integer truncation of
single-precision float in $f1
xor $t1,$t2,$t3 Bitwise XOR (exclusive OR) : Set $t1 to bitwise XOR of $t2 and $t3
xori $t1,$t2,100 Bitwise XOR immediate : Set $t1 to bitwise XOR of $t2 and zero-extended 16bit immediate
2- Les pseudo-Instructions
abs $t1,$t2 ABSolute value : Set $t1 to absolute value of $t2 (algorithm from Hacker's Delight)
add $t1,$t2,-100 ADDition : set $t1 to ($t2 plus 16-bit immediate)
add $t1,$t2,100000 ADDition : set $t1 to ($t2 plus 32-bit immediate)
addi $t1,$t2,100000 ADDition Immediate : set $t1 to ($t2 plus 32-bit immediate)
addiu $t1,$t2,100000 ADDition Immediate Unsigned: set $t1 to ($t2 plus 32-bit immediate), no
overflow
addu $t1,$t2,100000 ADDition Unsigned : set $t1 to ($t2 plus 32-bit immediate), no overflow
and $t1,$t2,100 AND : set $t1 to ($t2 bitwise-AND 16-bit unsigned immediate)
and $t1,100 AND : set $t1 to ($t1 bitwise-AND 16-bit unsigned immediate)
andi $t1,$t2,100000 AND Immediate : set $t1 to ($t2 bitwise-AND 32-bit immediate)
andi $t1,100 AND Immediate : set $t1 to ($t1 bitwise-AND 16-bit unsigned immediate)
andi $t1,100000 AND Immediate : set $t1 to ($t1 bitwise-AND 32-bit immediate)
b label Branch : Branch to statement at label unconditionally
beq $t1,-100,label Branch if EQual : Branch to statement at label if $t1 is equal to 16-bit
immediate
beq $t1,100000,label Branch if EQual : Branch to statement at label if $t1 is equal to 32-bit
immediate
beqz $t1,label Branch if EQual Zero : Branch to statement at label if $t1 is equal to zero
bge $t1,$t2,label Branch if Greater or Equal : Branch to statement at label if $t1 is greater or
equal to $t2
bge $t1,-100,label Branch if Greater or Equal : Branch to statement at label if $t1 is greater or
equal to 16-bit immediate
bge $t1,100000,label Branch if Greater or Equal : Branch to statement at label if $t1 is greater or
equal to 32-bit immediate
bgeu $t1,$t2,label Branch if Greater or Equal Unsigned : Branch to statement at label if $t1 is
greater or equal to $t2 (unsigned compare)
bgeu $t1,-100,label Branch if Greater or Equal Unsigned : Branch to statement at label if $t1 is
greater or equal to 16-bit immediate (unsigned compare)
84
bgtu $t1,100000,label Branch if Greater Than Unsigned: Branch to statement at label if $t1 is
greater than 16-bit immediate (unsigned compare)
ble $t1,$t2,label Branch if Less or Equal : Branch to statement at label if $t1 is less than or equal
to $t2
ble $t1,-100,label Branch if Less or Equal : Branch to statement at label if $t1 is less than or
equal to 16-bit immediate
ble $t1,100000,label Branch if Less or Equal : Branch to statement at label if $t1 is less than or
equal to 32-bit immediate
bleu $t1,$t2,label Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is less
than or equal to $t2 (unsigned compare)
bleu $t1,-100,label Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is less
than or equal to 16-bit immediate (unsigned compare)
bleu $t1,100000,label Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is
less than or equal to 32-bit immediate (unsigned compare)
blt $t1,$t2,label Branch if Less Than : Branch to statement at label if $t1 is less than $t2
blt $t1,-100,label Branch if Less Than : Branch to statement at label if $t1 is less than 16-bit
immediate
blt $t1,100000,label Branch if Less Than : Branch to statement at label if $t1 is less than 32-bit
immediate
bltu $t1,$t2,label Branch if Less Than Unsigned : Branch to statement at label if $t1 is less than
$t2
bltu $t1,-100,label Branch if Less Than Unsigned : Branch to statement at label if $t1 is less than
16-bit immediate
bltu $t1,100000,label Branch if Less Than Unsigned : Branch to statement at label if $t1 is less
than 32-bit immediate
bne $t1,-100,label Branch if Not Equal : Branch to statement at label if $t1 is not equal to 16-bit
immediate
bne $t1,100000,label Branch if Not Equal : Branch to statement at label if $t1 is not equal to 32bit immediate
bnez $t1,label Branch if Not Equal Zero : Branch to statement at label if $t1 is not equal to zero
div $t1,$t2,$t3 DIVision : Set $t1 to ($t2 divided by $t3, integer division)
div $t1,$t2,-100 DIVision : Set $t1 to ($t2 divided by 16-bit immediate, integer division)
div $t1,$t2,100000 DIVision : Set $t1 to ($t2 divided by 32-bit immediate, integer division)
divu $t1,$t2,$t3 DIVision Unsigned : Set $t1 to ($t2 divided by $t3, unsigned integer division)
divu $t1,$t2,-100 DIVision Unsigned : Set $t1 to ($t2 divided by 16-bit immediate, unsigned
integer division)
divu $t1,$t2,100000 DIVision Unsigned : Set $t1 to ($t2 divided by 32-bit immediate, unsigned
integer division)
li $t1,-100 Load Immediate : Set $t1 to 16-bit immediate (sign-extended)
li $t1,100 Load Immediate : Set $t1 to unsigned 16-bit immediate (zero-extended)
li $t1,100000 Load Immediate : Set $t1 to 32-bit immediate
la $t1,($t2) Load Address : Set $t1 to contents of $t2
la $t1,-100 Load Address : Set $t1 to 16-bit immediate (sign-extended)
la $t1,100 Load Address : Set $t1 to 16-bit immediate (zero-extended)
la $t1,100($t2) Load Address : Set $t1 to sum (of $t2 and 16-bit immediate)
la $t1,100000 Load Address : Set $t1 to 32-bit immediate
la $t1,100000($t2) Load Address : Set $t1 to sum (of $t2 and 32-bit immediate)
la $t1,label Load Address : Set $t1 to label's address
la $t1,label($t2) Load Address : Set $t1 to sum (of $t2 and label's address)
la $t1,label+100000 Load Address : Set $t1 to sum (of label's address and 32-bit immediate)
la $t1,label+100000($t2)Load Address : Set $t1 to sum (of label's address, 32-bit immediate, and
$t2)
85
move $t1,$t2 MOVE : Set $t1 to contents of $t2
mul $t1,$t2,-100 MULtiplication : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits
of the product of $t2 and 16-bit signed immediate (use mfhi to access HI, mflo to access LO)
mul $t1,$t2,100000 MULtiplication : Set HI to high-order 32 bits, LO and $t1 to low-order 32
bits of the product of $t2 and 32-bit immediate (use mfhi to access HI, mflo to access LO)
rem $t1,$t2,$t3 REMainder : Set $t1 to (remainder of $t2 divided by $t3)
rem $t1,$t2,-100 REMainder : Set $t1 to (remainder of $t2 divided by 16-bit immediate)
rem $t1,$t2,100000 REMainder : Set $t1 to (remainder of $t2 divided by 32-bit immediate)
remu $t1,$t2,$t3 REMainder : Set $t1 to (remainder of $t2 divided by $t3, unsigned division)
remu $t1,$t2,-100 REMainder : Set $t1 to (remainder of $t2 divided by 16-bit immediate,
unsigned division)
remu $t1,$t2,100000 REMainder : Set $t1 to (remainder of $t2 divided by 32-bit immediate,
unsigned division)
rol $t1,$t2,$t3 ROtate Left : Set $t1 to ($t2 rotated left by number of bit positions specified in
$t3)
rol $t1,$t2,10 ROtate Left : Set $t1 to ($t2 rotated left by number of bit positions specified in 5bit immediate)
ror $t1,$t2,$t3 ROtate Right : Set $t1 to ($t2 rotated right by number of bit positions specified in
$t3)
ror $t1,$t2,10 ROtate Right : Set $t1 to ($t2 rotated right by number of bit positions specified in
5-bit immediate)
3- Les Directives
.align Align next data item on specified byte boundary (0=byte, 1=half, 2=word, 3=double)
.ascii Store the string in the Data segment but do not add null terminator
.asciiz Store the string in the Data segment and add null terminator
.byte Store the listed value(s) as 8 bit bytes
.data Subsequent items stored in Data segment at next available address
.double Store the listed value(s) as double precision floating point
.end_macro End macro definition. See .macro
.eqv Substitute second operand for first. First operand is symbol, second operand is expression
(like #define)
.extern Declare the listed label and byte length to be a global data field
.float Store the listed value(s) as single precision floating point
.globl Declare the listed label(s) as global to enable referencing from other files
.half Store the listed value(s) as 16 bit halfwords on halfword boundary
.include Insert the contents of the specified file. Put filename in quotes.
.kdata Subsequent items stored in Kernel Data segment at next available address
.ktext Subsequent items (instructions) stored in Kernel Text segment at next available address
.macro Begin macro definition. See .end_macro
.set Set assembler variables. Currently ignored but included for SPIM compatability
.space Reserve the next specified number of bytes in Data segment
.text Subsequent items (instructions) stored in Text segment at next available address
.word Store the listed value(s) as 32 bit words on word boundary
86
Service
print integer
Code in
Arguments
$v0
1
$a0 = integer to print
Result
print float
2
$f12 = float to print
print double
3
$f12 = double to print
print string
4
$a0 = address of null-terminated
string to print
read integer
5
$v0 contains integer read
read float
6
$f0 contains float read
read double
7
$f0 contains double read
read string
8
$a0 = address of input buffer
$a1 = maximum number of
characters to read
See note below table
sbrk (allocate heap
memory)
9
$a0 = number of bytes to
allocate
$v0 contains address of allocated
memory
exit (terminate
execution)
10
print character
11
$a0 = character to print
See note below table
read character
12
print integer in
hexadecimal
34
$a0 = integer to print
Displayed value is 8 hexadecimal
digits, left-padding with zeroes if
necessary.
print integer in
binary
35
$a0 = integer to print
Displayed value is 32 bits, leftpadding with zeroes if necessary.
print integer as
unsigned
36
$a0 = integer to print
Displayed as unsigned decimal value.
50
$a0 contains value of user-chosen
option
$a0 = address of null-terminated
0: Yes
string that is the message to user
1: No
2: Cancel
51
$a0 contains int read
$a1 contains status value
0: OK status
$a0 = address of null-terminated -1: input data cannot be correctly
string that is the message to user parsed
-2: Cancel was chosen
-3: OK was chosen but no data had
been input into field
52
$f0 contains float read
$a1 contains status value
0: OK status
$a0 = address of null-terminated -1: input data cannot be correctly
string that is the message to user parsed
-2: Cancel was chosen
-3: OK was chosen but no data had
been input into field
ConfirmDialog
InputDialogInt
InputDialogFloat
$v0 contains character read
87
Service
InputDialogDouble
InputDialogString
MessageDialog
MessageDialogInt
MessageDialogFloat
Code
in $v0
Arguments
Result
$f0 contains double read
$a1 contains status value
0: OK status
-1: input data cannot be correctly parsed
-2: Cancel was chosen
-3: OK was chosen but no data had been
input into field
53
$a0 = address of nullterminated string that is the
message to user
54
See Service 8 note below table
$a1 contains status value
0: OK status. Buffer contains the input
string.
$a0 = address of null-2: Cancel was chosen. No change to
terminated string that is the
buffer.
message to user
$a1 = address of input buffer -3: OK was chosen but no data had been
input into field. No change to buffer.
$a2 = maximum number of
-4: length of the input string exceeded the
characters to read
specified maximum. Buffer contains the
maximum allowable input string plus a
terminating null.
55
$a0 = address of nullterminated string that is the
message to user
$a1 = the type of message to
be displayed:
0: error message, indicated by
Error icon
N/A
1: information message,
indicated by Information icon
2: warning message, indicated
by Warning icon
3: question message,
indicated by Question icon
other: plain message (no icon
displayed)
56
$a0 = address of nullterminated string that is an
information-type message to
user
$a1 = int value to display in
string form after the first
string
N/A
57
$a0 = address of nullterminated string that is an
information-type message to
user
$f12 = float value to display
in string form after the first
string
N/A
88
Service
MessageDialogDouble
MessageDialogString
Code in
$v0
Arguments
Result
58
$a0 = address of null-terminated string that is an informationtype message to user
N/A
$f12 = double value to display in string form after the first
string
59
$a0 = address of null-terminated string that is an informationtype message to user
N/A
$a1 = address of null-terminated string to display after the
first string
89
EntreeA:
.asciiz
EntreeB:
.asciiz
Quotient: .asciiz
Reste:
.asciiz
reponse: .asciiz
.data
" Entrez la valeur de A"
" Entrez la Valeur de B "
" Le quotient est =\n "
" Le reste =\n "
" Voulez-Vous continuer? tapez Oui"
.text
fait la division entière entre 2 entiers A et B
# Ce programme
main: li $v0,51
la $a0,EntreeA
syscall
move $t1,$a0
li
$v0,51
la
$a0,EntreeB
syscall
move $t2,$a0
div
$t3,$t1,$t2
li
$v0,56
la
$a0,Quotient
move $a1,$t3
syscall
rem
$t4,$t1,$t2
la
$a0,Reste
move $a1,$t4
syscall
li
$v0,50
la
$a0,reponse
syscall
blez $a0,main
li
$v0,10
syscall
90
.data
message1: .asciiz
" A="
message2: .asciiz
" B="
message3: .asciiz
" Le PGDC =\n "
reponse:
.asciiz
" Voulez-Vous continuer? tapez OUI"
.text
# Ce programme determine le PGDC entre 2 entiers A et B
Début:
li $v0,51
la $a0,message1
syscall
move $t1,$a0
li $v0,51
la $a0,message2
syscall
move $t2,$a0
rem $t3,$t1,$t2
boucle: blez $t3,fin
move $t1,$t2
move $t2,$t3
rem $t3,$t1,$t2
j
boucle
fin:
li $v0,56
la $a0,message3
move $a1,$t2
syscall
li $v0,50
la $a0,reponse
syscall
blez $a0,Début
li $v0,10
syscall
91
.data
message: .asciiz
" Donner une valeur de N >= 2 \n"
sortie: .asciiz
" Factoriel de N = N!= "
reponse: .asciiz
"Voulez-vous continuer? tapez Oui"
# Ce programme évalue Factoriel d'un entier N
.text
debut:
li
$v0,51
la
$a0,message
syscall
move $s1, $a0
move
$t1,$a0
bltz
$t1,debut
bltz
$a1,debut
li
$t2,1
sub
$t3,$t1,$t2
blez
$t3,fin
move
$t2,$t1
addi
$t1,$t1,-1
boucle: mul
$t2,$t2,$t1
addi
$t1,$t1,-1
bgtz
$t1, boucle
fin:
li
$v0,56
la
$a0,sortie
move
$a1,$t2
syscall
li
$v0,50
la
$a0,reponse
syscall
blez
$a0,debut
li
$v0,10
syscall
92
entrée: .asciiz
maximum\n"
sortie: .asciiz
reponse: .asciiz
.data
" Donner un Nombre de deux chiffre au
" le nombre inverse est :\n "
"Voulez-vous continuer? Tapez OUI"
.text
#
li $v0,55
#
la $a0,message
#
li $a1,0
#
syscall
debut:
li
$v0,51
la
$a0,entrée
syscall
move
$t1,$a0
move
$t4,$a0
addi
$t2,$t1,-9
blez
$t2,debut
div
$t2,$t1,100
bgtz
$t2,debut
div
$t2,$t1,10
rem
$t3,$t1,10
beq
$t3,$t1 suite
mul
$t4,$t3,10
j
continue
suite:
add
$t4,$t4,$t3
continue: add
$t4,$t4,$t2
li
$v0,56
la
$a0,sortie
move
$a1,$t4
syscall
li
$v0,50
la
$a0,reponse
syscall
blez
$a0,debut
li
$v0,10
syscall
93
lectureA: .asciiz
lectureB: .asciiz
ecritureA: .asciiz
ecritureB: .asciiz
saut:
.asciiz
reponse:
.asciiz
main:
.data
" Tapez une Valeur entière de A"
" Tapez une Valeur entière de B"
" Le PGDC de A et B est = "
" Le PPMC de A et B est = "
"\n"
" Voulez-Vous coontinuer? tapez OUI"
.text
li
$v0,4
la $a0,saut
syscall
li $v0,51
la $a0,lectureA
syscall
move $t1,$a0
li $v0,51
la $a0,lectureB
syscall
move $t2,$a0
mul
$t4,$t1,$t2
rem $t3,$t1,$t2
boucle: blez $t3,fin
move $t1,$t2
move $t2,$t3
rem $t3,$t1,$t2
j
boucle
fin:
li $v0,56
la $a0,ecritureA
move $a1,$t2
syscall
div $t4,$t4,$t2
la $a0,ecritureB
move $a1,$t4
syscall
li $v0,50
la $a0,reponse
syscall
blez $a0,main
li $v0,10
syscall
94
lectureA: .asciiz
lectureB: .asciiz
ecritureA: .asciiz
ecritureB: .asciiz
reponse:
.asciiz
.data
" Tapez une Valeur entière de A"
" Tapez une Valeur entière de B"
" Le PGDC de A et B est \n "
" Le PPMC de A et B est \n "
" Voulez-Vous coontinuer? tapez OUI"
.text
Début:
li $v0,51
la $a0,lectureA
syscall
bltz $a1,Début
# (a1)=-1 ou -2 ou -3 erreur Sur A
beq $a0,$zero,Début # Erreur si A=0
move $t1,$a0
RelireB: li $v0,51
la $a0,lectureB
syscall
bltz $a1,RelireB
# (a1)=-1 ou -2 ou -3 erreur Sur B
beq $a0,$zero,RelireB
# Erreur si B=0
move $t2,$a0
mul
$t4,$t1,$t2
rem $t3,$t1,$t2
boucle:
fin:
blez $t3,fin
move $t1,$t2
move $t2,$t3
rem $t3,$t1,$t2
j
boucle
li $v0,56
la $a0,ecritureA
move $a1,$t2
syscall
div $t4,$t4,$t2
la $a0,ecritureB
move $a1,$t4
syscall
li $v0,50
la $a0,reponse
syscall
blez $a0,Début
li $v0,10
syscall
95
.data
LectureA: .asciiz
" Tapez une Valeur : A= "
LectureB: .asciiz
" Tapez une Valeur : B= "
LectureC: .asciiz
" Tapez une Valeur : C= "
Ecriture0S: .asciiz
" Delta négative : pas de solutions dans R\n "
Ecriture1S: .asciiz
" Racine double: X1 = X2 = -B/(2*A)= \n"
Solution1: .asciiz
" 2 Racines distinctes\n X1 = "
Solution2: .asciiz
" 2 Racines distinctes\n X2 = "
delta:
.asciiz
" delta = "
quatre:
.float
4
Résultat:
.asciiz
" Résultat :\n"
reponse:
.asciiz
" Voulez-Vous continuer? Tapez Oui"
.text
main:
li
$v0,52
la
$a0,LectureA
syscall
bltz $a1,main
mov.s $f1,$f0 # (F1)= A
lectB: la
$a0,LectureB
syscall
bltz $a1,lectB
mov.s $f2,$f0 # (F2)= B
lectC:
la
$a0,LectureC
syscall
bltz $a1,lectC
mov.s $f3,$f0 # (F3)= C
mul.s $f4,$f2,$f2
mul.s $f5,$f1,$f3
la
$t1,quatre
l.s
$f6,($t1)
mul.s $f5,$f5,$f6
sub.s $f4,$f4,$f5
la
$a0,delta
li
$v0,57
mov.s $f12,$f4
syscall
96
j
fin
inf0:
li
$v0,59
la
$a1,Ecriture0S
la
$a0,Résultat
syscall
j
fin
sup0:
add.s $f1,$f1,$f1
li
$t5,0
mtc1 $t5,$f9
sqrt.s $f8,$f4
add.s $f8,$f8,$f2
sub.s $f9,$f9,$f8
div.s $f9,$f9,$f1
mov.s $f12,$f9
li
$v0,57
la
$a0,Solution1
syscall
fin:
sqrt.s $f8,$f4
sub.s $f8,$f8,$f2
div.s $f12,$f8,$f1
li
$v0,57
la
$a0,Solution2
syscall
li
$v0,50
la
$a0,reponse
syscall
blez $a0,main
li
$v0,10
syscall
97