The document discusses procedures and macros in programming, highlighting how procedures allow the reuse of instructions to save memory and simplify programs, while macros automate repetitive coding. It explains the structure and invocation of procedures, including call and ret instructions, parameter passing techniques, and the concepts of re-entrant and recursive procedures. Additionally, it contrasts procedures and macros in terms of memory usage and efficiency, providing examples of both implementations.

1. PROCEDURES & MACROS

2. Procedures
• While writing programs, sometimes it may be required
to use same set of instructions repeatedly.
• If these instructions are actually written again & again,
the program size increases and occupies more memory
space.
• To avoid this, these instructions can be written as a
separate program (subprogram) and whenever this set
of instructions is required, an instruction can be
written in the main program CALL this subprogram.
• This saves the memory space.
• A subprogram which is called from the main program
to execute certain set of instructions is called
subroutine or procedure.

3. Procedures
• Declaring PROCEDURES:
• The syntax for procedure declaration:
• name PROC [NEAR/FAR]
; Instructions of the procedures
; are written here.
RET
• name ENDP

4. Procedures
• Example:
Delay PROC
MOV CX,COUNT
AGAIN: NOP
LOOP AGAIN
RET
Delay ENDP

5. Procedures
• A procedure in 8086 can be accessed with a CALL &
RET instruction.
• CALL instruction: This performs two operations
1. Saves the return address or the address of the
instruction next to the CALL instruction on the stack.
Return address is the address where the program will
return to after the procedure completes execution.
– If the call to procedure is in the same code segment, i.e. a
near CALL, then only the contents of IP are pushed on the
stack.
– If the call to procedure is in another code segment, i.e. a
far CALL, then the contents of IP as well as CS are pushed
on the stack.
2. It loads the IP & CS register with a new starting
address of the procedure and then branches to the
procedure.

6. Procedures
• RET instruction:
• When 8086 executes a CALL instruction, it
stores the return address of the CALLing
routine on the stack.
• A RET instruction at the end of the procedure
copies the return address stored on the stack
back into the CS and IP registers and then
returns execution to the main program.

7. Procedures
• Passing Parameters to procedures:
• Procedures may require input data or constants for
their execution.
• Their data or constants may be passed to the
procedure by the main program or some procedures
may access the readily available data of constants
available in memory.
• Generally following techniques are used to pass input
data/parameter to procedures in assembly language
programs,
1. Using global declared variable
2. Using registers of CPU architecture
3. Using memory locations
4. Using stack

8. Example : Using registers
CODE SEGMENT
START: MOV AX, 5555H
MOV BX,7272h
:
:
CALL PROC1
:
:
PROC1 PROCEDURE
:
:
ADD AX,BX
:
:
RET
PROC1 ENDP
CODE ENDS
END START

9. Procedures
• Re-entrant Procedures :
• A procedure is said to be re-entrant, if it can
be interrupted, used and re-entered without
losing or writing over anything. To be a re-
entrant,
• Procedure must first push all the flags and
registers used in the procedure.
• It should also use only registers or stack to pass
parameters.
• The flow of re-entrant procedure for a multiply
procedure when interrupt procedure is executed,
as shown in the next slide

10. Procedures

11. Procedures
• Recursive Procedures:
• A recursive procedure is a procedure which
calls itself.
• Here, the program sets aside a few locations in
stack for the storage of the parameters which
are passed each time the computation is done
and the value is returned.
• Each value returned is then obtained by
popping back from the stack at every RET
instruction when executed at the end of the
procedure.

12. Program to find the factorial using
recursiondata segment
n db 04h
res dw ?
data ends
code segment
assume cs:code, ds:data
start: mov ax,data
mov ds,ax
mov al,n
mov ah,00h
call fact
int 3

13. fact proc
cmp ax,01 ;if n=1, fact=1 else fact=n*fact(n-1)
jz exit
push ax
dec ax ;n-1
call fact ;fact(n-1) , RECURSION
pop ax
mul res ;n*fact(n-1)
mov res,ax ;res=factorial
ret
exit:
mov res,01
ret
fact endp
code ends
end start

14. Advantages of Procedures
• Simple modular programming
• Reduced workload and development time
• Debugging of program and procedure is easier
• Reduction in the size of the main program
• Reuse of procedures in the same program
many times or in another program.

15. MACROS
• Small sequences of codes of the same pattern
repeated frequently at different places which
perform the same operation on the different
data of the same data type are called MACRO.
• Macro is also called as an Open subroutine.
• When Called, the code written within macro
are executed automatically.
• Macros should be used when it has few
program statements.
• This simplifies the programming process.

16. MACROS
Advantages
• Simplify and reduce the amount of repetitive
coding
• Reduce errors caused by repetitive coding
• Makes program more readable
• Execution time is less as compared to
procedures as no extra instructions required

17. Procedure Vs Macros
• Procedure does occupy minimum memory
space than macro.
• In macro machine code is generated for
instructions each time when it is called but in
procedure machine code for instruction is put
only once in the memory
• Procedure is accessed by call Instruction
whereas Macro is accessed with the name
given.

18. MACROS
Defining Macros
The Directive MACRO indicates the beginning of a
MACRO
Name of the Macro followed by MACRO and arguments if
any are specified.
ENDM is always associated with MACRO which ends the
macro.
General Form :
Macro_name MACRO [Arguement1, arguement2…]
:
:
ENDM

19. MACROS
Example:
PRINT MACRO MES
MOV AX,09H
LEA DX, MES
INT 21H
ENDM
The above macro is used to display a string
specified in the argument MES on the screen,
when evoked by the main program as given in
the next slide.

20. MACROS
DATA SEGEMENT
STR DB 0DH,0AH,”Hello World$”
DATA ENDS
CODE SEGMENT
ASSUME DS:DATA, CS:CODE
START: MOV AX, DATA
MOV DS, AX
PRINT STR ; Calls Macro PRINT to display STR
; STR is the parameter passed which is
;taken as MES in the Macro PRINT.
:
:
CODE ENDS
END START