COMPUTER ORGANIZATION

&
ASSEMBLY LANGUAGE

1
Data-Related Operators and
Directives
⦿ OFFSET Operator
⦿ ALIGN Directive
⦿ PTR Operator
⦿ TYPE Operator
⦿ LENGTHOF Operator
⦿ SIZEOF Operator
⦿ LABEL Directive

2
 OFFSET Operator
⦿ OFFSET returns the distance in bytes, of a label from the
beginning of its enclosing segment
› Protected mode: 32 bits
› Real mode: 16 bits

The Protected-mode programs we write only have a single segment (we use
the flat memory model).

3
 OFFSET Examples
Let's assume that the data segment begins at 00404000h:

.data
bVal BYTE ?
wVal WORD ?
dVal DWORD ?
dVal2 DWORD ?

.code
mov esi,OFFSET bVal ; ESI = 00404000
mov esi,OFFSET wVal ; ESI = 00404001
mov esi,OFFSET dVal ; ESI = 00404003
mov esi,OFFSET dVal2 ; ESI = 00404007

4
 Relating to C/C++
The value returned by OFFSET is a pointer. Compare the following code written
for both C++ and assembly language:

; C++ version:
char array[1000];
char * p = &array;

.data
array BYTE 1000 DUP(?)
.code
mov esi,OFFSET myArray ; ESI is p

5
ALIGN Directive

ALIGN directive aligns a variable in

memory.
ALIGN Directive
Example Code:
.DATA
b1 BYTE ? ; Address of b1 = 00404000h

ALIGN 2

w1 WORD ? ; Address of w1 = 00404002

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

.data
myDouble DWORD 12345678h
.code
mov ax,myDouble ; error – why?

mov ax,WORD PTR myDouble ; loads 5678h

mov WORD PTR myDouble,4321h ; saves 4321h

To understand how this works, we need to know about little endian ordering
of data in memory.

8
 Little Endian Order
⦿ Little endian order refers to the way Intel stores
integers in memory.
⦿ Multi-byte integers are stored in reverse order,
with the least significant byte stored at the lowest
address
⦿ For example, the doubleword 12345678h would
be stored as:

When integers are loaded from memory into

registers, the bytes are automatically
re-reversed into their correct positions.

9
PTR Operator Examples
.data
myDouble DWORD 12345678h

mov al,BYTE PTR myDouble ; AL = 78h

mov al,BYTE PTR [myDouble+1] ; AL = 56h
mov al,BYTE PTR [myDouble+2] ; AL = 34h
mov ax,WORD PTR [myDouble] ; AX = 5678h
mov ax,WORD PTR [myDouble+2] ; AX = 1234h

10
 PTR Operator (cont)
PTR can also be used to combine elements of a smaller data type and move
them into a larger operand. The CPU will automatically reverse the bytes.

.data
myBytes BYTE 12h,34h,56h,78h

.code
mov ax,WORD PTR [myBytes] ; AX = 3412h
mov ax,WORD PTR [myBytes+2] ; AX = 5634h
mov eax,DWORD PTR myBytes ; EAX = 78563412h

11
 Your turn . . .
Write down the value of each destination operand:
.data
varB BYTE 65h,31h,02h,05h
varW WORD 6543h,1202h
varD DWORD 12345678h

.code
mov ax,WORD PTR [varB+2] ; a. 0502h
mov bl,BYTE PTR varD ; b. 78h
mov bl,BYTE PTR [varW+2] ; c. 02h
mov ax,WORD PTR [varD+2] ; d. 1234h
mov eax,DWORD PTR varW ; e. 12026543h

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

.data
var1 BYTE ?
var2 WORD ?
var3 DWORD ?
var4 QWORD ?

.code
mov eax,TYPE var1 ; 1
mov eax,TYPE var2 ; 2
mov eax,TYPE var3 ; 4
mov eax,TYPE var4 ; 8

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

.data LENGTHOF
byte1 BYTE 10,20,30 ; 3
array1 WORD 30 DUP(?),0,0 ; 32
array2 WORD 5 DUP(3 DUP(?)) ; 15
array3 DWORD 1,2,3,4 ; 4
digitStr BYTE "12345678",0 ; 9

.code
mov ecx,LENGTHOF array1 ; 32

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

.data SIZEOF
byte1 BYTE 10,20,30 ; 3
array1 WORD 30 DUP(?),0,0 ; 64
array2 WORD 5 DUP(3 DUP(?)) ; 30
array3 DWORD 1,2,3,4 ; 16
digitStr BYTE "12345678",0 ; 9

.code
mov ecx,SIZEOF array1 ; 64

15
 Spanning Multiple Lines (1 of 2)
A data declaration spans multiple lines if each line (except the last) ends with a
comma. The LENGTHOF and SIZEOF operators include all lines belonging to
the declaration:

.data
array WORD 10,20,
30,40,
50,60

.code
mov eax,LENGTHOF array ; 6
mov ebx,SIZEOF array ; 12

16
Spanning Multiple Lines (2 of 2)
In the following example, array identifies only the first WORD declaration.
Compare the values returned by LENGTHOF and SIZEOF here to those in the
previous slide:

.data
array WORD 10,20
WORD 30,40
WORD 50,60

.code
mov eax,LENGTHOF array ; 2
mov ebx,SIZEOF array ; 4

17
 LABEL Directive
⦿ Assigns an alternate label name and type to an existing
storage location
⦿ LABEL does not allocate any storage of its own
⦿ Removes the need for the PTR operator

.data
dwList LABEL DWORD
wordList LABEL WORD
intList BYTE 00h,10h,00h,20h
.code
mov eax,dwList ; 20001000h
mov cx,wordList ; 1000h
mov dl,intList ; 00h

18