1. Calling Procedures C calling conventions

2. Outline Procedures Procedure call mechanism Passing parameters Local variable storage C-Style procedures Recursion

3. Procedures defined Procedures perform specific frequently used tasks They can be repeatedly called from different places in your program These are essentially the same thing as functions and subroutines in high-level languages Procedures may have inputs/outputs, both, either, neither Essentially just labeled blocks of assembly language instructions with a special return instruction

4. Procedures prime directive Procedures should never alter the contents of any register that the procedure isn’t explicitly expected to modify If for example, if a proc is expected to return a value in EAX, it is required for it to modify EAX All other registers should appear unchanged Push them at the beginning and pop them at the end

5. Call Call does two things –It pushes the address of the instruction immediately following the call statement onto the stack –It loads the instruction pointer with the value of the label marking the beginning of the procedure you’re calling (this is essentially an unconditional jump to the beginning of the procedure

6. Passing parameters Using registers –Registers are the ultimate global variables –Your procedure can simply access information placed in specific registers –Also a simple way for your procedure to send data back to the caller –The procedure and any code that calls it must agree on where it will find its inputs and where it will put its output –This agreement is termed a “calling convention” –Many calling conventions are possible…

7. Passing parameters Using global memory locations –Memory locations declared at the beginning of your program are global and can be accessed from any procedure Using a parameter block –You may pass a pointer to an array or other type of memory block instead of an individual data value When calling (or being called by) code compiled from another language, your assembly code must conform to that language’s calling conventions!

8. Passing parameters in “C” Using the stack –Caller pushes all arguments expected by the proc onto the stack (in reverse order, push last argument first) –Proc can access these arguments directly from the stack by setting up the stack frame. push ebp ; save previous value of ebp mov ebp, esp ; mark start of stack frame arg1 is at [ebp+8] assuming call has pushed IP onto stack

9. Example ;call proc to calculate area of right triangle. ;proc expects two word sized args to be on the stack push 3 push 4 call TriangleArea ;now we must remove the variables from the stack ;every push must be popped. add esp, 4 ; ax now contains 6 (the result returned by TriangleArea)

10. Example continued y equ ebp+8;define [ebp+8] = y x equ ebp+12;define [ebp+12] = x TriangleArea: push ebp; save caller’s stack frame mov ebp, esp; start our own stack frame push edx; save edx so we can use it mov eax, [y]; fetch y mul double [x]; multiple by x shr eax, 1; divide by two pop edx; restore edx movesp, ebp; collapse the stack pop ebp; restore caller’s stk frame ret; return to caller

11. What just happened… 1C 18 14 10 C 8 4 0 ESP 3 Saved EBP 4 Return IP pushd 3 pushd 4 call TriangleArea TriangleArea push ebp mov ebp, esp push edx mov eax, [ebp+8] mul double [ebp+12] shr eax, 1 pop edx movesp, ebp pop ebp ret add esp, 4 Saved EDXESP Stack frame EBP

12. Local variable storage You may allocate stack space for use as local variables within procedures Subtract from the stack pointer the number of bytes you need to allocate after setting up the stack frame At the end of your procedure, just add the same amount you subtracted to free the memory you allocated just before you pop bp In the procedure, use the stack frame to address local variable storage

13. Local variable storage MyProc ;setup stack frame push ebp mov ebp, esp ;allocate space for two words sub esp, 4;access words at [ebp-4] and [ebp-8] … add esp, 4;destroy local variables (not needed) mov esp, ebp; restore caller’s stack pointer pop ebp;restore original ebp ret

14. Things to remember Always make sure that your stack is consistent (a proc doesn’t leave information on the stack that wasn’t there before the procedure executed) Always remember to save registers you modify that don’t contain return values

15. C-style procedures Assembly procedures that can be called by C programs Must follow the same calling procedure that C compilers use when building C programs You can also call C functions from assembly programs using the same protocol

16. C style procedures Suppose a C program calls an assembly procedure as follows –Proc1(a, b, c) Assume each argument is word-sized Further, assume the C compiler generates code to push a, b, and c onto the stack The assembly language procedure must be assembled with the correct ret (near or far) and stack handling of its procedures matching the corresponding values in the high-level module

17. C style procedures C compilers push arguments in reverse order, from right to left. –C is pushed first, then B, then A –Lowest index from EBP corresponds to first argument EBP+20 EBP+16 EBP+12 EBP+8 EBP+4 EBP a c b Return IP Saved EBP Proc1(a, b, c)

18. C style procedures If the returned value needs four or fewer bytes, it is by default returned in registers –one or two bytes - returned in AX –three or four bytes – returned in EAX (in 32-bit mode) More than four bytes –the called procedure stores data at some address and returns the address in EAX

19. C style procedures Caller is responsible for clearing the arguments from the stack as soon as it regains control after the call –this done by the compiler which generates an add to the ESP register to pop the arguments without moving any data –a far procedure called from C should end with RETF instead of RET

20. Example Calling an ASM proc from a C program – the proc lets you display a string at a given row and column #include extern void placeStr(char * s, unsigned int row, unsigned int col); void main(void) { intn; for (n = 10; n < 20; ++n) placeStr (“This is the string”, n, 45); }

21. Example (note: this is in 16 bit mode) global placeStr section.text placeStr: ; setup stack frame and save state PUSHBP MOVBP, SP PUSHAX PUSHBX PUSHDX ; get current page - returns in BH MOVAH, 0fh INT10h ; read unsigned args 2 and 3 MOVDL, [BP+10] MOVDH, [BP+8] ;set cursor position MOV AH, 02h INT 10h ;point to string MOV BX, [BP+6] ;call outAsc to disp string call outAsc ;restore state POP DX POP BX POP AX MOV SP, BP POP BP RETF

22. Putting the two together The C module must be compiled The assembly language module assembled The pair must be linked together into an executable Extern in C is exactly the same as Extern in assembly programs

23. Recursion Recursion: procedure calls itself RecursiveProc: DECAX JZQuitRecursion CALLRecursiveProc QuitRecursion: RET Requires a termination condition in order to stop infinite recursion Many recursively implemented algorithms are more efficient than their iterative counterparts

24. Recursion example Factorial: ; Input AX = CX = Value ; Output AX = Value ! DEC CX ;Test for base case CMP CX,0 JE FactDone IMUL CX ; Recurs Call Factorial FactDone: RET Stack contents Assume: AX = CX = 4 Return IP Iteration 1 CX = 4; AX = 4 Return Iteration IP 2 CX = 3; AX = 12 Return Iteration IP 3 CX = 2; AX = 24 Return Iteration IP 4 CX = 1; AX = 24

25. Recursion Recursion must maintain separate copies of all pertinent information (parameter value, return address, local variables) for each active call, all on the stack Recursive routines can consume a considerable amount of stack space In general, you will not know the depth to which recursion will take you