- Array variables is
nothing more than a
series of
simple variables
So:
- Everything that you have learned about how to define simple variables will apply to array variables
Specifically: be aware that you must obey the memory alignment requirements !!!
See: click here
- Initialized array
data structure is defined in
assembler code by
specifying the list of
initial values in the
array using
the assembler directives:
.byte .2byte .4bytethat you learned in this webpage: click here
Examples:
- To define a
byte typed array A
containing the following
initial values:
11 12 13 14 15 (I.e.: A[0] = 11, A[1] = 12, A[2] = 13, A[3] = 14, A[4] = 15)we need to write the following assembler directive:
A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A
The list of values will but stored consecutively in memory
Furthermore: the label A will be equated to the memory address of the first element of the array A
(This label will be used to compute the address of any given array element - see next few webpages)
- To define a
short typed array B
containing the following
initial values:
111 112 113 114 115 (I.e.: B[0] = 11, B[1] = 12, B[2] = 13, B[3] = 14, B[4] = 15)we need to write the following assembler directive:
B: .2byte 111, 112, 113, 114, 115 // short typed initialzied array B
The list of values will but stored consecutively in memory - and each value is stored in 2 bytes of memory.
The label B will be equated to the memory address of the first element of the array B
- To define an
int typed array C
containing the following
initial values:
1111 1112 1113 1114 1115 (I.e.: C[0] = 1111, C[1] = 1112, C[2] = 1113, C[3] = 1114, C[4] = 1115)we need to write the following assembler directive:
C: .4byte 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C
The list of values will but stored consecutively in memory - and each value is stored in 4 bytes of memory.
The label C will be equated to the memory address of the first element of the array C
- To define a
byte typed array A
containing the following
initial values:
-
UNinitialized array
data structure is defined in
assembler code by
specifying the list of
initial values in the
array using
the assembler directives:
.skip n // Reserve n consecutive bytes of memorythat you learned in this webpage: click here
You need to calculate the number of bytes that you need to reserve for the array that you want to define.... (that's pretty easy)
You can use the multiply operator * to compute the number of bytes needed.
Examples:
- To define a
byte typed array a
of 10 elements,
we write the following
assembler directive:
a: .skip 10*1 // byte typed UNinitialized array a (10 elements)
The label a will be equated to the memory address of the first element of the array a
- To define a
short typed array b
of 10 elements,
we write the following
assembler directive:
b: .skip 10*2 // short typed UNinitialized array b (10 elements)
The label b will be equated to the memory address of the first element of the array b
- To define an
int typed array c
of 10 elements,
we write the following
assembler directive:
c: .skip 10*4 // short typed UNinitialized array c (10 elements)
The label c will be equated to the memory address of the first element of the array c
- To define a
byte typed array a
of 10 elements,
we write the following
assembler directive:
- Example Program:
(Demo above code)
- Prog file:
/home/cs255001/demo/asm/3-array/array-def.s
/* -------------------------------------------------- Begin of the permanent program variables -------------------------------------------------- */ .data A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A a: .skip 10*1 // byte typed UNinitialized array a (10 elements) .align 1 B: .short 111, 112, 113, 114, 115 // short typed initialzied array B b: .skip 10*2 // short typed UNinitialized array b (10 elements) .align 2 C: .short 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C c: .skip 10*4 // int typed UNinitialized array c (10 elements)
How to run the program:
- To compile: as255 array-def
- To run: EGTAPI
Here's a snapshot of the memory content when you run this program in EGTAPI:
The content of the memory is shown in hexadecimal numbers
Each pair of hexadecimal digit represents the byte stored at that location in memory.
The memory address of the first byte in a line of bytes is given in hexadecimal at the left margin
You can see that the first 5 bytes (0b 0c 0d 0e 0f) is the initialized array A[ ] = 11, 12, 13, 14, 16
Then the next 10 bytes (all 00) is the UNinitialized array a[10] (10 elements)
The next byte (the 00 at the end of line 1) is skipped to comply with the alignment requirement for the B[ ] array:
- A short typed variable must start on an even address !!!
The first 10 bytes on line 2 belong to the initialized short array B:
006f hex = 111 decimal 0070 hex = 112 decimal 0071 hex = 113 decimal 0072 hex = 114 decimal 0073 hex = 115 decimal
Then the next 20 bytes (all equal to 00) belongs to the unintialized short array b[10]
The next 2 bytes (the 00 00 at the end of line 3) are skipped to comply with the alignment requirement for the C[ ] array:
- An int typed variable must start on an address that is divisible by 4 !!!
The bytes on line 4 and the first 4 bytes on line 5 belong to the initialized int array C:
00000457 hex = 1111 decimal 00000458 hex = 1112 decimal 00000459 hex = 1113 decimal 0000045a hex = 1114 decimal 0000045b hex = 1115 decimal
Then the next 40 bytes (all equal to 00) belongs to the unintialized int array c[10]
- Prog file:
/home/cs255001/demo/asm/3-array/array-def.s
- You can see in this
snap shot that
the address of the
label A is equal to
0x18784 --
which is the
address of the
first array element
of array A[ ]
that we defined using the
directive line
A: .byte 11, 12, 13, 14, 15: