Scribd Logo
Upload

Welcome to Scribd!

  • 44 views

    Branches and Procedure Calls: Harris & Harris Morgan Kaufmann / Elsevier, 2007

    Uploaded by

    David Velasquez
    Branches and Procedure Calls discusses control flow in computer programs including conditional and unconditional branching, and high-level control structures like if/else statements, while loops, and for loops. It reviews how these constructs are implemented in MIPS assembly language using instructions like beq, bne, j, jr, and slt. Key registers like $s0-s7 are used to represent variables and loops are implemented by comparing registers against constants and branching or jumping accordingly.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd

    Branches and Procedure Calls: Harris & Harris Morgan Kaufmann / Elsevier, 2007

    Uploaded by

    David Velasquez
    44 views21 pages
    Branches and Procedure Calls discusses control flow in computer programs including conditional and unconditional branching, and high-level control structures like if/else statements, while loops, and for loops. It reviews how these constructs are implemented in MIPS assembly language using instructions like beq, bne, j, jr, and slt. Key registers like $s0-s7 are used to represent variables and loops are implemented by comparing registers against constants and branching or jumping accordingly.

    Original Description:

    Ptt

    Original Title

    aRCHITECTURE2 (1)

    Copyright

    © © All Rights Reserved

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Branches and Procedure Calls discusses control flow in computer programs including conditional and unconditional branching, and high-level control structures like if/else statements, while loops, and for loops. It reviews how these constructs are implemented in MIPS assembly language using instructions like beq, bne, j, jr, and slt. Key registers like $s0-s7 are used to represent variables and loops are implemented by comparing registers against constants and branching or jumping accordingly.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    44 views21 pages

    Branches and Procedure Calls: Harris & Harris Morgan Kaufmann / Elsevier, 2007

    Uploaded by

    David Velasquez
    Branches and Procedure Calls discusses control flow in computer programs including conditional and unconditional branching, and high-level control structures like if/else statements, while loops, and for loops. It reviews how these constructs are implemented in MIPS assembly language using instructions like beq, bne, j, jr, and slt. Key registers like $s0-s7 are used to represent variables and loops are implemented by comparing registers against constants and branching or jumping accordingly.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    You are on page 1of 21

    Branches and Procedure Calls

    Lecture 14
    Digital Design and Computer Architecture
    Harris & Harris
    Morgan Kaufmann / Elsevier, 2007

    1
    Review: Instructions, Operands
    • Instructions
    – add, sub, addi, and, lw, sw, etc.
    • Operands
    – Registers
    – Memory
    – Immediates (constants)

    2
    Review: MIPS Register Set
    Name Reg Usage
    $0 0 Const 0
    $v0-$v1 2-3 Results & Expr. Eval.
    $a0-$a3 4-7 Procedure arguments
    $t0-$t7 8-15 Temporaries
    $s0-$s7 16-23 Saved variables
    $t8-$t9 24-25 More Temporaries
    $gp 28 Global Pointer
    $sp 29 Stack Pointer
    $fp 30 Frame Pointer
    $ra 31 Return address
    3
    Review: MIPS Memory

    Word
    Address

    0000000C F E D C

    00000008 B A 9 8

    00000004 7 6 5 4

    00000000 3 2 1 0
    MSB LSB

    4
    MIPS Memory: Big- and Little-Endian
    Little-Endian: Big-Endian:
    Word Word
    Address Address

    0000000C F E D C 0000000C C D E F

    00000008 B A 9 8 00000008 8 9 A B

    00000004 7 6 5 4 00000004 4 5 6 7

    00000000 3 2 1 0 00000000 0 1 2 3
    MSB LSB MSB LSB

    5
    Review: Instruction Formats
    R-Type
    op rs rt rd shamt funct
    6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

    I-Type
    op rs rt imm
    6 bits 5 bits 5 bits 16 bits

    J-Type
    op addr
    6 bits 26 bits

    6
    Shift Instructions
    # shift left
    sll $t0, $s1, 2 # $t0 <= $s1 << 2

    # shift right logical


    srl $t0, $s1, 2 # $t0 <= $s1 >> 2

    # shift right arithmetic


    sra $t0, $s1, 2 # $t0 <= $s1 >>> 2

    7
    Shift Instructions
    Assembly Code Field Values
    op rs rt rd shamt funct

    sll $t0, $s1, 2 0 0 17 8 2 0

    srl $s2, $s1, 2 0 0 17 18 2 2

    sra $s3, $s1, 2 0 0 17 19 2 3


    6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

    Machine Code
    op rs rt rd shamt funct

    000000 00000 10001 01000 00010 000000 (0x00114080)

    000000 00000 10001 10010 00010 000010 (0x00119082)

    000000 00000 10001 10011 00010 000011 (0x00119883)


    6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

    8
    Review: The Stored Program
    Assembly Code Machine Code
    lw $t2, 32($0) 0x8C0A0020
    add $s0, $s1, $s2 0x02328020
    addi $t0, $s3, -12 0x2268FFF4
    sub $t0, $t3, $t5 0x016D4022

    Stored Program
    Address Instructions

    0040000C 0 1 6 D 4 0 2 2
    00400008 2 2 6 8 F F F 4
    00400004 0 2 3 2 8 0 2 0
    00400000 8 C0 A0 0 2 0 PC

    Main Memory
    9
    Branching
    Conditional Branching:
    • branch if equal (beq)
    • branch if not equal (bne)

    Unconditional Branching:
    • jump (j)
    • jump register (jr)
    • jump and link (jal)

    10
    Conditional Branching (beq)
    # MIPS assembly

    addi $s0, $0, 4 # $s0 = 0 + 4 = 4


    addi $s1, $0, 1 # $s1 = 0 + 1 = 1
    sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
    beq $s0, $s1, target
    addi $s1, $s1, 1
    sub $s1, $s1, $s0

    target:
    add $s1, $s1, $s0 # $s1 = 4 + 4 = 8

    11
    Conditional Branching (bne)
    # MIPS assembly

    addi $s0, $0, 4 # $s0 = 0 + 4 = 4


    addi $s1, $0, 1 # $s1 = 0 + 1 = 1
    sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
    bne $s0, $s1, target
    addi $s1, $s1, 1
    sub $s1, $s1, $s0

    target:
    add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

    12
    Unconditional Branching (j)
    # MIPS assembly

    addi $s0, $0, 4 # $s0 = 4


    addi $s1, $0, 1 # $s1 = 1
    j target # jump to target
    sra $s1, $s1, 2 # not executed
    addi $s1, $s1, 1 # not executed
    sub $s1, $s1, $s0 # not executed

    target:
    add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

    13
    Unconditional Branching (jr)
    # MIPS assembly

    0x00002000 addi $s0, $0, 0x2010


    0x00002004 jr $s0
    0x00002008 addi $s1, $0, 1
    0x0000200C sra $s1, $s1, 2
    0x00002010 lw $s3, 44($s1)

    14
    High-Level Code Constructs

    • If/Else Statements
    • While Loops
    • For Loops

    15
    If Statement
    // high-level code
    if (i == j)
    f = g + h;
    f = f - i;

    // MIPS assembly
    # $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j

    16
    If / Else Statement
    // high-level code
    if (i == j)
    f = g + h;
    else
    f = f - i;

    // MIPS assembly
    # $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j

    17
    While Loops
    // high-level code
    int result = 5;
    while (result > 0) {
    result = result - 1;
    }

    // MIPS assembly
    # $s0 = result

    18
    For Loops
    // high-level code
    int sum = 0;
    for (i=0; i != 10; i = i+1)
    sum = sum + i;

    // MIPS assembly
    # $s0 = i, $s1 = sum

    19
    For Loops: Using slt
    // high-level code
    int sum = 0;
    for (i = 1; i < 101; i = i * 2)
    sum = sum + i;

    20
    For Loops: Using slt
    # MIPS assembly code
    # $s0 = i, $s1 = sum
    addi $s1, $0, 0 # sum = 0
    addi $s0, $0, 1 # i = 1
    addi $t0, $0, 101 # $t0 = 101

    loop:
    slt $t1, $s0, $t0 # if (i < 101) $t1 = 1, else $t1
    = 0
    beq $t1, $0, done # if $t1 == 0 (i >= 101), branch
    to done
    add $s1, $s1, $s0 # sum = sum + i
    sll $s0, $s0, 1 # i = i * 2
    j loop

    done:

    21

    You might also like