1. Logical and Decision Operations
Chapter 2

2. Logical operations Shift left Shift right Bit-wise AND Bit-wise OR
Example: sll $t2,$so,4
Reg t2 = $so << 4
Shift right
Example: srl $t2,$so,4
Reg t2 = $so >> 4
Bit-wise AND
Example: and $t0,$t1, $t2
Reg t0 = reg t1 & reg t2
Bit-wise OR
Example: or $t0,$t1,$t2
Reg $t0 = $t1 | $t2

3. Instructions for Selection (if..else)
If (i == j) then f = g + h; else f = g – h;
bne $s3,$s4, else
add $s0,$s1,$s2
j done
else: sub $s0,$s1,$s2
done:

4. Instructions for Iteration (while)
while (save[i] == k)
i = i + 1;
Let i be in reg $s3
Let k be in reg $s5
Let $t1 have the address of Save array element
Loop: sll $t1,$s3,2
add $t1,$t1$s6
lw $t0,0($t1)
bne $t0,$s5,Exit
addi $s3,$s3,1
j Loop

5. Compiling C procedures
int leaf_example (int g, int h, int i, int j) { int f; f = (g + h) – (i + j); return f; } How do you pass the parameters? How does compiler transport the parameters?

6. Passing Parameters/arguments
Special registers for arguments: a0, a1, a2, a3 Save temp register on the stack Perform operations And return value Restore values stored on the stack Jump back to return address

7. Steps in Execution of a Procedure
Place parameters in a place where procedures can access them
Transfer control to the procedure
Acquire the storage resources needed for the procedure
Perform the desired task
Place the result value in a place where the calling program can access it
Return control to the point of origin, since a procedure can be called from several points in a program

8. Register Mapping – Ahah!
R0 (r0) = R1 (at) = R2 (v0) = R3 (v1) = R4 (a0) = R5 (a1) = R6 (a2) = R7 (a3) = R8 (t0) = R9 (t1) = R10 (t2) = R11 (t3) = R12 (t4) = R13 (t5) = R14 (t6) = R15 (t7) =
R16 (s0) =
R17 (s1) =
R18 (s2) =
R19 (s3) =
R20 (s4) =
R21 (s5) =
R22 (s6) =
R23 (s7) =
R24 (t8) =
R25 (t9) =
R26 (k0) =
R27 (k1) =
R28 (gp) =
R29 (sp) = 7fffeffc
R30 (s8) =
R31 (ra) =

9. Procedure Call Conventions
$a0-$a3 : four argument registers in which to pass parameters
$vo-$v1: two value registers in which to return values
$ra: one return address register to return to point of origin of the call
MIPS assembly language also has a special instruction jal (jump and link) that saves the return address in $ra before transferring control to the procedure.
Eg: jal ProcedureAddress
Another instruction “jr” transfers control back to the called location.
Eg. jr $ra

10. Using the Stack “automatic storage”
Automatic store for “workspace” and temporary registers.
Use the stack:
Use the stack pointer to access stack;
Remember stack operates on LIFO
Also note that $ZERO is a convenience register that stores the value 0 (check your green sheet attached to your textbook)
Now we are ready to translate the procedure:

11. Translating the procedure
int leaf_example (int g, int h, int i, int j)
{ int f;
f = (g + h) – (i + j);
return f; }
Parameters g, h, i, j will be stored in argument registers: $a0,$a1,$a2,$a3 before the call
Once inside we plan to use $s0, $t0, $t1; so we need save their values on the stack;
Then use them to compute (g+h), (i+j) and f

12. MIPS code
addi $sp,$sp,-12 # make room on the stack sw $t1,8($sp) # save the temp registers sw $t0,4($sp) sw $so,o($sp) add $to,$ao,$a1 # t0  g + h add $t1,$a2,$a3 # t1  i + j sub $so,$t0,$t1 # f = t0 – t1 add $v0,$so,$zero # returns f ($vo = $s0 + 0) lw $s0,0(sp) # restore saved values into temp registers from stack lw $t0,4(sp) lw $t1,8(sp) addi $sp,$sp,12 jr $ra # jump back to the return address

13. Allocating Space on Stack
Stack is used to save and restore registers when calling a procedure
It may also be used to store return address
It may be used to store arguments
It may be used to store local arrays and data
The segment of the stack containing a procedure’s saved registers and local variables is called “procedure frame” or “activation record”
A frame pointer ($fp) points to first word of the frame of a procedure.

14. Stack and frame pointers
before
after
during fp fp sp sp fp
Saved arguments
Saved return addr
Saved regs .
Locals arrays
& structures sp

15. Delayed Branches Branch: execute successor even if branch taken!
Inst Fetch
Dcd & Op Fetch
Execute
execute successor
even if branch taken!
Inst Fetch
Dcd & Op Fetch
Execute
Then branch target
or continue
Inst Fetch
Single delay slot
impacts the critical path
add r3, r1, r2
sub r4, r4, 1
bz r4, LL
NOP
...
LL: add rd, ...
Compiler can fill a single delay slot with a useful instruction 50% of the time.
try to move down from above jump
move up from target, if safe

16. Delayed Branches li r3, #7 sub r4, r4, 1 bz r4, LL nop
LL: slt r1, r3, r5
subi r6, r6, 2
li r3, #7
sub r4, r4, 1
bz r4, LL
subi r6, r6, 2
LL: slt r1, r3, r5
compiler

17. Branch and Pipelines Time li r3, #7 execute sub r4, r4, 1 ifetch
Delay Slot
Branch Target
ifetch
sub r4, r4, 1
bz r4, LL
subi r6, r6, 2
ifetch
LL: slt r1, r3, r5
By the end of Branch instruction, the CPU knows whether or not
the branch will take place.
However, it will have fetched the next instruction by then,
regardless of whether or not a branch will be taken.
Why not execute it?

18. Putting it all together
Sort procedure
void sort (int v[], int n) {
int i, j;
for (i = 0; i < n; i = i+1) { // outer loop
for (j = i - 1; j >= 0 && v[j] > v[j+1]; j = j-1){
swap(v, j); }
} }
See fig. 2.34, 2.36
Hwk 2: 2.15 : due date: 2/6/2009, submit online.