CSCI-365 Computer Organization Lecture Note: Some slides and/or pictures in the following are adapted from: Computer Organization and Design, Patterson & Hennessy, ©2005 Some slides and/or pictures in the following are adapted from: slides ©2008 UCB 6

Arrays and Pointers Index: Use a register that holds the index i and increment the register in each step to effect moving from element i of the list to element i + 1 Pointer: Use a register that points to (holds the address of) the list element being examined and update it in each step to point to the next element Stepping through the elements of an array using the indexing method and the pointer updating method.

Arrays vs. Pointers Array indexing involves Multiplying index by element size Adding to array base address Pointers correspond directly to memory addresses Can avoid indexing complexity §2.14 Arrays versus Pointers

Selection Sort Example One iteration of selection sort. To sort a list of numbers, repeatedly perform the following: Find the max element, swap it with the last item, move up the “last” pointer

Selection Sort Using the Procedure max Example (continued) sort: beq $a0,$a1,done # single-element list is sorted jal max # call the max procedure lw $t0,0($a1) # load last element into $t0 sw $t0,0($v0) # copy the last element to max loc sw $v1,0($a1) # copy max value to last element addi $a1,$a1,-4 # decrement pointer to last element j sort # repeat sort for smaller list done:... # continue with rest of program Inputs to proc max Outputs from proc max In $a0 In $a1 In $v0 In $v1

Example Show a sequence of MIPS instructions corresponding to: clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; } Show a sequence of MIPS instructions corresponding to: clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; }

Example: Pointer and Array clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; } clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; } addi $t0,$zero 0 # i = 0 loop1: sll $t1,$t0,2 # $t1 = i * 4 add $t2,$a0,$t1 # $t2 = # &array[i] sw $zero, 0($t2) # array[i] = 0 addi $t0,$t0,1 # i = i + 1 slt $t3,$t0,$a1 # $t3 = # (i < size) bne $t3,$zero,loop1 # if (…) # goto loop1 addi $t0,$a0 0 # p = & array[0] sll $t1,$a1,2 # $t1 = size * 4 add $t2,$a0,$t1 # $t2 = # &array[size] loop2: sw $zero,0($t0) # Memory[p] = 0 addi $t0,$t0,4 # p = p + 4 slt $t3,$t0,$t2 # $t3 = #(p<&array[size]) bne $t3,$zero,loop2 # if (…) # goto loop2

Example Show MIPS instructions corresponding to: void swap(int v[], int k, int j) { int temp; temp = v [k]; v[k] = v [j]; v[j] = temp; } Show MIPS instructions corresponding to: void swap(int *p) { int temp; temp = *p; *p = *(p+1); *(p+1) = temp; }

Bitwise Operations Up until now, we’ve done arithmetic ( add, sub, addi ), memory access ( lw and sw ), and branches and jumps All of these instructions view contents of register as a single quantity (such as an integer) New Perspective: View register as 32 raw bits rather than as a single 32-bit number Since registers are composed of 32 bits, we may want to access individual bits (or groups of bits) rather than the whole Introduce two new classes of instructions –Logical & Shift Ops

Logical Operators Two basic logical operators –AND: outputs 1 only if both inputs are 1 –OR: outputs 1 if at least one input is 1 Truth Table: standard table listing all possible combinations of inputs and resultant output for each. E.g., ABA AND BA OR B

Logical Operators Instruction Names: – and, or : Both of these expect the third argument to be a register – andi, ori : Both of these expect the third argument to be an immediate MIPS Logical Operators are all bitwise, meaning that bit 0 of the output is produced by the respective bit 0’s of the inputs, bit 1 by the bit 1’s, etc. –C: Bitwise AND is & (e.g., z = x & y; ) –C: Bitwise OR is | (e.g., z = x | y; )

Uses for Logical Operators Note that and ing a bit with 0 produces a 0 at the output while and ing a bit with 1 produces the original bit This can be used to create a mask –Example: –The result of and ing these: mask: mask last 12 bits

Uses for Logical Operators The second bitstring in the example is called a mask. It is used to isolate the rightmost 12 bits of the first bitstring by masking out the rest of the string (e.g. setting it to all 0s) Thus, the and operator can be used to set certain portions of a bitstring to 0s, while leaving the rest alone –In particular, if the first bitstring in the above example were in $t0, then the following instruction would mask it: andi $t0,$t0,0xFFF

Uses for Logical Operators Similarly, note that or ing a bit with 1 produces a 1 at the output while or ing a bit with 0 produces the original bit This can be used to force certain bits of a string to 1s –For example, if $t0 contains 0x , then after this instruction: ori$t0, $t0, 0xFFFF –… $t0 contains 0x1234FFFF (e.g. the high-order 16 bits are untouched, while the low-order 16 bits are forced to 1s)

Shift Instructions (review) Move (shift) all the bits in a word to the left or right by a number of bits –Example: shift right by 8 bits –Example: shift left by 8 bits

Shift Instructions Since shifting may be faster than multiplication, a good compiler usually notices when C code multiplies by a power of 2 and compiles it to a shift instruction: a *= 8; (in C) would compile to: sll $s0,$s0,3 (in MIPS) Likewise, shift right to divide by powers of 2

Uses for Shift Instructions Suppose we want to isolate byte 0 (rightmost 8 bits) of a word in $t0. Simply use: andi $t0,$t0,0xFF Suppose we want to isolate byte 1 (bit 15 to bit 8) of a word in $t0. We can use: andi $t0,$t0,0xFF00 but then we still need to shift to the right by 8 bits...

Uses for Shift Instructions Could use instead: sll $t0,$t0,16 srl $t0,$t0,