Load and Store

How Do Variables Get from Memory to the Registers?

• Load: Assume that the address of variable a is in register $t0 and we want to load the value in a into $s0

      lw $s0, 0($t0)       # load what's in address $t0 into $s0
      

• What's this 0($t0) stuff?
• General idea: load a word (4 bytes) of data that is a certain distance (offset) from a base address
• $t0 is the address of the beginning of a segment in memory (the base address)
• The constant 0(...) specifies the offset from the beginning of the memory segment (in bytes)

Example: Assume that obj is a variable of type struct with several data members and that $t0 holds the address of the beginning of obj. How do we load obj.a into $s0, obj.b into $s1, and obj.e into $s2?

struct s_tag {
    int a;
    int b;
    int c;
    int d;
    int e;
} obj;

lw $s0, 0($t0)   # Load obj.a into $s0
lw $s1, 4($t0)   # Load obj.b into $s1
lw $s2, 16($t0)  # Load obj.e into $s2

• Local variables can also be represented as a constant offset from the beginning of the memory segment for local data.

From Registers Back to Memory

• Store: How do we compute obj.e += k? (Assume k is in $s4.)

      lw  $t8, 16($t0)    # load obj.e into $t8
      add $t8, $t8, $s4   # obj.e = obj.e + k
      sw  $t8, 16($t0)    # store $t8 back into obj.e
      

What about loading and storing elements from arrays?

• Problem: The lw/sw offset has to be a constant.
• So, how do we represent a variable array index, e.g., A[i]?
• Can't use a constant offset. So, compute the address of the individual array element, put it in a register, and use 0 as the offset.

Example: Read the contents of A[i] into $t1.

A is array of int (each int is a 4-byte word). The base address of A is in $s7; i is in $s6. The address of A[i] is $s7 + (4 * $s6). (We don't know how to multiply yet, but we can add $s6 to itself 4 times.

    add $t0, $s6, $s6   # $t0 = 2 * i (4)
    add $t0, $t0, $t0   # $t0 = 4 * i (8)
    add $t0, $s7, $t0   # $t0 = $s7 + (4 * i) = 2020 = &A[i]
    lw $t1, 0($t0)      # load what's in A[i] into $t1

Handy Trick ...

What's an efficient way to multiply binary numbers by 2? by 4?

    add $t0, $s6, $zero   # $t0 = i
    sll $t0, $t0, 2       # shift $t0 left by 2 ($r0 = i * 4)
    add $t0, $s7, $t0     # $t0 = $s7 + (4 * i) = addr of A[i]
    lw $t1, 0($t0)        # load what's in A[i] into $t1