• often have one or more input parameters
• often return a value

• If a function returns a value, then that is also the very last action that the function will do.

 Example:

    main()                 int func(int x, int y)
    {			   {
       int a, b;	      ....
			      ....
       func(a, b);	      ....
    }			   }

 Assembler code:

   main:  xxxxx          ->  func:  xxxxx
	  xxxxx         /
	  xxxxx        /
	  xxxxx       /
	  xxxxx      /
	  BSR func -
	  xxxxx
 

Because the "BSR func" will make the CPU jump to the first instruction in the function "func", you must pass the parameters (if any) to the function "func" BEFORE the "BSR func" instruction

 Example:

    main()                 int func(int x, int y)
    {			   {
       int a, b;	      ....
			      ....
       func(a, b);	      ....
    }			   }
 

• The caller function main passes two parameters (a and b) to the callee function func
• In high level programming laguage terminology:
  • The value of the actual parameters (a & b) are copied to the formal parameters (x & y)
• In assembler level, things are done quite differently....
• The ultimate goal is to instruct the callee function to work with a specific set of input values.
• This is achieved by:
  • Having the caller function main and the callee function func agree on a common location where to find the parameters

• Prior to writing the caller function main and the callee function func, you must first fix (= agree) on the location to pass each parameter
• When you write the caller function main in assembler, before the BSR func instruction, you must copy (= pass) the values of the actual parameters to the locations that you have fixed previously.
• When you write the callee function func in assembler, each time the code needs the value of some parameter variable, you must go get it from the previously fixed location.

• Same principle as passing parameter
• Caller and callee must agree on a fixed location for the callee to return the value
• Note that the caller can (and should) immediately save the returned value in one of its (caller's) local variables, or else the return value may be overwritten and lost !

    main()                 int func(int x, int y)
    {			   {
       int a, b, c;	      return (x*x + y*y);
       int i, j, k;        }  

       c = func(a, b);	      
       k = func(i, j);
    }			   

  func() has 2 parameters and 1 return value

  Agreement:  parameter 1 in register D0
	      parameter 2 in register D1

	      return value in register D7

  The asembler program will look like this:

   main:
	 MOVE.L a, D0  (pass a through D0)
	 MOVE.L b, D1  (pass b through D1)
	 BSR    func   ----------------------------+
                                                   |
	 MOVE.L D7, c                              |
						   |
						   |
         MOVE.L i, D0  (pass i through D0)         |
         MOVE.L j, D1  (pass j through D1)         |
	 BSR    func   -------------------------+  |
					        |  |
	 MOVE.L D7, k                           V  V
				    func: (func(x,y))
				           MULS  D0, D0  (Use the input parameters
					   MULS  D1, D1   put in the agreed locations)
					   ADD.L D1, D0   ** D0 = x^2 + y^2

					   MOVE.L D0, D7 (put return value
							  in previously
							  agreed location)
					   RTS
 

• Prog file: click here

How to run the program:

Right click on link and save in a scratch directory To compile:   as255 subroutine1 To run: use          m68000

This technique (using registers to pass parameters only work for one-level of subroutine call It fails will more than 1 level: If A( ) calls B( ) (and B( ) uses registers to pass its parameters) and then B( ) calls another function C( ) (and C( ) uses also uses registers to pass its parameters) then: Subroutine C( ) will erase the values stored in registers by subroutine B( ) !!!!! (because if you call enough functions deep enough, you will use up all registers sooner or later....)