MIPS Assembly Language I

1 / 28

# MIPS Assembly Language I - PowerPoint PPT Presentation

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, …)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'MIPS Assembly Language I' - Sophia

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### MIPS Assembly Language I

Computer Architecture CPSC 321 Andreas Klappenecker

MIPS

The MIPS assembly language has

• 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 \$t0, \$t1, \$t2 # \$t0=\$t1+\$t2

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
• 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)
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

Instruction Format Examples
• Register Format
• Immediate Format
• Jump Format
• j label
Hello World!

.text # code section

.globl main

main: li \$v0, 4 # system call for print string

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

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

lw \$s1, 8(\$s0) # \$s1 = Mem[\$s0+8]

The register \$s0contains 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.

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 = 4*length

loop: lw \$t2, 0(\$t0) # \$t2 = A[i]

addi \$t2, \$t2, 5 # \$t2 = \$t2 + 5

sw \$t2, 0(\$t0) # A[i] = \$t2

addi \$t0, \$t0, 4 # i = i+1

bne \$t0, \$t1, loop # if \$t0<\$t1 goto loop

.data

Aaddr: .word 0,2,1,4,5 # array with 5 elements

len: .word 5

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
• \$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!

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.
Procedures
• store address + 4 into \$ra
• 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.

# 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

.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”)

.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 \$s0>\$s1…

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.
Stack

\$sp = \$sp - 12

The stack can be used for

• parameter passing
• storing result variables

The stack pointer is contained in register \$sp.

stack pointer\$sp ->

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

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 \$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

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 n>1 then goto generic case

move \$v0,\$a0 # output = input if n=0 or n=1

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

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