Midterm #2 Review February 25, 2013 1 / 11 I will provide . . . a - PowerPoint PPT Presentation

Midterm #2 Review February 25, 2013 1 / 11

I will provide . . . • a list of relevant instructions for assembly problems • just the keywords and the names! • you should know the difference between (and how to use) • add , addi , sub , subi • move , la , li , lw , sw • blt , ble , bgt , bge • j , jr , jal • a diagram of the stack frame layout • same as in slides, but black & white 2 / 11

You should bring . . . • a pencil and eraser • one page of notes (optional) • a calculator (optional and probably not needed) 3 / 11

Structure of test Part 1: Procedure call vocabulary • procedure, procedure call, jump-and-link, return address, • caller, callee, calling conventions, • the stack, stack pointer, stack frame, argument section • saved register section, local variable section Part 2: Array addressing • For an array initialized in the data segment . . . • determine value given base address and offset • determine offset from the base address of a given value • Also, register values as pointers into an array 4 / 11

Structure of test Part 3: Implementing control structures • if-then, if-then-else • while loop, do-while loop, for loop Part 4: Procedure calls • How to call a procedure, and return from it • How to push/pop a stack frame • How to pass and retrieve arguments • using registers and the stack • How to save and restore the return address on the stack 5 / 11

Array addressing Answer the questions in comments below .data # the first ten powers of two (remember words are four bytes!) array: .word 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 .text la $t0, array # put base address into a register lw $t1, 4($t0) # value of $t1? 2 lw $t2, 20($t0) # value of $t2? 32 lw $t3, X($t0) # value of X so $t3=8? 12 lw $t4, Y($t0) # value of Y so $t4=64? 24 addi $t0, $t0, 8 # change base address pointer lw $t5, 0($t0) # value of $t5? 4 lw $t6, 12($t0) # value of $t6? 32 6 / 11

Control structures – if-then statement # Pseudocode: # if (3 + a >= b) { # a = a + b # } # Register mappings: # a => $t0 b => $t1 Strategy 1: Complement condition, branch on false addi $t2, $t0, 3 # tmp = a + 3 blt $t2, $t1, end # if (tmp < b) goto end add $t0, $t0, $t1 # (then) a = a + b end: addi $t2, $t0, 3 # tmp = a + 3 bge $t2, $t1, end # if (tmp >= b) goto then j end # jump to end on condition true then: add $t0, $t0, $t1 # (then) a = a + b end: 7 / 11

Control structures – for loop # Pseudocode: # sum = 0 # for (i = 0; i < n; i++) { # sum = sum + i # } # Register mappings: # sum => $t0 i => $t1 n => $t2 loop: li $t0, 0 # sum = 0 li $t1, 0 # i = 0 bge $t1, $t2, end # while (i >= n) goto end add $t0, $t0, $t1 # (body) sum = sum + i addi $t1, $t1, 1 # (update) i++ j loop # (end of loop) end: 8 / 11

Anatomy of a stack frame (for reference) . . .   (arg 3)    previous stack frame (arg 2) (arg 1)     sp+fsize → (arg 0)  sp+fsize-4 → local var m  . . .  local variable section local var 0 (empty) ← padding (if needed) return address ← return address  saved reg k  . . .  saved register section saved reg 0 arg n   . . .     16+sp → arg 4    argument section 12+sp → (arg 3) 8+sp → (arg 2)     4+sp → (arg 1)     sp → (arg 0) top of stack 9 / 11

Procedures and argument passing # Pseudocode: Register mappings: # int myProc(a,b,c,d,e,f,g) { a => $a0 b => $a1 # ... c => $a2 d => $a3 # x = subroutine() e => $t0 f => $t1 # return x g => $t2 # } myProc: Procedure prologue # retrieve args e, f, g from previous stack frame lw $t0, 16($sp) # retrieve e from prev stack frame lw $t1, 20($sp) # retrieve f from prev stack frame lw $t2, 24($sp) # retrieve g from prev stack frame # new stack frame, 6 words: # 4 word arg section, return address, padding addiu $sp, $sp, -24 # push new stack frame # save return address in previous stack frame sw $ra, 16($sp) # save return address 10 / 11

Procedures and argument passing # Pseudocode: Register mappings: # int myProc(a,b,c,d,e,f,g) { a => $a0 b => $a1 # ... c => $a2 d => $a3 # x = subroutine() e => $t0 f => $t1 # return x g => $t2 # } myProc: Procedure epilogue # restore return address in previous stack frame lw $ra, 16($sp) # save return address # pop stack frame addiu $sp, $sp, 24 # return jr $ra 11 / 11