EENG 4005 Microprocessors

1
EENG 4005Microprocessors
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
Stack Implementation in Memory
Original SP
Stack grows in direction of decreasing memory
addresses
Direction of increasing memory addresses
SSSP
FREE
FREE
FREE
FREE
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 gt SUB SP, 2
  MOV SSSP, AX
• SP increases as data is POPed
• POP AX gt MOV AX,
  SSSP 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
6AB3
BX
6AB3
B3
037FE
CX
DX
SP Before PUSH BX
SP After PUSH BX
SP
0800
SS
0300
03000
STACK segment
7
POP InstructionExample
To address 0FFFF
Register Array
01008
AX
POP BX
39
01007
392F
BX
392F
2F
01006
CX
DX
SP After POP BX
SP Before POP 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 64KWHY?

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

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
• ...
• lt modify contents of
• Registers AX BX gt
• ...
• POP BX Restore
  original value of BX
• POP AX Restore
  original value of AX

12
Store Return Address of a Procedure

• PrintRec PROC NEAR
• ...
• ltPrint value of a recordgt
• ...
• RET
• PrintRec ENDP
• main PROC FAR
• ...
• ltCalculate Scoresgt
• ...
• CALL PrintRec
• ltContinue Execution HEREgt
• ...
• 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
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

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 ') 648
  512 Bytes of Stack
• stkseg ends
• Begin Code/Data
  
• cseg segment public 'CODE'
  CODE SEGMENT
• assume cscseg, dscseg, ssstkseg,
  esnothing
• 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 (?)

15
Passing Parameters on the Stack Example (cont.)

• 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

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
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
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_SubroutineOffset
  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 PROC NEAR
• PUSH AX
• PUSH BX
• PUSH CX
• PUSH DX
• PUSH SI
• lt Code modifies AX,BX,CX,DX,SI gt
• 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
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

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 AHs values
• CBW sign extend AL --gt AX
• PUTI do the work puti expects
  the value of the
• signed integer in the AX register
• POP AX restore AH
• RET
• putsi ENDP

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, 2BP load return address into BX
• PrintLp MOV AL, CSBX 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 2BP, BX save as a new return address
• POP AX
• POP BX
• POP BP
• RET
• MyPrint ENDP

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, ES2BX get Js value
• ADD AX, ES4BX add in Ks value
• MOV ESBX, AX store result in I
• RET
• AddEM ENDP

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.

25
Macros (cont.)

• General Format
• MACRO_NAME MACRO Param1,Param2,...,P
  aramN
• LOCAL MyLabel
• Your Code ...
• ... Param1 ...
• ...Param2 ...
• Your Code ...
• JMP MyLabel
• Your Code ...
• MyLabel
• ... ParamN ...
• Your Code ...
• ENDM

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

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

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

29
Macros vs Procedures

• 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

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

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