Recursive procedure in MIPS - stack? - recursion

Question

I have to create a procedure eval_expr in MIPS. Basically, it performs basic operations like a calculator, so if an argument in address $a0 is positive then it stores a number, if it is negative, the operation is performed and it can be either:
-80, then addition is performed
-60, then subtraction is performed
-40, then we shift right
-20, then we shift left
$a0 + 4 stores the address of left sub-expression
$a0 + 8 stores the address of right sub-expression
Using pseudo-code, we can write this procedure as:
int eval_expr (expr e) {
if (is_number(e)) {
return e.op;
}
else {
if (e == -80)
return eval_expr(e.left) + eval_expr(e. right);
if (e == -60)
return eval_expr(e.left) - eval_expr(e.right);
if (e == -40)
return eval_expr(e.left) >> eval_expr(e.right);
if (e == -20)
return eval_expr(e.left) << eval_expr(e.right);
}
}
Here's the code I got so far:
eval_expr:
#stack frame
addi $sp $sp -24
sw $ra 4($sp)
sw $fp 8($sp)
addiu $fp $sp 20
#if positive
lw $t1 ($a0)
slti $t0 $t1 0
bne $t0 $zero else
add $v0 $t1 $zero
j destack
#if negative
else:
addi $t3 $zero -20
addi $t4 $zero -40
addi $t5 $zero -60
addi $t6 $zero -80
beq $a0 $t3 sl
beq $a0 $t4 sr
beq $a0 $t5 subs
beq $a0 $t6 addit
sl:
sw $a0 ($sp)
lw $a0 4($a0)
jal eval_expr
lw $a0 ($sp)
sw $v0 12($sp)
lw $a0 8($a0)
jal eval_expr
lw $t0 12($sp)
sllv $v0 $t0 $v0
j destack
sr:
sw $a0 ($sp)
lw $a0 4($a0)
jal eval_expr
lw $a0 ($sp)
sw $v0 12($sp)
lw $a0 8($a0)
jal eval_expr
lw $t0 12($sp)
srlv $v0 $t0 $v0
j destack
subs:
sw $a0 ($sp)
lw $a0 4($a0)
jal eval_expr
lw $a0 ($sp)
sw $v0 12($sp)
lw $a0 8($a0)
jal eval_expr
lw $t0 12($sp)
sub $v0 $t0 $v0
j destack
addit:
sw $a0 ($sp)
lw $a0 4($a0)
jal eval_expr
lw $a0 ($sp)
sw $v0 12($sp)
lw $a0 8($a0)
jal eval_expr
lw $t0 12($sp)
add $v0 $t0 $v0
j destack
#destacking
destack:
lw $a0 ($sp)
lw $ra 4($sp)
lw $fp 8($sp)
addi $sp $sp 24
jr $ra
Unfortunately it only works if the operation performed is shifting left. I think this is because this part of the code is not jumping anywhere (which indicated some sort of problem with stack?), therefore always shifting left is performed.
beq $a0 $t3 sl
beq $a0 $t4 sr
beq $a0 $t5 subs
beq $a0 $t6 addit
Here are all the tests I ran:
Evaluate : (2<<2)
** Test passed ** Expected : 8 Received : 8
Evaluate : (1<<(2+(3-4)))
!! TEST FAILED !! Expected : 2 Received : 1
Evaluate : (((2<<2)+(2<<2))<<((2<<2)+(2<<2)))
!! TEST FAILED !! Expected : 1048576 Received : 2048
Evaluate : ((((1<<(2+(3-4)))<<3)-4)-(((2<<2)+(2<<2))<<((2<<2)+(2<<2))))
!! TEST FAILED !! Expected : -1048564 Received : 128
Evaluate : (((((1<<(2+(3-4)))<<3)-4)-(((2<<2)+(2<<2))<<((2<<2)+(2<<2))))>>5)
!! TEST FAILED !! Expected : -32768 Received : 4096
Evaluate : (((1+2)+((1<<(2+(3-4)))<<3))-(((((1<<(2+(3-4)))<<3)-4)-(((2<<2)+(2<<2))<<((2<<2)+(2<<2))))>>5))
!! TEST FAILED !! Expected : 32787 Received : 1024

Answer 1

All right, if anyone is interested in answer - I was loading only an address, not an actual value (from register $a0). Here's the corrected version of the code:
eval_expr:
#stack frame
addi $sp $sp -24
sw $ra 4($sp)
sw $fp 8($sp)
addiu $fp $sp 20
#if positive
lw $t1 ($a0)
slti $t0 $t1 0
bne $t0 $zero else
add $v0 $t1 $zero
j destack
#if negative
else:
sw $a0 16($sp)
lw $a0 4($a0)
jal eval_expr
lw $a0 16($sp)
sw $v0 20($sp)
lw $a0 8($a0)
jal eval_expr
lw $t0 20($sp)
lw $a0 16($sp)
add $t1 $a0 $zero
lw $a0 ($a0)
addi $t3 $zero -20
beq $a0 $t3 sl
addi $t3 $zero -40
beq $a0 $t3 sr
addi $t3 $zero -60
beq $a0 $t3 subs
addi $t3 $zero -80
beq $a0 $t3 addit
#operations
sl:
sllv $v0 $t0 $v0
j destack
sr:
srav $v0 $t0 $v0
j destack
addit:
add $v0 $t0 $v0
j destack
subs:
sub $v0 $t0 $v0
j destack
#destacking
destack:
lw $a0 ($sp)
lw $ra 4($sp)
lw $fp 8($sp)
addi $sp $sp 24
jr $ra