1 / 31

ECE291 Computer Engineering II Lecture 8

ECE291 Computer Engineering II Lecture 8. 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

baka
Download Presentation

ECE291 Computer Engineering II Lecture 8

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 8 Josh Potts University of Illinois at Urbana- Champaign

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

  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 ECE291

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

  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 ECE291

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

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

  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 ECE291

  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…WHY? ECE291

  10. The Stack Use • To store • registers • return address information while procedures are executing • local variables that procedures may require • To pass parameters to procedures ECE291

  11. Temporary Register Storage • Push and Pop registers 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 ECE291

  12. Store Return Address of a Procedure PrintRec PROC NEAR ... <Print value of a record> ... RET PrintRec ENDP main PROC FAR ... <Calculate Scores> ... CALL PrintRec <Continue Execution HERE> ... CALL DOSXIT main ENDP At execution time 1. processor encounters the CALL to the procedure 2. pushes the return address (instruction pointer of the next instruction after the CALL) onto the stack 3. jumps to PrintRec 4. executes the code therein 5. pops the return address off the stack 6. returns to the calling code ECE291

  13. Passing Parameters on the Stack • Stack can be used to pass parameter(s) to a procedure • The caller pushes the procedure parameter onto the stack and the callee finds the parameter there • When the procedure completes its task, the parameter should be popped from the stack MOV AX, OFFSET String PUSH AX CALL getStr ;the proc getStr expects the offset to the String to ;be on the stack ECE291

  14. Passing Parameters on the Stack Example ;Use of Procedures when parameters are passed using Stack ………. ;====== Stack ======================================================== stkseg segment stack ; *** STACK SEGMENT *** db 64 dup ('STACK ') ; 64*8 = 512 Bytes of Stack stkseg ends ;====== Begin Code/Data ============================================== cseg segmentpublic 'CODE' ; *** CODE SEGMENT *** assume cs:cseg, ds:cseg, ss:stkseg, es:nothing LEN EQU 80 CR EQU 0dh LF EQU 0ah Prompt1 BYTE "Input a string", 0 Prompt2 BYTE "Do another? ", 0 String BYTE (LEN +1) DUP (?) ECE291

  15. Main PROC FAR Begin: mov ax, OFFSET Prompt1 push ax call putStr mov ax, OFFSET String push ax call getStr mov ax, OFFSET String push ax call putStr mov ax, OFFSET Prompt2 push ax call putStr mov ax, OFFSET String push ax call getStr mov bx, OFFSET String cmp BYTE PTR [bx], 'y' je Begin mov ax, 4c00h int 21h MAIN ENDP CSEG ENDS END MAIN Passing Parameters on the Stack Example (cont.) ECE291

  16. ;OFFSET of string to be printed must ;be on the stack and the string must ;be null terminated putStr PROC NEAR 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 PTR [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 putStr ENDP Passing Parameters on the Stack Example (cont.) OFFSET String RETURN IP BP OLD BP AX BX Removes passed parameters from the stack SP DX ECE291

  17. ;OFFSET of large enough buffer must ;have been pushed onto stack ;string will be null terminated getStr PROC NEAR 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 PTR [bx], 0 ;CR is converted in null term pop bx pop ax pop bp ret 2 getStr ENDP Passing Parameters on the Stack Example (cont.) OFFSET String RETURN IP BP OLD BP AX SP BX ECE291

  18. Procedures (Overview) • Group of instructions that usually perform one task • Reusable section of the software that is stored in memory once, but use 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 instruction following it on the stack • RET removes an address from the stack so the program returns to the instruction following the call • PROC NEAR My_Subroutine • PUSH IP • JUMP Offset My_Subroutine • PROC FAR My_Subroutine • 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 ECE291

  19. Procedures (Overview cont.) • Procedures should save and restore registers that are modified in a subroutine. PrintRec PROC NEAR 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 PrintRec ENDP LIB291 Routine to save ALL registers RSAVE: Save ALL registers RREST: Restore ALL registers ECE291

  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 reference by a pointer ECE291

  21. Passing Parameters in Registers • Example: putsi (put short integer) routine outputs the value in AL as a signed integer putsi PROC PUSH AX ;saves AH’s values CBW ;sign extend AL --> AX PUTI ;do the work; puti expects the value of the ; signed integer in the AX register POP AX ;restore AH RET putsi ENDP ECE291

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

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

  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 program • Parameter names are substituted • Useful for tedious programming tasks • Instantiated within code segment. ECE291

  25. Macros (cont.) • General Format MACRO_NAME MACROParam1,Param2,...,ParamN LOCAL MyLabel Your Code ... ... Param1 ... ...Param2 ... Your Code ... JMP MyLabel Your Code ... MyLabel: ... ParamN ... Your Code ... ENDM ECE291

  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 LOCAL directive for defining a local variable • If the label MyLabel in the previous example is not defined as local, the assembler will flag it with errors on the second and subsequent attempts to use the macro • The LOCAL directive must always immediately follow the MACRO directive without any intervening comments or spaces • 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 ECE291

  27. Macros (cont.) Example: DIV16 MACRO 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, X ; Load AX with Dividend CWD ; Extend Sign into DX IDIV Y ; Signed Division MOV Result, AX ; Store Quotient ENDM ECE291

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

  29. Proc_1 PROC NEAR MOV AX, 0 MOV BX, AX MOV CX, 5 RET Proc_1 ENDP Macro_1 MACRO MOV AX, 0 MOV BX, AX MOV CX, 5 ENDM CALL Proc_1 …... CALL Proc_1 …... Macro_1 …… Macro_1 Macros vs Procedures ECE291

  30. Macros vs Procedures (cont.) • In the example the macro and procedure produce the same result • The procedure definition generates code when the assembler encounters the PROC directive • The macro does not emit any code when processing the statements between the MACRO and ENDM • Upon encountering Macro_1 in the mnemonic field, MASM assembles every statement between the MACRO and ENDM directives and emits that code to the output file • At run time, the processor executes these instructions without the call/ret overhead ECE291

  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 ECE291

More Related