1 / 25

Assembly Language for Intel-Based Computers

Assembly Language for Intel-Based Computers. Kip R. Irvine. Chapter 8: Advanced Procedures. Chapter Overview. Stack Frames Recursion. Stack Parameters. More convenient than register parameters. Stack Frame. Also known as an activation record

phuc
Télécharger la présentation

Assembly Language for Intel-Based Computers

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. Assembly Language for Intel-Based Computers Kip R. Irvine Chapter 8: Advanced Procedures

  2. Chapter Overview • Stack Frames • Recursion Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  3. Stack Parameters • More convenient than register parameters Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  4. Stack Frame • Also known as an activation record • Area of the stack set aside for a procedure's return address, passed parameters, saved registers, and local variables • Created by the following steps: • Calling program pushes arguments on the stack and calls the procedure. • The called procedure pushes EBP on the stack, and sets EBP to ESP. • If local variables are needed, a constant is subtracted from ESP to make room on the stack. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  5. Explicit Access to Stack Parameters • A procedure can explicitly access stack parameters using constant offsets from EBP1. • Example: [ebp + 8] • EBP is often called the base pointer or frame pointer because it holds the base address of the stack frame. • EBP does not change value during the procedure. • EBP must be restored to its original value when a procedure returns. 1 BP in Real-address mode Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  6. Stack Frame Example .data sum DWORD ? .code push 6 ; second argument push 5 ; first argument call AddTwo ; EAX = sum mov sum,eax ; save the sum AddTwo PROC push ebp mov ebp,esp . . Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  7. AddTwo Procedure • Recall the AddTwo Procedure Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  8. RET Instruction • Return from subroutine • Pops stack into the instruction pointer (EIP or IP). Control transfers to the target address. • Syntax: • RET • RETn • Optional operand n causes n bytes to be added to the stack pointer after EIP (or IP) is assigned a value. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  9. Passing Arguments by Reference (1 of 2) • The ArrayFill procedure fills an array with 0 • The calling program passes the address of the array, along with a count of the number of array elements: .data count = 100 array dw count DUP(?) .code push OFFSET array push COUNT call ArrayFill Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  10. Passing Arguments by Reference (2 of 2) ArrayFill can reference an array without knowing the array's name: ArrayFill PROC push ebp mov ebp,esp pushad mov esi,[ebp+12] mov ecx,[ebp+8] cmp ecx,0 jle L2 L1: mov [esi],0 add esi,2 loop L1 L2: popad pop ebp ret 8 ArrayFill ENDP Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  11. Local Variables • To explicitly create local variables, subtract their total size from ESP. • The following example creates and initializes two 32-bit local variables (we'll call them locA and locB): MySub PROC push ebp mov ebp,esp sub esp,8 mov [ebp-4],123456h ; locA mov [ebp-8],0 ; locB . . Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  12. LOCAL Directive • A local variable is created, used, and destroyed within a single procedure • The LOCAL directive declares a list of local variables • immediately follows the PROC directive • each variable is assigned a type • Syntax: • LOCAL varlist Example: MySub PROC LOCAL var1:BYTE, var2:WORD, var3:DWORD Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  13. Using LOCAL Examples: LOCAL flagVals[20]:BYTE ; array of bytes myProc PROC ; procedure LOCAL t1:BYTE, ; local variables Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  14. LOCAL Example (1 of 2) BubbleSort PROC LOCAL temp:DWORD, SwapFlag:DWORD . . . ret BubbleSort ENDP BubbleSort PROC LOCAL temp:DWORD, SwapFlag:DWORD push ebp mov ebp,esp add esp,0FFFFFFF8h ; add -8 to ESP . . . mov esp,ebp pop ebp ret BubbleSort ENDP Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  15. LOCAL Example (2 of 2) Diagram of the stack frame for the BubbleSort procedure: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  16. Local Example • xyz proc • local v1:byte , v2:byte , v3:dword, flags[4]:BYTE • push bp • mov bp,sp • sub sp,12 • mov v1,21h • mov v2,43h • mov v3,44441111h • mov flags[0],00 • mov flags[1],11h • mov flags[2],22h • mov flags[3],33h • mov sp,bp • pop bp • ret • xyz endp Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  17. Local Example Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  18. Local Example • xyz proc • local v1:byte , v2:byte , v3:dword, flags[4]:BYTE • push bp • mov bp,sp • sub sp,12 • mov v1,21h • mov v2,43h • mov v3,44441111h • Mov cx,4 • Lea si,flags • L1: mov byte ptr ss:[si], 22h • inc si loop L1 • mov sp,bp • pop bp • ret • xyz endp Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  19. Recursion • What is recursion? • Recursively Calculating a Sum • Calculating a Factorial Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  20. What is Recursion? • The process created when . . . • A procedure calls itself • Procedure A calls procedure B, which in turn calls procedure A • Using a graph in which each node is a procedure and each edge is a procedure call, recursion forms a cycle: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  21. What is Recursion? .code A: call Endless mov ah,4CH int 21h Endless PROC mov edx, ecx inc ecx call Endless ret Endless ENDP End A Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  22. Recursively Calculating a Sum The CalcSum procedure recursively calculates the sum of an array of integers. Receives: ECX = count. Returns: EAX = sum .code mov ecx, 5 mov eax,0 call CalcSum Ll: ; any instructions • CalcSum PROC • cmp ecx,0 ; check counter value • jz L2 ; quit if zero • add eax,ecx ; otherwise, add to sum • dec ecx ; decrement counter • call CalcSum ; recursive call • L2: ret • CalcSum ENDP Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  23. Calculating a Factorial (1 of 3) This function calculates the factorial of integer n. A new value of n is saved in each stack frame: int function factorial(int n) { if(n == 0) return 1; else return n * factorial(n-1); } As each call instance returns, the product it returns is multiplied by the previous value of n. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  24. Calculating a Factorial (2 of 3) Factorial PROC push ebp mov ebp,esp mov eax,[ebp+8] ; get n cmp eax,0 ; n < 0? ja L1 ; yes: continue mov eax,1 ; no: return 1 jmp L2 L1: dec eax push eax ; Factorial(n-1) call Factorial ; Instructions from this point on execute when each ; recursive call returns. ReturnFact: mov ebx,[ebp+8] ; get n mul ebx ; eax = eax * ebx L2: pop ebp ; return EAX ret 4 ; clean up stack Factorial ENDP Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

  25. Calculating a Factorial (3 of 3) Suppose we want to calculate 12! This diagram shows the first few stack frames created by recursive calls to Factorial Each recursive call uses 12 bytes of stack space. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

More Related