CSE1303 Computer Science
Semester 3 (summer), 2003
Part B
Lecture B15 notes: Functions (part 2)

/* A function that gets called. */

int power(int b, int e)
{
    int result = 1;

    /* Keep going while exponent
       is positive. */
    while (e > 0)
    {
        /* Multiply by base. */
        result = result * b;

        /* less to multiply. */
        e--;
    }

    /* Return the result
       to the caller. */
    return result;
}

power:  # Save $ra and $fp.
        subu $sp, $sp, 8
        sw $ra, 4($sp)
        sw $fp, 0($sp)

        # Copy $sp to $fp
        move $fp, $sp

        # Alloc local variables.
        # 1 * 4 = 4 bytes.
        subu $sp, $sp, 4

        # Initialize locals.
        li $t0, 1
        sw $t0, -4($fp)  # result

        # Now we are inside
        # the function body. 

loop:   # Stop if e <= 0.
        lw $t0, 12($fp)  # e
        ble $t0, 0, end

        # result = result * b
        lw $t0, -4($fp)  # result
        lw $t1, 8($fp)  # b
        mul $t0, $t0, $t1
        sw $t0, -4($fp)  # result

        # e--
        lw $t0, $t0, 12($fp)  # e
        sub $t0, $t0, 1
        sw $t0, $t0, 12($fp)  # e

        # Repeat loop.
        j loop

end:    # Now ready to return.

        # Return result in $v0.
        lw $v0, -4($fp) # result

        # Remove local var.
        addu $sp, $sp, 4

        # Clean up stack
        lw $fp, 0($sp)
        lw $ra, 4($sp)
        addu $sp, $sp, 8

        # Return to caller.
        jr $ra

/* C program which calls a
   function. */

#include <stdio.h>
#include <stdlib.h>

int power(int b, int e);

int main()
{
    int base;
    int exp;
    int result;

    scanf("%d", &base);
    scanf("%d", &exp);

    result = power(base, exp);

    printf("%d", result);

    exit(0);
}

        .text
main:   # 3 * 4 = 12 bytes local
        move $fp, $sp
        subu $sp, $sp, 12

        li $v0, 5
        syscall
        sw $v0, -12($fp)  # base

        li $v0, 5
        syscall
        sw $v0, -8($fp)  # exp

        # Call function.
        # push 2 * 4 = 8 bytes
        # of arguments
        subu $sp, $sp, 8

        # arg 1 = base
        lw $t0, -12($fp)  # base
        sw $t0, 0($sp)  # arg 1

        # arg 2 = exp
        lw $t0, -8($fp)  # exp
        sw $t0, 4($sp)  # arg 2

        # Call power function
        jal power

        # Remove arguments, they
        # are no longer needed.
        # 2 * 4 = 8 bytes.
        addu $sp, $sp, 8

        # Store return value
        # in result.
        sw $v0, -4($fp)  # result

        # Print result.
        li $v0, 1
        lw $a0, -4($fp)  # result
        syscall

        li $v0, 10    # exit
        syscall

/* Main program to call
   factorial function. */

#include <stdlib.h>
#include <stdio.h>

int factorial(int p);

int main()
{
    int n;

    scanf("%d", &n);

    printf("%d", factorial(n));

    exit(0);
}

        .text
main:   # 1 * 4 = 4 bytes local.
        move $fp, $sp
        subu $sp, $sp, 4

        li $v0, 5
        syscall
        sw $v0, -4($fp)  # n

        # Call factorial.
        # 1 * 4 = 4 bytes arg.
        subu $sp, $sp, 4
        lw $t0, -4($fp)  # n
        sw $t0, 0($sp)  # arg 1
        jal factorial
        # Clear argument.
        addu $sp, $sp, 4
        move $a0, $v0 # returned
        li $v0, 1   # print int
        syscall

        li $v0, 10   # exit
        syscall

/* The factorial function. */

int factorial(int p)
{
    int result;

    if (p <= 1)
    {
        /* Base case. */
        result = 1;
    }
    else
    {
        /* Recursive case. */
        result =
            factorial(p-1) * p;
    }

    return result;
}

factorial:   # Function entry.
        subu $sp, $sp, 8
        sw $ra, 4($sp)
        sw $fp, 0($sp)
        move $fp, $sp
        # 1 * 4 = 4 bytes local.
        subu $sp, $sp, 4

        # if (p <= 1) ...
        lw $t0, 8($fp)  # p
        bgt $t0, 1, rec

        # result = 1
        li $t0, 1
        sw $t0, -4($fp)  # result
        j end

rec:    # Recursive call.
        # 1 * 4 = 4 bytes arg.
        subu $sp, $sp, 4

        # argument 1 = p 1
        lw $t0, 8($fp)  # p
        sub $t0, $t0, 1  # p-1
        sw $t0, 0($sp)  # arg 1

        jal factorial

        # Clean up argument.
        addu $sp, $sp, 4

        # Multiply by p.
        lw $t0, 8($fp)  # p
        mul $t0, $v0, $t0
        # Store result.
        sw $t0, -4($fp)  # result

end:    # return result
        lw $v0, -4($fp)  # result

        # Destroy local variable.
        addu $sp, $sp, 4

        # Function exit.
        lw $fp, 0($sp)
        lw $ra, 4($sp)
        addu $sp, $sp, 8
        jr $ra