Branching & Procedures

Module 15

Reading Assignment	Schedule of Lectures	Sample Problems 2,4
Previous Lecture	Next Lecture	The SPIM Simulator Supplemental Material

Control Flow

• Decision making instructions alter the control flow, i.e., the next instruction being executed
• Unconditional changes in control flow
• The jump instruction
• j  L1  -  the next instruction that is executed is the one with label L1
• Conditional changes in control flow
• The branch instruction
• beq $t0, $t1, L1
• if the contents of the two registers are equal, the next instruction that is executed is the one with label L1

Programming Constructs

• Iteration: for and while loops
• Basic structure

initialization           -- loop counters, variable values
termination check  -- are we done yet?
loop body              -- computation
branch                   -- branch back to the top of the loop

• Examples
• Executing a loop a fixed number of times: loop counts
• Loop counts and pointer arithmetic
• array accesses
• Conditionals: if-then and if-then-else
• Basic structure

condition evaluation: branch to F if false  -- which block of code is executed?
computations for true case -- execute this block is condition is true
branch to exit block -- now we are done here

F:  computations if false -- execute this block is condition is false
exit:  next block of code                                    -- we are done, move on.

• example
• The instructions beq and bne simply check if two registers are equal. It is very common for one of the registers to be $0 but not necessary. How can we check more general conditions?

Control Flow Branch Conditions

• Branching on more general conditions
• Branch on < or branch on =<
• branch on a < b < c
• how are these tests supported?
• We have an instruction that can record  the result of a comparison!
• slt $t0, $t1, $t2

register $t0 = 1 if  $t1 < $t2  - remember we are comparing the contents of the registers!

• We can now synthesize many different kinds of branching behavior as pseudoinstructions using slt
• bgt, blt, and bge are a few examples
• example: ble
• example: bgt
• An implementation of slt  will require multiple microinstructions or require modifications to the adder/subtractor
• The output of the test should be a 32-bit quantity that is 0 or 1

Addressing in Branches and Jumps

• Branch addresses are PC-relative
• If the branch condition is true then the next instruction to be executed is described as being located D words forward or backward from the current instruction
• Branch instructions can be encoded in I-format instructions
• this means the offset can only be represented in 16 bits
• the offset is a two's complement number
• program can branch 2¹⁵ words back or 2¹⁵ - 1 words forward
• offset is large enough for most real programs
• How does the hardware handle this? à next instruction logic!
• Example
• Jump instructions specify absolute addresses
• We cannot encode 32-bit addresses in a 32-bit instruction
• We need the 6-bit opcode therefore we encode a 26 bit word address
• How does the hardware handle this à next instruction logic!
• Example

Summary of Addressing in SPIM

• There are a variety of ways in which operands are addressed in SPIM.
• Immediate
• Register
• Base + offset
• PC-relative

The Datapath

• The availability of branch and jump instructions changes the next instruction fetch logic
• Consider the implementation of the beq $t0, $t1, loop instruction and the j index instruction
• The new value of the PC is either PC+4, PC+ branch-offset, or  the jump address
• Jump address and branch offset from the encoded instruction are expressed in words rather than bytes
• Convert jump address and branch offset to bytes by multiplying by four (left shift by 2)
• The branch condition is tested by the adder/subtractor unit
• We add some new control signals: beq and jmp sel (note Z comes from the adder subtractor)

• The next instruction fetch logic has new inputs: sign extended offset, jump address, beq, jmp sel and Z.

Procedure Calls

The Stack

• The stack is an area of memory managed in a special way
• Pushing a word onto the stack
• Popping a word from the stack
• Reserving a block of words on the stack
• Addressing in the stack

Procedure Calls

• What is the purpose of procedure calls?
• Compact programs
• Program re-use via libraries
• What is the behavior of procedure calls
• Branching to the start of the procedure
• the jal instruction
• Passing arguments into the procedure, where are they?
• in registers $a0-$a3
• excess parameters passed on the stack
• we establish a priori a set of rules for procedure passing
• Returning to the main program
• to return to the correct point we need to have stored the return address
• set of rules: return address is stored in a register say $31
• Examples

Hardware Support

• What modifications to the datapath do we need to support this behavior?
• Changing the PC when branching
• Saving the return address
• Restoring the PC on procedure return

Example:

This is an example of the structure of a loop where we keep a counter to count the number of times the
loop is executed. Note that we count down from 16 here. We could just as easily have written the loop
such that we count up. However in this case, to test whether we are completed we would have to compare the
counter value to the value 16. Comparison to the value 0 is easy in the SPIM instruction set since register $0
always contains the value 0.

.text
li $t0, 16
loop:   # first instruction of the
            #  loop body where you
            #  do some work for
            #  each iteration
            #
addi $t0, $t0, -1      # decrement the counter by 1
bne $t0, $0, loop    # if we are not done go back to the beginning
                                                   # of the loop

Example:

Now suppose in addition to executing a loop a fixed number of times, we are also scanning memory,
perhaps reading successive elements in an array. We should be able to manage the pointer to the locations in
memory. In this example the address of an array element is contained in $t2. Adding 4 to $t2 provides the
address of successive elements which are fetched from memory in successive iterations.

.data
start:    .word 22, 23,2, 4, 45, -6

            .text
li $t0, 6
            la $t2, start          # this instruction loads the value of start (an address) into $t0
loop:     lw $t1, 0($t2)     # access the array element in memory
           #
            #  loop body where you
            #  do some work for
            #  each iteration
            #
addi $t2, $t2, 4        # point to the next location on memory
addi $t0, $t0, -1      # decrement the counter by 1
bne $t0, $0, loop    # if we are not done go back to the beginning
                                        # of the loop

Example:

 Now let us grow the preceding example into something more concrete: adding the elements of the array. Let us
further assume that we do not know the number of elements of the array but we do know the last element is zero.
Note that unlike the preceding examples, we continue to execute the loop until we find a value of 0
rather than for a fixed number of iterations. We also find the need to use the "j" instruction.

.data
start:    .word 22, 23,2, 4, 45,0

            .text
            move $t0, $0          # let is use this register to compute the sum
            la $t2, start             # let use this register as a pointer into the array
loop:    lw $t5, 0($t2)         # access the array element in memory
beq $t5, $0, exit       # if the fetched value is zero exit the loop
addi $t2, $t2, 4        # point to the next location on memory
addi $t0, $t0, $t5     # update the sum of the elements
            j loop                      # now we are ready to start the next iteration
exit:                                    # the label "exit" is applied to the first
                                            # instruction after the loop

Example:

The following code adds two numbers if $t0 is equal to 0, otherwise the difference of the two numbers is computed.
This represents the basic if-then-else programming construct.

            .text
bne $t0, $0, else    # check if the contents of $t0 = 0, Branch if not equal
            add $t1, $t2, $t3    # this is the then part of the  code
            j exit                    # now we need to jump over the else branch of the code
else:     sub $t1, $t2, $t3  # this is the else part of the code
exit:     move $t4, $t1      # the program continues using the value in $t1
           ----
           ----

Example:

The following sequence of instructions implements the branch-on-less-than-or-equal-to instruction. Consider the
implementation of the following instruction: ble $t2, $t3, L1

            .text
slt $t1, $t3, $t2   # this instruction is recording if $t3 < $t2
beq $t1, $0, L1  # if the preceding test fails (i.e., $t1 =0) then we have $t2 = < $t3
           ---
           ---
           ---
L1:      ---
           ---

Example:

This example provides a code sequence that implements branch-on-greater-than: bgt $t2, $t3, L1

.text
slt $t1, $t3, $t2   # this instruction is recording if $t3 < $t2
bne $t1, $0, L1  # if the preceding test succeeds (i.e., $t1 = 1 signifying $t2 > $t3) then the branch is taken
           ---
           ---
           ---
L1:      ---
           ---

Questions and comments to Sudhakar Yalamanchili