Scribd Logo
Upload

Welcome to Scribd!

  • 79 views

    MIPS Assembly Language: CPSC 321 Computer Architecture Andreas Klappenecker

    Uploaded by

    Jeremie
    The document discusses MIPS assembly language instructions, addressing modes, and procedures for writing programs in MIPS assembly including loading values, arithmetic operations, control flow structures like loops and conditionals, calling procedures, using the stack, and examples like printing values and iterating through arrays. Key aspects covered include load/store instructions, registers, assembler directives, system calls, addressing modes, and writing recursive procedures.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd

    MIPS Assembly Language: CPSC 321 Computer Architecture Andreas Klappenecker

    Uploaded by

    Jeremie
    79 views30 pages
    The document discusses MIPS assembly language instructions, addressing modes, and procedures for writing programs in MIPS assembly including loading values, arithmetic operations, control flow structures like loops and conditionals, calling procedures, using the stack, and examples like printing values and iterating through arrays. Key aspects covered include load/store instructions, registers, assembler directives, system calls, addressing modes, and writing recursive procedures.

    Original Title

    mips1

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses MIPS assembly language instructions, addressing modes, and procedures for writing programs in MIPS assembly including loading values, arithmetic operations, control flow structures like loops and conditionals, calling procedures, using the stack, and examples like printing values and iterating through arrays. Key aspects covered include load/store instructions, registers, assembler directives, system calls, addressing modes, and writing recursive procedures.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    79 views30 pages

    MIPS Assembly Language: CPSC 321 Computer Architecture Andreas Klappenecker

    Uploaded by

    Jeremie
    The document discusses MIPS assembly language instructions, addressing modes, and procedures for writing programs in MIPS assembly including loading values, arithmetic operations, control flow structures like loops and conditionals, calling procedures, using the stack, and examples like printing values and iterating through arrays. Key aspects covered include load/store instructions, registers, assembler directives, system calls, addressing modes, and writing recursive procedures.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    You are on page 1of 30

    MIPS Assembly Language

    CPSC 321 Computer Architecture


    Andreas Klappenecker
    MIPS Assembly Instructions

     add $t0, $t1, $t2 # $t0=$t1+$t2


     sub $t0, $t1, $t2 # $t0=$t1-$t2

     lw $t1, a_addr # $t1=Mem[a_addr]


     sw $s1, a_addr # Mem[a_addr]=$t1
    Assembler directives

     .text assembly instructions follow


     .data data follows
     .globl globally visible label
    = symbolic address
    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
    Addressing modes

    lw $s1, addr # load $s1 from addr


    lw $s1, 8($s0) # $s1 = Mem[$s0+8]
    register $s0 contains the base address
    access the address ($s0)
    possibly add an offset 8($s0)
    Load and move instructions

    la $a0, addr # load address addr into $a0


    li $a0, 12 # load immediate $a0 = 12
    lb $a0, c($s1) # load byte $a0 = Mem[$s1+c]
    lh $a0, c($s1) # load half word
    lw $a0, c($s1) # load word
    move $s0, $s1 # $s0 = $s1
    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 $s0, label if $s0==0 goto label
    bnez $s0, label if $s0!=0 goto label
    bge $s0, $s1, label if $s0>=$s1 goto label
    ble $s0, $s1, label if $s0<=$s1 goto label
    blt $s0, $s1, label if $s0<$s1 goto label
    beq $s0, $s1, label if $s0==$s1 goto label
    bgez $s0, $s1, label if $s0>=0 goto label
    if-then-else structures
    if ($t0==$t1) then /* blockA */ else /* blockB */

    beq $t0, $t1, blockA


    j blockB
    blockA: … instructions of then block …
    j exit
    blockB: … instructions of else block …
    exit: … subsequent instructions …
    repeat-until loop
    repeat … until $t0>$t1

    loop: … instructions of loop …


    ble $t0, $t1, loop # if $t0<=$t1 goto loop

    Other loop structures are similar…


    Exercise: Derive templates for various loop structures
    System calls
     load argument registers
     load call code
     syscall

    li $a0, 10 # load argument $a0=10


    li $v0, 1 # call code to print integer
    syscall # print $a0
    SPIM system calls

    procedure code $v0 argument


    print int 1 $a0 contains number
    print float 2 $f12 contains number
    print double 3 $f12 contains number
    print string 4 $a0 address of string
    SPIM system calls

    procedure code $v0 result


    read int 5 res returned in $v0
    read float 6 res returned in $f0
    read double 7 res returned in $f0
    read string 8
    Example programs
     Loop printing integers 1 to 10
    1
    2
    3

     Increasing array elements by 5


    for(i=0; i<len; i++) {
    a[i] = a[i] + 5;
    }
    Print numbers 1 to 10
    main: li $s0, 1 # $s0 = loop counter
    li $s1, 10 # $s1 = upper bound of loop
    loop: move $a0, $s0 # print loop counter $s0
    li $v0, 1
    syscall
    li $v0, 4 # print “\n”
    la $a0, linebrk # linebrk: .asciiz “\n”
    syscall
    addi $s0, $s0, 1 # increase counter by 1
    ble $s0, $s1, loop # if ($s0<=$s1) goto loop
    li $v0, 10 # exit
    syscall
    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
    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 (byte addr.)
    add $t1, $t1, $t0 # $t1 = beyond last elem. A
    Increase array elements by 5
    Loop: lw $t2, ($t0) # $t2 = A[i]
    addi $t2, $t2, 5 # $t2 = $t2 + 5
    sw $t2, ($t0) # A[i] = $t2
    addi $t0, $t0, 4 # i = i+1
    bne $t0, $t1, loop # if $t0<$t1 goto loop
    li $v0, 10 # exit
    syscall
    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
     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
     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 $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 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 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
     Suppose that a procedure procA calls
    another procedure jal procB
     Problem: jal stores return address of
    procedure procB and destroys return
    address of procedure procA
     Save $ra and all necessary variables
    onto the stack, call procB, and retore
    Stack
    The stack can be high address 8($sp)
    used for
     parameter passing
    4($sp)

     storing return 0($sp)


    stack pointer $sp -->
    addresses
     storing result
    low address
    variables
     stack pointer $sp
    $sp = $sp - 12
    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

    You might also like

    pFad - Phonifier reborn

    Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

    Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


    Alternative Proxies:

    Alternative Proxy

    pFad Proxy

    pFad v3 Proxy

    pFad v4 Proxy