Lecture VIII: Branching and Control Statements. Xuan Guo. CSC 3210 Computer Organization and Programming Georgia State University.

Transcription

1 Lecture VIII: Branching and Control Statements CSC 3210 Computer Organization and Programming Georgia State University February 5, 2015

2 This lecture Plan for the lecture: Recap: Filling delay slot Branching Examples Control Statements While Annulled conditional branch Do For If Then If Else

3 Instruction Cycle von Neumann cycle broken into 4 machine cycles: Instruction fetch Execute Memory access Store results F E M W Fetch & decode instruction Execute arithmetic instruction Access memory for a load or store instruction Write instruction results back to register file obtain any operands compute branch target address fetch instruction at target of branch instruction compute memory address

4 Data Dependencies Load Delay Problem load [%o0], %o1 add %o1, %o2, %o

5 Branch Delay Problem call.mul add %o0, 2, %l0 Insert branch delay slot instruction (Ex: ) does nothing to change the state of the machine

6 pc & npc

7 Branching Testing store state of execution: conditional codes Z: whether the result was zero N: whether the result was negative V: whether execution resulted in a number too large to store in the register C: whether execution resulted in a number that generated a carry out of register addcc subcc cmp reg, reg_or_imm, reg reg, reg_or_imm, reg reg, reg_or_imm subcc reg, reg_or_imm, %g0 Special add and sub instructions: cc is appended to the mnemonic, and the instruction sets condition codes Z, N, V, and C to save the state of execution.

8 Branching also delayed control transfer instructions Branch instructions are similar to call instructions They will specify the label of the destination instruction. delayed instruction will be executed before branch takes place test the condition codes b icc label b icc stands for one of the branches testing the integer condition codes

9 Branching Assembler Mnemonic ba bn Unconditional Branches Branch always, goto Branch never Assembler Mnemonic Unconditional Branches Complement bl Branch on less than zero bge ble Branch on less or equal to zero bg be Branch on equal to zero bne bne Branch on not equal to zero be bge Branch on greater or equal to zero bl bg Branch on greater than zero ble

10 Example y = (x 1)/(x 10) for 0 <= x <= 9 C program: int x; int y; for(x = 0; x<=9; x++){ y = (x-1)/(x-10); } x = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 y = 0, 0, 0, 0, 0, 0, -1, -2, -3, -8

11 Example y = (x 1)/(x 10) for 0 <= x <= 9.global main main: mov 0, %x_r ba test sub %x_r, 1, %o0 sub %x_r, 10, %o1 call.div mov %o0, %y_r add %x_r, 1, %x_r test: cmp %x_r, 10 bl loop C program: for(x = 0; x<=9; x++){ } y = (x-1)/(x-10); x = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 y = 0, 0, 0, 0, 0, 0, -1, -2, -3, -8

12 .file "ex3.c".global.div.section ".text".align 4.global main.type main, #function.proc 04 main:!#prologue# 0 save %sp, -120, %sp!#prologue# 1 mov 2, %g1 st %g1, [%fp-20].ll2: ld [%fp-20], %g1 cmp %g1, 9 bg.ll3 ld [%fp-20], %g1 add %g1, -1, %o5 ld [%fp-20], %g1 add %g1, -10, %g1 mov %o5, %o0 mov %g1, %o1 call.div, 0 mov %o0, %g1 st %g1, [%fp-24] ld [%fp-20], %g1 add %g1, 1, %g1 st %g1, [%fp-20] b.ll2.ll3: mov %g1, %i0 ret restore.size main,.-main.ident "GCC: (GNU) 3.4.6"

13 Example y = (x 1)/(x 10) for 0 <= x <= 9.global main main: mov 0, %x_r ba test sub %x_r, 1, %o0 call.div sub %x_r, 10, %o1 mov %o0, %y_r add %x_r, 1, %x_r test: cmp %x_r, 10 bl loop y = (x 1)/(x 10) for 0 <= x <= 9.global main main: mov 0, %x_r ba test sub %x_r, 1, %o0 sub %x_r, 10, %o1 call.div mov %o0, %y_r add %x_r, 1, %x_r test: cmp %x_r, 10 bl loop

14 Example y = (x 1)/(x 10) for 0 <= x <= 9.global main main: mov 0, %x_r ba test call.div sub %x_r, 10, %o1 mov %o0, %y_r add %x_r, 1, %x_r test: cmp %x_r, 10 bl loop sub %x_r, 1, %o0 y = (x 1)/(x 10) for 0 <= x <= 9.global main main: mov 0, %x_r ba test sub %x_r, 1, %o0 call.div sub %x_r, 10, %o1 mov %o0, %y_r add %x_r, 1, %x_r test: cmp %x_r, 10 bl loop

15 While While ( a <= 17) { } a = a + b; c++;

16 While While ( a <= 17) { } a = a + b; c++; test: cmp %ar, 17 bg done add %ar, %br, %ar add %cr, 1, %cr ba test done:

17 While While ( a <= 17) { } a = a + b; c++; test: cmp %ar, 17 bg done add %ar, %br, %ar add %cr, 1, %cr ba test done: if a = 0, b = 1, the program wastes 2*17 machine cycles

18 While test: done: Put the testing at end of the loop and use a branch always at the begin ba test cmp %ar, 17 bg done add %ar, %br, %ar add add %cr, 1, %cr %ar, %br, %ar add %cr, 1, %cr test: ba test cmp %ar, 17 ble loop

19 While ba test add %cr, 1, %cr add %ar, %br, %ar test: cmp %ar, 17 ble loop ba test add %cr, 1, %cr test: cmp %ar, 17 ble loop add %ar, %br, %ar

20 While ba test add %cr, 1, %cr add %ar, %br, %ar test: cmp %ar, 17 ble loop ba test add %cr, 1, %cr test: cmp %ar, 17 ble loop add %ar, %br, %ar the addition is executed even when the condition is false

21 Annulled Conditional Branches All conditional branches may be annulled b icc, a ble, a bg, a ba, a If a conditional branch is annulled, the delay instruction is executed when the branch is taken but not if the branch is not taken

22 Annulled Conditional Branches

23 ba test add %cr, 1, %cr test: cmp %ar, 17 ble loop add %ar, %br, %ar ba test add %cr, 1, %cr test: cmp %ar, 17 ble, a loop add %ar, %br, %ar After all the iterations, only waste two machine cycles

24 Do y = (x 1)*(x 7)/(x 11) for 0 <= x <= 10 C program: main() { } int x, y; x = 0; do{ y = (x 1)*(x 7)/(x 11); x++; }while(x < 11);

25 Do y = (x 1)*(x 7)/(x 11) for 0 <= x <= 10 C program: main() { int x, y; x = 0; do{ y = (x 1)*(x 7)/(x 11); x++; }while(x < 11); } mov 0, %xr sub %xr, 1, %o0 call.mul sub %xr, 7, %o1 call.div sub %xr, 11, %o1 mov %o0, %yr add %xr, 1, %xr cmp %xr, 11 bl loop

26 Do mov 0, %xr sub %xr, 1, %o0 call.mul sub %xr, 7, %o1 call.div sub %xr, 11, %o1 mov %o0, %yr add %xr, 1, %xr cmp %xr, 11 bl loop find an instruction that does not change the condition codes mov 0, %xr sub %xr, 1, %o0 call.mul sub %xr, 7, %o1 call.div sub %xr, 11, %o1 add %xr, 1, %xr cmp %xr, 11 bl loop mov %o0, %yr No machine cycle is wasted.

27 Do mov0, %xr sub %xr, 1, %o0 call.mul sub %xr, 7, %o1 call.div sub %xr, 11, %o1 mov %o0, %yr add %xr, 1, %xr cmp %xr, 11 bl loop (repeat the first instruction in the loop to minimize the #instructions) Waste one machine cycle when the execution of the delay slot instruction is annulled. mov0, %xr sub %xr, 1, %o0 call.mul sub %xr, 7, %o1 call.div sub %xr, 11, %o1 add %xr, 1, %xr cmp %xr, 11 bl, a loop sub %xr, 1, %o0

28 For for (ex1, ex2, ex3) { statements } reform using while ex1; while(ex2){ } statements; ex3;