The document provides information on advanced assembly language procedures. It discusses the PROC, ADDR, INVOKE and PROTO directives which are used to declare and call procedures. The PROC directive declares a procedure with optional parameters, while INVOKE simplifies procedure calls by passing parameters in a single statement. PROTO creates a procedure prototype. ADDR returns the address of a variable. Stack frames and how parameters and local variables are accessed on the stack are explained. Recursive procedures and how they use stack frames are covered, with examples to calculate a sum and factorial recursively. Finally, the document discusses creating multimodule programs by dividing code across multiple source files that are assembled and linked together.

1. Advanced Procedures
COMPUTER ORG. & ASSEMBLY LANGUAGE

2. Group Members:
Saira Irshad
M Sikandar Mustafa
Arslan Liaqat
Maryam Noreen

3. Overview
INVOKE, ADDR, PROC and PROTO
Stack Frames
Recursion
Creating Multimodule Programs

4. PROC, ADDR, INVOKE and PROTO
Directives
ADVANCE PROCEDURES

5. PROC Directive
The PROC directive declares a procedure with an optional list of named
parameters.
Syntax:
label PROC paramList
paramList is a list of parameters separated by commas. Each parameter
has the following syntax:
paramName : type
Type must either be one of the standard ASM types (BYTE, SBYTE,
WORD, etc.), or it can be a pointer to one of these types.

6. PROC Directive
Alternate format permits parameter list to be on one or more separate lines:
label PROC,
paramList
The parameters can be on the same line . . .
param-1:type-1, param-2:type-2, . . ., param-n:type-n
Or they can be on separate lines:
param-1:type-1,
param-2:type-2,
. . .,
param-n:type-n

7. PROC example
• The AddTwo procedure receives two integers and returns
their sum in EAX.
AddTwo PROC,
val1:DWORD, val2:DWORD
push ebp
mov ebp, esp
mov eax,val1
add eax,val2
leave
ret 8
AddTwo ENDP

8. INVOKE Directive
The INVOKE directive simplifies a procedure call by allowing you to pass
parameters to a procedure in a single statement.
Syntax:
INVOKE procedureName [, argumentList]
ArgumentList is an optional comma-delimited list of procedure arguments
Arguments can be:
immediate values and integer expressions
variable names
address and ADDR expressions
register names

9. INVOKE Example
.data
byteVal BYTE 10
wordVal WORD 1000h
.code
; direct operands:
INVOKE Sub1,byteVal,wordVal
; register name, integer expression:
INVOKE Sub3,eax,(10 * 20)

10. ADDR Operator
.data
myWord WORD ?
.code
INVOKE mySub,ADDR myWord
• Returns address of variable
• Simple example:

11. PROTO Directive
Creates a procedure prototype.(Function Signature)
Syntax:
◦ label PROTO paramList
Every procedure called by the INVOKE directive must have a prototype

12. PROTO example
Standard configuration: PROTO appears at top of the program listing,
INVOKE appears in the code segment, and the procedure implementation
occurs later in the program:
MySub PROTO ; procedure prototype
.code
INVOKE MySub ; procedure call
MySub PROC ; procedure implementation
.
.
MySub ENDP

13. PROTO example
Prototype for the ArraySum procedure, showing its
parameter list:
ArraySum PROTO,
ptrArray:PTR DWORD, ; points to the array
szArray:DWORD ; array size
ArraySum PROC
ptrArray:PTR DWORD, ; points to the array
szArray:DWORD ; array size
.
.
RET
ArraySum ENDP

14. Stack Frames
ADVANCE PROCEDURES

15. Stack Frames
A stack frame is a frame of data that gets pushed onto the stack. A stack
frame would represent a function call and its argument data.
Also known as an activation record
Data pushed on stack frame is:
Arguments of function
Return Address
Local Variables of function
Temporary data used by the compiler

16. How it Works

17. Stack Frames

18. How it Works
Whenever a function call is made a “Stack frame” is created
registers used for this process are:
ESP – Stack Pointer
Always points to the top of Stack
EBP – Base pointer Or Frame pointer(FP)
Always points to Top of Stack frame
Must be reallocated its value after exit

19. How it Works

20. Explicit Access to Stack Parameters
A procedure can explicitly access stack parameters using constant
offsets from EBP.
Example: [ebp + 8]

21. Return from Subroutine in Assembly
It transfer control back to the previous Procedure or caller function or
target Address
Syntax:
◦ RET
◦ RET n
◦ Where n is number of byte or storage add from Stack Pointer (ESP)
after Instruction pointer (EIP) is assigned a value to transfer control

22. Example: Pass by value
Assembly Code
.data
sum DWORD ?
.code
push 6 ; second argument
push 5 ; first argument
call AddTwo ; EAX = sum
mov sum,eax ; save the sum
00000006
00000005
return address
EBP, ESP
[EBP + 4]
[EBP + 8]
[EBP + 12]
EBP
C++ equivalent code
◦ Int sum = AddTwo( 5, 6) ;

23. Example(cont.)
AddTwo Procedure in Assembly
00000006
00000005
return address
EBP, ESP
[EBP + 4]
[EBP + 8]
[EBP + 12]
EBP

24. Example(cont.)
AddTwo Function in C++
Int AddTwo(int x , int y)
{
return x+y;
}

25. Example : Pass By Reference
The ArrayFill procedure fills an array with 0
The calling program passes the address of the array, along with a count of the
number of array elements:
.data
count = 100
array dw count DUP(?)
.code
push OFFSET array
push COUNT
call ArrayFill
offset(array)
count
EBP
[EBP + 8]
[EBP + 12]
return address
EBP

26. Pass By Reference:
ArrayFill PROC
push ebp
mov ebp,esp
pushad
mov esi,[ebp+12]
mov ecx,[ebp+8]
cmp ecx,0
jle L2
L1:
mov [esi],0
inc esi
loop L1
L2:
popad
pop ebp
ret 8
ArrayFill ENDP
offset(array)
count
EBP
[EBP + 8]
[EBP + 12]
return address
EBP

27. Leave Instruction
Assign the value of Base Pointer(EBP) in Stack Pointer(ESP)
Pop EBP from stack
leave is same as:
mov esp,ebp
pop ebp

28. Local Variables
A local variable is created, used, and destroyed within a single
Procedure
Two Methods in assembly: Reserve Memory in stack and using
LOCAL Directive
The LOCAL directive declares a list of local variables
◦ immediately follows the PROC directive
◦ each variable is assigned a type

29. LOCAL directive
Syntax:
◦ LOCAL varlist
Example:
MySub PROC
LOCAL v1:BYTE, v2:WORD, v3:DWORD

30. Local Variable
MySub PROC
push ebp
mov ebp,esp
sub esp,8
mov [ebp-4],123456h ; locA
mov [ebp-8],0 ; locB
.
.
To explicitly create local variables, subtract their total size from ESP.
The following example creates and initializes two 32-bit local variables
(we'll call them locA and locB):
[EBP+8] Parameters
[EBP+4 ] : Return Address
EBP
[EBP-4 ] : 123456
[EBP-8]: 0
ESP

31. LOCAL Example
BubbleSort PROC
LOCAL temp:DWORD, SwapFlag:DWORD
push ebp
mov ebp,esp
add esp,0FFFFFFF8h ; add -8 to ESP
. . .
mov esp,ebp
pop ebp
ret
BubbleSort ENDP

32. LOCAL Example
return address
EBP EBP
[EBP - 4]
ESP
temp
SwapFlag [EBP - 8]
Diagram of the stack frame for the BubbleSort
procedure:

33. Another Example
xyz proc
local v1:byte , v2:byte ,
v3:dword
push bp
mov bp,sp
sub sp,12
mov v1,21h
mov v2,43h
mov v3,44441111h
mov sp,bp
pop bp
ret
xyz endp

34. Recursion:
What is recursion?
Recursively Calculating a Sum
Calculating a Factorial

35. What is Recursion?
The process created when . . .
◦ A procedure calls itself repeatedly
◦ Procedure A calls procedure B, which in turn calls procedure A
Using a graph in which each node is a procedure and each edge is a procedure
call, recursion forms a cycle:
A
B
D
E
C

36. Example in C++ : recursion
Void recursive(int n)
{
n = n-1;
if(n != 0)
Recursive(n);
}

37. Recursively Calculating a Sum
The CalcSum procedure recursively calculates the sum of an
array of integers. Receives: ECX = count. Returns: EAX = sum
.code
mov ecx, 5
mov eax,0
call CalcSum
L1:
; any instructions
CalcSum PROC
cmp ecx,0 ; check counter value
jz L2 ; quit if zero
add eax,ecx ; otherwise, add to sum
dec ecx ; decrement counter
call CalcSum ; recursive call
L2: ret
CalcSum ENDP

38. Calculating a Factorial (1 of 3)
This function calculates the factorial of integer n. A new value
of n is saved in each stack frame:
int function factorial(int n)
{
if(n == 0)
return 1;
else
return n * factorial(n-1);
}
5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0!
0! = 1
(base case)
1 * 1 = 1
2 * 1 = 2
3 * 2 = 6
4 * 6 = 24
5 * 24 = 120
1 = 1
recursive calls backing up
As each call instance returns, the
product it returns is multiplied by the
previous value of n.

39. Calculating a Factorial (2 of 3)
Factorial PROC
push ebp
mov ebp,esp
mov eax,[ebp+8] ; get n
cmp eax,0 ; n < 0?
ja L1 ; yes: continue
mov eax,1 ; no: return 1
jmp L2
L1: dec eax
push eax ; Factorial(n-1)
call Factorial
; Instructions from this point on execute when each
; recursive call returns.
ReturnFact:
mov ebx,[ebp+8] ; get n
mul ebx ; eax = eax * ebx
L2: pop ebp ; return EAX
ret 4 ; clean up stack
Factorial ENDP

40. Calculating a Factorial (3 of 3)
Suppose we want to calculate
12!
This diagram shows the first
few stack frames created by
recursive calls to Factorial
Each recursive call uses 12
bytes of stack space.
12 n
n-1
ReturnMain
ebp0
11
ReturnFact
ebp1
10
ReturnFact
ebp2
9
ReturnFact
ebp3
n-2
n-3
(etc...)

41. Alert!
Using a corrupt recursive function can cause your
program damage
Stack Overflow will take place
It can also effect other data on the stack

42. Multimodule Programs
A multimodule program is a program whose source code has been
divided up into separate ASM files.
Each ASM file (module) is assembled into a separate OBJ file.
All OBJ files belonging to the same program are linked using the link
utility into a single EXE file.
◦ This process is called static linking

43. Advantages
Large programs are easier to write, maintain, and debug when divided
into separate source code modules.
• When changing a line of code, only its enclosing module needs to be
assembled again. Linking assembled modules requires little time.
• A module can be a container for logically related code and data (think
object-oriented here...)
• encapsulation: procedures and variables are automatically hidden in a
module unless you declare them public

44. Creating a Multimodule Program
Here are some basic steps to follow when creating a multimodule
program:
◦ Create the main module
◦ Create a separate source code module for each procedure or set of
related procedures
◦ Create an include file that contains procedure prototypes for external
procedures (ones that are called between modules)
◦ Use the INCLUDE directive to make your procedure prototypes
available to each module

45. Example: ArraySum Program
Let's review the ArraySum.
Summation
Program (main)
Clrscr PromptForIntegers ArraySum DisplaySum
WriteStringWriteString ReadInt WriteIntWriteInt
Each of the four white rectangles will become a module.

46. ANY QUESTION