MIPS Assembly Language I Computer Architecture CPSC 321

MIPS Assembly Language I Computer Architecture CPSC 321 Andreas Klappenecker

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

MIPS Instructions and Registers The operands to arithmetic instructions cannot be arbitrary expressions like in high-level languages, but have to be registers. add $t 0, $t 1, $t 2 # $t 0=$t 1+$t 2 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.

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

MIPS Datapath

Instruction Word Formats • Register format op-code rs 6 rt 5 rd 5 shamt 5 funct 5 6 • Immediate format op-code rs 6 rt 5 immediate value 5 16 • Jump format op-code 6 26 bit current segment address 26

Instruction Format Examples • Register Format • add $t 0, $t 1, $t 2 • Immediate Format • addi $t 0, $t 1, 10 • Jump Format • j label

Hello World!. text # code section . globl main: li $v 0, 4 # system call for print string la $a 0, str # load address of string to print syscall # print the string li $v 0, 10 # system call for exit syscall # exit . data str: . asciiz “Hello world!n” # NUL terminated string, as in C

Memory Organization 0 x 7 fff ffff Stack segment Dynamic data 0 x 1000 0000 Static data Text segment 0 x 40 0000 Reserved 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. Data segment

Addressing modes lw $s 1, 8($s 0) # $s 1 = Mem[$s 0+8] The register $s 0 contains the base address. We can access the address by ($s 0) and add an offset 8($s 0); this will be useful for procedures that have to save registers on the stack.

Increase array elements by 5. text. globl main: loop: la $t 0, Aaddr # $t 0 = pointer to array A lw $t 1, len # $t 1 = length (of array A) sll $t 1, 2 # $t 1 = 4*length add $t 1, $t 0 # $t 1 = address(A)+4*length lw $t 2, 0($t 0) # $t 2 = A[i] addi $t 2, 5 # $t 2 = $t 2 + 5 sw # A[i] = $t 2, 0($t 0) addi $t 0, 4 # i = i+1 bne # if $t 0<$t 1 goto loop $t 0, $t 1, loop . data Aaddr: . word 0, 2, 1, 4, 5 len: . word 5 # array with 5 elements

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.

MIPS Registers • • • $zero contains the constant 0 $at is reserved for the assembler – do not use $v 0 and $v 1 contain results of procedure call $a 0, …, $a 3 contain arguments of procedure calls $t 0, …, $t 9 temporary registers (which are not preserved after a procedure call; caller needs to save these registers) $s 0, …, $s 7 temporary registers (by convention preserved after procedure call; callee needs to save these registers) $k 0, $k 1 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!

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

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

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.

Write your own procedures # prints the integer contained in $a 0 print_int: li $v 0, 1 # system call to syscall # print integer jr $ra # return main: . . . li $a 0, 10 # we want to print 10 jal print_int # print integer in $a 0

Write your own procedures. data linebrk: . asciiz “n”. text print_eol: # prints "n" li $v 0, 4 # la $a 0, linebrk # syscall # jr $ra # return main: . . . jal print_eol # printf(“n”)

Write your own procedures. data main: loop: li $s 0, 1 # $s 0 = loop ctr li $s 1, 10 # $s 1 = upperbnd move $a 0, $s 0 # print loop ctr jal print_int # jal print_eol # print "n" addi $s 0, 1 # loop ctr +1 ble $s 0, $s 1, loop # unless $s 0>$s 1…

Non-leaf procedures • Suppose that a procedure proc. A calls another procedure, jal proc. B • What kind of problem occurs? • Problem: jal stores the return address of procedure proc. B and destroys return address of procedure proc. A • Save $ra and all necessary variables onto the stack, call proc. B, and then restore.

Stack The stack can be used for § parameter passing § storing return addresses $sp = $sp - 12 high address 4($sp) § storing result variables The stack pointer is contained in register $sp. 8($sp) stack pointer $sp -> 0($sp) low address

Memory Organization 0 x 7 fff ffff Stack segment Dynamic data 0 x 1000 0000 Static data Text segment 0 x 40 0000 Reserved 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. Data segment

Fibonacci fib(0) = 0 fib(1) = 1 fib(n) = fib(n-1) + fib(n-2) 0, 1, 1, 2, 3, 5, 8, 13, 21, …

Fibonacci li $a 0, 10 # call fib(10) jal fib # move $s 0, $v 0 # $s 0 = fib(10) fib is a recursive procedure with one argument $a 0 need to store argument $a 0, temporary register $s 0 for intermediate results, and return address $ra

fib: gen: rreg: sub $sp, 12 # save registers on stack sw $a 0, 0($sp) # save $a 0 = n sw $s 0, 4($sp) # save $s 0 sw $ra, 8($sp) # save return address $ra bgt $a 0, 1, gen # if n>1 then goto generic case move $v 0, $a 0 # output = input if n=0 or n=1 j rreg # goto restore registers sub $a 0, 1 # param = n-1 jal fib # compute fib(n-1) move $s 0, $v 0 # save fib(n-1) sub $a 0, 1 # set param to n-2 jal fib # and make recursive call add $v 0, $s 0 # $v 0 = fib(n-2)+fib(n-1) lw $a 0, 0($sp) # restore registers from stack lw $s 0, 4($sp) # lw $ra, 8($sp) # add $sp, 12 jr $ra # decrease the stack size

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

SPIM system calls procedure print float print double print string code $v 0 1 2 3 4 argument $a 0 contains number $f 12 contains number $a 0 address of string

SPIM system calls procedure code $v 0 result read int 5 res returned in $v 0 read float 6 res returned in $f 0 read double 7 res returned in $f 0 read string 8