Array in ARM Assembly Language

In ARM assembly language, arrays are handled as a sequence of contiguous memory locations, and there are no dedicated array data structures like in high-level languages. Instead, you work with arrays using pointers and indexing. Here’s a breakdown of how to use arrays in ARM assembly:

1. Defining an Array

Arrays are typically defined in the data section of the assembly code using the .data directive. Each element in the array is allocated a certain number of bytes based on its data type (e.g., bytes for integers).

Example:

.data
my_array:    .word  1, 2, 3, 4, 5   ; An array of 5 integers

In this example, my_array is an array of 5 integers, each taking 4 bytes (assuming a 32-bit ARM architecture).

2. Accessing Array Elements

To access an element in the array, you calculate its address using a base address and an offset. The offset is determined by the index of the element multiplied by the size of each element.

Example:

To access the third element (3 in the example above):

LDR R0, =my_array     //Load the address of my_array into R0
    LDR R1, [R0, #8]      //Load the third element (index 2, 2 * 4 bytes = 8) into R1

3. Modifying Array Elements

You can also modify elements in the array using the same addressing technique.

Get Mumin Ahmod’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Example:

To change the value of the fourth element (4 to 10):

LDR R0, =my_array     //Load the address of my_array into R0
    MOV R2, #10           //Load the value 10 into R2
    STR R2, [R0, #12]     // Store 10 in the fourth element (index 3, 3 * 4 bytes = 12)

4. Iterating Over an Array

To iterate over an array, you can use a loop structure, incrementing a register that holds the current index.

Example:

MOV R3, #0            //Initialize index to 0

loop_start:
    LDR R0, =my_array     //Load the address of my_array into R0
    LDR R1, [R0, R3, LSL #2] //Load the current array element into R1 (R3 * 4)
    
    ; Process R1 (e.g., print or modify it)
    
    ADD R3, R3, #1        //Increment the index
    CMP R3, #5            // Compare index with the array length (5)
    BLT loop_start        //If index < 5, branch to loop_start

5. Multi-Dimensional Arrays

For multi-dimensional arrays, you can extend the addressing logic. For a 2D array, you typically use a formula to calculate the offset based on both dimensions.

Example:

.data
my_2D_array: .word 1, 2, 3, 4, 5, 6, 7, 8 // 2x4 array

.text
    ; Accessing element at row 1, column 2 (6)
    LDR R0, =my_2D_array
    MOV R1, #1            // Row index
    MOV R2, #2            // Column index
    MOV R3, #4            // Number of columns
    ADD R4, R1, R1, LSL #2 // Calculate row offset (row_index * row_size)
    ADD R4, R4, R2, LSL #2 //Calculate total offset (row_offset + col_index * col_size)
    LDR R5, [R0, R4]      ///Load the value into R5

Summary

• Arrays in ARM assembly are defined in the data section and accessed using pointers and offsets.
• You can read and modify array elements using load (LDR) and store (STR) instructions.
• Iteration through arrays can be implemented with loop structures using index registers.
• Multi-dimensional arrays require careful calculation of offsets based on their dimensions.

Understanding these concepts will help you effectively work with arrays in ARM assembly programming!