Opérations mathématiques

Tous les calculs ont lieu entre registres. Une instruction arithmétique nomme d'abord la destination, suivie des deux sources qu'elle lit : signifie dest = src1 + src2.

Opération arithmétique

t2, t0, t1←add

add place t0 + t1 dans t2.

Les deux lignes qui entrent par la gauche sont t0 et t1, toujours dans cet ordre. Elles entrent dans la même forme quel que soit l'opérateur en cours : addition, soustraction, multiplication, division ou reste. Deux valeurs entrent, une opération a lieu, et un résultat sort dans t2 à droite. nomme t2 en premier car c'est là que le résultat atterrit, ce qui correspond à l'unique règle d'ordre que suit chaque instruction arithmétique de cette leçon.

Addition et soustraction

prend les nombres contenus dans deux registres et stocke leur somme dans un troisième. fait de même pour la soustraction : calcule t0 - t1. Les deux instructions lisent uniquement depuis des registres.

Enregistrer l'arithmétique

add t2, t0, t1 # t2 = t0 + t1
sub t2, t0, t1 # t2 = t0 - t1

Une chose à savoir : un registre ne contient que 32 bits, il y a donc un plafond. Si un résultat est trop grand pour tenir, aucune erreur n'est levée. La valeur revient silencieusement à des nombres très bas et l'exécution continue. Les valeurs du quotidien n'atteindront pas cette limite, mais le plafond vaut la peine d'être connu.

Pour utiliser un nombre fixe à la place d'un second registre, ajoutez la lettre i, qui signifie immédiat : ajoute la constante 1. Il n'y a pas de subi, donc pour soustraire une constante, vous ajoutez une constante négative : .

💡

ajoute une constante. ajoute deux registres. Confondre les deux est l'erreur de débutant la plus courante.

Multiplication et division

multiplie deux registres. les divise en nombres entiers et jette la fraction, donc 7 / 2 donne 3. donne le reste, donc 7 % 2 donne 1. La division ne provoque jamais de plantage. Diviser par zéro renvoie -1.

Multiplier, diviser, reste

mul t2, t0, t1 # t2 = t0 * t1
div t2, t0, t1 # t2 = t0 / t1 (entier)
rem t2, t0, t1 # t2 = t0 % t1 (reste)

Assemblage

Additionner deux nombres et afficher le résultat

li t0, 7
li t1, 5
add t1, t0, t1 # t1 = 7 + 5 = 12
mv a0, t1 # le service d'affichage lit a0
li a7, 1
ecall
li a7, 10
ecall

charge 7 dans t0. charge 5 dans t1. les additionne et écrit 12 dans t1. copie le résultat dans a0, car le service d'impression lit toujours sa valeur depuis a0. Ensuite sélectionne le service d'impression d'entier et l'exécute. Enfin, et terminent le programme.

Bonus : la multiplication par décalage

Quand le facteur est une puissance de deux, une méthode plus rapide que existe. (décalage logique à gauche) déplace les bits d'un registre vers la gauche, et chaque position décalée double la valeur : décaler de 1 pour multiplier par 2, de 2 pour 4, de 3 pour 8. Le décalage coûte moins cher que la multiplication, donc les compilateurs l'utilisent souvent.

Multiplier par 8 à l'aide de décalages

li t0, 5 # commence avec 5
 # décalage à gauche de 3 bits (5 * 2^3 = 5 * 8)
sll a0, t0, 3 # a0 = 40
li a7, 1 # afficher un entier
ecall
li a7, 10
ecall

met 5 dans t0. décale ses bits de trois positions vers la gauche. Chaque position double la valeur, donc 5 double trois fois (5, 10, 20, 40), donnant 40 dans a0. Le reste suit le schéma d'impression précédent. Essayez de changer le 3 en 1 ou 2 et prédisez le résultat avant de l'exécuter.

Multiplier par décalage

5sll a0, t0, 0

×2 →

10sll a0, t0, 1

×2 →

20sll a0, t0, 2

×2 →

40sll a0, t0, 3

5 décalé à gauche de 0 bits reste 5.

Les huit cases sont la forme binaire du nombre au-dessus d'elles, un bit chacune, lues de gauche à droite comme d'habitude. Décaler toute la ligne d'une position vers la gauche est la même opération que multiplier par 2, car déplacer un chiffre d'une position vers la gauche dans n'importe quelle base multiplie sa valeur par cette base. Le binaire n'a que deux chiffres, donc le multiplicateur est 2. Décaler trois fois cumule cela en une multiplication par 8, ce qui correspond à ce que fait au nombre 5.

Ouvrir dans Litessera Lux, l'assembleur RISC-V Offrez-moi un café