Transcript 06_Using Memory

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.
beq
program
counter (PC)
var1
address
var2
offset
+
effective address
Load and store instructions
lw 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 address
sw R, address
Similar 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.
Byte access
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.
 The
 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.
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, onedimensional 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
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++
 To
Accessing Array Elements
ar: .space 20
#20-element array of char
. . .
la $s0, ar
lb $s1,5($s0)
base address
#get the base address
#access the target element
target element
address of target element
Finding the Element Address
The formula for finding the
address of an element in an
array can be generalized to
char = 1 byte
integer = 4 bytes
a = b + s*i
b = base address
s = size of each element
i = number of positions between the
target and the base address
can be viewed as an
offset from the base
address
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
0
1
1
2
3
4
5
6
(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
0
1
1
2
3
4
5
6
(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 = 2
a = b + s*6
Column-major order: e
= 3, j = 2, k = 1
a = b + s*7
0
1
2
3
0
1
2
x