arrays in mips assembly computer organization and assembly language: module 6
DESCRIPTION
Memory u A memory cell is a unit of memory with a unique address. u The entire memory is a collection of memory cells. u Each memory cell holds eight bits, or 1 byte. u A word designates the amount of memory used to store an integer, e.g., 1 word = 4 bytesTRANSCRIPT
Arrays in MIPS Assembly
Computer Organization and Assembly Language: Module 6
Motivation
Real programs use abstractions like lists, trees, stacks, and queues.
The data associated with these abstractions must be ordered within memory.
Assembly language does not provide convenient ways to access data in memory like high-level languages do.
It therefore necessary to calculate explicitly the locations of data within the structure.
Memory
A memory cell is a unit of memory with a unique address.
The entire memory is a collection of memory cells. Each memory cell holds eight bits, or 1 byte. A word designates the amount of memory used to
store an integer, e.g., 1 word = 4 bytes
Storing an integer
Assume a 32-bit word. The number of bits used to store an integer is 32 or 4 bytes. It can also be thought of as an array of 4 bytes.
By convention, the smallest of the four byte addresses is used to indicate the address of the word.
The smallest of the byte addresses in a word must be a multiple of four words are aligned
RISC: load/store architecture Most RISC designs don't allow arithmetic and logic
instructions to access memory Source, target of operation must be registers
A few special load/store instructions are used to move data from memory to registers This means RISC architecture require more registers
than CISC architectures
Specifying an address In a load/store architecture, only two types of
instructions specify addresses: store and load instructions control instructions
Control instructions specify the target address of the next instruction if the control of the program execution is to be transferred there branch jump
PC-relative addressing A machine language instruction can specify the target of a
branch as an offset to the address of the instruction. The offset is added to the value of the PC to find the
effective address of the next instruction. An addressing mode that implies the use of a PC is PC-relative.
offsetbeq var1 var2
programcounter (PC)
address +
effective address
Load and store instructionslw R, address
R is the target register. In its most general form the address can include both a constant (which can be a label) and a base register. For example,
lw $22, 12($25) The effective address is computed by adding 12 to the
contents of the base register $25. Note that ($25) means the contents of register 25. The word at the effective address is loaded into register 22. Make sure that the effective address is a multiple of 4.
Store to memory Data can be copied from the register R to the memory
location specified by addresssw R, addressSimilar to the load instruction the address can include both a constant and a base register specification.sw, $13, 4($9)The effective address is computed by adding 4 to the contents of register 9.
The sb is equivalent to the store word instruction, sw, only that it stores 1 byte instead of 4 bytes to the effective address.
Only the least significant byte of the register is used. The lb and lbu instructions load the byte into
the least significant byte of the register. lbu loads the byte as unsigned, i.e. the other three
bytes in the register are set to 0 lb sign-extends the byte -- the other three bytes are set
to whatever the sign of the byte is.
Byte access
Valid memory reference formats lw $s0, label sw $s0, label($s1) sb $s2, 16($t0) lw $s0, ($s3)
Array The array is the most important
and most general data structure. All other data structures can be
implemented using an array. The computer memory itself is
organized as a large, one-dimensional array.
All uses of the memory are simply allocations of part of this gigantic array.
0x00000000
0xffffffff
Allocating Space for Arrays To allocate space for an array of ASCII characters{label}: .ascii “abcdef”{label}: .asciiz “abcdef” #null terminated
An array of integers can be allocated space and initialized using the word directive{label}: .word 2, 4, 8, 0x10, 32
An array of un-initialized bytes can be allocated using the space directive{label}: .space 80 #space for 20 integers #or 80 characters
Accessing Array Elements To access element i of the array, we must add an
offset to the array’s starting address, also called the base address. This is the address associated with the label of the array.
We must make sure that the value of i is the correct displacement between the ith element and the base address.
For ease of calculation, we assume the array is indexed starting with 0, as in C or C++
Accessing Array Elementsar: .space 20 #20-element array of char
. . .la $s0, ar #get the base addresslb $s1,5($s0) #access the target element
target elementbase address address of target element
Finding the Element Address
The formula for finding the address of an element in an array can be generalized to
b = base addresss = size of each elementi = number of positions between the target and the base address
char = 1 byteinteger = 4 bytes
can be viewed as an offset from the base address
a = b + s*i
Two-dimensional Arrays The number of bytes needed for the array is found
by multiplying the size of each element times the number of elements
2 x 7 array
Example 15.4
To declare a 2 x 7 array of integers, we can use the following:
ar: .space 56
7 x 2 x (4 bytes)
Storage Order
Row-major order: the array is stored as a sequence of arrays consisting of rows
0 1 2 3 54 60
1
(0,0)(0,1)(0,2)
Storage Order
Column-major order: The array is stored as a sequence of arrays consisting of columns instead of rows
0 1 2 3 54 60
1
(0,0)(1,0)(0,1)
Accessing elements in 2D arrays
We know that the formula for finding the address of an element (x, y) in an array of size L x W is
a = b + s*I I = e*j + k
e = range of the minor dimension (L or W)j = index of the major dimension (y or x)k = index of the minor dimension (x or y)
Example: 2-D array
Row-major order: e = 4, j = 1, k = 2a = b + s*6
Column-major order: e = 3, j = 2, k = 1a = b + s*7
0 1 2 30
1
2
x