CODEWITHSUNDEEP
mips
jstnchng
jstnchng

Reputation: 1

How does a program written in MIPS knows what to return?

I have this program I just wrote:

countzeroes:

    li      $v0, 0  # count = 0
    li      $t0, 0  # int i = 0
    li      $v1, 1  # compare bit = 1

cz_loop:

    bge     $t0, 32, cz_exit # exit loop if i >= 32
    andi    $t1, $a0, 1 # bit = arg0 & 1
    beq     $t1, $v1, cz_skip # skip if bit = 1
    addi    $v0, $v0, 1 # adds 1 to count

cz_skip:

    srl     $a0, $a0, 1 # shifts input right by 1
    add     $t0, $t0, 1 # i++

    j       cz_loop

cz_exit:

    jr      $ra

Pretty simple, just computes the number of zeroes in a 32 bit word. I was wondering how the program knows how to return $v0 at the end? I know v0 and v1 are return registers, but I was wondering if those two are always returned. If not, how does the program know to return v0?

In addition, I know jr $ra jumps to the return address- but what does that mean?

Thanks for your help.

Upvotes: 0

Views: 1565

Answers (2)

Jordan
Jordan

Reputation: 27

In MIPS there are three different jumps you'll see. j, jr & jal.

j: it is considered an unconditional jump. Simply just do:

j function

jr:aka jump to register. Exactly as the name sounds you jump to register. This is when you have a register already saved somewhere in your program you want to jump back to. It will usually look like so:

jr $ra

$ra being the register which had been previously set aside before your jal (see below) which will jump the program back to that address.

jal: aka Jump and link copies the address of the next instruction into the register and then jumps to the address label. In other words, both jal and jr are used in conjunction with each other mainly for going to functions which are usually placed after the exit calls.

Ex:

main:
        #program
        jal function
        #continue with program
    function:
        #
        #do something
        #
        jr $ra

Also, most helpful site when I started learning: http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

Some other quick hints that I wish someone told me when I started:

  • Always start with "main:"
  • Be wary of the difference between high/low registers in multiplying and dividing integers
  • Always keep track of your registers because with so many $s and $t and $f and $p and $a and $v registers working at one time things can get messy very quickly.

Upvotes: 2

kevinkl3
kevinkl3

Reputation: 961

"how the program knows how to return $v0 at the end?"

It doesn't know, you're writing the "return" value in $v0, in fact you could return the "result or return values" in any available register such as the temporals, it's just a convention to use the $v0 register to return values (in MIPS).

"I was wondering if those two are always returned"

Remember that in any subroutine in your program you always have access to all registers, so there's not "restriction" about what register store values that can be semantically called "return values", so I could easily create a method that returns 3 numbers in $t0, $t1, $t2 but that's my choice, you can return values in the stack also, there are a lot of possibilities, and this depends and lays down on the good programming practices and also the calling conventions, here you can find the MIPS calling convention: https://courses.cs.washington.edu/courses/cse410/09sp/examples/MIPSCallingConventionsSummary.pdf

" jr $ra jumps to the return address- but what does that mean?"

The program is executed instruction by instruction(the program has an instruction pointer aka program counter), when you call a subroutine the address of the next instruction is being stored in the $ra register, then when you make jr $ra, the program execution returns to that address (the instruction pointer gets the value of $ra).

Upvotes: 2

Related Questions