CS255 Syllabus

The `call` and `jmpl` instruction of SPARC

The "call" and "jmpl" (jump and link) instructions in SPARC is the equivalent of M68000's "bsr" (or "jsr") and "rts".
The "call" and "jmpl" instructions are like branching instructions in that they will alter the execution flow.
As such, they suffer from the same "delay branching" phenomenom observed in the branching instruction.
So when you program in SPARC, follow every "call" and "jmpl" instructions with a nop instruction to avoid executing an extra instruction unintentially (will cause a lot of hadache to track down this bug...)

The "call" and "jmpl" instructions are use to perform the following functions in a function call:

  Code in Java/C/C++:
  ============================================================

  main(...)              ---->  int func(int x, int y, int z)
  {			/	{
     ...	       /	   ...
     ...	      /		   ...
     r = func(a, b, c)		   return(value);
     ^                          }           |
     |  			            |
     +--------------------------------------+
     ...
  }


  Assembler code in SPARC:
  ============================================================

  main:  ...			     func: + Save frame pointer of 
	 ...				       my caller
 	 ... 				   + Obtain my own copy of
	 Put parameters in 	               local registers
	   Output registers                + Allocate space on stack
	 Call func			   ....
                                 	   .... (function body)
 	 Assign return value to		   ....
	   its destination
 	 ... 				   Pass return value in 
					     an input register
					   + Return local registers
					   + Deallocate locaL
					     variables from stack
					   + Restore frame pointer 
					     of my caller
					   Return to my caller

The "call" instruction:

 Syntax:
	  call  Label
	  xxx
	  yyy

 Effect:
	  1. "Pass" the return address (the value in the PC)
	     in output register o7
	  2. Load PC with the destination address of the call
	     (address associated with "Label")

 NOTE: the instruction "xxx" following "call Label" will be executed
       before SPARC can make the jump to "Label"
       Thus: always put a nop instruction after the "call" instruction

 NOTE: the return address stored in o7 is the address of
       the call Label instruction !

Similarities between "call" in SPARC and "bsr" in M68000
The "call" instruction of SPARC is similar to the "bsr" or "jsr" instruction of M68000:
- Both "call" and "bsr" passes the return address to the called function.
  - M68000's "bsr" instruction passes the return address using the program stack (just like the parameters on the stack !)
  - SPARC's "call" instruction passes the return address using the output register o7 (just like the parameters using output registers o0, o1, etc !)
Difference between "call" in SPARC and "bsr" in M68000
There is one important different between the "call" instruction of SPARC the "bsr" or "jsr" instruction of M68000:
```
 Suppose we have a call/bsr instruction located at address 5000 
 in memory:

      M68000				SPARC
      =================			==================
      ....				....
 5000 bsr Label			   5000	call Label
 5004 xxx			   5004 xxx
      yyy			   5008 yyy

 
```
- The "bsr" instruction of M68000 will pass (push) the return address of the instruction that follows "bsr Label" on the program stack, i.e., "bsr Label" will push the return address 5004 on the program stack
- The "call" instruction of SPARC will pass the address of the "call Label" as return address in output register o7, i.e., "call Label" will pass 5000 inside register o7 !
The reason for doing this is beyond the sope of this class, it is related to "instruction abortion" and "instruction redo" techniques used in "interrupt handling".
The bottom line is: SPARC has the ability to return to different places from a function call.
When a function returns back to the caller in M68000, it would return to the instruction "xxx" that is after the "bsr Label".
But because the instruction "xxx" following the "call Label" have been executed by SPARC before it could branch to "Label", the "normal" return location is not the instruction "xxx" following the "call Label" instruction, but the instruction "yyy" !
Notice that the address of the instruction "yyy" is 8 more than the address of the "call Label" instruction.
The value "8" will be very significant in the "return from subroutine" instruction - discussed next....

The "jmpl" instruction:

The "jmpl" (jump and link) instruction is a very powerful instruction that - among other things - can be used in a function/subroutine to return to its caller
There are 2 forms, one uses a constant and the other a register.

Let us first look at the syntax of the "jmpl" instruction and what it does:

 Syntax:
	  jmpl  %r1 + constant, %r3     jmpl  %r1 + %r2, %r3
	  xxx				xxx
	  yyy				yyy

 Effect:
	  1. Store the return address in register %r3
	  2. Load PC with the (destination) address "r1 + constant"
	     or "r1 + r2"

 NOTE: the instruction "xxx" following "jmpl" will be executed
       before SPARC can make the jump to address "r1 + constant" or
       address "r1 + r2"
       Thus: always put a nop instruction after the "jmpl" instruction

 NOTE: if you use for register r3 the output register o7,
       then the "jmpl" instruction will store the return address
       in the same place as the call instruction !
       (In other words, you can use "jmpl" to replace the "call"
	instruction - if you so desire)

How to return from a subroutine/function to the caller.
- Fact: the caller using "call ...." will deposit a return address that is equal to the address of the call instruction in memory in output register o7 (see details above where the "call" instruction was discussed).
- Fact: you want to return to the address given in register o7 plus 8 - see here: click here
- Fact: although the return address was deposited in output register o7, the function could move the window down and the return address could thus be stored in input register i7....
- The instruction to return to the caller will depend on which register contains the return address.
  - If the output register o7 contains the return value, then the instruction:
```
   jmpl  %o7 + 8, %g0
 
```
    is used to load "o7 + 8" into the Program Counter (PC) to return to the caller.
  - On the other hand, if the input register i7 contains the return value, then the instruction:
```
   jmpl  %i7 + 8, %g0
 
```
    is used to load "i7 + 8" into the Program Counter (PC) to return to the caller.
Here is a demo program showing the effect of CALL and JMPL: click here
Here is a demo program showing a simple call and return sequence: click here

The call and jmpl instruction of SPARC

The `call` and `jmpl` instruction of SPARC