1. EENG 4005 Microprocessors

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

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
EENG4005

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

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
EENG4005

6. PUSH Instruction ExampleTo
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
EENG4005

7. POP Instruction ExampleTo
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
EENG4005

8. PUSH & POP (More I)
PUSH and POP always store or retrieve words of data (never bytes) in the 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
EENG4005

9. PUSH & POP (More II)
The 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?
EENG4005

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

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
EENG4005

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
EENG4005

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
EENG4005

14. Passing Parameters on the Stack Example
;Use of Procedures when parameters are passed using Stack
……….
;====== Stack ========================================================
stkseg segment stack ; *** STACK SEGMENT ***
db dup ('STACK ') ; 64*8 = 512 Bytes of Stack
stkseg ends
;====== Begin Code/Data ==============================================
cseg segment public '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 (?)
EENG4005

15. Passing Parameters on the Stack Example (cont.)
Main PROC FAR
Begin:
mov ax, OFFSET Prompt1
push ax
call putStr
mov ax, OFFSET String
call getStr
mov ax, OFFSET Prompt2
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
EENG4005

16. Passing Parameters on the Stack Example (cont.)
;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
OFFSET String
RETURN IP BP
OLD BP AX BX
Removes passed
parameters from
the stack SP DX
EENG4005

17. Passing Parameters on the Stack Example (cont.)
;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
OFFSET String
RETURN IP BP
OLD BP AX SP BX
EENG4005

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
EENG4005

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
EENG4005

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
EENG4005

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
EENG4005

22. Passing Parameters in the Code Stream
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, ;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
EENG4005

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
EENG4005

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.
EENG4005

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

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
EENG4005

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
EENG4005

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
EENG4005

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

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
EENG4005

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
EENG4005