Introduction to MIPS

Introduction

We're going to cover the basic facts about MIPS ISA, and also explain some of the semantics.

MIPS has 32 32-bit integer registers, labelled $r0 to $r31. (MIPS also has floating point registers, but we'll ignore them for now).
$r0 is hardwired 0. It always has a value of 0.
$r29 is the stack pointer, but this is by convention. There is no push and pop instruction that uses this register implicitly.
$r31 is used in jal instructions (for subroutine calls). This is implicitly used by jal and jalr instructions.
MIPS has two additional integer registers: HI and LO, use in multiplication instructions.
All instructions are 32 bits long.
There are three instruction formats: R-type, J-type, and I-type. They are explained in a future set of notes.
Addresses are 32 bits long. Thus, each process can access up to 2³² addresses.
Instructions must be saved at word-aligned addresses, meaning that the first byte of the instruction is stored at an address divisible by 4. A word-aligned address ends in 00 if written in binary.
MIPS is a load-store architecture. It accesses memory only through load instructions (which copy a value from memory to a register) or through store instructions (which copy a value from a register to memory). All other instructions that do computations work on registers.
Load-store architectures are common for RISC architectures. In CISC architectures, where there are few registers, it's common for instructions (like add) to access registers and memory.
Register access is fast. Memory access is slow.
The cache is not visible to the ISA programmer.

Semantics

As we explain what the instructions do, it will be convenient to explain the semantics using some notation. We'll explain the notation here, so we can use it later on.

There are 32 integer registers. We'll pretend that they are an array of 32 registers. Thus, R[i] is the same as register $ri. In particular, R[3] is the same as $r3.
This is a convenience in notation. Assembly language programmers can NOT use indexing for registers. Thus, you can NOT use $ri, where i is a variable.
We treat memory as if it were a large one-dimensional array. The name of that array is M.
<- is used as the assignment operator. For example, R[i] <- R[j] means that R[i] is assigned R[j]'s value.
M₄[ addr ] accesses 4 byte starting at addr in memory. This address must be word-aligned.
M₁[ addr ] accesses 1 byte starting at addr in memory. This can be any address.
M₄[ R[i] ] accesses 4 bytes starting at the address stored in register i.
R[i]_j refers to bit j of register i. We assume that bits are numbered right to left, starting at 0 on the right for the LSb, and ending at 31 on the left as the MSb.
R[i]_hi-lo refers to a range of bits from bit hi to lo (inclusive) of register i. We assume that bits are numbered right to left, starting at 0 on the right for the LSb, and ending at 31 on the left as the MSb.
We may refer to two hidden registers: PC, the program counter, which stores the current address of the instruction being executed, and IR which stores the instruction being executed.
Hidden registers are not directly accessible by the ISA programmer, but they can help to explain what the instructions do.
(IR₁₅)¹⁶ means to repeat bit B₁₅ 16 times (thus, producing a 16 bit value).
To create 32 bit values, we may need to concatenate several bitstrings together. We will use :: (two colons), as the concatenation operator. For example, (IR₁₅)¹⁶::IR_15-0 means bit B₁₅ of the IR register repeated 15 times, concatenated with the low 16 bits of the IR. This produces a 32 bit result.

Web Accessibility