Xuan Guo. CSC 3210 Computer Organization and Programming Georgia State University. March 31, Lecture XX: Subroutines (3) Xuan Guo

Transcription

1 CSC 3210 Computer Organization and Programming Georgia State University March 31, 2015

2 This lecture Plan for the lecture: Recap: Subroutine Linkage Arguments to subroutines More arguments to subroutines Return Values Leaf Subroutines Pointers as arguments Examples

3 Save & restore After save instruction %o6 (%sp) becomes %i6(%fp). save %sp, -96, %sp subtracts 96 from the current stack pointer but saves the result in the new stack pointer, leaving the old stack pointer unchanged. The old stack pointer becomes the new frame pointer restore instruction restores the register window set. restores the registers from the stack. restore is also an add instruction.

4 Subroutine Linkage (1) In SPARC,two instructions for linking to subroutine which save the address of calling instruction in %o7. return is to the address pointed by %o inside the subroutine, since o7 is mapped to i7, the return is made to %i7+8.

5 Subroutine Linkage (2) The SPARC architecture supports two instructions, call and jmpl, for linking to subroutines

6 jmpl Instruction Used when the address of the subroutine is computed and not known address is loaded into a register subroutine address is the sum of the source arguments, and the address of the jmpl instruction is stored in the destination register jmpl reg rs1, reg rs2 / constant, reg rd. always followed by a delay slot instruction to call a subroutine whose address is in register %o0 and to store the return address into %o7, we would write: jmpl %o0, %o7

7 Call Instruction If the subroutine name is known at assembly time, the call instruction may be used It stores %pc contents to %o7 call label or %register (points address) Transfers control to that address, and stores the address of call into %o7. call %o0 is expanded as jmpl %o0, %o7 always followed by a delay slot instruction

8 ret instruction The call to subroutine is: call subr nop And at the entry of the subroutine subr: save %sp, %sp with the return ret restore The ret is expanded to: jmpl %i7 + 8, %g0

9 Arguments to Subroutines (1) Placing arguments in stack, In, SPARC first 6 arguments can be placed in the out registers. Only 6 out registers are available since %o6 is stack pointer and %o7 is used for storing calling address. After save instruction the arguments will be available to subroutine in %i0-%i5

10 Arguments to Subroutines (2) 64 bytes for saving 16 registers starting at %sp 4 bytes for structure return pointer at %sp bytes for 6 arguments starting at %sp Pointer == Address additional arguments may be placed on stack starting at %sp + 92 and can be accessed by the called subroutine at %fp + 92 Stand format for writing subroutine:.global subroutine_name: subroutine_name: save %sp, -( more_args + local ) & -8, %sp where local variables for called subroutine (callee) are accessed at %fp local_var_offset

11 where passed arguments for called subroutine (callee) are accessed at %fp + arguments_offset

12 Subroutines with more than 6 arguments (1) The arguments offsets are logically defined as define(struct_s, 64) define(arg1_s, 68) define(arg2_s, 72) define(arg3_s, 76) define(arg4_s, 80) define(arg5_s, 84) define(arg6_s, 88) in terms of a macro argd: define(struct_s, 64) define(arg_d, `eval($1 * 4 +struct_s) ) define(a8_s, arg_d(8)) define(a7_s, arg_d(7)) ld [%fp + a8_s], %o0

13 Subroutines with more than 6 arguments (2) May be stored in stack The calling subroutine must make enough space for the extra arguments arg7_offset = 92 arg8_offset = arg7_offset + 4.global main main: save %sp, (-92-8)&-8, %sp /** int foo(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { return a1+a2+a3+a4+a5+a6+a7 +a8; } **/ mov 70, %l0 st mov 20, %l0 call foo st %l0, [%sp + arg7_offset] %l0, [%sp + arg8_offset]

14 Subroutines with more than 6 arguments (3) /** int foo(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { return a1+a2+a3+a4+a5+a6+a7+a8; } **/ arg7_offset = 92 arg8_offset = arg7_offset + 4 foo: %l0.global foo save %sp, -96, %sp!load 7th and 8th arguments ld [%fp+arg7_offset], add %l0, %i0, %i0 ld [%fp+arg8_offset], %l0 add %l0, %i0, %i0 ret restore main:.global main save %sp, (-92 - arg8_offset)&-8, %sp mov 70, %l0 st mov 20, %l0 call foo st %l0, [%sp + arg7_offset] %l0, [%sp + arg8_offset]

15 Return Values Functions are subroutines which return a value In SPARC, the return value is always returned in an out register, e.g. %o0, i.e. %i0 of called program We have to put the return value in the corresponding in" register before executing restore instruction Consider the.mul routine we pass arguments to the routine using %o0 and %o1 and then expect the result to be passed back into %o0 this means the routine places the result into %i0 before returning

16 Leaf Subroutines Subroutines that do not call any other subroutines Can be made efficient by working on same register sets of the parent subroutine. register use should be restricted to %o0 - %o5, %g0, %g1. Does not require restore or save Return to parent is to %o7 + 8 instead of %i7 + 8 foo:.global foo!does not need save!save %sp, -96, %sp!load 7th and 8th arguments ld [%sp+arg7_offset], %o1 add %o1, %o0, %o0 ld [%fp+arg8_offset], %o1!add %o1, %o0, %o0 retl add %o1, %o0, %o0 retl is expanded as jmpl %o7 + 8, %g0 ret is expanded as jmpl %i7 + 8, %g0

17 Pointers as arguments swap(int *a, int *b) { int temp ; temp = *a; *a = *b; *b = temp; } a_offset = -4; b_offset = -8; main:.global main save %sp, (-92+b_offset)&-8, %sp mov 5, %o0 st %o0, [%fp + a_offset]; mov 7, %o1 st %o1, [%fp + b_offset]; add %fp, a_offset, %o0 call swap add %fp, b_offset, %o1 mov 1, %g1 ta 0 swap:.global swap ld [%o0], %o2 ld [%o1], %o3 st %o3, [%o0] retl st %o2, [%o1]

18 Examples (1) The figure below shows a set of 128 registers and 24 of them mapped as in, local and out. Show the mapping after 4 save and 2 restore instructions. You have to show the positions for new in, local and out registers, the new positions for cwp and wim.

19 Example (2) bonus Assuming you need 9 arguments (word type) to be passed to a subroutine that you are calling from main, and you need memory space for the following variables in main. What is the total size of stack required for the main subroutine? int a, b short c char d

20 Example (3) Write a subroutine to swap the lower half of register with its upper half. Use it in the main routine with example value 0x1234ABCD (Hint: put any constant > 4095 to a register, you can use set value, reg rd )