MIPS Assembly Language CPSC 321 Computer Architecture Andreas

MIPS Assembly Language CPSC 321 Computer Architecture Andreas Klappenecker

MIPS Assembly Instructions n n add $t 0, $t 1, $t 2 sub $t 0, $t 1, $t 2 # $t 0=$t 1+$t 2 # $t 0=$t 1 -$t 2 lw $t 1, a_addr sw $s 1, a_addr # $t 1=Mem[a_addr] # Mem[a_addr]=$t 1

Assembler directives n n n . text. data. globl assembly instructions follow data follows globally visible label = symbolic address

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

Addressing modes lw $s 1, addr # load $s 1 from addr lw $s 1, 8($s 0) # $s 1 = Mem[$s 0+8] register $s 0 contains the base address access the address ($s 0) possibly add an offset 8($s 0)

Load and move instructions la $a 0, addr # load address addr into $a 0 li $a 0, 12 # load immediate $a 0 = 12 lb $a 0, c($s 1) # load byte $a 0 = Mem[$s 1+c] lh $a 0, c($s 1) # load half word lw $a 0, c($s 1) # load word move $s 0, $s 1 # $s 0 = $s 1

Control Structures Assembly language has very few control structures: § Branch instructions if cond then goto label § Jump instructions goto label We can build while loops, for loops, repeat-until loops, if-then-else structures from these primitives

Branch instructions beqz $s 0, label if $s 0==0 goto label bnez $s 0, label if $s 0!=0 goto label bge $s 0, $s 1, label if $s 0>=$s 1 goto label ble $s 0, $s 1, label if $s 0<=$s 1 goto label blt if $s 0<$s 1 $s 0, $s 1, label goto label beq $s 0, $s 1, label if $s 0==$s 1 goto label bgez $s 0, $s 1, label if $s 0>=0 goto label

if-then-else structures if ($t 0==$t 1) then /* block. A */ else /* block. B */ beq $t 0, $t 1, block. A j block. B block. A: … instructions of then block … j exit block. B: … instructions of else block … exit: … subsequent instructions …

repeat-until loop repeat … until $t 0>$t 1 loop: … instructions of loop … ble $t 0, $t 1, loop # if $t 0<=$t 1 goto loop Other loop structures are similar… Exercise: Derive templates for various loop structures

System calls n n n load argument registers load call code syscall li $a 0, 10 li $v 0, 1 syscall # load argument $a 0=10 # call code to print integer # print $a 0

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 read int read float read double read string code $v 0 5 6 7 8 result res returned in $v 0 res returned in $f 0

Example programs n Loop printing integers 1 to 10 1 2 3 n Increasing array elements by 5 for(i=0; i<len; i++) { a[i] = a[i] + 5; }

Print numbers 1 to 10 main: loop: li $s 0, 1 # $s 0 = loop counter li $s 1, 10 # $s 1 = upper bound of loop move $a 0, $s 0 # print loop counter $s 0 li $v 0, 1 syscall li $v 0, 4 # print “n” la $a 0, linebrk # linebrk: . asciiz “n” syscall addi $s 0, 1 # increase counter by 1 ble $s 0, $s 1, loop # if ($s 0<=$s 1) goto loop li $v 0, 10 # exit syscall

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

Increase array elements by 5. text. globl main: 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 (byte addr. ) add $t 1, $t 0 # $t 1 = beyond last elem. A

Increase array elements by 5 Loop: lw $t 2, ($t 0) # $t 2 = A[i] addi $t 2, 5 # $t 2 = $t 2 + 5 sw $t 2, ($t 0) # A[i] = $t 2 addi $t 0, 4 # i = i+1 bne $t 0, $t 1, loop # if $t 0<$t 1 goto loop li $v 0, 10 syscall # exit

Increase array elements by 5. data Aaddr: . word 0, 2, 1, 4, 5 len: . word 5 Idiosyncratic: Byte addressing => loop in steps of 4 Describe meaning of registers in your documentation!

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

Procedures n n one of the few means to structure your assembly language program small entities that can be tested separately can make an assembly program more readable recursive procedures

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 n n n Suppose that a procedure proc. A calls another procedure jal proc. B Problem: jal stores 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 retore

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

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!!! n n 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