```## LSU EE 4720 -- Spring 2015 -- Computer Architecture
#
## Array Access Examples

# Time-stamp: <23 January 2015, 10:03:50 CST, koppel@dmk-laptop>

################################################################################
## Array Access Examples

# Given the base address of an array (address of first element, say &a[0]),
# need to compute the address of an element at index i, (say, &a[i]).
# To do this compute:
#
#  English: Address of i'th element of a = address of a + i * size of element.

# :Example:
#
# Array accesses.  In most examples i is the index (the number of the
# element to load).  Note that i must be multiplied by the size of the
# element before adding it on to the address of the first element.
#
# Registers:  a, s1;  b, s5;  s, s2;  us, s3;  c, s4;  i, t0;  x, t1

# char *c; ...      # \$s4 = c;  \$t0 = i
# x = c[i];
#

lb \$t1, 0(\$t5)      # x = c[i];   \$t1 -> c[i]

# char *c; ...      # \$s4 = c;  \$t0 = i
# x = c[i+1] + c[i+2];
#

lb \$t6, 1(\$t5)      # \$t6 -> c[i+1]
lb \$t7, 2(\$t5)      # \$t7 -> c[i+2]
add \$t1, \$t6, \$t7   # x = c[i+1] + c[i+2]

# int *a; ...       # \$s1 = a;  \$t0 = i
# x = a[i];

sll \$t5, \$t0, 2     # \$t5 -> i * 4;  Each element is four characters.
lw \$t1, 0(\$t5)      # x = a[i];   \$t1 -> a[i]

# int *a; ...       # \$s1 = a;  \$t0 = i
# x = a[i+1] + a[i+2];
#
sll \$t5, \$t0, 2     # \$t5 -> i * 4;  Each element is four characters.
lw \$t6, 4(\$t5)      # \$t6 -> a[i+1]
lw \$t7, 8(\$t5)      # \$t7 -> a[i+2]
add \$t1, \$t6, \$t7   # x = a[i+1] + a[i+2]

# int x, j, *a, *b; # \$t1 = x;  \$t2 = j;  \$s1 = a;  \$s2 = b
# j = 3;
# b = a + j;
# x = *b;      // x = a[3];

addi \$t2, \$0, 3     # j = 3;
sll \$t5, \$t2, 2     # \$t5 -> j * 4
add \$s5, \$s1, \$t5   # b = a + j;
lw \$t1, 0(\$s5)      # x = *b = a[j]

# short *s; ...     # \$s2 = s;  \$t0 = i
# x = s[i];
#
sll \$t5, \$t0, 1     # \$t5 -> i * 2;  Each element is two characters.
lh \$t1, 0(\$t5)      # x = s[i];   \$t1 -> s[i]

#                     \$s3 = us;  \$t0 = i
# unsigned short *us;
# x = us[i];
#
sll \$t5, \$t0, 1     # \$t5 -> i * 2;  Each element is two characters.
lhu \$t1, 0(\$t5)      # x = us[i];   \$t1 -> us[i]

# struct str { int i; char c; int j; char p[3]} ;
# str a;
# ..
# x = a.i + a.c;     // \$t1 -> x;    \$a1 -> &a (address of a)

lw \$t1, 0(\$a1)  # \$t1-> a.i;
lb \$t2, 4(\$a1)  # \$t2-> a.c;