1 / 47

Chapter 6 Procedures

Chapter 6 Procedures. 6.1 The 80x86 Stack. Hardware Stack. Allocated with directive, for example .STACK 4096 allocates 4096 uninitialized memory bytes Visual Studio project setting can also be used to allocate stack space Most access is indirect, through the stack point register ESP

tawny
Télécharger la présentation

Chapter 6 Procedures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 6 Procedures

  2. 6.1 The 80x86 Stack

  3. Hardware Stack • Allocated with directive, for example.STACK 4096allocates 4096 uninitialized memory bytes • Visual Studio project setting can also be used to allocate stack space • Most access is indirect, through the stack point register ESP • Operating system initializes ESP to point to byte above stack • As program executes, it points to the last item pushed on the stack

  4. push instruction • Usual format: push source • source can in memory, register or immediate • doubleword or word pushed on the stack • Formats to use when the assembler cannot determine operand size • pushd source • pushw source

  5. push execution • ESP decremented by size of operand • Operand stored in stack where ESP points after being decremented • Flags not changed

  6. push Example

  7. pop instruction and execution • Usual format: pop destination • doubleword or word destination can in memory or register • Operand stored in stack where ESP points is copied to destination • ESP incremented by size of operand after the value is copied • Flags not changed

  8. pop Example

  9. Pushing/Popping Flags • pushfd pushes EFLAGS register contents onto stack • popfd pops doubleword from top of stack into EFLAGS

  10. Viewing the Stack with Debugger • Stop at breakpoint • View registers • ESP contains address of byte above stack • Subtract number of bytes to view from the address in ESP • Use this as the starting address at which to view memory • Example – if ESP contains 0042FFC4, using 0042FFC4 – 20 = 0042FFA4 lets you see the top 32 (2016) bytes of the stack

  11. 6.2 32-bit Procedures with Value Parameters

  12. Terminology • Procedure - a subprogram that is essentially a self-contained unit • Main program or another subprogram calls a procedure • A procedure may simply do a task or it may return a value • value-returning procedure is sometimes called a function

  13. Procedure Concepts • Transfer of control from calling program to procedure and back • Passing parameter values to procedure and results back from the procedure • Having procedure code that is independent of the calling program The cdecl protocol provides one standard implementation scheme

  14. Procedure Definition • In a code segment with body statements bracketed by PROC and ENDP directives giving procedure name .CODE procName PROC ; procedure body ... procName ENDP

  15. Transferring Control to a Procedure • In the “main” program, use callprocName • The next instruction executed will be the first one in the procedure

  16. Returning from a Procedure • In the procedure, use ret • The next instruction executed will be the one following the call in the “main” program

  17. How call Works • The address of the instruction following the call is pushed on the stack • The instruction pointer register EIP is loaded with the address of the first instruction in the procedure

  18. How ret Works • The doubleword on the top of the stack is popped into the instruction pointer register EIP • Assuming that this was the address of the instruction following the call, that instruction will be executed next • If the stack has been used for other values after the call, these must be removed before the ret instruction is executed

  19. Alternative ret Format • ret n • n is added to ESP after the return address is popped • This is most often used to logically remove procedure parameters that have been pushed onto the stack • Not used in cdecl protocol

  20. Parameter Terminology • A procedure definition often includes parameters (also called formal parameters) • These are associated with arguments (also called actual parameters) when the procedure is called • For a procedure's in (pass-by-value) parameters, values of the arguments are copied to the parameters when the procedure is called • These values are referenced in the procedure using their local names (the identifiers used to define the parameters)

  21. Implementing Value Parameters • Parameter values normally passed on the stack • Pushed in reverse order from argument list • Example • Design or high-level code: sum := add2(value1, value2) • 80x86 implementation:push ecx ; assuming value2 in ECXpush value1 ; assuming value1 in memorycall add2 ; call procedure to find sumadd esp, 8 ; remove parameters from stackmov sum, eax ; sum in memory • With the cdecl protocol the calling program must remove parameters from the stack • A single integer value normally returned in EAX

  22. Procedure Entry Code • Since the stack pointer ESP may change, a procedure starts with entry code to set the base pointer EBP to an address in the stack • This location is fixed until exit code restores EBP right before returning • In the procedure body, parameters are located relative to EBP • Entry code also saves contents of registers that are used locally within the procedure body • Exit code restores these registers

  23. Example Procedure add2 PROC ; add two words passed on the stack ; return the sum in the EAX register push ebp ; save EBP mov ebp,esp ; establish stack frame mov eax,[ebp+8] ; copy first parameter value add eax,[ebp+12] ; add second parameter value pop ebp ; restore EBP ret ; return add2 ENDP

  24. Stack frame upon entry to procedure add2 and after EBP established in entry code

  25. Accessing Parameters in a Procedure • Use based addressing • Since the value is actually on the stack, [EBP+n] references the value • Example:mov eax,[ebp+8]copies the last parameter pushed to EAX

  26. Saving/Restoring Registers • Push registers in entry code after EBP is established • Exit code pops registers in the opposite order • Calling program’s flag values from can be saved with pushfd/popfd

  27. Entry and Exit Code Summary • Entry code: push ebp ; establish stack frame mov ebp, esp push ... ; save registers ... push ... pushfd ; save flags • Exit code: popfd ; restore flags pop ... ; restore registers ... pop ... pop ebp ; restore EBP ret ; return

  28. Procedure Call Summary

  29. 6.3 Additional 32-bit Procedure Options

  30. Reference Parameters • The address of the argument instead of its value is passed to the procedure • Reference parameters are used: • To send a large argument (for example, an array or a structure) to a procedure • To send results back to the calling program as argument values

  31. Passing an Address • lea instruction can put address of an argument in a register, and then the contents can be pushed on the stack lea eax, minimum ; 3rd parameter push eax

  32. Returning a Value in a Parameter • Get address from stack • Use register indirect addressing mov ebx, [ebp+16] ; get addr of min ... mov [ebx], eax ; min := a[i]

  33. Allocating Local Variable Space • save EBP and establish stack frame • subtract number of bytes of local space from ESP • save registers used by procedure • Access both parameters and local variables in procedure body using based addressing • return value, if any, goes in EAX • restore saved registers • copy EBP to ESP • restore EBP • return New entry and exit code actions are bold

  34. Recursive Procedure • Calls itself, directly or indirectly • Many algorithms are very difficult to implement without recursion • A recursive call is coded just like any other procedure call

  35. Separate Assembly • Procedure code can be in a separate file from the calling program • File with call has an EXTERN directive to describe procedure that is defined in another file • ExampleEXTERN minMax:PROC

  36. 64-bit procedures

  37. Stack Usage • Normally push and pop quadwords • call pushes a 64-bit address on the stack • ret pops a 64-bit address into RIP • Calling procedure’s entry code must reserve space on the stack for arguments. • Typical code includes sub rsp,120

  38. 64-bit protocol • Different from cdecl • First four arguments passed in registers • Later arguments copied to stack • Fifth argument is copied to [RSP+32]

  39. Register Usage • RAX, RCX, RDX, and R8-R11 are called volatile • A called procedure is free to change them • RBX, RDI, RSI, RBP, RSP and R12-R15 are called nonvolatile • A called procedure has the responsibility of preserving them • In practice, it is safest to preserve any register that you don’t want destroyed by a called procedure

  40. Procedure to Add Five Integers ; void add5(int x1,int x2,int x3,int x4,int x5); ; returns sum of arguments add5 PROC mov eax, ecx ; x1 add eax, edx ; x2 add eax, r8d ; x3 add eax, r9d ; x4 add eax, DWORD PTR [rsp+40] ; x5 ret ; return add5 ENDP

  41. 6.5 Macro Definition and Expansion

  42. Macro • Expands to the statements it represents • Expansion then assembled • Resembles a procedure call, but is different • Each time a macro appears in code, it is expanded • There is only one copy of procedure code

  43. Macro Definition name MACRO list of parameters assembly language statements ENDM • Parameters in the MACRO directive are ordinary symbols, separated by commas • The assembly language statements may use the parameters as well as registers, immediate operands, or symbols defined outside the macro

  44. Macro Example 1 Given the definition add2 MACRO nbr1, nbr2 ; put sum of two doubleword parameters in EAX mov eax, nbr1 add eax, nbr2 ENDM the macro call add2 value, 30 ; value + 30 expands to ; put sum of two doubleword parameters in EAX mov eax, value add eax, 30

  45. Macro Example 2 Given the definition add2 MACRO nbr1, nbr2 ; put sum of two doubleword parameters in EAX mov eax, nbr1 add eax, nbr2 ENDM the macro call add2 eax, ebx ; sum of two values expands to ; put sum of two doubleword parameters in EAX mov eax, eax add eax, ebx

  46. Macro Example 3 Given the definition add2 MACRO nbr1, nbr2 ; put sum of two doubleword parameters in EAX mov eax, nbr1 add eax, nbr2 ENDM the macro call add2 value expands to ; put sum of two doubleword parameters in EAX mov eax, value add eax, (won’t assemble)

  47. Macros in IO.H • Each expands to a statement that calls a procedure, for example atod MACRO source ; convert ASCII string ; to integer in EAX lea eax,source ; source address to AX push eax ; source parameter on stack call atodproc ; call atodproc(source) add esp, 4 ; remove parameter ENDM

More Related