Stack operations

Procedure

Computer Organization and Assembly Languages p g z y g g Yung-Yu Chuang

Overview

• Stack Operations

• Defining and Using Procedures

• Stack frames, parameters and local variables, p

• Recursion

• Related directives

• Related directives

Stack operations

Stack operations

Stacks

• LIFO (Last-In, First-Out) data structure.

h/ i

• push/pop operations

• You probably have had experiences on implementing it in high-level languages.

• Here, we concentrate on runtime stack, , ,

directly supported by hardware in the CPU.

It is essential for calling and returning from g g procedures.

Runtime stack

• Managed by the CPU, using two registers

SS ( t k t) – SS (stack segment)

– ESP (stack pointer) * : point to the top of the stack ll difi d b CALL RET PUSH d POP usually modified by CALL, RET, PUSH and POP

stack SS

ESP stack

segment ESP

memory

PUSH and POP instructions

• PUSH

– PUSH r/m16 – PUSH r/m32 – PUSH imm32

• POP syntax:y

– POP r/m16 – POP r/m32/

PUSH operation

• A push operation decrements the stack pointer by 2 or 4 (depending on operands) and copies a value into the 4 (depending on operands) and copies a value into the location pointed to by the stack pointer.

0FF0 0FEC

0FF0 0FEC

0FF4 0FF0

0FF4 0FF0

PUSH 0A5h

0FFC 0FF8

ESP ^0FFC

0FF8

000000A5 00000006

ESP ¹⁰⁰⁰

00000006 1000

000000A5

PUSH operation

• The same stack after pushing two more integers:

0FF0 0FEC

0FF0 0FEC

0FF4 0FF0

ESP ^0FF4

0FF0

00000002

ESP

0FFC 0FF8

000000A5 00000001

0FFC 0FF8

000000A5 00000001

00000006 1000

000000A5

00000006 1000

000000A5

PUSH 01h PUSH 02h

POP operation

• Copies value at stack[ESP] into a register or variable.

• Adds n to ESP where n is either 2 or 4 depending on

• Adds n to ESP, where n is either 2 or 4, depending on the attribute of the operand receiving the data

0FF0 0FEC

0FF0 0FEC

ESP ^0FF4

0FF0

00000002

0FF4 0FF0

0FFC 0FF8

000000A5

00000001 ESP

0FFC 0FF8

000000A5 00000001

00000006 1000

000000A5

00000006 1000

000000A5

POP EAX

When to use stacks

• Temporary save area for registers

T dd f CALL

• To save return address for CALL

• To pass arguments

• Local variables

• Applications which have LIFO nature such as

• Applications which have LIFO nature, such as reversing a string

Example of using stacks

Save and restore registers when they contain important values. Note that the PUSH and POP instructions are in

push esi ; push registers the opposite order:

push esi ; push registers push ecx

push ebx

mov esi,OFFSET dwordVal ; starting OFFSET mov ecx,LENGTHOF dwordVal; number of units mov ecx,LENGTHOF dwordVal; number of units mov ebx,TYPE dwordVal ;size of a doubleword call DumpMem ; display memory

pop ebx ; opposite order pop ecx

p p

Example: Nested Loop

When creating a nested loop, push the outer loop counter before entering the inner loop:

mov ecx,100 ; set outer loop count before entering the inner loop:

L1: ; begin the outer loop push ecx ; save outer loop count mov ecx,20 ; set inner loop count L2: ; begin the inner loop

;

;

loop L2p ; repeat the inner loopp p

pop ecx ; restore outer loop count loop L1 ; repeat the outer loop

loop L1 ; repeat the outer loop

Example: reversing a string

.data

aName BYTE "Abraham Lincoln",0 aName BYTE Abraham Lincoln ,0 nameSize = ($ - aName) – 1

.code

main PROC

P h th th t k

; Push the name on the stack.

mov ecx,nameSize mov esi,0

mov esi,0 L1:

movzx eax,aName[esi] ; get character

push eax ; push on stack

inc esi

Example: reversing a string

; Pop the name from the stack, in reverse,

; and store in the aName array.y mov ecx,nameSize

mov esi,0 L2:

pop eax ; get character mov aName[esi] al ; store in string mov aName[esi],al ; store in string inc esi

Loop L2p exit

i

main ENDP END main

Related instructions

• PUSHFD and POPFD

– push and pop the EFLAGS register

– LAHF, SAHF are other ways to save flags

• PUSHAD pushes the 32-bit general-purpose registers on the stack in the following order

– EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI

• POPAD pops the same registers off the stack in p p g reverse order

– PUSHA and POPA do the same for 16-bit registersg

Example

MySub PROC pushad pushad ...

; modify some register

; modify some register ...

popad popad ret M S b ENDP

Do not use this if your procedure uses registers for return values

MySub ENDP

Defining and using procedures

Defining and using procedures

Creating Procedures

• Large problems can be divided into smaller tasks to make them more manageable

tasks to make them more manageable

• A procedure is the ASM equivalent of a Java or C++ function

C++ function

• Following is an assembly language procedure named sample:

named sample:

sample PROC .

. retet

sample ENDP

A d bl k f t t t th t d ith t

A named block of statements that ends with a return.

Documenting procedures

• A description of all tasks accomplished by the Suggested documentation for each procedure:

• A description of all tasks accomplished by the procedure.

• Receives: A list of input parameters; state their

• Receives: A list of input parameters; state their usage and requirements.

• Returns: A description of values returned by the

• Returns: A description of values returned by the procedure.

• Requires: Optional list of requirements called

• Requires: Optional list of requirements called preconditions that must be satisfied before the procedure is called

procedure is called.

For example, a procedure of drawing lines could assume th t di l d t i l d i hi d

that display adapter is already in graphics mode.

Example: SumOf procedure

;--- SumOf PROC

SumOf PROC

;

; Calculates and returns the sum of three 32-bit

; integers

; integers.

; Receives: EAX, EBX, ECX, the three integers.

; May be signed or unsigned.

R t EAX d th t t fl

; Returns: EAX = sum, and the status flags

; (Carry, Overflow, etc.) are changed.

; Requires: nothing

;--- add eax,ebx

add eax,ecx ret

SumOf ENDP

CALL and RET instructions

• The CALL instruction calls a procedure

– pushes offset of next instruction on the stack

– copies the address of the called procedure into EIP

• The RET instruction returns from a procedure

– pops top of stack into EIP

• We used jl and jr in our toy computer for CALL and RET, BL and MOV PC, LR in ARM., ,

CALL-RET example

main PROC

00000020 ll M S b 00000020 call MySub 00000025 mov eax,ebx

0000025 is the offset

of the instruction . .

main ENDP

immediately following the CALL instruction

MySub PROC

00000040 d

00000040 i th ff t 00000040 mov eax,edx .

.

00000040 is the offset of the first instruction

inside MySub .

ret

MySub ENDP

CALL-RET example

The CALL instruction

pushes 00000025 onto ESP ^00000040

pushes 00000025 onto the stack, and loads 00000040 into EIP

ESP 00000025 EIP

The RET instruction

00000025 pops 00000025 from

the stack into EIP

ESP ^00000025

00000025

ESP EIP

Nested procedure calls

main PROC .

.

call Sub1 exit

main ENDP

0100 0050

Sub1 PROC .

.

call Sub2

0100

EIP

0150 ^ret

Sub1 ENDP Sub2 PROC

0200

EIP

0150

. .

call Sub3 ret

Sub2 ENDP

0250

Sub2 ENDP Sub3 PROC .

.

0300

Stack

ret Stack

Local and global labels

A local label is visible only to statements inside the same procedure. A global label is visible everywhere.

main PROC

jmp L2 ; error!

p g y

jmp L2 ; error!

L1:: ; global label

exit

main ENDP sub2 PROC

L2: ; local label

jmp L1 ; ok

jmp L1 ; ok

ret

sub2 ENDP

Procedure parameters

• A good procedure might be usable in many diff

different programs

• Parameters help to make procedures flexible

• Parameters help to make procedures flexible because parameter values can change at

runtime runtime

• General registers can be used to pass parameters

Procedure parameters

The ArraySum procedure calculates the sum of an array.

It makes two references to specific variable names:

ArraySum PROC

mov esi,0 ; array index

p

mov esi,0 ; array index

mov eax,0 ; set the sum to zero L1:

L1:

add eax,myArray[esi] ; add each integer to sum add esi,4 ; point to next integer

l L1 t f i

loop L1 ; repeat for array size mov theSum,eax ; store the sum

ret

ArraySum ENDP

Procedure parameters

This version returns the sum of any doubleword array whose address is in ESI. The sum is returned in EAX:

ArraySum PROC

; Recevies: ESI points to an array of doublewords,

S

; ECX = number of array elements.

; Returns: EAX = sum

;---

;

push esi push ecx

mov eax 0 ; set the sum to zero mov eax,0 ; set the sum to zero

L1: add eax,[esi] ; add each integer to sum add esi,4 ; point to next integer loop L1 repeat for arra si e loop L1 ; repeat for array size pop ecx

pop esi ret

Calling ArraySum

.data

array DWORD 10000h 20000h 30000h 40000h array DWORD 10000h, 20000h, 30000h, 40000h theSum DWORD ?

code .code

main PROC

mov esi OFFSET array mov esi, OFFSET array mov ecx, LENGTHOF array

ll A S

call ArraySum

mov theSum, eax

USES operator

• Lists the registers that will be saved (to avoid side effects) (return register shouldn’t be saved) side effects) (return register shouldn t be saved)

ArraySum PROC USES esi ecx

mov eax,0 ; set the sum to zero, ; ...

MASM generates the following code:

MASM generates the following code:

ArraySum PROC push esi

h

push ecx .

.

pop ecx pop esi ret

ArraySum ENDP

Stack frames, parameters and

local variables

Stack frame

• Also known as an activation record

A f h k id f d '

• Area of the stack set aside for a procedure's return address, passed parameters, saved

i t d l l i bl registers, and local variables

• Created by the following steps:

– Calling procedure pushes arguments on the stack and calls the procedure.

– The subroutine is called causing the return The subroutine is called, causing the return address to be pushed on the stack.

– The called procedure pushes EBP on the stack, and t EBP t ESP

sets EBP to ESP.

– If local variables are needed, a constant is

subtracted from ESP to make room on the stack.

– The registers needed to be saved are pushed.

Stack frame

ESP

saved ESP

saved registers

EBP ebp local

variables [EBP-4]

ebp

EBP

[EBP+4]

[EBP 4]

ebp

ret addr [EBP+4]

[EBP+8]

parameters ebp

Explicit access to stack parameters

• A procedure can explicitly access stack

t i t t ff t f EBP parameters using constant offsets from EBP.

– Example: [ebp + 8]

• EBP is often called the base pointer or frame

pointer because it holds the base address of the p

stack frame.

EBP does not change value during the

• EBP does not change value during the procedure.

• EBP must be restored to its original value when a procedure returns.p

Parameters

• Two types: register parameters and stack parameters

parameters.

• Stack parameters are more convenient than i t t

register parameters.

pushad push TYPE array

p

mov esi,OFFSET array mov ecx,LENGTHOF array

p y

push LENGTHOF array push OFFSET array mov ebx,TYPE array

call DumpMem popad

call DumpMem popad

register parameters stack parameters

Parameters

call by value call by reference

i t AddT ( b) i t AddT (& &b) int sum=AddTwo(a, b); int sum=AddTwo(&a, &b);

.date

a DWORD 5 b DWORD 6 push b

push a ll dd

push OFFSET b push OFFSET a

ll dd

call AddTwo call AddTwo

ESP ESP

5 6

offset(a) offset(b)

ESP ESP

( )

Stack frame example

.data

sum DWORD ? sum DWORD ? .code

push 6 ; second argument

p g

push 5 ; first argument call AddTwo ; EAX = sum

mov sum,eax ; save the sum AddTwo PROC

AddTwo PROC push ebp

mov ebp,esp

t dd

ebp EBP

[EBP+4]

.

. ⁵

ret addr [EBP+4]

[EBP+8]

Stack frame example

AddTwo PROC push ebp push ebp

mov ebp,esp ; base of stack frame mov eax,[ebp + 12] ; second argument (6) mov eax,[ebp + 12] ; second argument (6) add eax,[ebp + 8] ; first argument (5) pop ebp

p p p

ret 8 ; clean up the stack AddTwo ENDP ; EAX contains the sum

ebp EBP

Who should be responsible to

5

ret addr [EBP+4]

[EBP+8]

remove arguments? It depends on the language model.

RET Instruction

• Return from subroutine

Pops stack into the instruction pointer (EIP or

• Pops stack into the instruction pointer (EIP or IP). Control transfers to the target address.

Syntax:

• Syntax:

– RET RET n – RET n

• Optional operand n causes n bytes to be added to the stack pointer after EIP (or IP) is assigned to the stack pointer after EIP (or IP) is assigned a value.

Passing arguments by reference

• The ArrayFill procedure fills an array with 16 bit random integers

16-bit random integers

• The calling program passes the address of the l ith t f th b f array, along with a count of the number of array elements:

.data

count = 100

( ) array WORD count DUP(?) .code

push OFFSET array push OFFSET array push COUNT

call ArrayFill

Passing arguments by reference

ArrayFill can reference an array without knowing the array's name:

ArrayFill PROC

knowing the array s name:

y EBP

push ebp

mov ebp,esp

h d ^{ret addr}

ebp EBP

[EBP+4]

pushad

mov esi,[ebp+12]

mov ecx [ebp+8] _{ff t( )}

count [EBP+8]

[EBP+12]

mov ecx,[ebp+8]

. .

offset(array) [EBP+12]

Passing 8-bit and 16-bit arguments

• When passing stack arguments, it is best to

push 32 bit operands to keep ESP aligned on a push 32-bit operands to keep ESP aligned on a doubleword boundary.

Uppercase PROC push ebp

mov ebp, esp

push ‘x’ ; error Call Uppercase

mov ebp, esp

mov al, [ebp+8]

cmp al, ‘a’

jb L1 .data

jb L1

cmp al, ‘z’

ja L1

b l 32

charVal BYTE ‘x’

.code

movzx eax, charVal sub al, 32

L1: pop ebp ret 4

, push eax

Call Uppercase Uppercase ENDP

Saving and restoring registers

• When using stack parameters, avoid USES.

M S b2 PROC USES ec ed MySub2 PROC USES ecx, edx

push ebp

mov ebp, esp

MySub2 PROC push ecx push edx mov eax, [ebp+8]

pop ebp ret 4

p

push ebp

mov ebp, esp

mov eax, [ebp+8]

MySub2 ENDP

mov eax, [ebp+8]

pop ebp pop edx pop ecx

ESP,EBP

ebp pop ecx

ret 4

MySub2 ENDP edx

[EBP 8]

ebp

ecx ret addr

[EBP+8]

Local variables

• The variables defined in the data segment can be taken as static global variables

be taken as static global variables.

visibility=the whole program lifetime=program duration

visibility the whole program

• A local variable is created, used, and destroyed within a single procedure (block)

within a single procedure (block)

• Advantages of local variables:

Restricted access: easy to debug less error prone – Restricted access: easy to debug, less error prone – Efficient memory usage

– Same names can be used in two different proceduresSame names can be used in two different procedures

Creating local variables

• Local variables are created on the runtime stack usually above EBP

stack, usually above EBP.

• To explicitly create local variables, subtract th i t t l i f ESP

their total size from ESP.

MySub PROC

push ebp ^[EBP-8]

mov ebp,esp sub esp,8

mov [ebp 4] 123456h EBP ^ebp ESP^[EBP-4]

mov [ebp-4],123456h mov [ebp-8],0

. ret addr

p

…[EBP+4]

. …

Local variables

• They can’t be initialized at assembly time but can be assigned to default values at runtime can be assigned to default values at runtime.

void MySub()

MySub PROC push ebp

mov ebp, esp ²⁰

void MySub() {

int X=10;

int Y=20;

sub esp, 8

mov DWORD PTR [ebp-4], 10

mov DWORD PTR [ebp-8], 20 _EBP 10 int Y=20;

...

}

[ p ], ...

mov esp, ebp pop ebp

return ESP address

EBP

pop ebp ret

MySub ENDP

stack EBP

Local variables

X_local EQU DWORD PTR [ebp-4]

MySub PROC

Y_local EQU DWORD PTR [ebp-8]

MySub PROC push ebp

mov ebp, esp sub esp, 8

mov DWORD PTR [ebp-4], 10 mov DWORD PTR [ebp 8] 20

mov X_local, 10 mov Y local 20

mov DWORD PTR [ebp-8], 20 ...

mov esp, ebp

mov Y_local, 20 mov esp, ebp

pop ebp ret

LEA instruction (load effective address)

• The LEA instruction returns offsets of both direct and indirect operands at run time direct and indirect operands at run time.

– OFFSET only returns constant offsets (assemble time).

i i d h bt i i th ff t f

• LEA is required when obtaining the offset of a stack parameter or local variable. For example:

CopyString PROC, count:DWORD

[20]

LOCAL temp[20]:BYTE

mov edi OFFSET count; invalid operand mov edi,OFFSET count; invalid operand mov esi,OFFSET temp ; invalid operand lea edi,count ; ok

LEA example

void makeArray() {

makeArray PROC push ebp {

char myString[30];

for (int i=0; i<30; i++) m String[i] ‘*’

push ebp

mov ebp, esp sub esp, 32

lea esi [ebp 30]

myString[i]=‘*’;

}

lea esi, [ebp-30]

mov ecx, 30

L1: mov BYTE PTR [esi], ‘*’

inc esi loop L1

add esp 32 pop ebp

ret

makeArray ENDPy

ENTER and LEAVE

• ENTER instruction creates stack frame for a called procedure

called procedure

– pushes EBP on the stack push ebp

– set EBP to the base of stack frame mov ebp, espset EBP to the base of stack frame mov ebp, esp – reserves space for local variables sub esp, n

• ENTER nbytes, nestinglevelENTER nbytes, nestinglevel

– nbytes (for local variables) is rounded up to a

multiple of 4 to keep ESP on a doubleword boundary – nestinglevel: 0 for now

MySub PROC MySub PROC MySub PROC

enter 8,0

MySub PROC push ebp

mov ebp,esp mov ebp,esp

ENTER and LEAVE

• LEAVE reverses the action of a previous ENTER instruction

instruction.

MySub PROC

MySub PROC y

push ebp

mov ebp, esp MySub PROC

enter 8, 0 .

sub esp, 8 .

. .

.

mov esp, ebp pop ebp

.

leave

ret p p p

ret

MySub ENDP ret

MySub ENDP

LOCAL directive

• The LOCAL directive declares a list of local i bl

variables

– immediately follows the PROC directive – each variable is assigned a type

• Syntax:

LOCAL varlist

Example:a ple:

MySub PROC

LOCAL var1:BYTE var2:WORD var3:SDWORD LOCAL var1:BYTE, var2:WORD, var3:SDWORD

MASM-generated code

BubbleSort PROC

LOCAL temp:DWORD, SwapFlag:BYTEp , p g . . .

ret

B bbl S t ENDP BubbleSort ENDP

MASM generates the following code:

BubbleSort PROC push ebp

mov ebp esp mov ebp,esp

add esp,0FFFFFFF8h ; add -8 to ESP . . .

mov esp,ebp pop ebp

ret ret

Non-Doubleword Local Variables

• Local variables can be different sizes

• How are they created in the stack by LOCAL directive:

– 8-bit: assigned to next available byte

– 16-bit: assigned to next even (word) boundary – 32-bit: assigned to next doubleword boundary

MASM-generated code

ESP ^[EBP-8]

[EBP 4]

SwapFlag

[EBP-4]

p g

temp

ebp EBP

ebp

mov eax, temp, p mov eax, [ebp-4], [ p ]

Reserving stack space

• .STACK 4096

b1 ll b2 b2 ll b3 h

• Sub1 calls Sub2, Sub2 calls Sub3, how many bytes will you need in the stack?

Sub1 PROC

LOCAL array1[50]:DWORD ; 200 bytes Sub2 PROC

LOCAL array2[80]:WORD ; 160 bytes Sub3 PROC

LOCAL array3[300]:WORD ; 300 bytes 660+8(ret addr)+saved registers…

Recursion

Recursion

Recursion

• The process created when . . .

A d ll it lf

– A procedure calls itself

– Procedure A calls procedure B, which in turn calls procedure A

calls procedure A

• Using a graph in which each node is a

d d h dg i d ll

procedure and each edge is a procedure call, recursion forms a cycle:

A

B

E B

E

Calculating a factorial

This function calculates the factorial of integer n.

A new value of n is saved in each stack frame:

5! = 5 * 4! 5 * 24 = 120 recursive calls backing up

A new value of n is saved in each stack frame:

int factorial(int n)

{ 5! 5 4!

4! = 4 * 3! 4 * 6 = 24 5 24 120

{

if (n == 0) return 1;

3! = 3 * 2! 3 * 2 = 6

else

return n*factorial(n-1);

} 2! = 2 * 1!

1! = 1 * 0! 1 * 1 = 1 2 * 1 = 2

}

1! 1 0!

0! = 1

1 1 1

1 = 1

factorial(5);

Calculating a factorial

Factorial PROC push ebp

mov ebp,esp

mov eax,[ebp+8] ; get n cmp eax,0p ; n > 0?

ja L1 ; yes: continue mov eax,1 ; no: return 1 jmp L2

j p

L1:dec eax

push eax ; Factorial(n-1) call Factorial

ReturnFact:

mov ebx,[ebp+8] ; get n mov ebx,[ebp+8] ; get n

mul ebx ; edx:eax=eax*ebx L2:pop ebp ; return EAX

L2:pop ebp ; return EAX

ret 4 ; clean up stack

Calculating a factorial

push ebp

mov ebp,esp ebp

mov eax,[ebp+8]

cmp eax,0 ret Factorial ebp

p

ja L1

mov eax,1 jmp L2

0…

j p

L1:dec eax push eax

call Factorial

t F t i l ebp

ReturnFact:

mov ebx,[ebp+8] ¹¹

ret Factorial

mov ebx,[ebp+8]

mul ebx

L2:pop ebp ^{ret main}

ebp

L2:pop ebp

Related directives

Related directives

.MODEL directive

• .MODEL directive specifies a program's memory

d l d d l ti (l ifi )

model and model options (language-specifier).

• Syntax:

.MODEL memorymodel [,modeloptions]

• memorymodel can be one of the following:

• memorymodel can be one of the following:

– tiny, small, medium, compact, large, huge, or flat

i l d h l ifi

• modeloptions includes the language specifier:

– procedure naming scheme

– parameter passing conventions

• .MODEL flat, STDCALL.MODEL flat, STDCALL

Memory models

• A program's memory model determines the number and sizes of code and data segments number and sizes of code and data segments.

• Real-address mode supports tiny, small,

di t l d h d l

medium, compact, large, and huge models.

• Protected mode supports only the flat model.

Small model: code < 64 KB, data (including stack) < 64 KB.

All offsets are 16 bits.

Flat model: single segment for code and data, up to 4 GB. g g , p All offsets are 32 bits.

Language specifiers

• STDCALL (used when calling Windows functions)

– procedure arguments pushed on stack in reverse procedure arguments pushed on stack in reverse order (right to left)

– called procedure cleans up the stack

@ (f l dd @8)

– _name@nn (for example, _AddTwo@8)

• C

procedure arguments pushed on stack in reverse – procedure arguments pushed on stack in reverse

order (right to left)

– calling program cleans up the stack (variable number

f h )

of parameters such as printf) – _name (for example, _AddTwo)

• PASCAL

• PASCAL

– arguments pushed in forward order (left to right) – called procedure cleans up the stackcalled procedure cleans up the stack

INVOKE directive

• The INVOKE directive is a powerful replacement for Intel’s CALL instruction that lets you pass

for Intel s CALL instruction that lets you pass multiple arguments

• Syntax:

• Syntax:

INVOKE procedureName [, argumentList]

• ArgumentListArgumentList is an optional comma-delimited is an optional comma delimited list of procedure arguments

• Arguments can be:

• Arguments can be:

– immediate values and integer expressions – variable namesvariable names

– address and ADDR expressions – register namesg

INVOKE examples

.data

byteVal BYTE 10y

wordVal WORD 1000h .code

di t d

; direct operands:

INVOKE Sub1,byteVal,wordVal

; address of variable:

INVOKE Sub2,ADDR byteVal

; register name, integer expression:

INVOKE Sub3,eax,(10 * 20) INVOKE Sub3,eax,(10 20)

; address expression (indirect operand):

INVOKE example

.data

val1 DWORD 12345h val1 DWORD 12345h val2 DWORD 23456h

code .code

INVOKE AddTwo, val1, val2 push val1

h l2 push val2 call AddTwo

ADDR operator

• Returns a near or far pointer to a variable, depending on which memory model your depending on which memory model your program uses:

Small model: returns 16 bit offset

• Small model: returns 16-bit offset

• Large model: returns 32-bit segment/offset Fl d l 32 bi ff

• Flat model: returns 32-bit offset

• Simple example:

.data

myWord WORD ? .code

INVOKE mySub,ADDR myWord

ADDR example

.data

A DWORD 20 DUP(?) Array DWORD 20 DUP(?) .code

...

INVOKE Swap, ADDR Array, ADDR [Array+4]

push OFFSET Array+4 push OFFSET Array Call Swap

PROC directive

•The PROC directive declares a procedure with an optional list of named parameters

an optional list of named parameters.

•Syntax:

label PROC [attributes] [USES] 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.

• Example: foo PROC C USES eax, param1:DWORD

PROC example

• The AddTwo procedure receives two integers and returns their sum in EAX

returns their sum in EAX.

• C++ programs typically return 32-bit integers from functions in EAX

AddTwo PROC,

functions in EAX.

AddTwo PROC, ,

val1:DWORD, val2:DWORD

, push ebp

mov ebp, esp

8 mov eax,val1

add eax val2

mov eax, dword ptr [ebp+8]

add eax, dword ptr [ebp+0Ch]

leave add eax,val2

ret

AddTwo ENDP

leave ret 8

AddTwo ENDP

PROC example

Read_File PROC USES eax, ebx, pBuffer:PTR BYTE

LOCAL fileHandle:DWORD

mov esi, pBuffer Read_File PROC h b

o es , p u e

mov fileHandle, eax .

push ebp

mov ebp, esp

add esp, 0FFFFFFFCh .

ret

Read_File ENDP

push eax push ebx

mov esi, dword ptr [ebp+8]

mov dword ptr [ebp-4], eax .

. .

pop ebx pop eax ret

ret

PROTO directive

• Creates a procedure prototype S

• Syntax:

– label PROTO paramList

• Every procedure called by the INVOKE directive must have a prototype

• A complete procedure definition can also serve as its own prototypep yp

PROTO directive

• Standard configuration: PROTO appears at top of the li ti INVOKE i th d t program listing, INVOKE appears in the code segment, and the procedure implementation occurs later in

the program:

the program:

MySub PROTO ; procedure prototype .code

INVOKE MySub ; procedure call

MySub PROC ; procedure implementation MySub PROC ; procedure implementation

. .

PROTO example

• Prototype for the ArraySum procedure,

h i i li

showing its parameter list:

ArraySum PROTO, ArraySum PROTO,

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

ArraySum PROC USES esi, ecx,

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

Multimodule programs

Multimodule programs

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

separate OBJ file.

• All OBJ files belonging to the same program li k d i th li k tilit i t i l are linked using the link utility into a single EXE file.

– This process is called static linking

Advantages

• Large programs are easier to write, maintain, and debug when divided into separate source and debug when divided into separate source code modules.

Wh h i li f d l it

• When changing a line of code, only its enclosing module needs to be assembled again Linking assembled modules requires again. Linking assembled modules requires little time.

A d l b t i f l i ll

• A module can be a container for logically related code and data

• encapsulation: procedures and variables are automatically hidden in a module unless you declare them public

declare them public

Creating a multimodule program

• Here are some basic steps to follow when ti lti d l

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

Multimodule programs

• MySub PROC PRIVATE sub1 PROC PUBLIC sub1 PROC PUBLIC

• EXTERN sub1@0:PROC

• EXTERN sub1@0:PROC PUBLIC count SYM1

• PUBLIC count, SYM1 SYM1=10

d t .data

count DWORD 0

• EXTERN name:type

INCLUDE file

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

INCLUDE Irvine32.inc

u ct o s t at a e ot t e v e3 l b a y:

PromptForIntegers PROTO,

ptrPrompt:PTR BYTE, ; prompt string

t A PTR DWORD i t t th

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 ptrPrompt:PTR BYTE, ; prompt string

Main.asm

TITLE Integer Summation Program INCLUDE sum.inc

code .code

main PROC

call Clrscr

INVOKE PromptForIntegers, ADDR prompt1,

ADDR array ADDR array, Count

...

call Crlf

INVOKE ExitProcess,0 main ENDP

main ENDP