Procedures in more detail - PowerPoint PPT Presentation

callum-brooks
procedures in more detail n.
Skip this Video
Loading SlideShow in 5 Seconds..
Procedures in more detail PowerPoint Presentation
Download Presentation
Procedures in more detail

play fullscreen
1 / 34
Download Presentation
Procedures in more detail
235 Views
Download Presentation

Procedures in more detail

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Proceduresin more detail

  2. Procedures • Why use procedures? • Code reuse • More readable code • Less code • Microprocessors (and assembly languages) provide only minimal support for procedures • Must build a standard form for procedures 2

  3. Procedures • Procedure call • { . • . • x = larger (a, b); • . • . • } • Procedure header and parametersint larger (int x, int y) • Procedure body{ • if (x > y) • bigger = x; • else • bigger = y; • return (bigger); • } 3

  4. Procedures • Steps in the execution of the procedure: • Save return address • Procedure call • Execute procedure • Return • What is the return address? • What is the procedure call? • What is the return? • MAL uses registers rather than variables for return address 4

  5. Procedures • Modern load/store architectures (MIPS, Sparc) have a Jump and Link instruction: jal procedure_name • Places the address of the instruction following the jal call into $RA ($31) • $31 is an arbitrary (and common) choice made at architecture time • Why isn’t the register used within the instruction call? jal $31, procedure_name #INVALID CODE • Branches (jumps) to the address given by the label (procedure_name) 5

  6. Procedures The example becomes: jal proc1 # use of $ra is implied . . jal proc1 . . proc1: # 1st instruction of procedure here . . jr $ra # $ra is the alias for $31 6

  7. Nested Procedures What happens if a procedure calls another procedure(nesting) using jal? jal proc1 . . jal proc1 . proc1: . jal proc2 . jr $ra proc2: . . jr $ra 7

  8. Nested Procedures Even more exciting, what happens if a procedure calls itself (recursion)? jal proc1 . . jal proc1 . . proc1: . . jal proc1 . . jr $ra 8

  9. Nested Procedures • Must save return address as generated • Unknown how many to save • Needed in reverse order of saved • Use a … 9

  10. System Stack A stack is so frequently used for procedure call/return, that many computer systems predefine a system stack. 10

  11. System Stack • The system stack is for dynamic data (vs static, known before runtime) • Return addresses • Saving registers to move other data into register bank (“spilling”) • Local variables – several instances may be defined at once with multiple calls • Dynamic memory allocation • The system stack is very large • In a multi-user environment, how many system stacks are there? 11

  12. System Stack • The MIPS system stack is defined to grow towards a smaller address • very common implementation • The stack pointer points to an empty location at the top of the stack • The stack pointer is $sp ($29) • It is defined and initialized before program execution begins • If $sp ($29) is used for any other purpose, the stack is pointer is lost. • This would be bad, very bad!! 12

  13. System Stack Memory Smaller address yourprogramhere Grows towards smaller addresses systemstack here Largeraddress 13

  14. System Stack • push, in MAL: • sw $?, ($sp) # the $? is replaced by some register • sub $sp, $sp, 4 # contains the data to be pushed • Or • sub $sp, $sp, 4 • sw $?, 4($sp) • pop, in MAL: • add $sp, $sp, 4lw $?, ($sp) • Or • lw $?, 4($sp) • add $sp, $sp, 4 • Which forms are better if there is an interrupt that usesthe same stack? 14

  15. System Stack • Often a procedure pushes/pops many things. • add $sp, $sp, -4 • sw $s2, 4($sp) • add $sp, $sp, -4 • sw $s3, 4($sp) • add $sp, $sp, -4 • sw $s4, 4($sp) • But we do not need to change $sp each time. • add $sp, $sp, -12 • sw $s2, 12($sp) • sw $s3, 8($sp) • sw $s4, 4($sp) • Can do this for the pop as well 15

  16. System Stack: Saving Return Addresses jal doit ... jal doit ... doit: sub $sp, $sp, 4 #push return address sw $ra, 4($sp) ... ... jal another #overwrites $ra ... lw $ra, 4($sp) #pop return address add $sp, $sp, 4 jr $ra 16

  17. System Stack: Saving Return Addresses • Note how every pop has a push. • Never leave a procedure without popping everything that was pushed. • Always match up your pushes and pops. 17

  18. Parameter Passing • Parameter = Argument • There is even less architectural support for parameter passing • Need to create a convention 18

  19. Parameter Passing • Follow the convention • Follow the convention carefully • Follow the convention consistently • Never change the convention once defined • Place data in a specific parameter location • Both the calling program and the procedure need to know where the parameters are. • Procedure may place return values there. 19

  20. Parameter Passing • Call by value (C, C++) • The parameter passed may not be modified by the procedure. • This can be implemented by passing a copy of the value. • The procedure can modify the value (copy) passed to it, but the value is not changed outside the scope of the procedure. • Call by reference (Fortran, C/C++ &, Pascal var) • The parameter passed to the subroutine can be modified. • The modification is seen outside the scope of the subroutine. • Similar to having access to global variable. 20

  21. Parameter Passing • Simplest method: Use registers • The calling program puts the parameter(s) into specific registers, and the procedure uses them. • . • . • move $s4, $s2 # put parameter in register $s4 • jal decrement • move $s2, $s4 # copy parameter back to its # correct place • . • . • decrement: • add $s4, $s4, -1 • jr $ra • Why not just use $s2 within the procedure? 21

  22. Parameter Passing Another method: Use system Stack • When there aren’t enough registers for all parameters, use the system stack in something called an activation record (AR). • Used for all parameters in machines with few registers. • eg. HC11, 6502, 8086, … 22

  23. Parameters on system stack • sub $sp, $sp, 8 # allocate space for parameters • sw $s2, 8($sp) # place parameter 1 into AR of proc • sw $s3, 4($sp) # place parameter 2 into AR of proc • jal proc • . • proc: • sub $sp, $sp, 12 # allocate remainder of AR for proc • # assume fixed size (too big) # activation record • lw $t0, 20($sp) # retrieve parameter 1 • lw $t1, 16($sp) # retrieve parameter 2 • # use parameters in procedure calculations • add $sp, $sp, 20 # remove AR of proc • jr $ra 23

  24. Parameters on system stack • Calling program • Allocate space for parameters • Places parameters into stack • Calls procedure • Procedure: • Allocates AR (or remainder of AR) • De-allocates AR of procedure (or at least most of it) • MIPS convention • The first 4 parameters are passed in register • The alias for $4-$7 is $a0-$a3. • The first parameter is passed in $a0. • Space for all parameters passed in $a0-$a3 is allocated in the procedure’s AR. 24

  25. MIPS Convention If there are nested subroutine calls, and registers $a0-$a3 are used for parameters, the values would be lost procA: #receives 3 parameters in $a0, $a1, $a2 … # set up procB’s parameters move $a0, $t0 # overwrites procA’s parameter in $a0 move $a1, $t1 # overwrites procA’s parameter in $a1 jal procB # the nested procedure call # procA continues after procB returns # procA’s passed parameters are needed, but have been # overwritten Solutions… 25

  26. MIPS Convention • Need to expand on the MIPS convention to now preserve the argument registers also • Caller • Place parameters in $a0 to $a3 • jal procedure • Procedure • Allocate remainder of AR and push $ra • Procedure calculations 26

  27. MIPS Convention Procedure continued… • To call proc2 • Place current parameters ($a0-$a3) into AR • Set up parameters to proc2 in $a0-$a3 • Call proc2 (jal proc2) • Copy any return values out of $v0-v1, $a0-$a3 • Restore current parameters from AR back to $a0-$a3 • More procedure calculations • Get procedure’s return address from AR • De-allocate AR • Return (jr $ra) 27

  28. Summary: Parameter Passing Styles • Use registers • Advantages • Disadvantages • Use some registers, and place the rest on the stack • Advantages • Disadvantages • Put all parameters on the stack (an unsophisticatedcompiler might do this) • Advantages • Disadvantages • Put parameters in memory set aside for them • Advantages • Disadvantages 28

  29. Register Spilling • When in a procedure may need to use registers that are already being used, what to do? • Callee saved • A procedure clears out some registers for its own use • Register values are preserved across procedure calls • MIPS calls these saved registers: $s0-$s8 (aliases for$16-$23, $30) • The called procedure • Saves register values in its AR, • Uses the register for local variables, • Restores register values before it returns. 29

  30. Register Spilling • Caller Saved • The calling program saves the registers that it doesnot want a called procedure to overwrite • These register values are NOT preserved across procedure calls • MIPS calls these temporary registers: $t0-$t9(aliases for $8-$15, $24-$25) • Procedures use these registers for local variables • The values do not need to be preserved outside thescope of the procedure. • How about $v0-$v1, and $a0-$a3? 30

  31. Procedure Calls From the compiler’s point of view, a procedure call looks like: call setup procedure call return cleanup . procedure: prologue . calculations . epilogue 31

  32. MIPS Procedure Calls • The full MIPS convention includes… • Call Setup • Save any callee-save registers that are currently in use • Place current parameters into current stack frame • Allocate space for all parameters for procedure to becalled • Change $sp by the total parameter size • Place first 4 parameters to procedure into $a0-$a3 • Place remaining parameters on stack • Procedure Call • jal 32

  33. MIPS Procedure Calls • Prologue • Allocate space for remainder of stack frame • Save return address in stack frame • Copy needed parameters from stack frame into registers • Save any needed save registers into current stack frame • Epilogue • Restore (copy) return address from stack frame into $ra • Restore any saved registers • De-allocate stack frame (or most of it) • Move $sp so the space for the procedure’s frame is gone • Return Cleanup • Copy needed return values and parameters from $v0-$v1,$a0-$a3, or stack frame to correct places • De-allocate remainder of procedure’s stack frame • Move $sp so the space for the procedure’s frame is gone • Restore any saved registers from call setup 33

  34. Summary: Procedure Calls • Minimal ASM support • Need formal and consistent mechanism • Why? • Activation record includes • Return addresses • parameters • Save registers • Saved arguments • … • Caller must… • Callee must… 34