MIPS Architecture

• Memory organisation– the purpose of memory is to store groups of bits and

deliver them to the processor (for loading into regs)

– memory can hold both data and program

– SPIM simulator:• 0x0040 0000 - text segment/program instructions

• 0x1000 0000 - data segment

• 0x7FFF FFFF and decreasing addresses - stack segment

– a word is the number of bits that can be transferred at one time on the data bus and stored in a reg

– Mips: 32-bits/4 bytes; others use different sizes

MIPS Architecture

• storage order of words– little-endian - store the little end of the word first

• processor organisation– registers

– where it stores information

– what it does in executing instructions

– MIPS:• all registers are 32-bit

• PC (program counter) holds address of next instruction

• 32 general purpose registers (can use name or number)

• instruction set: load & store, operations, jump & branch, others

MIPS Architecture

Registers

• First reg ($0) is a constant 0 and cannot be changed

• Last reg ($31/$ra) stores the return address from a proc.

$1($at) - Assembler temporary. We will avoid using it.

$v0 - $v1 - values returned by a function

$a0 - $a3 - arguments to a function

$t0 - $t9 - temporary use. Use freely but if you call a procedure that procedure may change it.

$s0 - $s7 - saved by procedures. When you are writing a proc you must save and restore previous values.

MIPS ArchitectureInstruction set

• load and store

– load data from memory into a reg, or store reg contents in memory

– lw $t0, num1 #load word in num1 into $t0

– sw $t0, num2 # store word in $t0 into num2

– li $v0, 4 # load immediate value (constant) 4 into $v0

• operations: arithmetic and logic

– perform the operation on data in 2 regs and store result in 3rd reg

– add $t0, $t3, $t4 # $t0 = $t3 + $t4

• jump and branch

– alter the PC to control flow of program (if and loop statements)

• specialised instructions (e.g. floating point instructions)

Basic Assembly Language InstructionsLevels

• binary machine instructions (in hex)

• symbolic actual machine instructions (regs shown: $31)

• assembly language instructions

• RISC (not always 1:1 correspondence)

Load and Store instructions

• move data between memory and the processor

• always 2 operands, a register and an address

• register is always first, direction of movement is opposite

– lw $t0, Num1 # load word, $t0=Num1

– sw $t0, Num2 # store word, Num2=$t0

• load immediate: li $vo, 4

• load address: la $a0, prompt_message (note diff with lw)

Basic Assembly Language InstructionsArithmetic

• done in registers, with 3 operands

• add Rdest, Rsrc1, src2

• (x + 5 - y) * 35/3 lw $t0, x # load x from memory

lw $t1, y # load y from memory

add $t0, $t0, 5 # x + 5

sub $t0, $t0, $t1 # x + 5 - y

mul $t0, $t0, 35 # (x + 5 - y) * 35

div $t0, $t0, 3 # (x + 5 - y) * 35/3

• arithmetic overflow, signed numbers

– add, sub, mulo, div check for overflow (not mul)

– “arithmetic overflow” and program usually stops

• unsigned numbers: addu, subu, mulou, divu

Basic Assembly Language InstructionsInput and Output - System calls

• difficult and specialised job

• SPIM: 10 basic services

• call code always goes in $v0 and the system is called with syscall

Service Code Arguments Results

print int 1 $a0 = integer signed decimal integer printed in window

print str 4 $a0 = str address string printed in window

read int 5 (none) $v0 holds integer that was entered

read str 8 $a0=store address characters are stored

$a1= length limit

exit 10 (none) Ends the program

Basic Assembly Language InstructionsControl structures

• if, while, for

• PC determines order of program execution

• unconditional jump

– puts the address of a label in the PC

– execution continues from that point

– jar also saves the old PC value as a “return address” in register $ra ($31)

Inst Example Meaning

j label j do_it_again next instruction is at the label do_it_again:

jal label jal my_proc execution of procedure my_proc will start.$ra holds address of instruction following the jal

jr Rsrc jr $ra Return from procedure call by putting $ra value back into the PC

Basic Assembly Language InstructionsControl structures

• conditional jump

– the condition is always a comparison of 2 registers, or a reg and a constant

– normally use signed numbers (if unsigned, add a ‘u’ to the command)

– can compare with z using $0 as src2 (or add ‘z’ to command)

Instruction Branch to label if Unsigned

beq Rsrc1,Src2,label Rsrc1 = Src2

bne Rsrc1,Src2,label Rsrc1 <> Src2

blt Rsrc1,Src2,label Rsrc1 < Src2 bltu

bgt Rsrc1,Src2,label Rsrc1 > Src2 bgtu

ble Rsrc1,Src2,label Rsrc1 <= Src2 bleu

bge Rsrc1,Src2,label Rsrc1 >= Src2 bgeu

Basic Assembly Language InstructionsControl structures

• IF constructs: choosing alternatives (if, if-then-else)

IF num < 0 thennum = - num

ENDIF

IF temperature >= 25 thenactivity = “go

swimming”else

activity = “ride bicycle”endifprint (activity)

lw $t0, numbgez $t0, endif0# must be ltz -----sub $t0, $0, $t0 # 0 - numsw $t0, numendif0:# num is now non-negativelw $t0, temperatureblt $t0, 25, else25la $a0, swimj endif25else25:la $a0, cycleendif25:li $v0, 4 # print string call codesyscall

Note: “branch around” and jump ins needed before else

Basic Assembly Language InstructionsControl structures

• loops: while and for (both pre-test loops), repeat (post-test loop)

Basic Assembly Language InstructionsControl structures

sum = 0num = 0WHILE num >= 0 DO sum = sum + num read (num)ENDWHILE

(write 10 lines)FOR countdown = 10 downto 1 DO print “Hello again …”ENDFOR

mov $t0, $0 # sum = 0mov $v0, $0 # num = 0while5: bltz $v0, endwhile5 # $v0 < 0? add $t0, $v0 #$v0 switches role here li $v0, 5 # read int call syscallj while5endwhile5:# set up print arguments before loopla $a0, hello_againli $v0, 4 # print string callli $t0, 10 # countdownfor10:beqz $t0, endfor10 syscall # print another line sub $t0, 1 # decr countdownj for10 # continue for loopendfor10

Basic Assembly Language Instructions

Instruction formats and addressing modesInstruction formats

register immediate jump

Addressing modes immediate - value built in to the instruction register - register used for data

Memory referencing - used with load and store instructions label - fixed address built in to the instruction indirect - register contains the address Base addressing - field of a record Indexed addressing - element of an array

Basic Assembly Language Instructions

Instruction formats

• all instructions fit in 32-bit words

• decoding starts with the leftmost 6-bits, the op code

Register • For operations using only registers as operands, the operation code is

000000

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

000000 src reg target reg Dest shift amt function

000000 01010 00111 00101 00000 100010

• the last line of the table gives as an example a subtract instruction, sub $5, $10, $7

• 3 5-bit fields identify the 3 regs: src, target/src, dest (diff from assembly)

Basic Assembly Language Instructions

Instruction formats (Register)

• flow between registers and ALU

• add $t3, $t1, $t2– $t1 = $9, $t2 = $10, $t3 = $11

Basic Assembly Language InstructionsImmediate

• 16-bit immediate (constant), 6-bit op, 2 regs

• addi $t1, $t2, 0xfffe (actually adds 0xfffffffe, -2)

• shorter numbers are sign extended

6 bits 5 bits 5 bits 16 bits

op code src reg target reg immediate value

001000 01010 01001 1111 1111 1111 1110

Basic Assembly Language InstructionsJump

• use all 26-bits following the op code for jump address

• last 2 bits are always 0 (word alignment)

• upon execution, the 26-bit jump target is shifted left 2 bits and stored in the PC, causing the jump

6 bits 26 bits - jump target (words)

j 0x0040000c

000010 0x0100003

• can only target the first 256Mb of memory

• workarounds: reserve “low” memory, use jump-reg instructions

Basic Assembly Language InstructionsAddressing Modes - Immediate

• usually use lower 16-bits, uses 2 instructions if > 16-bits

• PC-relative addressing - offset or displacement usedExamples of instructions with immediate data:

addi $t0,t1,65 sub $t0,7 #assembled as: addi $t0, $t0, -7 li $t3, 0x12345678 #assembled as

lui $at, 0x1234 ori $t3, $at, 0x5678 #puts it all

together bgez $t5, 16 #skip 4 instructions ahead

if # $t5 is non-negative

# (4 is encoded in #immediate field)

Basic Assembly Language InstructionsAddressing Modes - Immediate

• faster than memory

• some instructions reference registers exclusively

• 32 regs, only 5 bits to specify a register

Examples:

addu $t3, $t1, $t2# add (unsigned) $t3 = $t1 + $t2

sub $t0, $t3 # subtract (signed) $t0 = $t0 - $t3

Basic Assembly Language InstructionsMemory Addressing

• can address up to 4GB (slower access)

• label - fixed address built into the instruction– also known as direct addressinglw $t0, MyNumber # load the word into $t0

sb $t9, firstInitial # store rightmost 8 bits of $t9 in data seg

• indirect - register contains the address– a register can be used as a pointer

– e.g. stepping through a string one step at a timecatStr: .asciiz “cat”

la $t0, catStr # load address i.e. put address of catStr into $t0

lb $t1, ($t0) # ‘c’ is now in $t1

addi $t0, 1 # point to next character

lb $t2, ($t0) # ‘a’ is now in $t2

Basic Assembly Language InstructionsMemory Addressing - indirect addressing (cont.)

• base addressing– useful for referring to fields or a record or input

– e.g. telephone numbers: area code/prefix/number/extension

– 4 short ints (16-bit halfwords)

– the extension starts 6 bytes from the beginning of the record

– add offset 6 to a register pointing to the record

la $t0, MyPhone # $t0 points to a telephone record

lh $t1, 6($t0) # $t1 loaded with the extension no. in record

Basic Assembly Language InstructionsMemory Addressing - indirect addressing (cont.)

• indexed addressing– useful for indexing arrays

– e.g. copying a 10 byte string to another string

li $t1, 9 # $t0 indexes arrays

copyloop:

lb $t1, str1($t0) # $t1 used to transfer character

sb $t1, str2($t0) # to str2

sub $t10, 1 # decrement array index

bgez $t0, copyloop # repeat until $t0 < 0

• if moving words, need to decrement by 4 instead of 1

• assembler actually uses 3 machine ins for each indexed ins

Basic Assembly Language InstructionsMemory Addressing -the bottom linesb $t1, str2($t0) (address was 0x1001000C; 0x1001 = 4097)

Underlying instruction: sb $9, 12($1)

op code sb rs ($1) rt - $9 immediate (offset) 0x000c

101000 00001 01001 0000 0000 0000 1100