Recursive problems converting C code to MIPS Exponentiation - mips

Question

I'm trying to do exponentiation with recursion, I'm struggling with the recursive part as it's getting stuck in an infinite loop. I'm just confused as to why it's getting stuck in the loop with power and even. Odd hasn't been started I was planning on reusing some of the code from even to get me started on odd.
C code
/* Prompt user for two non-negative integers. Raised the first to the
power of the second and print it. */
#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
/* Is the parameter even? */
int is_even (int n);
/* Return a*b. */
int multiply (int a, int b);
/* Return a^b. */
int power (int base, int exponent);
int
main ()
{
int base, exponent;
printf ("Please enter non-negative base: ");
scanf ("%d", &base);
printf ("Please enter non-negative exponent: ");
scanf ("%d", &exponent);
if (base == 0 && exponent == 0)
{
printf ("Can't raise 0 to zero power.\n");
exit (0);
}
int result = power (base, exponent);
printf ("%d^%d=%d\n", base, exponent, result);
}
/* Determine if a non-negative number is even by inspecting
the least-significant bit. A leaf procedure. */
int
is_even (int n)
{
if ((n & 0x1) == 0)
{
return TRUE;
}
return FALSE;
}
/* Multiply the parameters together by repeated addition. A leaf
procedure. */
int
multiply (int a, int b)
{
int result = 0;
while (a > 0)
{
result += b;
a--;
}
return result;
}
/* Calculate b raised to the power of a recursively. */
int
power (int b, int e)
{
int even_exponent, temp, result;
/* Base case of the recursion: exponent is 0. */
if (e == 0)
{
return 1;
}
/* There are two recursive cases. First, determine whether
the exponent is even or odd. */
even_exponent = is_even (e);
if (even_exponent)
{
/* Even case. */
temp = power (b, e / 2);
result = multiply (temp, temp);
}
else
{
/* Odd case. */
temp = power (b, (e - 1) / 2);
result = multiply (b, temp);
result = multiply (result, temp);
}
return result;
}
MIPS code
power:
#If exponent $s1 is equal to zero returns 1 as result
beq $s1,$zero,expoZero
addi $t0,$t0,1
jal checkEven
#if base is even go to even
beq $s2,$zero,even
beq $s2,$t1,odd
#if base is odd go to odd
addi $sp, $sp, 4
lw $ra, 0($sp)
checkEven:
#Check if exponent is even or odd
addi $sp, $sp, -8
sw $ra, 4($sp)
sw $s1, 0($sp)
andi $s2,$s1,0x1
lw $s1, 0($sp)
lw $ra, 4($sp)
addi $sp, $sp 8
jr $ra
expoZero:
#returns 1
li $s3, 1
jr $ra
even:
addi $sp, $sp, -4
sw $ra,0($sp)
#if the base is even it performs a^(b/2)*a^(b/2)
srl $s1,$s1,1 #$s1/2
jal power
move $s4,$v0
move $a0,$s4
move $a1,$s4
jal multiply
#returns result
addi $s3, $s3, 1
addi $sp, $sp, 4
lw $ra,0($sp)
jr $ra
odd:
#if the base is odd it performs a*a^((b-1)/2)*a^((b-1)/2)
#returns result
addi $s3, $s3, 1
jr $ra
multiply:
addi $sp, $sp -24
sw $ra, 20($sp)
sw $s0, 16($sp)
sw $s1, 12($sp)
sw $s2, 8($sp)
sw $s3, 4($sp)
sw $s4, 0($sp)
#set result equal to zero
move $s3,$zero
#test for a > 0
slt $t2,$a0,$zero #a < 0
loop:
#while (a<0)
beq $t2,$zero,exit
add $s3,$s3,$a1 #result += b
addi $a0,$a0,-1 #a--
j loop
exit:
lw $s4, 0($sp)
lw $s3, 4($sp)
lw $s2, 8($sp)
lw $s1, 12($sp)
lw $s0, 16($sp)
lw $ra, 20($sp)
addi $sp, $sp, 24
j power

Answer 1

I'd try something like this:
int pow(int const x, unsigned const e)
{
int const y(e % 2 ? x : 1);
//int const y(((x ^ 1) & -(e % 2)) ^ 1);
return !e ? 1 : 1 == e ? x : pow(x * x, e / 2) * y;
}
Shouldn't be too hard to convert to MIPS.
Godbolt made this:
pow(int, unsigned int):
b $L4
li $2,1 # 0x1
$L9:
beq $5,$0,$L6
nop
beq $5,$3,$L3
li $6,1 # 0x1
$L10:
mult $2,$6
srl $5,$5,1
mflo $2
nop
nop
mult $4,$4
mflo $4
$L4:
andi $3,$5,0x1
beq $3,$0,$L9
li $3,1 # 0x1
bne $5,$3,$L10
move $6,$4
$L3:
mult $4,$2
mflo $2
j $31
nop
$L6:
li $4,1 # 0x1
mult $4,$2
mflo $2
j $31
nop
See? Recursion was optimized away by the compiler.