Continuing with the call convention

• Last time we discovered that branch and normal jump are insufficient.
  • We produced this code

    .data
    phrase:		.asciiz "hello world"
    .text
    main:
    	la	$t0, phrase
    	lb	$t1, 0($t0)
    	# next line added after class
    	move	$a0, $t1
    	jal	ToUpper
    	# next line added after class
    	move	$t1, $a0
    	
    loopTop:
    	beq	$t1, $zero, done
    	
    	li	$v0, 11
    	move	$a0, $t1
    	syscall
    	
    	addi	$t0, $t0, 1
    	lb	$t1,0($t0)
    	
    	# next line added after class
    	move	$a0, $t1
    	jal 	ToUpper
    	# next line added after class
    	move	$t1, $a0
    	
    LoopMiddle:
    
            # other code goes here
    	b	loopTop	
    done:
    	li	$v0, 10
    	syscall
    	
    ToUpper:
    	blt	$a0, 97, ToUpperOut
    	bgt	$a0, 122, ToUpperOut
    	addi	$a0, $a0, -32
    ToUpperOut:
    	jr	$ra
    

  • The problem was, branches and jumps could not return to an arbitrary position in the code.
  • JAL and JR did accomplish this.
• But
  • toUpper is an exteremely smiple routine.
  • It has no local variables.
  • It has only one parameter.
  • It uses no registers
  • It calls no other routines.
• What if we want to wanted to do something more complex?
• The answer is the stack.
  • Memory is set up in a standard manner.
    • The text segment is always loaded at address 0x00400000
    • The data segment is loaded at 0x10010000
    • A register called the global pointer points to a place to store global (think static in c/c++) data
    • the stack pointer $sp points to the first available space in high memory
      • Everything above the stack pointer is in use by something else (kernel)
      • The stack pointer is pointing at data we should not mess with.
      • Below the stack pointer is free for our use
      • Until we run into the heap.
    • We will not deal with the heap this semester, but it is where new or malloc allocate memory.
• Managing the stack.
  • Each function has access to the data on the top of the stack.
  • The beginning (or high memory location) is the address contained in the frame pointer $fp
  • The end (or low memory address) is pointed to by the stack pointer.
  • This memory is called the activation record
  • This is where the function stores all temporary values.
• The stack is handeled by
  • Store the current value of the frame pointer at -4 off of the stack pointer.

    sw	$fp, -4(sp)
    addiu	$fp, $sp, -4
    	 

  • Next store any registers which need to be preserved across the call
    • $s*
    • $ra
  • We don't need to store the current $sp, since it is calculated from the current $fp.
  • Say we are going to make a function call, and we wish to use $s0 and $s1
    • We will need to store $ra, since the function call will overwrite it.
    • We will also possibly need to store $a*, if they hold parameters we need. Assume $a0 and $a1
    • We will definately need to store $s9 and $s1
    • So store
      • ra at $fp-4
      • a0 at $fp-8
      • a1 at $fp-12
      • s0 at $fp-16
      • s1 at $fp-20

        	sw	$ra,  -4($fp)
        	sw	$a0,  -8($fp)
        	sw	$a1, -12($fp)
        	sw	$s0, -16($fp)
        	sw	$s1, -20($fp)
        

    • Finally adjust the stack pointer to point at the last address in use in this frame.

      	addui	$sp, $fp, -20
      

  • Once we are finished with the routine, we need to restore everything
    • really just reverse this process.

      	sw	$ra,  -4($fp)
      	sw	$a0,  -8($fp)  # but only if needed
      	sw	$a1, -12($fp)  # but only if needed
      	sw	$s0, -16($fp)
      	sw	$s1, -20($fp)
      	addiu	$sp, $fp, 4
      	lw	$fp, -4($sp)
      	jr	$ra
      

  • In between there may be a need to store more items in the activation record.
    • Any local variables
    • If a function call is made and $t* need to be saved.
    • Additional parameters or return values for a function call.