COURSE OUTCOMES OF Microprocessor and programming Describe the architecture and organization of microprocessor along with instruction set format. C404.2 Describe modes and functional block diagram of 8086 along with pins and their functions C404.3 List and describe memory and addressing modes C404.4 List, describe and use different types of instructions, directives and interrupts C404.5 Develop assembly language programs using various programming tools. Visit for more Learning Resources

CHAPTER 6 PROCEDURES AND MACROS

Outline Program Stack PUSH & POP instructions Procedures Macros Macros vs. procedures Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

PUSH Instruction Example 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 Josh Potts ECE291

POP Instruction Example 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 Josh Potts ECE291

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 Josh Potts ECE291

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? Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 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 (?) Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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, 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 Josh Potts ECE291

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 Josh Potts ECE291

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. Josh Potts ECE291

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

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 Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291

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 …… Josh Potts ECE291

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 Josh Potts ECE291

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 Josh Potts ECE291 For more detail contact us