Today's topics



Multi-dimensional arrays
String processing
Macros
2-dimensional arrays

Example declaration:
Matrix DWORD

Row major order

Row index first (5 rows, 3 columns)


i.e., 5 rows, 3 elements per row
In HLLs, reference Matrix[0][2]


5 DUP(3 DUP(?)) ; 15 elements
Last element in first row … etc.
In assembly language, it’s just a set of
contiguous memory locations
2-dimensional arrays

An element’s address is calculated as the
base address plus an offset
BaseAddress + elementSize * [(row# * elementsPerRow) + column#]

Example: Suppose Matrix is at address
20A0h
4*[(3*3)+1]

= 4*[9+1]
The address of Matrix[3][1] is
= 4 * Ah
20A0h + 4 * [(3 * 3) + 1] = 20C8h = 28h
Base
address
Size of
DWORD
Row
index
Elements
per row
Column
index
Matrix: element addresses
(hexadecimal)
Matrix
0
1
2
0
20A0
20A4
20A8
1
20AC
20B0
20B4
2
20B8
20BC
20C0
3
20C4
20C8
20CC
4
20D0
20D4
20D8
Local Directive


A local variable is created, used, and
destroyed within a single procedure
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
Local variables

MASM keeps local variables on the system
stack

Generates replacement code for the LOCAL
directive
Sort PROC
LOCAL temp:DWORD, SwapFlag:BYTE
; procedure code
ret
Sort ENDP
MASM generates the following code:
Sort PROC
push ebp
mov ebp,esp
sub esp,08h
;subtract 8 from ESP
; to create space for local variables
; procedure code
pop ebp
ret
Sort ENDP
LEA Instruction
•
•
•
•
LEA means Load Effective Address
Returns offsets of both direct and indirect
operands.
LEA is required when obtaining the offset of a
local variable or stack parameter.
Example:
CopyString PROC
LOCAL temp[20]:BYTE, count:DWORD
mov
mov
lea
lea
edi,OFFSET
esi,OFFSET
edi,count
esi,temp
count; invalid operand
temp ; invalid operand
; ok
; ok
String primitives



A string is an array of BYTE
In most cases, an extra byte is needed for the
zero-byte terminator
MASM has some “string primitives” for
manipulating strings byte-by-byte

Most important are:





lodsb
stosb
cld
std
;
;
;
;
load string byte
store string byte
clear direction flag
set direction flag
There are many others

Explore on your own
lodsb and stosb

lodsb




Moves byte at [esi] into the AL register
Increments esi if direction flag is 0
Decrements esi if direction flag is 1
stosb



Moves byte in the AL register to memory at [edi]
Increments edi if direction flag is 0
Decrements edi if direction flag is 1
cld and std

cld




Sets direction flag to 0
Causes esi and edi to be incremented by lodsb and
stosb
Used for moving “forward” through an array
std



Sets direction flag to 1
Causes esi and edi to be decremented by lodsb and
stosb
Used for moving “backward” through an array
Demo Program

Linked to course website “Resources”
page

demo6.asm: Shows capitalizing and reversing
a string
Questions on …



Arrays ?
Parameter passing ?
System stack ?



Stack frame ?
Local variables?
Strings?
Procedure (summary)

Separate, named section of code.






May have parameters
Calling mechanism
Return mechanism
During assembly, procedure code is
translated once.
During execution, control is transferred to
the procedure at each call (activation record,
etc.). May be called many times.
All labels, etc. are local to the activation
record.
Macro

Separate, named section of code


Once defined, it can be invoked (called)
one or more times.


May have parameters
Use name only (don’t use CALL)
During assembly, entire macro code is
substituted for each call (expansion)


Similar to a constant
Invisible to the programmer
Defining Macros




A macro must be defined before it can be
used.
Parameters are optional.
Each parameter follows the rules for
identifiers.
Syntax:
macroname MACRO [parameter-1, parameter-2,...]
statement-list
ENDM
Invoking Macros

To invoke a macro, just give the name and
the arguments (if any).



Each argument matches a declared parameter.
Each parameter is replaced by its
corresponding argument when the macro is
expanded.
When a macro expands, it generates
assembly language source code.
Example macro definition and call
Sets up registers and uses Irvine's library WriteString
mWriteStr MACRO buffer
push edx
mov edx,OFFSET buffer
call WriteString
pop edx
ENDM
.data
str1 BYTE "Welcome!",10,13,0
str2 BYTE "Please tell me your name ",0
.code
. . .
mWriteStr str1
mWriteStr str2
. . .
Example macro expansion
The expanded code shows how the str1 argument
replaced the parameter named buffer:
mWriteStr MACRO buffer
push edx
mov edx,OFFSET buffer
call WriteString
pop edx
ENDM
1
1
1
1
push
mov
call
pop
edx
edx,OFFSET str1
WriteString
edx
Example macro definition and call
The mReadStr macro provides a convenient wrapper around
ReadString procedure calls.
mReadStr MACRO varName
push ecx
push edx
mov edx,OFFSET varName
mov ecx,(SIZEOF varName) – 1 ; Why?
call ReadString
pop edx
pop ecx
ENDM
.data
firstName BYTE 30 DUP(?)
.code
. . .
mReadStr firstName
. . .
A more complex macro
seq
macro
a, b
mov eax,a
mov ebx,b
test:
cmp eax,ebx
jg
quit
call WriteDec
inc eax
jmp test
quit:
endm
; Print a sequence
;
from a to b
; if a <= b
; print a and repeat
; otherwise quit
What's the problem?
 Code
is expanded for each call
 If the macro is called more than
once . . .
 Duplicate
labels
 Register conflicts
Duplicate labels


You can specify that a label is LOCAL
MASM handles the problem by appending
a unique number to the label
Seq
LOCAL
mov
mov
test:
cmp
jg quit
. . .
macro
a, b
test
; Print a sequence
eax,a
;
from a to b
ebx,b
eax,ebx
; if a <= b
Local variables in macros

You can specify that a variable is LOCAL
seq
macro
a, b
; Print a sequence
LOCAL
test
;
from a to b
LOCAL
sum
.data
;; data segment
sum
DWORD ? ;; define local var
.code
;; code segment
mov eax,a
mov ebx,b
test:
cmp eax,ebx ; if a <= b
jg
quit
. . .
Parameters


Arguments are substituted exactly as
entered, so any valid argument can be
used.
Example calls to seq :
seq
seq
seq
x,y
ecx,edx
1,20
;memory
;registers
;literals
Macro vs. Procedure


Macros are very convenient, easy to understand
Macros actually execute faster than procedures


Macros are invoked by name




No return address, stack manipulation, etc.
Parameters are “in-line”
Macro does not have a ret statement (Why?)
Why would you ever use a procedure instead of
a macro?
If the macro is called many times, the assembler
produces “fat code”


Invisible to the programmer
Each macro call expands the program code by the
length of the macro code
Macro vs. Procedure


Use a macro for short code that is called “a few”
times.
Use a procedure for more complex tasks or code
that is called “many” times



The terms “few” and “many” are relative to the size of
the whole program
Is it OK to invoke a macro inside of a loop that
executes 1000 times ?
Is it OK to invoke a procedure inside of a loop
that executes 1000 times ?
Demo Program

Linked to course website “Resources”
page

demo7.asm: shows macros, macro calls, and
macro parameters
Questions?
If learning assembly language does
nothing else for you, it makes you
appreciate high-level languages.