Make a copy of this assignment in notepad. Fill the information as we discuss the material. Upload the completed file as submission.

Do NOT use Visual Studio to put the answers BUT to validate your understanding.

OFFSET Operator $-$

returns the distance in bytes, of a label from the beginning of its enclosing segment

Protected mode: $32$ bits

Let's assume that the data segment begins at $00404000$h:

$.$data

bVal BYTE $?$

wVal WORD $?$

dVal DWORD $?$

dVal$2$ DWORD $?$

$.$code

mov esi,OFFSET bVal ; ESI $=$

mov esi,OFFSET wVal ; ESI $=$

mov esi,OFFSET dVal ; ESI $=$

mov esi,OFFSET dVal$2$ ; ESI $=$

PTR Operator $-$

Overrides the default type of a label $($variable$).$ Provides the flexibility to access part of a variable.

$.$data

myDouble DWORD $12345678$h

$.$code

mov ax$,$myDouble ;

mov ax$,$WORD PTR myDouble ; loads $???$

mov WORD PTR myDouble,$4321$h ; saves $???$

mov al$,$BYTE PTR myDouble ; AL $=$

mov al$,$BYTE PTR $[$myDouble$+1]$ ; AL $=$

mov al$,$BYTE PTR $[$myDouble$+2]$ ; AL $=$

mov ax$,$WORD PTR myDouble ; AX $=$

mov ax$,$WORD PTR $[$myDouble$+2]$ ; AX $=$

$.$data

myBytes BYTE $12$h$,34$h$,56$h$,78$h

$.$code

mov ax$,$WORD PTR $[$myBytes$]$ ; AX $=$

mov ax$,$WORD PTR $[$myBytes$+2]$ ; AX $=$

mov eax,DWORD PTR myBytes ; EAX $=$

$.$data

varB BYTE $65$h$,31$h$,02$h$,05$h

varW WORD $6543$h$,1202$h

varD DWORD $12345678$h

$.$code

mov ax$,$ WORD PTR $[$varB$+2]$ ; a$.$

mov bl$,$ BYTE PTR varD ; b$.$

mov bl$,$ BYTE PTR $[$varW$+2]$ ; c$.$

mov ax$,$ WORD PTR $[$varD$+2]$ ; d$.$

mov eax, DWORD PTR varW ; e$.$

TYPE Operator $-$

The TYPE operator returns the size, in bytes, of a single element of a data declaration.

$.$data

var$1$ BYTE $?$

var$2$ WORD $?$

var$3$ DWORD $?$

var$4$ QWORD $?$

$.$code

mov eax,TYPE var$1$ ; EAX $=?$

mov eax,TYPE var$2$ ; EAX $=?$

mov eax,TYPE var$3$ ; EAX $=?$

mov eax,TYPE var$4$ ; EAX $=?$

LENGTHOF Operator $-$

The LENGTHOF operator counts the number of elements in a single data declaration.

$.$data LENGTHOF

byte$1$ BYTE $10,20,30$ ; $??$

array$1$ WORD $30$ DUP$(?),0,0$ ; $??$

array$2$ WORD $5$ DUP$(3$ DUP$(?))$ ; $??$

array$3$ DWORD $1,2,3,4$ ; $??$

digitStr BYTE $"12345678",0$ ; $??$

$.$code

mov ecx, LENGTHOF array$1$ ; ecx $=??$

mov ecx, LENGTHOF array$2$ ; ecx $=??$

mov ecx, LENGTHOF array$3$ ; ecx $=??$

mov ecx, LENGTHOF digitStr ; ecx $=??$

SIZEOF Operator $-$

The SIZEOF operator returns a value that is equivalent to multiplying LENGTHOF by TYPE.

$.$data SIZEOF

byte$1$ BYTE $10,20,30$ ; $??$

array$1$ WORD $30$ DUP$(?),0,0$ ; $??$

array$2$ WORD $5$ DUP$(3$ DUP$(?))$ ; $??$

array$3$ DWORD $1,2,3,4$ ; $??$

digitStr BYTE $"12345678",0$ ; $??$

$.$code

mov ecx, SIZEOF array$1$ ; ecx $=??$

mov ecx, SIZEOF array$2$ ; ecx $=??$

mov ecx, SIZEOF array$3$ ; ecx $=??$

mov ecx, SIZEOF digitStr ; ecx $=??$

$.$data

array WORD $10,20,$

$30,40,$

$50,60$

$.$code

mov eax,LENGTHOF array ; EAX $=??$

mov ebx,SIZEOF array ; ebx $=??$

$.$data

array WORD $10,20$

WORD $30,40$

WORD $50,60$

$.$code

mov eax,LENGTHOF array ; EAX $=??$

mov ebx,SIZEOF array ; ebx $=??$

Indirect operand $-$

holds the address of a variable, usually an array or string. It can be dereferenced $($just like a pointer$).$

$.$data

val$1$ BYTE $10$h$,20$h$,30$h

$.$code

mov esi,OFFSET val$1$

mov al$,[$esi$]$ ; dereference ESI, AL $=??$

inc esi

mov al$,[$esi$]$ ; AL $=??$

inc esi

mov al$,[$esi$]$ ; AL $=??$

If val$1$ was WORD, what would change.

If val$1$ was DWORD, what would change.

Use PTR to clarify the size attribute of a memory operand.

$.$data

myCount WORD $0$

$.$code

mov esi, OFFSET myCount

inc $[$esi$]$ ; $??$

inc WORD PTR $[$esi$]$ ; $??$

add $[$esi$],20$ ; $??$

JMP Instruction

JMP is an unconditional jump to a label that is usually within the same procedure.

Syntax: JMP target

Logic: EIP $$ target

The LOOP instruction creates a counting loop

Syntax: LOOP target

Logic:

ECX $<---$ ECX $1$

if ECX $!=0$