Mips assembly language i
This presentation is the property of its rightful owner.
Sponsored Links
1 / 28

MIPS Assembly Language I PowerPoint PPT Presentation


  • 79 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

MIPS Assembly Language I

An Image/Link below is provided (as is) to download presentation

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

MIPS Assembly Language I

Computer Architecture CPSC 321 Andreas Klappenecker


Mips assembly language i

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

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

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)


Mips datapath

MIPS Datapath


Instruction word formats

Instruction Word Formats

Register format

Immediate format

Jump format

op-code rs rt rd shamt funct

6 555 5 6

op-code rs rt immediate value

6 55 16

op-code 26 bit current segment address

6 26


Instruction format examples

Instruction Format Examples

  • Register Format

    • add $t0, $t1, $t2

  • Immediate Format

    • addi $t0, $t1, 10

  • Jump Format

    • j label


Hello world

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


Memory organization

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


Addressing modes

Addressing modes

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

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

add $t1, $t1, $t0 # $t1 = address(A)+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

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 registers1

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

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

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


Procedures1

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

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


Write your own procedures1

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


Write your own procedures2

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


Non leaf procedures

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

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.

high address

stack pointer$sp ->

low address


Memory organization1

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

Fibonacci

fib(0) = 0

fib(1) = 1

fib(n) = fib(n-1) + fib(n-2)

0, 1, 1, 2, 3, 5, 8, 13, 21,…


Fibonacci1

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


Mips assembly language i

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

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


Spim system calls

SPIM system calls


Spim system calls1

SPIM system calls


  • Login