1 / 28

MIPS Assembly Language I

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

Sophia
Télécharger la présentation

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 # $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.

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

  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 = 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

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

  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. high address stack pointer$sp -> 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 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

  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

  28. SPIM system calls

More Related