.text main: sub $sp, $sp, 8 move $fp, $sp sw $a0, 8($fp) sw $a1, 4($fp) # Simulation sauvegarde FP, RA sub $sp, $sp, 8 # Allocation des variables locales sub $sp, $sp, 0 # Appel a la fonction run--------------------- # On alloue la place pour le resultat sub $sp, $sp, 0 # On calcule les arguments # On calcule l'argument # A0 <- 30 li $a0, 30 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal run # On restaure SP add $sp, $fp, 4 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ li $v0, 10 syscall print: li $v0, 1 syscall li $v0, 4 la $a0, newline syscall jr $ra putchar: li $v0, 11 lw $a0, 4($fp) syscall add $sp, $sp, 16 jr $ra sbrk: li $v0, 9 lw $a0, 4($fp) syscall add $sp, $sp, 16 sw $v0, 0($sp) jr $ra add: # Allocation des variables locales sub $sp, $sp, 0 # On returne ---------------- # On compile le renvoi ------------- # Calcul de l'expression à gauche # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 12($fp) jr $ra lw $a0, 0($sp) sw $a0, 12($fp) jr $ra div: # Allocation des variables locales sub $sp, $sp, 4 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Calcul de l'expression à gauche # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 8192 li $a0, 8192 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul mul $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # On returne ---------------- # On compile le renvoi ------------- # Calcul de l'expression à gauche # Calcul de l'expression à gauche # Calcul de t------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de t-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de l'expression à gauche # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 2 li $a0, 2 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul div $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul div $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 12($fp) jr $ra lw $a0, 0($sp) sw $a0, 12($fp) jr $ra inside: # Allocation des variables locales sub $sp, $sp, 0 # On returne ---------------- # On compile le renvoi ------------- # Appel a la fonction iter--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 0 li $a0, 0 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 0 li $a0, 0 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 0 li $a0, 0 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal iter # On restaure SP add $sp, $fp, 24 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ lw $a0, 0($sp) sw $a0, 12($fp) jr $ra lw $a0, 0($sp) sw $a0, 12($fp) jr $ra iter: # Allocation des variables locales sub $sp, $sp, 8 # If-then-else ====================== # On calcule le test # Calcul de l'expression à gauche # Calcul de n------------------------- # Calcul de l'adresse add $a0, $fp, 20 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de n-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 100 li $a0, 100 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul seq $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On cherche le test en memoire, il se fera ecraser plus tard lw $a0, 0($sp) # Si A0 = 0, i.e. si faux, on va a l0 beqz $a0, l0 # Sinon, on effectue then --------------- # On returne ---------------- # On compile le renvoi ------------- # A0 <- 1 li $a0, 1 sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 24($fp) jr $ra # On saute apres le else b l1 # Le else -------------------- l0: l1: # Fin If-then-else ====================== # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xn------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xn-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de xn------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xn-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -12 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de yn------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de yn-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de yn------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de yn-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # If-then-else ====================== # On calcule le test # Calcul de l'expression à gauche # Appel a la fonction add--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xn2------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xn2-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de yn2------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de yn2-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal add # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ sub $sp, $sp, 4 # Calcul de l'expression à droite # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 4 li $a0, 4 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul sgt $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On cherche le test en memoire, il se fera ecraser plus tard lw $a0, 0($sp) # Si A0 = 0, i.e. si faux, on va a l2 beqz $a0, l2 # Sinon, on effectue then --------------- # On returne ---------------- # On compile le renvoi ------------- # A0 <- 0 li $a0, 0 sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 24($fp) jr $ra # On saute apres le else b l3 # Le else -------------------- l2: l3: # Fin If-then-else ====================== # On returne ---------------- # On compile le renvoi ------------- # Appel a la fonction iter--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de l'expression à gauche # Calcul de n------------------------- # Calcul de l'adresse add $a0, $fp, 20 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de n-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de a------------------------- # Calcul de l'adresse add $a0, $fp, 16 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de a-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de b------------------------- # Calcul de l'adresse add $a0, $fp, 12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de b-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction add--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction sub--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xn2------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xn2-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de yn2------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de yn2-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal sub # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de a------------------------- # Calcul de l'adresse add $a0, $fp, 16 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de a-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal add # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction add--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 2 li $a0, 2 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xn------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xn-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de yn------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de yn-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de b------------------------- # Calcul de l'adresse add $a0, $fp, 12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de b-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal add # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal iter # On restaure SP add $sp, $fp, 24 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ lw $a0, 0($sp) sw $a0, 24($fp) jr $ra lw $a0, 0($sp) sw $a0, 24($fp) jr $ra mul: # Allocation des variables locales sub $sp, $sp, 4 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Calcul de l'expression à gauche # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul mul $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # On returne ---------------- # On compile le renvoi ------------- # Calcul de l'expression à gauche # Calcul de l'expression à gauche # Calcul de t------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de t-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de l'expression à gauche # A0 <- 8192 li $a0, 8192 sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 2 li $a0, 2 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul div $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 8192 li $a0, 8192 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul div $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 12($fp) jr $ra lw $a0, 0($sp) sw $a0, 12($fp) jr $ra of_int: # Allocation des variables locales sub $sp, $sp, 0 # On returne ---------------- # On compile le renvoi ------------- # Calcul de l'expression à gauche # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 8192 li $a0, 8192 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul mul $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 8($fp) jr $ra lw $a0, 0($sp) sw $a0, 8($fp) jr $ra run: # Allocation des variables locales sub $sp, $sp, 28 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de l'expression à gauche # A0 <- 0 li $a0, 0 sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 2 li $a0, 2 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul sub $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -12 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -16 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction div--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction sub--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xmax------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xmax-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de xmin------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xmin-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal sub # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de l'expression à gauche # A0 <- 2 li $a0, 2 sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de steps------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de steps-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul mul $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal div # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -20 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de l'expression à gauche # A0 <- 0 li $a0, 0 sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul sub $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -24 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -28 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction div--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction sub--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de ymax------------------------- # Calcul de l'adresse add $a0, $fp, -24 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de ymax-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de ymin------------------------- # Calcul de l'adresse add $a0, $fp, -20 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de ymin-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal sub # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de steps------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de steps-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal div # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Calcul de i------------------------- # Calcul de l'adresse add $a0, $fp, -32 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de i-------------------- # Allocation des variables locales sub $sp, $sp, 0 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -32 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # A0 <- 0 li $a0, 0 sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # While ================================== b l5 # Le corps de la boucle ----------------- l4: # Allocation des variables locales sub $sp, $sp, 0 # Allocation des variables locales sub $sp, $sp, 8 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction add--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de ymin------------------------- # Calcul de l'adresse add $a0, $fp, -20 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de ymin-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de i------------------------- # Calcul de l'adresse add $a0, $fp, -32 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de i-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de deltay------------------------- # Calcul de l'adresse add $a0, $fp, -28 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de deltay-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal add # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # Calcul de j------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de j-------------------- # Allocation des variables locales sub $sp, $sp, 0 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -12 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # A0 <- 0 li $a0, 0 sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # While ================================== b l7 # Le corps de la boucle ----------------- l6: # Allocation des variables locales sub $sp, $sp, 0 # Allocation des variables locales sub $sp, $sp, 4 # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -8 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Appel a la fonction add--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de xmin------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de xmin-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Appel a la fonction mul--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Appel a la fonction of_int--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de j------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de j-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal of_int # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de deltax------------------------- # Calcul de l'adresse add $a0, $fp, -16 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de deltax-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal mul # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal add # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # If-then-else ====================== # On calcule le test # Appel a la fonction inside--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- # On avance sub $sp, $sp, 4 # On calcule l'argument # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, -8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal inside # On restaure SP add $sp, $fp, 12 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On cherche le test en memoire, il se fera ecraser plus tard lw $a0, 0($sp) # Si A0 = 0, i.e. si faux, on va a l8 beqz $a0, l8 # Sinon, on effectue then --------------- # Appel a la fonction putchar--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 48 li $a0, 48 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal putchar # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # On saute apres le else b l9 # Le else -------------------- l8: # Appel a la fonction putchar--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 49 li $a0, 49 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal putchar # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ l9: # Fin If-then-else ====================== # Incrementation droite ============== # On calcule n et on le met sur SP # Calcul de j------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de j-------------------- # On decale SP add $sp, $sp, -4 # On fait n=n+1 (osef du resultat) # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -12 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Calcul de l'expression à gauche # Calcul de j------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de j-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # On jette le resultat de n=n+1 a la poubelle add $sp, $sp, 4 # Fin incrementation droite ============== # Fin du corps de la boucle ------------ # Le test l7: # Calcul de l'expression à gauche # Calcul de j------------------------- # Calcul de l'adresse add $a0, $fp, -12 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de j-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de l'expression à gauche # A0 <- 2 li $a0, 2 sw $a0, 0($sp) sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de steps------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de steps-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul mul $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul slt $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On charge le test en memoire lw $a0, 0($sp) bnez $a0, l6 # Fin du While ========================== # Appel a la fonction putchar--------------------- # On alloue la place pour le resultat sub $sp, $sp, 4 # On calcule les arguments # On calcule l'argument # A0 <- 10 li $a0, 10 sw $a0, 0($sp) # On avance sub $sp, $sp, 4 # On sauvegarde FP et RA sw $fp, 0($sp) sw $ra, -4($sp) # On place FP et SP move $fp, $sp sub $sp, $sp, 8 # On appelle la fonction jal putchar # On restaure SP add $sp, $fp, 8 # On restaure RA et FP lw $ra, -4($fp) lw $fp, 0($fp) # Fin appel ------------------------------------------------ # Incrementation droite ============== # On calcule n et on le met sur SP # Calcul de i------------------------- # Calcul de l'adresse add $a0, $fp, -32 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de i-------------------- # On decale SP add $sp, $sp, -4 # On fait n=n+1 (osef du resultat) # Affectation e1=e2 ------------------------- # Calcul de l'adresse de e1 add $a0, $fp, -32 sw $a0, 0($sp) # Decalage sub $sp, $sp, 4 # Calcul de e2 # Calcul de l'expression à gauche # Calcul de i------------------------- # Calcul de l'adresse add $a0, $fp, -32 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de i-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # A0 <- 1 li $a0, 1 sw $a0, 0($sp) # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul add $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # Chargement de l'adresse de e1 lw $s0, 4($sp) # Copie de e2 a l'adresse indiquee4 lw $a0, 0($sp) sw $a0, 0($s0) # Dernier decalage : on revient add $sp, $sp, 4 # Copie de e1 sur SP lw $a0, -4($sp) sw $a0, 0($sp) #-------------------------------------------- # On jette le resultat de n=n+1 a la poubelle add $sp, $sp, 4 # Fin incrementation droite ============== # Fin du corps de la boucle ------------ # Le test l5: # Calcul de l'expression à gauche # Calcul de i------------------------- # Calcul de l'adresse add $a0, $fp, -32 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de i-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de steps------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de steps-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul slt $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) # On charge le test en memoire lw $a0, 0($sp) bnez $a0, l4 # Fin du While ========================== jr $ra sub: # Allocation des variables locales sub $sp, $sp, 0 # On returne ---------------- # On compile le renvoi ------------- # Calcul de l'expression à gauche # Calcul de x------------------------- # Calcul de l'adresse add $a0, $fp, 8 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de x-------------------- sub $sp, $sp, 4 # Calcul de l'expression à droite # Calcul de y------------------------- # Calcul de l'adresse add $a0, $fp, 4 sw $a0, 0($sp) # Chargement de l'adresse en memoire lw $s0, 0($sp) # Copie de la variable sur le sommet de la pile lw $a0, 0($s0) sw $a0, 0($sp) # Fin du calcul de y-------------------- # On les charge dans A0 et A1 lw $a1, 0($sp) add $sp, $sp, 4 lw $a0, 0($sp) # Calcul sub $a0, $a0, $a1 # On met le résultat sur la pile sw $a0, 0($sp) lw $a0, 0($sp) sw $a0, 12($fp) jr $ra lw $a0, 0($sp) sw $a0, 12($fp) jr $ra .data newline: .asciiz "\n"