1. 1 Branches and Procedure Calls Lecture 14 Digital Design and Computer Architecture Harris & Harris Morgan Kaufmann / Elsevier, 2007

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

3. 3 Review: MIPS Register Set NameRegUsage $00Const 0 $v0-$v12-3Results & Expr. Eval. $a0-$a34-7Procedure arguments $t0-$t78-15Temporaries $s0-$s716-23Saved variables $t8-$t924-25More Temporaries $gp28Global Pointer $sp29Stack Pointer $fp30Frame Pointer $ra31Return address

4. 4 Review: MIPS Memory

5. 5 MIPS Memory: Big- and Little-Endian Little-Endian: Big-Endian:

6. 6 Review: Instruction Formats

7. 7 Shift Instructions # shift left sll $t0, $s1, 2# $t0 <= $s1 << 2 # shift right logical srl $t0, $s1, 2# $t0 > 2 # shift right arithmetic sra $t0, $s1, 2# $t0 >> 2

8. 8 Shift Instructions

9. 9 Review: The Stored Program

10. 10 Branching Conditional Branching: branch if equal ( beq ) branch if not equal ( bne ) Unconditional Branching: jump ( j ) jump register ( jr ) jump and link ( jal )

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

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

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

14. 14 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)

15. 15 High-Level Code Constructs If/Else Statements While Loops For Loops

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

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

18. 18 While Loops // high-level code int result = 5; while (result > 0) { result = result - 1; } // MIPS assembly # $s0 = result

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

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

21. 21 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:

22. 22 Procedure Calls Definitions Caller: calling procedure Callee: called procedure How it works Caller needs to call a procedure without any unintended side effects Callee returns to point of call (place it was called from) when done Caller passes arguments to callee Callee returns result to caller

23. 23 Procedure Calls // high-level code int main() { simple();... } // void means the function returns no value void simple(){ return; }

24. 24 Procedure Calls # MIPS assembly code 0x00400200 main: jal simple 0x00400204 add $s0, $s1, $s2... 0x00401020 simple: jr $ra

25. 25 Input Arguments, Return Values // high-level code int main() { int y;... y = diffofsums(2, 3, 4, 5);... } int diffofsums(int f, int g, int h, int i) { int result; result = (f + g) - (h + i); return result; }

26. 26 Input Arguments, Return Values # MIPS assembly # $s0 = y main:... addi $a0, $0, 2 # argument 0 = 2 addi $a1, $0, 3 # argument 1 = 3 addi $a2, $0, 4 # argument 2 = 4 addi $a3, $0, 5 # argument 3 = 5 jal diffofsums # call procedure add $s0, $v0, $0 # y = returned value... # $s0 = result diffofsums: add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 jr $ra # return to caller

27. 27 Next Time More on Procedures Addressing Modes Linking and Launching Applications