Week 10

Chapter 8: Advanced Procedures

Class 20 (From Book's Page No 303)

 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs

37
 Recursion

• What is Recursion?
• Recursively Calculating a Sum
• Calculating a Factorial

38
 What is Recursion?

• The process created when . . .

• A procedure calls itself
• 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

E B

D C

39
 Recursively Calculating a Sum
The CalcSum procedure recursively calculates the sum of an
array of integers. Receives: ECX = count. Returns: EAX = sum
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

Stack frame:

40
 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:
recursive calls backing up
int function factorial(int n)
{ 5! = 5 * 4! 5 * 24 = 120
if(n == 0)
return 1; 4! = 4 * 3! 4 * 6 = 24
else
return n * factorial(n-1); 3! = 3 * 2! 3*2=6
}
2! = 2 * 1! 2*1=2

As each call instance returns, the 1! = 1 * 0! 1*1=1

product it returns is multiplied by the
previous value of n. 0! = 1 1=1
(base case)

41
 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

See the program listing

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

43
 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs
• Java Bytecodes

44
INVOKE, ADDR, PROC, and PROTO

• INVOKE Directive
• ADDR Operator
• PROC Directive
• PROTO Directive
• Parameter Classifications
• Example: Exchaning Two Integers
• Debugging Tips

45
Not in 64-bit INVOKE Directive
mode!
• In 32-bit mode, the INVOKE directive is a powerful
replacement for Intel’s CALL instruction that lets you
pass multiple arguments
• 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

46
 INVOKE Examples

.data
byteVal BYTE 10
wordVal WORD 1000h
.code
; direct operands:
INVOKE Sub1,byteVal,wordVal

; address of variable:
INVOKE Sub2,ADDR byteVal

; register name, integer expression:

INVOKE Sub3,eax,(10 * 20)

; address expression (indirect operand):

INVOKE Sub4,[ebx]

47
Not in 64-bit ADDR Operator
mode!
• Returns a near or far pointer to a variable, depending on
which memory model your program uses:
• Small model: returns 16-bit offset
• Large model: returns 32-bit segment/offset
• Flat model: returns 32-bit offset
• Simple example:

.data
myWord WORD ?
.code
INVOKE mySub,ADDR myWord

48
Not in 64-bit PROC Directive (1 of 2)
mode!
• 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.

49
 PROC Directive (2 of 2)

• Alternate format permits parameter list to be on one or

more separate lines:
label PROC, comma required

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

50
 AddTwo Procedure (1 of 2)

• The AddTwo procedure receives two integers and returns

their sum in EAX.

AddTwo PROC,
val1:DWORD, val2:DWORD

mov eax,val1
add eax,val2

ret
AddTwo ENDP

51
 PROC Examples (2 of 3)

FillArray receives a pointer to an array of bytes, a single byte fill

value that will be copied to each element of the array, and the
size of the array.

FillArray PROC,
pArray:PTR BYTE, fillVal:BYTE
arraySize:DWORD

mov ecx,arraySize
mov esi,pArray
mov al,fillVal
L1: mov [esi],al
inc esi
loop L1
ret
FillArray ENDP

52
 PROC Examples (3 of 3)

Swap PROC,
pValX:PTR DWORD,
pValY:PTR DWORD
. . .
Swap ENDP

ReadFile PROC,
pBuffer:PTR BYTE
LOCAL fileHandle:DWORD
. . .
ReadFile ENDP

53
 PROTO Directive

• Creates a procedure prototype

• Syntax:
• label PROTO paramList
• Parameter list not permitted in 64-bit mode
• Every procedure called by the INVOKE directive must
have a prototype
• A complete procedure definition can also serve as its
own prototype

54
 PROTO Directive
• 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

55
 PROTO Example
• Prototype for the ArraySum procedure, showing its
parameter list:

ArraySum PROTO,
ptrArray:PTR DWORD, ; points to the array
szArray:DWORD ; array size

Parameters are not permitted in 64-bit mode.

56
 Parameter Classifications
• An input parameter is data passed by a calling program to a
procedure.
• The called procedure is not expected to modify the
corresponding parameter variable, and even if it does, the
modification is confined to the procedure itself.
• An output parameter is created by passing a pointer to a variable
when a procedure is called.
• The procedure does not use any existing data from the variable,
but it fills in a new value before it returns.

• An input-output parameter is a pointer to a variable containing input

that will be both used and modified by the procedure.
• The variable passed by the calling program is modified.

57
 Trouble-Shooting Tips

• Save and restore registers when they are modified by a

procedure.
• Except a register that returns a function result

• When using INVOKE, be careful to pass a pointer to the correct

data type.
• For example, MASM cannot distinguish between a DWORD
argument and a PTR BYTE argument.

• Do not pass an immediate value to a procedure that expects a

reference parameter.
• Dereferencing its address will likely cause a general-
protection fault.

58
 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs

59
 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

60
 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

61
 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

62
 Example: ArraySum Program
• Let's review the ArraySum program from Chapter 5.

Summation
Program (main)

Clrscr PromptForIntegers ArraySum DisplaySum

WriteString ReadInt WriteString WriteInt

Each of the four white rectangles will become a module. This

will be a 32-bit application.
63
 Sample Program output

Enter a signed integer: -25

Enter a signed integer: 36

Enter a signed integer: 42

The sum of the integers is: +53

64
 INCLUDE File
The sum.inc file contains prototypes for external functions that
are not in the Irvine32 library:
INCLUDE Irvine32.inc

PromptForIntegers PROTO,
ptrPrompt:PTR BYTE, ; prompt string
ptrArray:PTR DWORD, ; points to the array
arraySize:DWORD ; size of the array

ArraySum PROTO,
ptrArray:PTR DWORD, ; points to the array
count:DWORD ; size of the array

DisplaySum PROTO,
ptrPrompt:PTR BYTE, ; prompt string
theSum:DWORD ; sum of the array

65
 Summary
• Stack parameters
• more convenient than register parameters
• passed by value or reference
• ENTER and LEAVE instructions
• Local variables
• created on the stack below stack pointer
• LOCAL directive
• Recursive procedure calls itself
• Calling conventions (C, stdcall)
• MASM procedure-related directives
• INVOKE, PROC, PROTO

66