Assembler programming examples of accessing array

Introduction
- We now have learned everything neccessary to write ARM assembler program codes to access and update array elements
  I will show you 4 different assembler programs programs.
  These demo programs are found in the demo directory /home/cs255001/demo/asm/3-array

Demo program array-ldr1.s: moving array elements into a register (for later computation) - constant array index

The demo program array-ldr1.s show you the assembler coding techniques to move array elements of different data types in a register (so you can use the value in the array element in further computation)

I have define the following arrays in this assembler program:

byte A[5] = {11, 12, 13, 14, 15}; // byte typed array with 5 elements short B[5] = {111, 112, 113, 114, 115}; // short typed array with 5 elements int C[5] = {1111, 1112, 1113, 1114, 1115}; // int typed array with 5 elements

I wrote assembler code to:

The array-ldr1.s program is as follows:

// The .text segment .text main: // ============================================================ A[3] movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A // Address of A[3] = base addr + 3*1 ldrsb r2, [r0, #3] // Load A[3] into r2 // ============================================================ B[3] movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B // Address of B[3] = base addr + 3*2 ldrsh r3, [r0, #6] // Load B[3] into r3 // ============================================================ C[3] movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C // Address of C[3] = base addr + 3*4 ldr r4, [r0, #12] // Load C[3] into r4 // ********************************************************************** // The .data segment // ********************************************************************** .data A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A .align 1 B: .2byte 111, 112, 113, 114, 115 // short typed initialzied array B .align 2 C: .4byte 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C

Explanation:

How to move the byte value A[3] into register r2:

We first move the base address of the array A into some free register (I used r0):

movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of A[3] = 3 * size(one array element) = 3 * 1 = 3

So this instruction will move the byte value A[3] into register r2:

ldrsb r2, [r0, #3] // Load A[3] into r2

How to move the short value B[3] into register r3:

We first move the base address of the array B into some free register (I re-used r0):

movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of B[3] = 3 * size(one array element) // short is 2 bytes = 3 * 2 = 6

So this instruction will move the short value B[3] into register r3:

ldrsh r3, [r0, #6] // Load B[3] into r3

How to move the int value C[3] into register r4:

We first move the base address of the array C into some free register (I re-used r0):

movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of B[3] = 3 * size(one array element) // int is 4 bytes = 3 * 4 = 12

So this instruction will move the int value C[3] into register r4:

ldr r4, [r0, #12] // Load C[3] into r4

I will show you the demo in class.....

Demo program array-str1.s: updating array elements with a value in a register

The demo program array-str1.s show you the assembler coding techniques to update array elements of different data types using a value stored in a register (i.e.: saving the computaion result in memory)

I have define the following arrays in this assembler program:

I wrote assembler code to:

Update the byte value A[3] with the value in the register r1
Update the short value B[3] with the value in the register r1
Update the int value C[3] with the value in the register r1

The array-str1.s program is as follows:

// The .text segment .text main: // ==================== I put an arbitrary value in reg r1 mov r1, #44 // Value to be stored // ============================================================ A[3] movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A // Address of A[3] = base addr + 3*1 strb r1, [r0, #3] // Store r1 into A[3] (byte) // ============================================================ B[3] movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B // Address of B[3] = base addr + 3*2 strh r1, [r0, #6] // Store r1 into B[3] (short) // ============================================================ C[3] movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C // Address of C[3] = base addr + 3*4 str r1, [r0, #12] // Store r1 into C[3] (int) // ********************************************************************** // The .data segment // ********************************************************************** .data A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A .align 1 B: .2byte 111, 112, 113, 114, 115 // short typed initialzied array B .align 2 C: .4byte 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C

Explanation:

How to update the byte value A[3] with the value in register r1:

We first move the base address of the array A into some free register (I used r0):

movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of A[3] = 3 * size(one array element) = 3 * 1 = 3

So this instruction will update the byte value A[3] with the value in register r1:

strb r1, [r0, #3] // Store r1 into A[3] (byte)

How to update the short value B[3] with the value in register r1:

We first move the base address of the array B into some free register (I re-used r0):

movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of B[3] = 3 * size(one array element) // short is 2 bytes = 3 * 2 = 6

So this instruction will update the short value B[3] with the value in register r1:

strh r1, [r0, #6] // Store r1 into A[3] (byte)

How to update the int value C[3] with the value in register r1:

We first move the base address of the array C into some free register (I re-used r0):

movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C

Because the index is a constant (= 3), we can pre-compute the offset:

Offset of B[3] = 3 * size(one array element) // int is 4 bytes = 3 * 4 = 12

So this instruction will update the int value C[3] with the value in register r1:

str r1, [r0, #12] // Load C[3] into r4

I will show you the demo in class.....

Demo program array-ldr2.s: moving array elements into a register (for later computation) - variable array index

The demo program array-ldr2.s show you the assembler coding techniques to move array elements of different data types in a register (so you can use the value in the array element in further computation)

This program uses a variable as array index.

I have define the same arrays in this assembler program:

I wrote assembler code to:
The variable int k is initialized with some arbitrary value.

The array-ldr2.s program is as follows:

// The .text segment .text main: // ============================================================ A[3] movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of A[3] = base addr + k*1 ldrsb r2, [r0, r1] // Load A[k] into r2 // ============================================================ B[3] movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of B[3] = base addr + k*2 add r1, r1, r1 // r1 = k+k = 2*k ldrsh r3, [r0, r1] // Load B[3] into r3 // ============================================================ C[3] movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of C[3] = base addr + k*4 add r1, r1, r1 // r1 = k+k = 2*k add r1, r1, r1 // r1 = 2*k + 2*k = 4*k ldr r4, [r0, #12] // Load C[3] into r4 // ********************************************************************** // The .data segment // ********************************************************************** .data A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A .align 1 B: .2byte 111, 112, 113, 114, 115 // short typed initialzied array B .align 2 C: .4byte 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C k: .4byte 3 // This value is arbitrary

Explanation:

How to move the byte value A[k] into register r2:

We first move the base address of the array A into some free register (I used r0):

movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A

Because the index is a variable (k), so we must compute the offset with the value stored in the variable k:

Offset of A[k] = k * size(one array element) = k * 1 = k

We first read the value stored in the variable k into another register (I used r1):

movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte !

We should multiply with the size(byte) = 1; but since multiplying with 1 will not change the result, we have found the offset.

Then this instruction will move the byte value A[k] into register r2:

ldrsb r2, [r0, r1] // Load A[k] into r2

How to move the short value B[k] into register r3:

We first move the base address of the array B into some free register (I re-used r0):

movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B

Because the index is a variable (k), so we must compute the offset with the value stored in the variable k:

Offset of B[k] = k * size(one array element) = k * 2

We first read the value stored in the variable k into another register (I used r1):

movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte !

Then compute the offset k*2... we can use an addition operation:

add r1, r1, r1 // r1 = k+k = 2*k

Then this instruction will move the short value B[k] into register r3:

ldrsh r3, [r0, r1] // Load B[k] into r3

How to move the int value C[3] into register r4:

We first move the base address of the array C into some free register (I re-used r0):

movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C

Because the index is a variable (k), so we must compute the offset with the value stored in the variable k:

Offset of B[k] = k * size(one array element) // int is 4 bytes long = k * 4

We first read the value stored in the variable k into another register (I used r1):

movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte !

Then compute the offset k*2... we can use 2 addition operations:

add r1, r1, r1 // r1 = k+k = 2*k add r1, r1, r1 // r1 = 2*k + 2*k = 4*k

Then this instruction will move the int value C[3] into register r4:

str r4, [r0, r1] // Load C[3] into r4

I will show you the demo in class.....

Demo program array-str2.s: updating array elements with a value in a register - variable array index

This is the same as array-str1.s, instead of updating A[3], B[3] and C[3], I update A[k], B[k] and C[k]

The technique used is the same as array-ldr2.s so I won't write the whole explaning again.

I will only show you the code:

.text main: mov r10, #44 // Value to be stored // ============================================================ A[3] movw r0, #:lower16:A movt r0, #:upper16:A // r0 = base address of array A movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of A[3] = base addr + k*1 strb r10, [r0, r1] // Store r10 in A[k] (byte) // ============================================================ B[3] movw r0, #:lower16:B movt r0, #:upper16:B // r0 = base address of array B movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of B[3] = base addr + k*2 add r1, r1, r1 // r1 = k+k = 2*k strh r10, [r0, r1] // Store r10 in B[3] (short) // ============================================================ C[3] movw r0, #:lower16:C movt r0, #:upper16:C // r0 = base address of array C movw r1, #:lower16:k movt r1, #:upper16:k // r1 = address of k ldr r1, [r1] // r1 = value in variable k // Comment: use ldrsh if k is short ! // use ldrsb if k is byte ! // Address of C[3] = base addr + k*4 add r1, r1, r1 // r1 = k+k = 2*k add r1, r1, r1 // r1 = 2*k + 2*k = 4*k str r10, [r0, #12] // Store r10 in C[3] (int) // ****************************************************************** // Data section // ****************************************************************** .data A: .byte 11, 12, 13, 14, 15 // byte typed initialzied array A .align 1 B: .2byte 111, 112, 113, 114, 115 // short typed initialzied array B .align 2 C: .4byte 1111, 1112, 1113, 1114, 1115 // int typed initialzied array C k: .4byte 3 // Arbitrary value