CHAPTER

fit@hcmus
fit@hcmus
REMIND

 ISA
 RISC vs CISC
fit@hcmus
PREREQUITES

 Install MARS software already

fit@hcmus
What will you learn?

 Basic of a MIPS program

 Registers
 Memory Organization
 Operations
 System calls
 Procedures
fit@hcmus
MIPS Instruction Set

 Large share of embedded core market

Applications in consumer electronics, network/storage equipment,
cameras, printers, …
 Typical of many modern ISAs
fit@hcmus
MIPS Principles

According to the RISC architecture with 4 principles:

 Simpler is more stable
 Smaller is faster
 Increase processing speed for frequent cases
 Design requires good compromise
fit@hcmus
MIPS Assembly Program

.data # data label declaration

label1: <data type> <initial value>
label2: <data type> <initial value>
…
.text # instructions follow this directive
.globl #global text label, can access from another file
.globl main # This is the required global text label of
the program
…
main: # indicated start of code
…
#end of program
How to use MARS to code an assembly program

 Introduce how to use MARS tool

 Create a basic assembly program
 Observe the changing in the registers set and memory
fit@hcmus
Policy of use conventions for registers
Name Register Number Usage
$zero 0 The constant value 0
$v0 2 Result from callee
$v1 3 Return to caller
$a0 4 Argument to callee
$a1-$a3 5-7 From caller: caller saves
$t0-$t7 8-15 Temporaries: callee can clobber
$s0-$s7 16-23 Saved: callee can clobber
$t8-$t9 24-25 More temporaries (conditions)
$gp 28 Global pointer
$sp 29 Stack pointer
$fp 30 Frame pointer
$ra 31 Return address (caller saves)
$at 1 Reserved for assembler
$k0-$k1 26-27 Reserved for the OS kernel
fit@hcmus
Memory Organization

 Address, index
 Byte addressing
 Little/ Big Endian byte order
 MIPS addressing mode
fit@hcmus
Address/ Index

 The address is a value used to specify the location of a

specific data element within a memory array
 The address of a word matches the address of one of the
4 bytes within the word and addresses of sequential
words differ by 4
fit@hcmus
Byte addressing

 Byte addressing is the index

points to a byte of memory
 MIPS uses byte addressing,
with word addresses are
multiples of 4
 To access a word in memory,
the instruction must supply Chap2, A. Patterson and J. L. Hennessy, Computer Organization and Design: The Hardware/Software Interface,5th ed,
2014 Figure 2.3

the memory address Actual MIPS memory addresses

and
contents of memory for those
words
fit@hcmus Little/ Big Endian byte order
Bytes in a word can be numbered in two ways:
 Byte 0 at the leftmost (most significant) to the rightmost
(least significant), called big-endian (MIPS uses big-endian
byte order)
 The leftmost (most significant) to byte 0 at the rightmost
(least significant), called little-endian
Bit 31

Bit 31
Bit 0

Bit 0
Big-endian Little-endian

Byte 0 Byte 1 Byte 2 Byte 3 Byte 3 Byte 2 Byte 1 Byte 0

00 00 07 E4 E4 07 00 00
fit@hcmus
MIPS addressing mode

MISPS supports the following

addressing mode:
 Immediate addressing
 Register addressing
 Memory addressing
o Base addressing
o PC-relative addressing
o Pseudo-direct addressing
fit@hcmus
MIPS Operations

 Arithmetic
 Logical
 Data transfer
 Branch (Unconditional/ conditional)
fit@hcmus
Arithmetic operations

Syntax (R-format): op rd, rs, rt

op: operation code

rd: destination register number

rs: the first source register number

rt: the second source register number/ an immediate

fit@hcmus
Arithmetic operations

C code:
A=B + C

MIPS code Compiler will

add $s0, $s1, $s2 associate the
variables to the
registers
fit@hcmus
Discussions

1. How to know if an operation compiled from C is a signed

operation or not?
 Compiler
2. Can an operand be used as both a source and a target?
 Yes
3. Can constant data specify in an instruction?
 Yes (use I-format)
addi $s0, $s1, 3(addi = add immediate)
addi $s0, $s1, -3 (do not have subi)
fit@hcmus
Example: compute multiple operands

C code:
f = (g + h) – (i + j)

MIPS code: f$s0, h $s1 , i $s2 , j $s3

add $t0, $s1, $s2 # temp1 = g + h
add $t1, $s3, $s4 # temp2 = i + j
sub $s0, $t0, $t1 # f = temp1 – temp2
fit@hcmus
Example: assignment/ move between registers

C code:
a = b

MIPS code:
add $t1, $t0, $zero # a  $t1, b  $t0
#$zero contains the constant value 0
fit@hcmus
Arithmetic operations: Multiply & Division
 Two 32-bit registers for product
HI: most-significant 32 bits
LO: least-significant 32-bits
 Use HI/LO registers for
result
rs rt HI LO  HI: 32-bit remainder
 LO: 32-bit quotient
remainder quotient  Use mfhi, mflo instructions
to access the result
rs rt HI LO
fit@hcmus
Arithmetic operations: Multiplication
Syntax 1: mult rs, rt / multu rs, rt

Get the result:

mfhi rd #test HI value to see if product overflow 32 bits

mflo rd
Syntax 2: mul rd, rs, rt

# Least significant 32 bits of product  rd

fit@hcmus
Arithmetic operations: Division
Syntax : div rs, rt / divu rs, rt

Get the result:

mfhi rd #HI contains 32 bits of remainder

mflo rd #LO contains 32 bits of quotient

No overflow or divide by 0 checking (software’s job)

fit@hcmus
Arithmetic operations: Floating-point numbers

 Coprocessor1: the adjunct processor that extends the

ISA
 Separate FP (Floating-point) registers:
o Single-precision: $f0 - $31 (32 registers)
o Use the paired registers to save double precision floating-
point number

 FP instructions only operate on FP registers

fit@hcmus
Example: floating-point operands

Single-precision:
add.s $f0, $f1, $f2

Double-precision:
add.d $f0, $f1, $f2
fit@hcmus
Logical Operations

Instructions for bitwise manipulation

Operation C Java MIPS

Shift left << << sll
Shift right >> >>> srl
Bitwise AND & & and, andi
Bitwise OR | | or, ori
Bitwise NOT ~ ~ nor

Useful for extracting and inserting groups of bits in a word

fit@hcmus
Logical Operations: Shift operations

Syntax (R-format): op rd, rs, shamt

op: operation code

rd: destination register number

rs: the source register number

shamt: How many positions to shift (< 32 bits)

fit@hcmus
Logical Operations: Shift operations

Shift left logical: shift left and fill with 0 bits

sll $s0, $s1, 2 # $s1 shl 2  $s0
Shift right logical: shift right and fill with 0 bits
srl $s0, $s1, 2 # $s1 shr 2  $s0
Shift right arithmetic: shift right and fill with bits which has
a value equal to the MSB bit
sra $s0, $s1, 2 # $s1 sar 2  $s0
fit@hcmus
Logical Operations: Logical math operations

Syntax (R-format): op rd, rs, rt

op: operation code

rd: destination register number

rs: the first source register number

rt: the second source register/ immediate

fit@hcmus
Logical Operations: Logical math operations

MIPS does not support instructions for NOT, XOR, NAND

#a$s1, b $s2
and $s0, $s1, $s2 # a AND b
ori $s0, $s1, 2 # a OR i (a constant
number)
nor $t0, $t1, $zero #NOT A = A NOR 0
fit@hcmus
Data transfer

 RAM access only allow load/ store instructions

 Load word has destination first, store has destination last

31
fit@hcmus
Data transfer operations

Syntax (I-format): op rt,(constant/address)rs

op: operation code
rs: base address
rt: destination/ source register number
Constant: -215  215 – 1
Address: offset added to base address in rs (offset is
always a multiple of 4)

32
fit@hcmus
Data transfer operations
lw rt, offset(rs) # load a word at the
address $s0 + 12 from the memory
sw rt, offset(rs) # store a word to the
memory at the location $s0 + 12

33
fit@hcmus
Example

 Suppose that A is an array of 100 words with the starting

address (base address) contained in register $s0.
 The value ​of the variable g are stored in registers $s1
and $s2 respectively
C code: g = A[2];
MIPS code:
lw $t0, 8($s0) #load A[2] to the register
$t0
add $s1, $t0,$zero #save the value of A[2]
to g 34
fit@hcmus
Example

C code: A[12] = h + A[8];

MIPS code:
lw $t0, 32($s0) #load A[8] to the register
$t0
add $t0, $s2,$t0 #temporary register $t0=h +
A[8]
sw $t0, 48 ($s0)#store h + A[8] back to
A[12]

35
fit@hcmus
Discussions

 Load a byte xzzz zzzz from memory to a register in CPU.

(Useful for ASCII)
lb $t0, g
What is the value of this register (x is the MSB of the byte) ?
 Sing-extended: xxxx xxxx xxxx xxxx xxxx xxxx xzzz zzzz
 If you want the remaining bits from the right to have a
zero value (unsigned number)
 Load byte unsigned: lbu $t0, g

36
fit@hcmus
Discussions

Load/ store a half of word (useful for Unicode)

 Load halft: lh $t0, g #load ½ word – the 2 right
most bytes
 Store half: sh $t0, g #store ½ word – the 2 right
most bytes

37
fit@hcmus
Branch operations:

 Two kinds of branch instructions:

o Conditional
o Unconditional
 MIPS branch destination address = PC + (4 * offset)
o Target address = PC + offset × 4
o PC already plus 4 bytes by this time

38
fit@hcmus
Branch operations: Conditional branch
Syntax (I-format): oprs , rt , target address
rs: the first source register number
rt: the second source register number
Target Address: the address of the next instruction
beq rs, rt, label #if (opr1 == opr2) goto
label
bne rs, rt, label #if (opr1 != opr2) goto
label

39
fit@hcmus
Example
C Code: MIPS code:
if(a==b) #a  $t0, b  $t1, i  $t2
i = 1; beq $t0, $t1, Label
else addi $t2, $zero, 0
i = 0; Label
addi $t2, $zero, 1

40
fit@hcmus
Branch operations: Unconditional branch
Syntax (J-format): opTarget Address
rs: the first source register number
rt: the second source register number
Target Address: the address of the next instruction
j label #goto label

41
fit@hcmus
Example
C Code: MIPS code:
Do{ #a  $t0
Task 1; Loop:
}while(a!=0) Task 1
Task 2 bne $t0, $zero, Loop
j Task 2

42
fit@hcmus
Discussion

 Bigger/ smaller comparison ?

 MIPS support slt instruction to make the solutions for not
equal comparison
Syntax: slt rd, rs, rt
Explain: if (rs < rt)
rd = 1
else
rd = 0
43
fit@hcmus
Example
a < b
slt $t0, $s0, $s1 # if (a < b) then $t0 = 1
bne $t0, $0, Label # if (a < b) then goto Label
Another Task # else then do something
Label
a > b
slt $t0, $s1, $s0 # if (b < a) then $t0 = 1
bne $t0, $0, Label # if (b < a) then goto Label
Another Task # else then do something
Label
Another Task # else then do something

44
fit@hcmus
Example
a  b
slt $t0, $s0, $s1 # if (a < b) then $t0 = 1
beq $t0, $0, Label # if (a  b) then goto Label
Another Task # else then do something
Label
a  b
slt $t0, $s1, $s0 # if (b < a) then $t0 = 1
beq $t0, $0, Label # if (b  a) then goto Label
Another Task # else then do something
Label

45
fit@hcmus
Discussion

Compare with constant?

 MIPS support slti instruction to make the solutions for not
equal comparison
Syntax: slti rd, rs, constant
Explain: if (rs < constant)
rd = 1
else
rd = 0
46
fit@hcmus
Example: Switch...case in C

C code: C code: Convert to if...else

switch (k) { if (k == 0)
case 0: f = i + j; break; f = i + j;
case 1: f = g + h; break;
else if (k == 1)
case 2: f = g - h; break;
f = g + h;
}
else if (k == 2)
f = g – h;

f g h i j k
$s0 $s1 $s2 $s3 $s4 $s5 47
fit@hcmus
Example: Switch..case in MIPS
bne $s5, $0, L1 # if (k != 0) then goto L1
Add $s0, $s3, $s4 # else (k == 0) then f = i + j
J Exit # end of case  Exit (break)
L1:
addi $t0, $s5, -1 # $t0 = k – 1
bne $t0, $0, L2 # if (k != 1) then goto L2
add $s0, $s1, $s2 # else (k == 1) then f = g+ h
J Exit # end of case  Exit (break)
L2:
addi $t0, $s5, -2 # $t0 = k – 2
bne $t0, $0, Exit # if (k != 2) then goto Exit
sub $s0, $s1, $s2 # else (k == 2) then f = g - h
Exit:

48
fit@hcmus
System calls

 Through the system call (syscall) instruction to request a

service from a small set of the operating system services
 System call code  $v0
 Arguments  $a0 - $a3 ($f12 for floating-point)
 Return value  $v0 ($f0 for floating-point)

49
fit@hcmus

System
calls

50
fit@hcmus
Example

addi $v0, $0, 4 # $v0 = 0 + 4 = 4

# print string syscall

la $a0, str # $a0 = address(str)

syscall # execute the system call

51