Architecture Des Ordinateurs (MIPS R3000): C3-Opérateurs arithmétiques et logiques MIPS

CHAP3

Opérateurs arithmétiques et logiques MIPS

Les instructions MIPS sont quasi-implémentées en matériel, mais très peu nombreuses (57 au total). Les pseudo-instructions MIPS remplacent des petites portions de MIPS fréquentes (mais non implémentés dans le matériel), basées sur les instructions réelles du MIPS et utilisent un registre intermédiaire spécifique ($at).

Exemple : li $t0, 0xabcd à ori $t0, $zero, 0xabcd

1 Addition dans l'assembleur MIPS

Il y a 4 opérateurs addition dans l'assembleur MIPS:

add , Les contenus des registres Rs et Rt sont ajoutés pour former un résultat sur 32 bits qui est placé dans le registre Rd. Génération d’une exception si dépassement de capacité.

Syntaxe: add Rd, Rs, Rt
signification: Rd <-- Rs + Rt

R :

000000

00000

100000

addi , La valeur immédiate sur 16 bits subit une extension de signe, et est ajoutée au contenu du registre Rs pour former un résultat sur 32 bits qui est placé dans le registre Rt. Génération d’une exception si dépassement de capacité.

Syntaxe: addi Rt, Rs, Immediate
signification: Rt <- Rs + Immediate

I :

001000

imm16

addu , Addition registre registre non-signée. qui est identique à l'opérateur add, sauf que les valeurs dans les registres sont supposées être des nombres binaires non signés ou entiers. Comme il n'y a pas de valeur négative, les valeurs vont de 0..(2^32)-1.

Syntaxe: addu Rd, Rs, Rt
signification: Rd ← Rs + Rt

R :

000000

00000

100001

addiu , qui est identique à l'opérateur addi, mais là encore, les nombres sont supposés non signés

Syntaxe: addiu Rt, Rs, Immediate
signification: Rt ← Rs + Immediate

I :

001001

imm16

En plus des vrais opérateurs, il y a un certain nombre d'opérateurs pseudo-add , qui sont:

add en utilisant une valeur immédiate de 16 bits. Ceci est un raccourci pour que l'opérateur add implémente un opérateur addi. Le même principe s'applique pour addu si une valeur immédiate est utilisée, et l'opérateur est converti en un addiu. Le format, la signification et la traduction de cette instruction sont:

Syntaxe: add Rt, Rs, Immediate
Signification: Rt ← Rs + Immediate
Traduction: addi Rt, Rs, Immédiat

add, addi, addu ou addiu avec une valeur immédiate 32 bits. Lors de l'examen de cet opérateur, il est important de noter que dans l'instruction de format I, la valeur immédiate ne peut contenir que 16 bits. Donc, si une instruction immédiate contient un nombre nécessitant plus de 16, le nombre doit être chargé en deux étapes. La première étape consiste à charger les 16 bits supérieurs du nombre dans un registre à l'aide de Load Upper Immediate (lui), puis à charger les 16 bits inférieurs à l'aide de ou à l'aide de Or Immediate (ori). L'addition est ensuite effectuée à l'aide de l'opérateur d'ajout d'instruction R. Ainsi, l'instruction:

addi Rt, Rs, Immediat(32 bits)

sera traduit en:

lui $at, Immediat(16 bits sup.) # charger les 16 bits supérieurs du nombre dans $at
ori $at, $at, Immediat(16 bits inf.) # charger les 16 bits inférieurs dans $at
add Rt, Rs, $at

2 Soustraction dans l'assembleur MIPS

La soustraction dans l'assembleur MIPS est similaire à l'addition avec une seule exception. Les sub, subu et subui se comportent comme les opérateurs add, addu et addui. La seule différence majeure avec la soustraction est que le subi est implémenté sous la forme d'une pseudo-instruction, avec la valeur à soustraire chargée dans le registre $at, puis l'opérateur sub (format R) est utilisé.

sub, qui prend la valeur des registres Rs et Rt contenant des entiers, soustrait les nombres et stocke la valeur dans le registre Rd. Génération d’une exception si dépassement de capacité. Le format et la signification sont:

Syntaxe: sub Rd, Rs, Rt
signification: Rd ← Rs - Rt

R :

000000

00000

100010

sub pseudo-opérateur , qui prend la valeur de Rs, soustrait la valeur immédiate(16 bits) de l'instruc-tion et stocke le résultat dans Rt. Le format, la signification et la traduction sont:

format: sub Rt, Rs, Immédiat
signification: Rt ← Rs - Immédiat
traduction: addi $at, $zero, immédiat
sub Rt, Rs, $at

subi pseudo-opérateur , qui prend la valeur de Rs, soustrait la valeur immédiate(16 bits) de l'instruc-tion et stocke le résultat dans Rt. Le format, la signification et la traduction sont:

format: subi Rt, Rs, Immédiat

signification: Rt ← Rs - Immédiat

traduction: addi $at, $zero, immédiat

sub Rt, Rs, $at

subu, opérateur identique à sub, sauf que les valeurs dans les registres sont supposées être des nombres binaires non signés ou entiers. Il n'y a pas de valeurs négatives, les valeurs vont donc de 0..(2^32)-1. Le format et la signification sont les mêmes que ceux de l'opérateur sub au dessus:

format: subu Rd, Rs, Rt

signification: Rd ← Rs - Rt

R :

000000

00000

100011

subiu pseudo-opérateur, identique au pseudo-opérateur subi, mais là encore, les nombres sont supposés non signés:

format: subiu Rt, Rs, Immediate

signification: Rt ← Rs - immédiat
traduction: addi $at, $zero, immédiat
subu Rt, Rs, $at

3 Multiplication dans l'assembleur MIPS

La multiplication et la division sont plus compliquées que l'addition et la soustraction et nécessitent l'utilisation de deux nouveaux registres à usage spécial, les registres hi et lo. Les registres hi et lo ne sont pas inclus dans les 32 registres d'usage général qui ont été utilisés jusqu'à présent et ne sont donc pas directement sous le contrôle du programmeur.

Dans MIPS, toutes les valeurs entières doivent être sur 32 bits. Donc, s’il existe une réponse valide, elle doit figurer dans les 32 bits inférieurs de la réponse. Ainsi, pour mettre en œuvre la multiplication dans MIPS, les deux nombres doivent être multipliés à l’aide de l’opérateur mult et le résultat valide doit être déplacé du registre lo. Ceci est montré dans le fragment de code suivant qui multiplie la valeur dans $t1 par la valeur dans $t2 et stocke le résultat dans $t0.

mult $t1, $t2 # [hi , lo] <- Rs * Rt

mflo $t0 # $t0 ← lo

Les opérateurs de multiplication MIPS examinés sont:

mult, opérateur qui multiplie les valeurs de Rs et Rt et enregistre le résultat dans les registres lo et hi. Le format et la signification de cet opérateur est:

format: mult Rs Rt

signification: [hi, lo] ← Rs * Rt

R :

000000

00000

011000

mflo, opérateur qui déplace la valeur du registre hi dans le registre Rd. Le format et la signification de cet opérateur sont:

format: mflo Rd

signification: Rd <- lo

R :

000000

00000

010010

mfhi, opérateur qui déplace la valeur du registre hi dans le registre Rd. Le format et la signification de cet opérateur sont:

format: mfhi Rd
signification: Rd ← hi

R :

000000

00000

010000

mthi, Copie d’un registre général dans le registre Hi.

format: mthi Rd

signification: Hi <- Rd

R :

000000

00000

010001

mtlo, Copie d’un registre général dans le registre Li.

format: mtlo Rd

signification: Lo <- Rd

R :

000000

00000

010011

mul, pseudo-opérateur qui multiplie (multiplication sans débordement) les valeurs dans Rs et Rt et les stocke dans Rd. Le format et la signification de cet opérateur sont:

format: mul Rd, Rs, Rt
signification: Rd ← Rs * Rt

traduction: mult Rs, Rt

mflo Rd

mulo, pseudo-opérateur qui multiplie les valeurs dans Rs et Rt et les stocke dans Rd, vérifie le débordement. Si un dépassement de capacité se produit, une exception est déclenchée et le programme est arrêté avec une erreur. Le format et la signification de cet opérateur sont:

format: mulo Rd, Rs, Rt

signification: Rd ← Rs * Rt

traduction: mult Rs, Rt

mfhi $at

mflo Rd

sra Rd, Rd,0x000000f1

beq $at, Rd, 0x00000001

break

mflo Rd

Notez que l'opérateurs mul a une implémentation immédiate16 de pseudo-opérateur. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: mul Rd, Rs, immédiat16
signification: Rd ← Rs * Immediate16
traduction: addi $Rd, $zéro, immédiat16
mult Rd, Rs, Rt

4 Division en assembleur MIPS

Dans MIPS, lorsque la division entière est terminée, le registre lo contiendra le quotient et le registre hi contiendra le reste. Cela signifie qu'en arithmétique entière MIPS, lorsque le quotient est extrait du registre bas, les résultats sont tronqués. Si le programmeur veut arrondir le nombre, celui-ci peut être implémenté en utilisant le reste. Maintenant que les bases de la division entière ont été couvertes, deux opérateurs de division MIPS seront examinés:

div, opérateur qui a 3 formats. Le premier format est le seul format réel de cet opérateur. L'opérateur divise Rs par Rt et stocke le résultat dans la paire de registres [hi, lo] avec le quotient dans le bas (lo) et le reste dans le haut (hi). Le format et la signification de cet opérateur sont:

format: div Rs, Rt

signification: [Lo]<-- Rs / Rt

[Ho] <-- Rs % Rt

R :

000000

00000

011010

Le deuxième format de l'opérateur div est une pseudo-instruction. C'est un format à 3 adresses, mais c'est toujours une pseudo-instruction. En plus d'exécuter une instruction de division, cette pseudo-instruction vérifie également une division par zéro. Les détails de la vérification ne seront pas abordés à ce stade, car ils s'agit d'instructions bne et break. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: div Rd, Rs, Rt

signification: [si Rt != 0] Rd <-- Rs / Rt

sinon arrêt

traduction: bne Rt, $ zero, 0x00000001

break

div Rs, Rt

mflo Rd

Le troisième format (immédiat) de l'opérateur div est une pseudo-instruction. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: div Rd, Rs, immédiat

signification: Rd ← Rs / Immediat

traduction: addi $ Rt, $ zéro, immédiat

div Rs, Rt

mflo Rd

divu, division entière et reste non-signé registre avec registre. Le contenu du registre rs est divisé par le contenu du registre rt, le contenu des deux registres étant considéré comme des nombres non signés. Le résultat de la division est placé dans le registre spécial Lo, et le reste dans le registre spécial Hi. Le format et la signification de cet opérateur sont:

format: divu Rs, Rt

signification: [Lo] <-- Rs / Rt

[Ho] <-- Rs % Rt

R :

000000

00000

011011

rem (reste), opérateur qui a 2 formats. Il n'y a que des pseudo formats pour cette instruction. Le premier format de l'opérateur rem est une pseudo-instruction. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: div Rd, Rs, Rt
signification: [si Rt! = 0] Rd <-- Rs% Rt
sinon arrêt
traduction: bne Rt, $zero, 0x00000001
break
div Rs, Rt
mfhi Rd

Le deuxième format (immédiat) de l'opérateur rem est également une pseudo-instruction. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: rem Rd, Rs, immédiat
signification: Rd ← Rs / Immediat
traduction: addi $ Rt, $ zéro, immédiat
div Rs, Rt
mfhi Rd

5 Opérateurs logiques

Les opérateurs logiques couverts sont:

and, opérateur qui a trois formats. Le premier format est le seul format réel de cet opérateur. L'opérateur effectue un ET binaire sur Rs et Rt et stocke le registre de résultat Rd. Le format et la signification de cet opérateur sont:

format: and Rd, Rs, Rt

signification: Rd ← Rs ET Rt

R :

000000

00000

100100

Le second format de l'opérateur and est une pseudo-instruction. Dans ce cas, le 3ème opérateur est une valeur immédiate, il ne s'agit donc que d'un raccourci pour la mise en œuvre de l'opérateur andi. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: and Rt, Rs, immédiat16

signification: Rt ← Rs ET Immédiat16

traduction: andi Rt, Rs, immédiat16

Le troisième format de l'opérateur and est également une pseudo-instruction et est étrange en ce sens que seuls les opérateurs logiques ont ce format. Dans cette instruction, Rs et Rt sont supposés être le même registre et le troisième opérateur est une valeur immédiate. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: and Rs, immédiat16

signification: Rs ← Rs ET Immediate16

traduction: andi Rs, Rs, immédiat16

andi. l'opérateur effectue un ET binaire sur Rs et une valeur immédiate16, et stocke le résultat dans Rt. Le format et la signification de cet opérateur sont:

format: andi Rt, Rs, immédiat16
signification: Rt ← Rs ET Immédiat16

I :

001100

Immediat16

Le raccourci avec un seul registre (pseudo-instruction) s'applique également à andi.

format: andi Rs, immédiat16
signification: Rs ← Rs AND Immediat16
traduction: andi Rs, Rs, immédiat16

or, opérateur qui a trois formats. Le premier format est le seul format réel de cet opérateur. L'opérateur effectue une opération OR par bits de Rs et Rt et stocke le registre de résultat Rd. Le format et la signification de cet opérateur sont:

format: or Rd, Rs, Rt
signification: Rd ← Rs OU Rt

R :

000000

00000

100101

Le second format de l'opérateur or est une pseudo-instruction. Dans ce cas, le 3ème opérateur est une valeur immédiate16 et il ne s'agit donc que d'un raccourci pour la mise en œuvre de l'opérateur ori. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: or Rt, Rs, immédiat16
signification: Rt ← Rs OU Immédiate16
traduction: ori Rt, Rs, Immédiat16

Le raccourci avec un seul registre (pseudo-instruction) s'applique également à l'instruction or.

format: or Rs, immédiat16
signification: Rs ← Rs OU Immédiate16
traduction: ori Rs, Rs, immédiat16

ori, l’opérateur fait un OU un à un de Rs et une valeur immédiate16, et stocke le résultat dans Rt. Le format et la signification de cet opérateur sont:

format: ori Rt, Rs, immédiat16
signification: Rt ← Rs OU Immédiat16

I :

001101

Immediat16

Le raccourci avec un seul registre (pseudo-instruction) s'applique également à l'instruction ori.

format: ori Rs, immédiat16
signification: Rs ← Rs OU Immédiat16
traduction: ori Rs, Rs, Immédiat16

xor, opérateur qui a trois formats. Le premier format est le seul format réel de cette opérateur. L'opérateur effectue une opération OU exclusive par bits de Rs et Rt et stocke le résultat dans Rd. Le format et la signification de cet opérateur sont:

format: xor Rd, Rs, Rt
signification: Rd ← Rs XOR Rt

R :

000000

00000

100110

Le second format de l'opérateur xor est une pseudo-instruction. Dans ce cas la 3ème l'opérateur est une valeur immédiate16, et il ne s'agit donc que d'un raccourci pour la mise en œuvre de l'opérateur ori. Le format, la signification et la traduction des pseudo-opérateurs sont les suivants:

format: xor Rt, Rs, immédiat16
signification: Rt ← Rs XOR Immediat16
traduction: xori rt, rs, immédiat16

Le raccourci avec un seul registre (pseudo-instruction) s'applique également à l'instruction xor.

format: xor Rs, immédiat16
signification: Rs ← Rs XOR Immediat16
traduction: xori Rs, Rs, immédiat16

xori. L’opérateur fait un OU Exclusif un à un de Rs et une valeur immédiate16, et stocke le résultat dans Rt. Le format et la signification de cet opérateur sont:

format: xori Rt, Rs, Immediat16
signification: Rt ← Rs XOR Immediat16

I :

001110

Immediat16

Le raccourci avec un seul registre (pseudo-instruction) s'applique également à l'instruction xori.

format: xori Rs, Immediat16
Signification: Rs ← Rs XOR Immediat16
traduction: xori Rs, Rs, Immediat16

nor, opérateur Non_ou bit-à-bit registre avec registre. Un non_ou bit-à-bit est effectué entre les contenus des registres Rs et Rt Le résultat est placé dans le registre R.

format: nor Rd, Rs, Rt
Signification: Rd ←Rs Non_Ou Rt

R :

000000

00000

100111

not, Pseudo-opérateur fait une inversion (NON) des bits de Rs et stocke le registre de résultat Rt. Le format et la signification de cet opérateur et la traduction des pseudo-opérateurs sont les suivants:

format: not Rt, Rs

Signification: Rs ← NON (Rt)
traduction: nor Rs, Rs, Rs

syscall, Appel à une fonction du système (en mode noyau). Un appel système est effectué, transférant immédiatement, et inconditionnellement le contrôle au gestionnaire d’exception.

Note : par convention, le numéro de l’appel système, c.-à-d. le code de la fonction système à effectuer, est placé dans le registre $V0.

format: syscall
Signification: pcß0x80000080

R :

000000

00000

001100

6 Accès à la mémoire

. Les données statiques sont définies à l'aide de la directive .data assembler. Toute la mémoire allouée dans le programme dans un segment .data est une donnée statique. Le segment de données statique (ou simplement les données) de la mémoire est la partie de la mémoire commençant à l'adresse 0x10000000 et se poursuivant jusqu'à l'adresse 0x10040000. Les éléments de données définis entrent en existence au démarrage du programme et le restent jusqu'à son achèvement. Ainsi, bien que les valeurs de données puissent changer au cours de l'exécution du programme, la taille et l'adresse des données ne changent pas. Lorsque l'assembleur commence à s'exécuter, il garde trace de la prochaine adresse disponible dans le segment de données. Initialement, la valeur du prochain emplacement disponible dans le segment de données est définie sur 0x10010000.

Exemple:

.data

A: .word 0x1234567

.space 14

B: .word 0xFEDCBA98

Un mot (.word) correspond à 4 octets. Par conséquent, l'étiquette A: pointe sur une allocation de 4 octets d'adresse 0x10010000 et allant jusqu'à 0x10010003. La prochaine adresse disponible dans le segment de données est mise à jour pour devenir 0x10010004.

La directive .space met de côté 14 octets, commençant à 0x10010004 et s'étendant à 0x10010011. Il n'y a pas d'étiquette (label) sur cette partie du segment de données, ce qui signifie que le programmeur doit y accéder directement via une adresse. Ceci est valide, mais n’est vraiment pas très utile, en particulier lorsque plusieurs directives .data sont utilisées, car il est difficile de garder la trace de l’adresse suivante.

Enfin, un autre mot mémoire est alloué à l’étiquette B:. Cette mémoire aurait pu être placée à 0x10010012 (18)10, car il s'agit du prochain octet disponible. Cependant, spécifier que cet élément de données est un mot signifie qu'il doit être placé sur une limite de mot. Si l'adresse suivante disponible ne se trouve pas sur une limite de mot lorsqu'une allocation de mot est demandée, l'assembleur passe au mot suivante et l'espace entre les deux est simplement perdu pour le programme c.a.d il est placé à 0x10010014.

Tous les accès mémoire dans MIPS sont effectués via une forme d’operteur "Load" ou "Store". Ces opérateurs incluent le chargement / stockage d'un: octet (lb, sb); demi-mot (lh, sh); mot (lw, sw); ou double mot (ld, sd). L'opérateur de lecture de constante (lui) ne fait pas d’accès mémoire. Dans cette section, seuls les entiers d'un octet seront considérés, donc seuls les opérateurs lb, lbu et sb seront présentés:

lui : opérateur de lecture d’une constante dans les poids forts. La constante immédiate(16bits) est décalée de 16 bits à gauche, et est complétée de zéro. La valeur ainsi obtenue est placée dans Rs.

format: lui Rs, Imm # Rs=BBBBBBBBBBBBBBBB0000000000000000 , B: bites (0 ou 1)
Signification: Rs ← Imm

I :

001111

00000

Immediat16

lb : opérateur de lecture d’un octet signé de la mémoire. L’adresse de chargement est la somme de la valeur immédiate sur 16 bits, avec extension de signe, et du contenu du registre Rs. Le contenu de cette adresse subit une extension de signe et est ensuite placé dans le registre Rt.

format: lb Rt, Imm(Rs) # Rt = SSSSSSSS SSSSSSSS SSSSSSSS BBBBBBBB , S: signe, B: bit
Signification: Rt ← Mémoire [Imm + Rs]

I :

100000

Immediat16

Le deuxième format de lb est un pseudo-opérateur qui permet de stocker l'adresse d'une étiquette (Label) dans Rs, puis l'opérateur réel lb est appelé pour charger la valeur.

format: lb Rt, Label

signification: Rt ← Mémoire [Label]

traduction: lui Rs, 0x10010000

lb Rt, offset (Rs) # offset est le déplacement de la valeur dans le segment de données

lbu : opérateur de lecture d’un octet non-signé de la mémoire. L’adresse de chargement est la somme de la valeur immédiate sur 16 bits, avec extension de signe, et du contenu du registre Rs. Le contenu de cette adresse est étendu avec des zéro et est ensuite placé dans le registre Rt.

format: lbu Rt, Imm(Rs) # Rt = 00000000 00000000 0000000 BBBBBBBB, B: bit

Signification: Rt ← Mémoire [Imm + Rs]

I :

100100

Immediat16

sb: opérateur d'écriture d’un octet en mémoire. L’adresse d’écriture est la somme de la valeur immédiate sur 16 bits, avec extension de signe, et du contenu du registre Rs. L’octet de poids faible du registre Rt est écrit à l’adresse ainsi calculée.

format:sb Rt, Imm(Rs)

signification: Mémoire [Imm+Rs] ← Rt

I :

101000

Immediat16

Le deuxième format de l'opérateur sb est un pseudo-opérateur qui permet à l'adresse d'une étiquette (Label) d'être stockée dans Rs. L'opérateur sb réel est ensuite appelé pour stocker la valeur.

format: sb Rs, Label

signification: Mémoire [Label] ← Rs

traduction: lui Rs, 0x10010000

sb Rt, offset (Rs) # offset est le déplacement de la valeur dans le segment de données

Exemple 1:

# Illustrer l'opérateur d'addition add de format R
li $t1, 100
li $t2, 50
add $t0, $t1, $t2
# illustrer add avec un immédiat. Notez qu'une
# operation add avec une pseudo-instruction
# traduite dans une instruction addi
addi $t0, $t0, 50
add $t0, $t0, 50
# En utilisant un nombre non signé. Notez que le
# résultat n'est pas ce qui est attendu
# pour les nombres négatifs.
addiu $t0, $t2, -100
# addition utilisant un immédiat32. Notez que
# 5647123 base 10 est 0x562b13
addi $t1, $t2, 5647123

Un détail important de cette capture d'écran est la représentation du programme dans deux colonnes. La première colonne est intitulée Source et cette colonne contient le programme exactement tel que vous l'avez entré. La deuxième colonne s'intitule Basic et contient le code source tel qu'il est fourni à l'assembleur. Il y a un certain nombre de changements entre le code source d'origine et le code de base. Tous les codes mnémoniques du registre ont été modifiés pour le code de base. Mais le plus gros changement est que toutes les instructions utilisant des pseudo-opérateurs ont été changées en instructions utilisant un ou plusieurs opérateurs réels.
Par exemple, à la ligne 14, où on a add $t0, $t0, 50, l'opérateur add a été remplacé par l'opérateur addi, comme indiqué dans la section précédente. Il en va de même pour la ligne 22, où l'instruction addi $t1, $t2, 5647123 a été associée à une instructions lui, ori et add (instruction. au format R).
Cette capture d'écran montre que certains opérateurs utilisés dans le chapitre précédent sont en réalité des pseudo-opérateurs. L'opérateur li était suspect car il ne disposait que de 2 paramètres d'adresse, une source et une destination, et il s'avère en réalité ne pas être un véritable opérateur. Il est souvent utile de regarder la colonne Basic dans le simulateur Mars pour voir comment votre source est réellement présentée par l’assembleur.

Exemple 2:

#################################
# Calculer le résultat de 2 * x ^ 3+ 5 * x^2 + 4
#################################
.text
  .globl main
main:
addi $v0, $zero, 4 # Donner une valeur d'entrée
  la $a0, prompt
  syscall

  addi $v0, $zero, 5
  syscall

  move $s0, $v0

  mul $t0, $s0, $s0 # Calcule de 2*x*x*x+5*x+4 et le stocke dans $s1.
mul $t0, $s0, $t0
  mul $t0, $t0, 2
mul $t1, $s0, $s0
  mul $t1, $t1, 5
  add $t0, $t0, $t1
  addi $s1, $t0, 4

addi $v0, $zero, 4 # Imprimer la chaîne de résultat
  la $a0, result
  syscall

  addi $v0, $zero, 1 # Imprimer le résultat
  move $a0, $s1
  syscall

addi $v0, $zero, 10 # Fin du programme
  syscall
#################################
  .data
prompt: .asciiz "\nEntrer une valeur entière: "
result: .asciiz "\nLe résultat est: "

vendredi 9 novembre 2018

C3-Opérateurs arithmétiques et logiques MIPS

CHAP3

Opérateurs arithmétiques et logiques MIPS

1 Addition dans l'assembleur MIPS

2 Soustraction dans l'assembleur MIPS

3 Multiplication dans l'assembleur MIPS

4 Division en assembleur MIPS

5 Opérateurs logiques

6 Accès à la mémoire

Exemple:

Exemple 1:

Exemple 2: