Assembly Language for x86

Processors 7th Edition

Kip R. Irvine

Chapter 8: Advanced
Procedures

Slides prepared by the author.

Revision date: 1/15/2014

(c) Pearson Education, 2014. All rights reserved. You may modify and copy this slide show for your
personal use, or for use in the classroom, as long as this copyright statement, the author's name, and
the title are not changed.
 Chapter Overview

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs
• Advanced Use of Parameters
(optional)
• Java Bytecodes (optional)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 2

2014.
 Stack Frames

• Stack Parameters
• Local Variables
• ENTER and LEAVE
Instructions
• LOCAL Directive
• WriteStackFrame Procedure

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 3

2014.
 Stack Frame
• Also known as an activation record
• Area of the stack set aside for a procedure's
return address, passed parameters,
saved registers, and local variables
• Created by the following steps:
• Calling program pushes arguments on the
stack and calls the procedure.
• The called procedure pushes EBP on the
stack, and sets EBP to ESP.
• If local variables are needed, a constant is
subtracted from ESP to make room on the
stack.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 4

2014.
 Stack Parameters
• More convenient than register parameters
• Two possible ways of calling DumpMem.
Which is easier?

pushad push TYPE array

mov esi,OFFSET array push LENGTHOF array
mov ecx,LENGTHOF array push OFFSET array
mov ebx,TYPE array call DumpMem
call DumpMem
popad

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 5

2014.
 Passing Arguments by Value
• Push argument values on stack
• (Use only 32-bit values in protected mode to
keep the stack aligned)

• Call the called-procedure

• Accept a return value in EAX, if any

• Remove arguments from the stack if the

called- procedure did not remove them

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 6

2014.
 Example

.data
val1 DWORD 5 (val2 6
val2 DWORD 6 ) 5 ESP
(val1
.code )
push val2
push val1
Stack prior to
CALL

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 7

2014.
 Passing by Reference
• Push the offsets of arguments on the
stack
• Call the procedure

• Accept a return value in EAX, if any

• Remove arguments from the stack if the

called procedure did not remove them

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 8

2014.
 Example

.data (offset 00000004

val1 DWORD 5 00000000
val2 DWORD 6
val2) ESP
(offset
.code val1)
push OFFSET val2
push OFFSET val1 Stack prior to
CALL

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 9

2014.
 Stack after the CALL

value or addr of
val2

value or addr of
val1 ESP
return address

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 10

2014.
 Passing an Array by Reference (1
of 2)
• The ArrayFill procedure fills an array with
16-bit random integers
• The calling program passes the address of the
array, along with a count of the number of
array elements:

.data
count = 100
array WORD
count
DUP(?)
.code
push OFFSET array
push COUNT
call ArrayFill

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 11

2014.
 Passing an Array by Reference (2
of 2)
ArrayFill can reference an array without knowing
the array's name:

ArrayFill PROC
push ebp offset(arra [EBP +
mov 12]
y) count
ebp,esp
mov esi,[ebp+12]
pushad return [EBP + 8]
mov ecx,[ebp+8] address
EBP
. EBP
.

ESI points to the beginning of the array, so it's easy to

use a loop to access each array element. View the
complete program.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 12

2014.
 Accessing Stack Parameters
(C/C++)
• C and C++ functions access stack
parameters using constant offsets from EBP1.
• Example: [ebp + 8]
• EBP is called the base pointer or frame pointer
because it holds the base address of the stack
frame.
• EBP does not change value during the
function.
• EBP must be restored to its original value
when a function returns.
1 BP in Real-address
mode
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 13
2014.
 RET Instruction

• Return from subroutine

• Pops stack into the instruction pointer (EIP
or IP). Control transfers to the target
address.
• Syntax:
• RET
• RET n
• Optional operand n causes n bytes to be added
to the stack pointer after EIP (or IP) is
assigned a value.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 14

2014.
 Who removes parameters from the
stack?
Caller (C) ...... Called-procedure
or ......
(STDCALL): AddTwo PROC
push val2 push ebp
push val1 mov ebp,esp
call AddTwo mov eax,
[ebp+12]
add esp,8 add eax,
[ebp+8]
pop ebp
ret 8
( Covered later: The MODEL directive specifies calling
conventions )

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 15

2014.
 Your turn . . .
• Create a procedure named Difference that
subtracts the first argument from the
second one. Following is a sample call:
push 14 ; first argument
push 30 ; second argument
call Difference ; EAX = 16

Difference PROC
push ebp
mov ebp,esp
mov eax,[ebp + 8] ; second argument
sub eax,[ebp + ; first argument
12] pop ebp
ret 8
Difference ENDP

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 16

2014.
 Passing 8-bit and 16-bit
Arguments
• Cannot push 8-bit values on stack
• Pushing 16-bit operand may cause page
fault or ESP alignment problem
• incompatible with Windows API functions
• Expand smaller arguments into 32-bit
values, using MOVZX or MOVSX:
.data
charVal BYTE 'x'
.code
movzx eax,charVal
push eax
call Uppercase

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 17

2014.
 Passing Multiword Arguments
• Push high-order values on the stack first; work
backward in memory
• Results in little-endian ordering of data
• Example:
.data
longVal DQ 1234567800ABCDEFh
.code
push DWORD PTR longVal + 4 ; high doubleword
push DWORD PTR longVal ; low doubleword
call WriteHex64

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 18

2014.
 Saving and Restoring Registers
• Push registers on stack just after assigning
ESP to EBP
• local registers are modified inside the
procedure

push PROC
MySub ebp
mov ebp,esp
push ecx ; save local registers
push edx

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 19

2014.
 Stack Affected by USES
Operator
MySub1 PROC USES ecx edx
ret
MySub1 ENDP

• USES operator generates code to save and

restore registers:
MySub1 PROC
push ecx
push edx

pop

edx
pop ecx
ret

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 20

2014.
 Local Variables
• Only statements within subroutine can view or
modify local variables
• Storage used by local variables is released
when subroutine ends
• local variable name can have the same
name as a local variable in another
function without creating a name clash
• Essential when writing recursive procedures,
as well as procedures executed by multiple
execution threads

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 21

2014.
 Creating LOCAL Variables

Example - create two DWORD local

variables: Say: int x=10, y=20;
ret
address EBP
saved ebp [ebp-
MySub PROC 10 (x) 4]
push ebp 20 (y) [ebp-
mov ebp,esp 8]
sub esp,8 ;create 2 DWORD variables

mov DWORD PTR [ebp-4],10 ; initialize x=10

mov DWORD PTR [ebp-8],20 ; initialize y=20

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 22

2014.
 LEA Instruction
• LEA returns offsets of direct and indirect
operands
• OFFSET operator only returns constant
offsets
• LEA required when obtaining offsets of
stack parameters & local variables
• Example
CopyString PROC,
count:DWORD
mov edi,OFFSET count ; invalid operand
LOCAL
mov esi,OFFSET temp ; invalid operand
temp[20]:BYT
lea edi,count ; ok
E
lea esi,temp ; ok

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 23

2014.
 LEA Example

Suppose you have a Local variable at [ebp-8]

And you need the address of that local variable

in ESI
You cannot use this:
mov esi, OFFSET [ebp-8] ; error

Use this instead:

lea esi,[ebp-8]

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 24

2014.
 ENTER Instruction
• ENTER instruction creates stack frame for a
called procedure
• pushes EBP on the stack
• sets EBP to the base of the stack frame
• reserves space for local variables
• Example:
MySub PROC
enter 8,0
• Equivalent
to:
MySub PROC
push ebp
mov ebp,esp
sub esp,8

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 25

2014.
 LEAVE Instruction
Terminates the stack frame for a procedure.
Equivalent
operations
MySub PROC push ebp
enter mov
8,0 ebp,esp sub ; 2 local
... esp,8 DWORDs
...
leav
... mov esp,ebp ; free local
e ret space pop ebp
MySub
ENDP

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 26

2014.
 LOCAL Directive

• The LOCAL directive declares a list of

local variables
• immediately follows the PROC
directive
• each variable is assigned a type
• Syntax:
LOCAL varlist
Example:

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 27

2014.
 Using LOCAL

Example
s:
LOCAL flagVals[20]:BYTE ; array of bytes

LOCAL pArray:PTR WORD ; pointer to an array

myProc PROC, ; procedure

LOCAL t1:BYTE, ; local variables

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 28

2014.
 LOCAL Example (1 of 2)

BubbleSort PROC
LOCAL
temp:DWORD,
SwapFlag:BYTE
. . .
ret
BubbleSort ENDP

MASM
generates the
mov ebp,esp
following code:
add esp,0FFFFFFF8h ; add -8 to ESP
. . .
BubbleSort
mov
PROC push ebp
esp,ebp pop
ebp
ret
BubbleSort ENDP
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 29
2014.
 LOCAL Example (2 of 2)

Diagram of the stack frame for the

BubbleSort procedure:

return address
EBP EBP
temp [EBP -
ESP SwapFla 4]
g [EBP
- 8]

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 30

2014.
 Non-Doubleword Local Variables

• Local variables can be different sizes

• How 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 31

2014.
 Local Byte Variable

Example1 PROC
LOCAL var1:BYTE
mov al,var1 ; [EBP - 1]
ret
Example1 ENDP

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 32

2014.
 WriteStackFrame Procedure
• Displays contents of current stack
frame
• Prototype:

numParam:DWORD,
WriteStackFrame PROTO,; number of passed parameters
numLocalVal: DWORD, ; number of DWordLocal variables
numSavedReg: DWORD ; number of saved registers

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 33

2014.
 WriteStackFrame Example
main PROC
mov eax, 0EAEAEAEAh
mov ebx, 0EBEBEBEBh
INVOKE aProc,
1111h, 2222h
exit
main ENDP

aProc PROC USES eax ebx,

x: DWORD, y: DWORD
LOCAL a:DWORD, b:DWORD
PARAMS = 2
LOCALS = 2
SAVED_REGS = 2
mov a,0AAAAh
mov b,0BBBBh
INVOKE
WriteStackF
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 34
2014. rame,
 The Microsoft x64 Calling
Convention
• CALL subtracts 8 from RSP
• First four parameters are placed in RCX,
RDX, R8, and R9. Additional parameters are
pushed on the stack.
• Parameters less than 64 bits long are
not zero extended
• Return value in RAX if <= 64 bits
• Caller must allocate at least 32 bytes of
shadow space so the subroutine can copy
parameter values

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 35

2014.
 The Microsoft x64 Calling
Convention
• Caller must align RSP to 16-byte boundary
• Caller must remove all parameters from
the stack after the call
• Return value larger than 64 bits must be
placed on the runtime stack, with RCX
pointing to it
• RBX, RBP, RDI, RSI, R12, R14, R14, and R15
registers are preserved by the subroutine; all
others are not.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 36

2014.
 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs
• Advanced Use of Parameters
(optional)
• Java Bytecodes (optional)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 37

2014.
 Recursion

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 38

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 39

2014.
 Recursively Calculating a Sum
The CalcSum procedure recursively calculates the sum
of an array of integers. Receives: ECX = count.
Returns: EAX = sum
cmp ecx,0
CalcSum PROC ; 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

View the
Stack complete
program
frame:

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 40

2014.
 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
int function factorial(int n) up
{ 5! = 5 * 4! 5 * 24 =
120
if(n == 0)
return 1; 4! = 4 * 3! 4 * 6 = 24
else
return 3! = 3 * 2! 3*2=6
n *
factorial 2! = 2 * 1! 2*1=2
(n-1);
As}each call instance returns, 1! = 1 * 0! 1*1=1
the product it returns is
multiplied by the previous 0! = 1 1=1
(base
value of n. case)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 41

2014.
 Calculating a Factorial (2 of 3)

Factorial PROC
push ebp
mov
mov eax,[ebp+8]
ebp,esp ; 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: ebp ; return EAX
ret
pop 4 ; clean up stack
Factorial ENDP

See the program

Irvine, Kip [Link]
Assembly Language for x86 Processors 7/e, 42
2014.
 Calculating a Factorial (3 of 3)
12 n
ReturnMain
ebp
Suppose we want
11 n-
to calculate 12! 0
1
Return
This diagram shows Fact
the first few stack ebp
frames created by 1 10 n-
recursive calls to Return
2
Factorial Fact
ebp
Each recursive call
9 n-
uses 12 bytes of 2
3
stack space. ReturnFact
ebp3
(etc...)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 43

2014.
 What's Next

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 44

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 45

2014.
Not in 64- INVOKE
bit mode!
Directive
• 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 46

2014.
 INVOKE Examples

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

; address of
variable:
INVOKE
Sub2,ADDR
byteVal

; register name, integer expression:

INVOKE Sub3,eax,(10 * 20)
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 47
2014.
Not in 64- ADDR
bit mode!
Operator
• 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 48

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 49

2014.
 PROC Directive (2 of 2)

• Alternate format permits parameter list to be

on one or more separate lines:
label PROC, comma
required
paramLi
• Thestparameters 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 50

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 51

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 52

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 53

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 54

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 55

2014.
 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.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 56

2014.
 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.
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 57
2014.
 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.

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 58

2014.
 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs
• Advanced Use of Parameters
(optional)
• Java Bytecodes (optional)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 59

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 60

2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 61

2014.
 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
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 62
2014.
module
 Example: ArraySum Program
• Let's review the ArraySum program from
Chapter 5.
Summation
Program
(main)

Clrsc PromptForIntege ArraySu DisplaySu

r rs m m

WriteStrin ReadIn WriteStrin WriteIn

WriteI
g t g tnt

Each of the four white rectangles will become a

module. This will be a 32-bit application.
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 63
2014.
 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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 64

2014.
 INCLUDE File
The [Link] file contains prototypes for external
functions that are not in the Irvine32 library:
INCLUDE [Link]

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

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 65

2014.
 Inspect Individual Modules

• Main
• PromptForIntege
rs
• ArraySum
• DisplaySum

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 66

2014.
 What's Next

• Stack Frames
• Recursion
• INVOKE, ADDR, PROC, and PROTO
• Creating Multimodule Programs
• Advanced Use of Parameters
(optional)
• Java Bytecodes (optional)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 67

2014.
 Java Bytecodes
• Stack-oriented instruction format
• operands are on the stack
• instructions pop the operands, process,
and push result back on stack
• Each operation is atomic
• Might be be translated into native code by a
just in time compiler

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 68

2014.
 Java Virual Machine (JVM)
• Essential part of the Java Platform
• Executes compiled bytecodes
• machine language of compiled Java
programs

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 69

2014.
 Java Methods
• Each method has its own stack
frame
• Areas of the stack frame:
• local variables
• operands
• execution environment

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 70

2014.
 Bytecode Instruction Format
• 1-byte opcode
• iload, istore, imul, goto, etc.
• zero or more operands

• Disassembling Bytecodes
• use [Link], in the Java Development Kit
(JDK)

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 71

2014.
 Primitive Data Types
• Signed integers are in twos complement
format, stored in big-endian order

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 72

2014.
 JVM Instruction Set
• Comparison Instructions pop two operands
off the stack, compare them, and push the
result of the comparison back on the stack
• Examples: fcmp and dcmp

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 73

2014.
 JVM Instruction Set
• Conditional Branching
• jump to label if st(0)
<= 0
ifle label
• Unconditional
Branching
• call subroutine
jsr label

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 74

2014.
 Java Disassembly Examples
• Adding Two
Integers
int A = 3;
int B = 2;
int sum = 0;
sum = A + B;

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 75

2014.
 Java Disassembly Examples
• Adding Two
Doubles
double A = 3.1;
double B = 2;
double sum = A + B;

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 76

2014.
 Java Disassembly Examples
• Conditional Branch
double A = 3.0;
boolean result = false;
if( A > 2.0 )
result = false;
else
result =
true;

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 77

2014.
 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
• Java Bytecodes – another approch to
programming
Irvine, Kip R. Assembly Language for x86 Processors 7/e, 78
2014.
 5/ 68 75 7S
7q 6F

Irvine, Kip R. Assembly Language for x86 Processors 7/e, 79

2014.