reveal.js

# Arrays and Procedures

---

CS 130 // 2024-09-17

# Announcement

## Exam 1

* Originally scheduled for next week on Tuesday
* Pushing it back to **Thursday, September 26th**
* We will try it asynchronous - done on your own time outside of class
* I will give you several days in which to complete it
* Individual, no collaboration of any kind
* Open book/notes
* No AI, no Internet outside of class resources
* If you were to use a resource (even if you weren't supposed to), you need to cite it

### Kinds of Questions

Blackboard test tool
* free response
* multiple choice
* fill-in-the-blank

# Review

## Compiling an `if` Statement

```python
    if i == j:
        k = 1

print("The value of k is",k)
```

</div>
<div>

```mips
.data

i: 5
j: 8
k: 0
message: .asciiz "The value of k is "

.text

lw $s0, i
	lw $s1, j
	
	bne $s0, $s1, disp_msg
	li $s2, 1
	sw $s2, k

disp_msg:
	li $v0, 4 #4 is the code for printing a string
	la $a0, message #the argument for the syscall
	syscall 
	
	li $v0, 1 #1 is the code for printing an int
	lw $a0, k #the argument for the syscall
	syscall 
```
<div>

# Loops

## Compiling a `while` Statement

```python
i = 1
while i != 10:  
   print(i)
   i += 1
```

---

```mips
.text
	li $s0, 1
	li $t0, 10
	
start_loop:
	beq $s0, $t0, done

li $v0, 1 #print integer - no newline after!
	add $a0, $s0, $zero #copy $s0 into $a0
	syscall

addi $s0, $s0, 1
	b start_loop

done:
```

## How can we do less than?

- How can you use the `slt` instruction with this?

```python
sum = 0
i = 0

while i < 10:
    sum = sum + i
    i += 1

print(sum)
```

</div>

## Assignment

- [Assignment 3](../../assignments/assignment-3/)
  - Translate a Python program that has both an if statement and a loop

# Arrays

## What is an array?

<section style="text-align: left;">
     
An array is a series of data items stored in consecutive memory locations

- Python: list

- Java: array, ArrayList

- C/C++: array, Vector

</section>

## Example array program

```mips
.data
 
#arrays get stored in consecutive 32-bit memory addresses 
my_array: 1, 2, 3, 4
 
.text

la $s0, my_array #load the base address of the array

#Addresses go up by 4 because each byte has its own address
#So a word takes up 4 addresses
lw $t0, 0($s0) #load my_array[0]
lw $t1, 4($s0) #load my_array[1]
lw $t0, 8($s0) #load my_array[2]
lw $t0, 12($s0) #load my_array[3]
```

### New flavor of `lw`

```mips
lw $t1, 4($s0) #load my_array[1]
```

- Meaning
    - load the 32-bit value stored at the address `$s0`+4
- Good for accessing items in an array

## Arrays in memory

```mips
.data
 
#arrays get stored in consecutive 32-bit memory addresses 
my_array: 1, 2, 3, 4
```

![array in Mars memory](/Fall2024/CS130/assets/images/array-in-memory.png)

### Translating a program that uses an array

```python
    my_array = [10,6,0,27,92,18,42]
    i = 0

while i < 7:
        print(my_array[i])
        i = i + 1
```
</div>
<div>

```mips
.data
 
my_array: 10, 6, 0, 27, 92, 18, 42
newline: .asciiz "\n"
 
   
.text

la $s0, my_array #load the base address of the array
	li $t0, 0 #loop counter

loop:

slti $t1, $t0, 7 #check if loop counter < 7
	beq $t1, $zero, end #if not < 7, branch to end
	
	#calculate address of next thing in the array
	sll $t2, $t0, 2 #multiply the loop counter by 4
	add $t2, $t2, $s0 #add counter*4 to my_array address
	
	#print the item from the array
	lw $a0, 0($t2) #load next value from array
	li $v0, 1 #print integer
	syscall
	
	#print a newline
	la $a0, newline 
	li $v0, 4 #print string
	syscall
	
	addi $t0, $t0, 1 #increment the loop counter

b loop

end:
```
<div>

## Exercise

- edit the above MIPS program to also find the sum of all the items in the array

# Procedures

### Compile a Simple Leaf Procedure

```python
def func(x,y):
    return x + y
```

---

```mips
func: add $v0, $a0, $a1
      jr  $ra
```

* the first argument to the procedure is in `$a0`
* the second argument to the procedure is in `$a1`
* the return value of the procedure goes in `$v0`
* `jr`: jump to the instruction whose address is in register `$ra`

```mips
func: add $v0, $a0, $a1
      jr  $ra
```

When you call this function, you must
* put the first argument in `$a0`
* put the second argument in `$a1`
* put the **return address** in `$ra`
* jump to the function

### Calling Our Leaf Procedure

```python
def func(x,y):
    return x + y

def main():
    func(1, 2)
```

---

```mips
func:
    add $v0, $a0, $a1
    jr $ra

main:
    li  $a0, 1 #load the first argument
    li  $a1, 2 #load the second argument
    jal func
```
`jal`: **jump and link** - put the next instruction's address in `$ra` and jump to the procedure

### Nested Procedure Calls

```python
def main():
    func(1, func(2, func(3, 4)))
```

---

```mips
main:
    li  $a0, 3
    li  $a1, 4
    jal func

li   $a0, 2
    move $a1, $v0
    jal  func

li   $a0, 1
    move $a1, $v0
    jal  func
```
**remember:** `$v0` is where we find the returned value

## Calling a Procedure
1. Put parameters in appropriate registers
    + 
 `$a0`, `$a1`, `$a2`, `$a3`
2. 
 Transfer control to the procedure: *jump and link*
    + 
 `jal ProcedureLabel`
	- puts the current instruction's address into `$ra`
3. 
 Perform task
4. 
 Place result in a location the callee can find
    + 
 `$v0`, `$v1`
5. 
 Return control to the caller: *jump to addr. in register*
    + 
 `jr $ra`

## Exercise
- Convert the following Python code into MIPS
- Make sure to create two functions
    - make sure the print happens in `main`, not `double_it`

```python
def double_it(e):
    return e + e

def main():
    print( double_it(21) )
```