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