MIPS Assembly Language I

1
MIPS Assembly Language I

• Computer Architecture CPSC 321
  Andreas Klappenecker

2
MIPS

• The MIPS assembly language has
• arithmetic instructions (add, sub,)
• logical instructions (and, or,)
• branch instructions (bgtz, bne, )
• jump instructions (j, jr, )
• load and store instructions (lb, sw,)
• floating point instructions

3
MIPS Instructions and Registers

• The operands to arithmetic instructions cannot be
  arbitrary expressions like in high-level
  languages, but have to be registers.
• add t0, t1, t2 t0t1t2
• Registers are special locations of memory that
  are also visible to the programmer. The size of a
  register is 32 bits in the MIPS architecture.

4
MIPS Design Principles

• Simplicity favors regularity (instructions
  have exactly three operands)
• Smaller is faster
  (do not provide too many registers)
• Good design demands good compromises
  (all instructions have
  the same length, but three different formats)

5
MIPS Datapath
6
Instruction Word Formats

• Register format
• Immediate format
• Jump format

op-code rs rt
rd shamt funct
6 5 5 5 5
6
op-code rs rt
immediate value
6 5 5 16
op-code 26 bit current
segment address
6 26
7
Instruction Format Examples

• Register Format
• add t0, t1, t2
• Immediate Format
• addi t0, t1, 10
• Jump Format
• j label

8
Hello World!
.text code section .globl main main li
v0, 4 system call for print string la a0,
str load address of string to
print syscall print the string li v0,
10 system call for exit syscall
exit .data str .asciiz Hello world!\n
NUL terminated string, as in C
9
Memory Organization
0x7fff ffff
The memory is byte addressed. If you want to step
word by word through the memory, then you have to
increase your pointer each time by 4.
Stack segment
Dynamic data
Data segment
Static data
0x1000 0000
Text segment
0x40 0000
Reserved
10
Addressing modes
lw s1, 8(s0) s1 Mems08 The register
s0 contains the base address. We can access the
address by (s0) and add an offset 8(s0) this
will be useful for procedures that have to save
registers on the stack.
11
Increase array elements by 5
.text .globl main main la
t0, Aaddr t0 pointer to array A
lw t1, len t1 length (of
array A) sll t1, t1, 2 t1
4length add t1, t1, t0 t1
address(A)4length loop lw t2, 0(t0)
t2 Ai addi t2, t2, 5
t2 t2 5 sw t2, 0(t0)
Ai t2 addi t0, t0, 4 i
i1 bne t0, t1, loop if
t0ltt1 goto loop .data Aaddr .word
0,2,1,4,5 array with 5 elements len
.word 5
12
MIPS Registers

• The MIPS architecture has 32 registers with 32
  bits each, 0,,31.
• The MIPS assembly language provides more
  convenient symbolic names.
• The register usage follows certain conventions
  that you need to memorize.

13
MIPS Registers

• zero contains the constant 0
• at is reserved for the assembler do not use
• v0 and v1 contain results of procedure call
• a0,,a3 contain arguments of procedure calls
• t0,,t9 temporary registers (which are not
  preserved after a procedure call caller needs to
  save these registers)
• s0,,s7 temporary registers (by convention
  preserved after procedure call callee needs to
  save these registers)
• k0, k1 reserved do not use
• gp, sp, fp global area, stack pointer, frame
  pointer
• ra return address (used by a procedure call)

We come back to these conventions!
14
Register Conventions

• Suppose you store the value 7 in s3 and call a
  procedure. Does s3 still contain 7 after the
  procedure call?
• Yes, it should (if the procedure is using s3,
  then it is supposed to save its value, and has to
  restore the value of s3 before returning)
• Suppose you store the value 7 in t3 and call a
  procedure. Does t3 still contain 7 after the
  procedure call?
• No, not necessarily. The variable t3 is
  temporary and the procedure is allowed to
  overwrite this register and does not have to
  restore its value.

15
Procedures

• jal addr
• store address 4 into ra
• jump to address addr
• jr ra
• allows subroutine to jump back
• care must be taken to preserve ra!
• more work for non-leaf procedures

16
Procedures

• Procedures are one of the few means to structure
  your assembly language program
• Program small entities that can be tested
  separately
• Procedures can make an assembly program more
  readable
• Recursive procedures sometimes elegantly solve
  problems.

17
Write your own procedures
prints the integer contained in a0 print_int
li v0, 1 system call to syscall
print integer jr ra
return main . . . li a0, 10 we want to
print 10 jal print_int print integer in
a0
18
Write your own procedures
.data linebrk .asciiz \n .text print_eol
prints "\n" li v0, 4
la a0, linebrk syscall
jr ra
return main . . . jal print_eol
printf(\n)
19
Write your own procedures
.data main li s0, 1
s0 loop ctr li s1, 10
s1 upperbnd loop move a0, s0
print loop ctr jal print_int
jal print_eol print "\n"
addi s0, s0, 1 loop ctr 1
ble s0, s1, loop unless s0gts1
20
Non-leaf procedures

• Suppose that a procedure procA calls another
  procedure, jal procB
• What kind of problem occurs?
• Problem jal stores the return address of
  procedure procB and destroys return address of
  procedure procA
• Save ra and all necessary variables onto the
  stack, call procB, and then restore.

21
Stack
sp sp - 12

• The stack can be used for
• parameter passing
• storing return addresses
• storing result variables
• The stack pointer is contained in register sp.

8(sp)
4(sp)
0(sp)

high address
stack pointer sp -gt
low address
22
Memory Organization
0x7fff ffff
The memory is byte addressed. If you want to step
word by word through the memory, then you have to
increase your pointer each time by 4.
Stack segment
Dynamic data
Data segment
Static data
0x1000 0000
Text segment
0x40 0000
Reserved
23
Fibonacci
fib(0) 0 fib(1) 1 fib(n) fib(n-1)
fib(n-2) 0, 1, 1, 2, 3, 5, 8, 13, 21,
24
Fibonacci
li a0, 10 call fib(10) jal fib
move s0, v0 s0 fib(10) fib is a
recursive procedure with one argument a0 need to
store argument a0, temporary register s0 for
intermediate results, and return address ra
25
fib sub sp,sp,12 save registers
on stack sw a0, 0(sp) save
a0 n sw s0, 4(sp) save
s0 sw ra, 8(sp) save return
address ra bgt a0,1, gen if
ngt1 then goto generic case move v0,a0
output input if n0 or n1 j
rreg goto restore
registers gen sub a0,a0,1 param
n-1 jal fib compute
fib(n-1) move s0,v0 save
fib(n-1) sub a0,a0,1 set
param to n-2 jal fib
and make recursive call add v0, v0, s0
v0 fib(n-2)fib(n-1) rreg lw a0,
0(sp) restore registers from stack
lw s0, 4(sp) lw ra,
8(sp) add sp, sp, 12
decrease the stack size jr ra
26
Practice, practice, practice!!!

• Read Chapter 3 and Appendix A
• Write many programs and test them
• Get a thorough understanding of all assembly
  instructions
• Study the register conventions carefully

27
SPIM system calls
procedure code v0 argument
print int 1 a0 contains number
print float 2 f12 contains number
print double 3 f12 contains number
print string 4 a0 address of string
28
SPIM system calls
procedure code v0 result
read int 5 res returned in v0
read float 6 res returned in f0
read double 7 res returned in f0
read string 8