1 / 29

# Today's topics - PowerPoint PPT Presentation

Today's topics. Multi-dimensional arrays String processing Macros. 2-dimensional arrays. Example declaration: Matrix DWORD 5 DUP(3 DUP(?)) ; 15 elements Row major order Row index first (5 rows, 3 columns) i.e., 5 rows, 3 elements per row In HLLs, reference Matrix[0][2]

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' Today's topics' - mimir

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

• Multi-dimensional arrays

• String processing

• Macros

• Example declaration:

Matrix DWORD 5 DUP(3 DUP(?)); 15 elements

• Row major order

• Row index first (5 rows, 3 columns)

• i.e., 5 rows, 3 elements per row

• In HLLs, reference Matrix[0][2]

• Last element in first row … etc.

• In assembly language, it’s just a set of contiguous memory locations

• 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

• The address of Matrix[3][1] is

20A0h + 4 * [(3 * 3) + 1] = 20C8h

4*[(3*3)+1]

= 4*[9+1]

= 4 * Ah

= 28h

Column index

Size of DWORD

Elements per row

Row index

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

• MASM keeps local variables on the system stack

• Generates replacement code for the LOCAL directive

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

• Returns offsets of both direct andindirect 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 edi,OFFSET count ; invalid operand

mov esi,OFFSET temp ; invalid operand

lea edi,count ; ok

lea esi,temp ; ok

• 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 ; load string byte

• stosb ; store string byte

• cld ; clear direction flag

• std ; set direction flag

• There are many others

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

• Linked to course website “Resources” page

• demo6.asm: Shows capitalizing and reversing a string

• Arrays ?

• Parameter passing ?

• System stack ?

• Stack frame ?

• Local variables?

• Strings?

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

• Separate, named section of code

• May have parameters

• Once defined, it can be invoked (called) one or more times.

• 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

• 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

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

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

.code

. . .

mWriteStr str1

mWriteStr str2

. . .

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 push edx

1 mov edx,OFFSET str1

1 call WriteString

1 pop edx

push ecx

push edx

mov edx,OFFSET varName

mov ecx,(SIZEOF varName) – 1 ; Why?

pop edx

pop ecx

ENDM

.data

firstName BYTE 30 DUP(?)

.code

. . .

. . .

seq macro a, b ; Print a sequence

mov eax,a ; from a to b

mov ebx,b

test:

cmp eax,ebx ; if a <= b

jg quit ; print a and repeat

call WriteDec ; otherwise quit

inc eax

jmp test

quit:

endm

• Code is expanded for each call

• If the macro is called more than once . . .

• Duplicate labels

• Register conflicts

• You can specify that a label is LOCAL

• MASM handles the problem by appending a unique number to the label

Seq macro a, b

LOCAL test

; Print a sequence

mov eax,a ; from a to b

mov ebx,b

test:

cmp eax,ebx ; if a <= b

jg quit

. . .

• 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

. . .

• Arguments are substituted exactly as entered, so any valid argument can be used.

• Example calls to seq :

seq x,y ;memory

seq ecx,edx ;registers

seq 1,20 ;literals

• Macros are very convenient, easy to understand

• Macros actually execute faster than procedures

• No return address, stack manipulation, etc.

• Macros are invoked by name

• 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

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

• Linked to course website “Resources” page

• demo7.asm: shows macros, macro calls, and macro parameters

If learning assembly language does nothing else for you, it makes you appreciate high-level languages.