1 / 31

ECE291 Computer Engineering II Lecture 7

ECE291 Computer Engineering II Lecture 7. Josh Potts University of Illinois at Urbana- Champaign. Outline. Program Stack PUSH & POP instructions Procedures Macros Macros vs procedures. Stack Key Characteristics. Used to store temporary data during program execution

yvonne
Download Presentation

ECE291 Computer Engineering II Lecture 7

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. ECE291Computer Engineering IILecture 7 Josh Potts University of Illinois at Urbana- Champaign

  2. Outline • Program Stack • PUSH & POP instructions • Procedures • Macros • Macros vs procedures

  3. Stack Key Characteristics • Used to store temporary data during program execution • One point of access - the top of the stack • A stack is always operated as Last-In-First-Out (LIFO) storage, i.e., data are retrieved in the reverse order to which they were stored • Instructions that directly manipulate the stack • PUSH - place element on top of stack • POP - remove element from top of stack

  4. In Use In Use FREE In Use FREE In Use FREE In Use FREE In Use Stack Implementation in Memory Original SP Stack grows in direction of decreasing memory addresses Direction of increasing memory addresses SS:SP SS

  5. Stack Implementation in Memory (cont.) • SS - Stack Segment • SP (stack pointer) always points to the top of the stack • SP initially points to top of the stack (high memory address). • SP decreases as data is PUSHed PUSH AX ==> SUB SP, 2 ; MOV [SS:SP], AX • SP increases as data is POPed POP AX ==> MOV AX, [SS:SP] ; ADD SP, 2 • BP (base pointer) can point to any element on the stack

  6. PUSH InstructionExample To address 12FFF Register Array 03800 PUSH BX AX 6A 037FF BX 6AB3 6AB3 B3 037FE CX DX SP BeforePUSH BX SP AfterPUSH BX SP 0800 SS 0300 03000 STACK segment

  7. POP InstructionExample To address 0FFFF Register Array 01008 AX POP BX 39 01007 BX 392F 392F 2F 01006 CX DX SP AfterPOP BX SP BeforePOP BX SP 1006 SS 0000 00000 STACK segment

  8. PUSH & POP(More I) • PUSH and POP always store or retrieve words of data (never bytes) in the 8086-80286 microprocessor • The 80386/80486 allow words or double words to be transferred to and from the stack • The source of data for PUSH • any internal 16-bit/32-bit register, immediate data, any segment register, or any two bytes of memory data • The POP places data into • internal register, segment register (except CS), or a memory location

  9. PUSH & POP(More II) • The 80286 and later microprocessors there is also PUSHA and POPA to store and retrieve, respectively the contents of internal register set (AX, CX, DX, BX, SP, BP, SI, and DI) • Stack initialization, example: • assume that the stack segment resides in memory locations 10000h-1FFFFh • the stack segment (SS) is loaded with 1000h • the SP is loaded with 0000h - to start the stack at the top of the 64K (so first push does 0000h – 0002h = FFFEh, storing data in 1FFFEh and 1FFFFh)

  10. Stack Use • To store • registers • return address information while procedures are executing • local variables that procedures may require • To pass parameters to procedures (i.e. function arguments)

  11. Temporary Register Storage • Push and Popregisters to preserve their value Example: push ax ; Place AX on the stack push bx ; Place BX on the stack ... < modify contents of Registers AX & BX > ... pop bx ; Restore original value of BX pop ax ; Restore original value of AX

  12. Store Return Address of a Procedure PrintRec ... <Print value of a record> ... ret main ... <Calculate Scores> ... CALLPrintRec <Continue Execution HERE> ... CALL DOSXIT • At execution time • Processor encounters the CALL to the procedure • pushes the return address (instruction pointer of the next instruction after the CALL) onto the stack • jumps to PrintRec label • executes the code therein • pops the return address off the stack back into the Instruction Pointer (IP) • returns to the calling code

  13. Passing Parameters on the Stack • Stack can be used to pass parameter(s) to a procedure • The caller (you, or rather your program) pushes the parameter onto the stack and the called procedure finds the parameter there • When the procedure completes its task, the parameter should be popped from the stack either by the procedure or by the caller. mov ax, String ;pointer to variable String push ax call getStr ;the proc getStr expects the offset address of ;String to be on the stack

  14. Passing Parameters on the Stack Example ;Use of Procedures when parameters are passed using Stack ;====== Stack =================================================== stkseg segment stack ; *** STACK SEGMENT *** resb 64*8 ; 64*8 = 512 Bytes of Stack stktop ends ;====== Begin Code/Data ========================================= Segment CODE ; *** CODE SEGMENT *** LEN EQU 80 CR EQU 0dh LF EQU 0ah Prompt1 DB "Input a string", 0 Prompt2 DB "Do another? ", 0 String DB (LEN+1) TIMES DB 0

  15. Main ..start mov ax, stkseg mov ss, ax mov sp, stktop .begin push Prompt1 call putStr push String call getStr push String call putStr push Prompt2 call putStr mov ax, String push ax call getStr mov bx, String cmp BYTE [bx], 'y' je .Begin mov ax, 4c00h int 21h Passing Parameters on the Stack Example (cont.)

  16. ;OFFSET of string to be printed must ;be on the stack and the string must ;be null terminated putStr push bp mov bp, sp push ax push bx push dx mov bx, [bp + 4] ;expect bx to point to string mov ah, 2h ; prepare to print a char with 21h .nextChar: cmp BYTE [bx], 0h ;check for null terminator je .foundEnd ;when found exit mov dl, [bx] int 21h ; print with 21h inc bx ;point to next char jmp .nextChar .foundEnd: pop dx pop bx pop ax pop bp ret 2 OFFSET String RETURN IP BP OLD BP AX BX SP DX Passing Parameters on the Stack Example (cont.) Removes passed parameters from the stack

  17. ;OFFSET of large enough buffer must ;have been pushed onto stack ;string will be null terminated getStr push bp mov bp, sp push ax push bx mov bx, [bp + 4] ;base address of storing buffer mov ah, 01h .getLoop: int 21h cmp al, CR ;look for CR in al je .getEnd mov [bx], al ;bx points to storage location inc bx jmp .getLoop .getEnd: mov BYTE [bx], 0;CR is converted in nullterm pop bx pop ax pop bp ret 2 Passing Parameters on the Stack Example (cont.) OFFSET String RETURN IP BP OLD BP AX SP BX

  18. Procedures (Overview) • Group of instructions that usually perform a specific task • Reusable section of the software that is stored in memory once, but used as often as necessary • The stack stores the return address whenever a procedure is called during the execution of the program • CALL pushes the address of the following instruction onto the stack • RET removes the address from the stack so the program returns to the instruction following the call • My_Procedure_Label • PUSH IP • JUMP My_Subroutine • My_Far_Procedure_Label • PUSH CS • PUSH IP • JUMP Segment My_Subroutine:Offset My_Subroutine RET POP (CS:) IP Near calls and returns transfer control between procedures in the same code segment Far calls and returns pass control between different segments

  19. Procedures (Overview cont.) • Procedures should save and restore registers that are modified in a subroutine. PrintRec push ax push bx push cx push dx push si < Code modifies AX,BX,CX,DX,SI > pop si pop dx pop cx pop bx pop ax ret

  20. Procedures(Overview) • Parameters to a procedure can be passed in • on the stack • global memory locations • registers • in the code stream • in a parameter block referenced by a pointer

  21. Passing Parameters in Registers • Example: putsi (put short integer) routine outputs the value in AL as a signed integer putsi push ax ;saves AH’s values cbw ;signed extend AL --> AX call PUTI ;another procedure that actually does the work ;puti expects the value of the ;signed integer in the AX register pop ax ;restore AH ret

  22. Example: ……… call MyPrint DB “Code stream parameter.”, 0 ……… Consider the following implementation of MyPrint MyPrint PUSH BP MOVE BP, SP PUSH BX PUSH AX MOV BX, [BP+2] ;load return address into BX .PrintLp: MOV AL, [CS:BX] ;get next character CMP AL, 0 ;check for end of the string JZ .EndStr CALL PrintChar ;procedure that displays a ;single character INC BX ;move to the next char JMP .PrintLp .EndStr: INC BX ;point at first byte beyond zero MOV [BP+2], BX ;save as a new return address POP AX POP BX POP BP RET Passing Parameters in the Code Stream

  23. Passing Parameters via a Parameter Block Consider simple subroutine that adds J and K together, storing the result in I. ParmBlock I RESW ;I, J, K must appear in this order J RESW K RESW …… LES bx, ParmBlock ;loads far pointer into ES:BX CALL AddEm AddEm PUSH AX MOV AX, [ES:BX+2] ;get J’s value ADD AX, [ES:BX+4] ;add in K’s value MOV [ES:BX], AX ;store result in I RET

  24. Macros • A macro inserts a block of statements at various points in a program during assembly • Text substitutions made at compile time • NOT a procedure -- Code is literally dumped into the program • Parameter names are substituted • Useful for tedious programming tasks • Instantiated within code segment.

  25. Macros (cont.) • Generic Format %macro MACRO_NAME numargs Your Code ... ... %{1}... … %{2}... Your Code ... JMP %%MyLabel Your Code ... %%MyLabel: ... %{N}... Your Code ... %endmacro

  26. Local Variable(s) in a Macro • A local variable is one that appears in the macro, but is not available outside the macro • We use the %%prefix for defining a local label • If the label MyLabel in the previous example is not define as local, the assembler will flag it with errors on the second and subsequent attempts to use the macro • Macros can be placed in a separate file • use %include directive to include the file with external macro definitions into a program • no EXTERN statement is needed to access the macro statements that have been included

  27. Macros (cont.) Example: %macro DIV16 3 ; args: Result, X, Y ; Store into Result the signed result of X / Y ; Calculate Result = X / Y ; (all 16-bit signed integers) ; Destroys Registers AX,DX MOV AX, %{2} ; Load AX with Dividend CWD ; Extend Sign into DX IDIV %{3} ; Signed Division MOV %{1}, AX ; Store Quotient %endmacro

  28. Macros (cont.) • Example: Using the macro in a program ; Variable Section varX1 DW 20 varX2 DW 4 varR DW ? ; Code Section DIV16 word [varR],word [varX1],word [varX2] Will actually generate the following code (You won't actually see this unless you debug the program). MOV AX, word [varX1] CWD IDIV word [varX2] MOV word [varR], AX

  29. Proc_1 MOV AX, 0 MOV BX, AX MOV CX, 5 RET %macro Macro_1 0 MOV AX, 0 MOV BX, AX MOV CX, 5 %endmacro CALL Proc_1 …... CALL Proc_1 …... Macro_1 …… Macro_1 Macros vs Procedures

  30. Macros vs Procedures (cont.) • In the example the macro and procedure produce the same result • The procedure definition generates code in your executable • The macrodoes not emit any code when processing the statements between the %macro and %endmacro • Upon encountering Macro_1 in the mnemonic field, NASM assembles every statement between the %macro and %endmacro directives and emits that code to the output file • At run time, the processor executes these instructions without the call/ret overhead

  31. Macros vs Procedures (cont.) • Advantage of using macros • execution of macro expansion is usually faster (no call and ret) than the execution of the same code implemented with procedures • Disadvantage • assembler copies the macro code into the program at each macro invocation • if the number of macro invocations within the program is large then the program will be much larger than when using procedures

More Related