Do-While Example In C++ do { z--; while (a == b); z = b; In assembly language loop: addi $s2, $s2, -1 beq $s0, $s1, loop or $s2, $s1, $zero 25
Comparisons Set on less than (slt) compares its source registers and sets its destination register to 1 if src1 < src2 and to 0 otherwise (branch-if-less-than) Syntax: slt dest, src1, src2 Set on less than immediate (slti) perform the same comparison, but its second source operation is an immediate value Syntax: slti dest, src1, immed Combined with beq and bne these instructions can implement all possible relational operators 26
Relational Branches (1) Branch if less than slt $t0, src1, src2 bne $zero, $t0, label Branch if greater than or equal slt $t0, src1, src2 beq $zero, $t0, label 27
Relational Branches (2) Branch if greater than slt $t0, src2, src1 bne $zero, $t0, label Branch if less than or equal slt $t0, src2, src1 beq $zero, $t0, label 28
Case/Switch Statement * Can be implemented like a chain of if-thenelse statements Using a jump address table is faster Must be able to jump to an address loaded from memory Jump register (jr) gives us that ability Syntax: jr src Instruction: jr $t1 #go to address in $t1 29
Compiling a Case (Switch) Statement Memory switch (k) { case 0: h=i+j; break; /*k=0*/ case 1: h=i+h; break; /*k=1*/ case 2: h=i-j; break; /*k=2*/ Assuming three sequential words in memory starting at the address in $t4 have the addresses of the labels L0, L1, and L2 and k is in $s2 $t4 add $t1, $s2, $s2 #$t1 = 2*k add $t1, $t1, $t1 #$t1 = 4*k add $t1, $t1, $t4 #$t1 = addr of JumpT[k] lw $t0, 0($t1) #$t0 = JumpT[k] jr $t0 #jump based on $t0 L0: add $s3, $s0, $s1 #k=0 so h=i+j j Exit L1: add $s3, $s0, $s3 #k=1 so h=i+h j Exit L2: sub $s3, $s0, $s1 #k=2 so h=i-j Exit:... L2 L1 L0 30
MIPS Organization src1 addr 5 src2 addr 5 dst addr 5 write data 32 Processor Register File 32 registers ($zero - $ra) 32 bits 32 32 src1 data src2 data read/write addr 32 Memory 1 1100 2 30 words Exec br offset 32 32 PC 32 Add 32 4 Fetch 32 PC = PC+4 Decode 32 32 Add 32 ALU 32 read data write data 32 32 4 5 6 7 0 1 2 3 byte address (big Endian) 32 bits 0 1100 0 1000 0 0100 0 0000 word address (binary) 31
Variable Index into Array Previous method for accessing array elements will only work if index is constant If index is a variable we must compute the address in code Formula: address + (index width) Since width is usually a power of two, we can use a left shift to perform the multiplication 32
Structures Like an array, a structure (struct) is made up of several smaller data elements stored contiguously in memory However the elements do not have to all be the same type The compiler will construct a table mapping each structure member to an offset 33
Bit Fields Structure members can be bit fields In this case multiple members are packed into a single byte or word To retrieve the value of a bit field, AND the word with a mask and then shift right To set the value of a bit field use a left shift and an OR 34
Procedures * A function (or procedure) is a sequence of instructions that can be used to perform a task When a function is called control transfers to the function; once the function completes its task it returns Functions may accept parameters (arguments) and/or return a value A function can also define local variables for its use which exist only until the function returns Functions can call other functions 35
Call and Return Call and return are nothing more than unconditional jumps The calling function (the caller) jumps to the beginning of the function The called function (the callee) jumps back to the point from which it was called (return address) Since a function can be called from any number of places the return address changes with each call 36
Jump and Link The jump and link (jal) instruction performs an unconditional jump just like j, but first saves the address of the next instruction in the return address register ($ra) jal label A function returns by jumping to the address stored in that register: jr $ra 37
Example (1) Calling a function: jal function1 Function: function1: add $t0, $t1, $t2 sub $t3, $t4, $t5 jr $ra 38
Calling Conventions We need a way to pass parameters to a function and get a return value from it A calling convention is a set of rules that define how parameters and return values are passed to/from functions as well as which registers a function can use Allows us to call functions compiled by different compilers and even languages 39
Parameters/Return Value Most MIPS software uses the same calling convention The first four parameters are placed in registers ($a0-$a3) additional parameters are placed on the stack Return values go in registers $v0-$v1 40
MIPS Registers Name Number Usage Saved on Call? $zero 0 Zero (hardware) N/A $at 1 reserved Assembler Temp No $v0-$v1 2-3 Return Value/Temporaries No $a0-$a3 4-7 Arguments No $t0-$t9 8-15, 24-25 Temporaries No $s0-$s7 16-23 Saved Values Yes $k0-$k1 26-27 Reserved for OS Kernel No $gp 28 Global Pointer Yes $sp 29 Stack Pointer Yes $fp 30 Frame Pointer Yes $ra 31 Return Address (hardware) Yes 41
Example (2) Function call or $a0, $s0, $zero jal function2 or $s0, $v0, $zero Function definition function2: add $v0, $a0, $a0 jr $ra 42
Register Use Callee-saved registers are owned by caller; if a function uses a callee-saved register it must save the old value and restore that value before it returns Caller-saved registers are owned by the callee; if a caller is using a caller-saved register, it must save the old value before calling the function and restore it after the function returns In MIPS, $s0-$s7 are callee-saved and $t0-$t9 are caller-saved 43
The Stack Data that a function needs to save in memory is pushed onto the stack Before returning, the function pops the data off of the stack In MIPS, the stack pointer ($sp) contains the address of the last word pushed onto the stack The stack grows downward from higher addresses to lower ones 44
Spilling Registers What if the callee needs more registers? What if the procedure is recursive? high addr uses a stack a last-in-first-out queue in memory for passing additional values or saving (recursive) return address(es) One of the general registers, $sp, is used to address the stack (which grows from high address to low address) add data onto the stack push top of stack $sp $sp = $sp 4 data on stack at new $sp remove data from the stack pop low addr data from stack at $sp $sp = $sp + 4 45
Accessing the Stack Push a word onto the stack addi $sp, $sp, -4 sw src, 0($sp) Pop a word off of the stack lw dest, 0($sp) addi $sp, $sp, 4 Typically we batch multiple pushes and pops together 46
Accessing the Stack (cont'd) Push three words onto the stack addi $sp, $sp, -12 sw $t0, 8($sp) sw $t1, 4($sp) sw $s0, 0($sp) Pop three words off of the stack lw $s0, 0($sp) lw $t1, 4($sp) lw $t0, 8($sp) addi $sp, $sp, 12 47
Stack Illustration High address $sp $sp Contents of register $t1 Contents of register $t0 $sp Contents of register $s0 Low address a. b. c. 48
Data on the Stack Data a function puts on the stack makes up its stack frame or activation record If there are more than four parameters, the extra parameters must be pushed onto the stack Non-leaf functions must save the value of the return address register ($ra) 49
Data on the Stack (cont'd) Any registers that must be saved are stored on the stack Also local variables that won't fit into registers (either because there are no registers left or the data is too big) Commonly a frame pointer ($fp) is used in addition to the stack pointer, since the stack pointer could change during the function 50
Stack Frame High address $fp $fp $sp $sp $fp Saved argument registers (if any) Saved return address Saved saved registers (if any) Local arrays and structures (if any) $sp Low address a. b. c. 51
Where Data is Stored The static data area holds global variables Fixed size In MIPS, the global pointer ($gp) contains the address of this area The stack holds local variables and functionrelated information Dynamic and managed automatically by the compiler The heap holds data allocated through new or malloc Dynamic and managed by the programmer 52
1000 0000 hex Text Program Memory $sp 7fff ffff hex Stack Dynamic data $gp 1000 8000 hex Static data pc 0040 0000 hex 0 Reserved 53
MIPS Registers Name Number Usage Saved on Call? $zero 0 Zero N/A $at 1 Assembler Temporary No $v0-$v1 2-3 Return Value/Temporaries No $a0-$a3 4-7 Arguments No $t0-$t9 8-15, 24-25 Temporaries No $s0-$s7 16-23 Saved Yes $k0-$k1 26-27 Reserved for OS Kernel No $gp 28 Global Pointer Yes $sp 29 Stack Pointer Yes $fp 30 Frame Pointer Yes $ra 31 Return Address Yes 54