Memory

MIPS is a load-store register architecture¹. Which means, it divides instructions into two categories: memory access and ALU operations. The arithmetic and logical operations are part of the ALU operations. Incidentally, ALU is called the arithmetic and logic unit.

MIPS has 32 registers, each are 32-bit long (or 4-byte long). Each word contains 32 bits (or 4 bytes). Not surprisingly, memory addresses are also 32-bit long.

So what is the significant of this magic number 32? It means that each memory address can fit into a register nicely. However, note that MIPS uses byte addresses. So, data in each memory address holds a single byte (i.e., 8 bits). Which means, consecutive words differ by 4 in their addresses.

Memory Instruction

Only load and store instructions can access data in memory. However, there are several variants of the instructions.

Word Addressing

1

lw $rt, offset($rs)

1

$rt = $rs[offset]; // assume integer

1

sw $rt, offset($rs)

1

$rs[offset] = $rt; // assume integer

In both instructions, the address is compute the same way: $rs + offset. Here, the register $rs holds the base address of the memory. Typically it will match with an array in the high-level program. Note that both instructions throws an error when the result $rs + offset is not word aligned (i.e., not multiple of 4 in the case of MIPS).

1

lw $t0, 4($s0)

1

$t0 = $s0[4];

1

sw $t0, 12($s0)

1

$s0[12] = $t0;

Byte Addressing

1

lb $rt, offset($rs)

1

sb $rt, offset($rs)

Unlike lw and sw, the address need not be word aligned (i.e., not multiple of 4). As such, the value can be any non-negative number between 0 and 2^32M-1. Typically, these operations are used for string (i.e., array of char which is 1 byte long).

1

{ $rs[7] , $rs[6] , $rs[5] , $rs[4] , $rs[3] , $rs[2] , $rs[1] , $rs[0] }

Other Addressing

1

lh $rt, offset($rs)

1

sh $rt, offset($rs)

1

lwl $rt, offset($rs)

1

swl $rt, offset($rs)

1

lwr $rt, offset($rs)

1

swr $rt, offset($rs)

Unaligned Addressing

1

lw $rt, offset($rs)

1

$rt = $rs[offset]; // assume integer

1

sw $rt, offset($rs)

1

$rs[offset] = $rt; // assume integer

MIPS disallows loading/storing unaligned word using lw/sw. These two above are pseudo-instructions to load/store unaligned words. They can naively be translated into multiple real instructions with additional temporary registers.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

lb  $t0, 3($s1)    # 0x00000033

lb  $t1, 4($s1)    # 0x00000044
sll $t1, $t1, 8    # 0x00004400
or  $t0, $t0, $t1  # 0x00004433

lb  $t1, 5($s1)    # 0x00000055
sll $t1, $t1, 16   # 0x00550000
or  $t0, $t0, $t1  # 0x00554433

lb  $t1, 6($s1)    # 0x00000066
sll $t1, $t1, 24   # 0x66000000
or  $t0, $t0, $t1  # 0x66554433

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

add $t0, zero, $s0 # 0x66554433
lb  $t0, 3($s1)    # 0x00000033

srl $t0, $t0, 8    # 0x00665544
lb  $t0, 4($s1)    # 0x00000044

srl $t0, $t0, 8    # 0x00006655
lb  $t0, 4($s1)    # 0x00000055

srl $t0, $t0, 8    # 0x00000066
lb  $t0, 4($s1)    # 0x00000066

Examples

As this is one of the more important concepts in MIPS, we will dedicate a section for examples. You are advised to try the example on your own first before looking at the answer.

1

A[7] = h + A[10];

1
2
3

$t0 = $s3[40];     // $t0 = A[10]     -- 40 is used because 40 = 4 * 10
$t0 = $s2 + $t0;   // $t0 = h + A[10]
$s3[28] = $t0;     // A[7] = $t0      -- 28 is used because 28 = 4 * 7

1
2
3

lw  $t0, 40($s3)   #  $t0 = A[10]     -- 40 is used because 40 = 4 * 10
add $t0, $s2, $t0  #  $t0 = h + A[10]
sw  $t0, 28($s3)   #  A[7] = $t0      -- 28 is used because 28 = 4 * 7

1
2
3
4
5
6

void swap(int v[], int k) {
  int temp;
  temp = v[k];
  v[k] = v[k+1];
  v[k+1] = temp;
}

1
2
3
4
5
6

$v0 = $a1 << 2;    // $v0    = k * 4     -- for word alignment
$v0 = $v0 + $a1;   // $v0    = (k*4)+v   -- computing the actual address
$t7 = $v0[0];      // temp   = v[k]
$t8 = $v0[4];      // $t8    = v[k+1]
$v0[0] = $t8;      // v[k]   = $t8
$v0[4] = $t7;      // v[k+1] = temp

1
2
3
4
5
6
7

swap:
  sll  $2, $5, 2   #  $v0    = k * 4     -- for word alignment
  add  $2, $4, $2  #  $v0    = (k*4)+v   -- computing the actual address
  lw   $15, 0($2)  #  temp   = v[k]
  lw   $16, 4($2)  #  $t8    = v[k+1]
  sw   $16, 0($2)  #  v[k]   = $t8
  sw   $15, 4($2)  #  v[k+1] = temp

1

A[3] = h + A[1];

1
2
3

lw  $t0, 4($s3)
add $t0, $s2, $t0
sw  $t0, 12($s3)