reveal.js

# Logic and Branching

---

CS 130 // 2024-09-12

# Logical Operations

## Boolean values
- Suppose I create a `bool` variable in Python:
    ```py
    b = True
    ```
- 
 How many bits of memory were just allocated?
    + 
 An entire word!
    + 
 `b` is a **memory address** that "points to" `True`

## Logical operator investigation

Before executing: guess what you think `$t0`-`$t5` will be

Execute it: were you right?

Is this how `and` and `or` behave in Python?
</div>
<div>

```mips
   .text

li $s0, 0
   li $s1, 1
   li $s2, 2
   li $s3, 3
   
   and $t0, $s0, $s1
   or $t1, $s0, $s1
   andi $t2, $s1, 1
   ori $t3, $s1, 0
   
   or $t4, $s1, $s2
   and $t5, $s2, $s3
```

</div>

## Set on Less Than investigation

Before executing: guess what you think `$t0`-`$t5` will be

Execute it: were you right?

What do `sle` and `sgt` mean? What do they get translated into by the assemler?
</div>
<div>

```mips
.text

li $s1, 2
li $s2, 2
li $s3, 3

#slt: "set on less than"
slt $t0, $s2, $s3
slt $t1, $s1, $s2
slt $t2, $s3, $s2
slti $t3, $s3, 10

#psuedoinstructions
sle $t4, $s1, $s3
sle $t5, $s1, $s2
sgt $t6, $s3, $s2
```

</div>

## Shifting investigation

Execute it: what do `sll` and `srl` do?

What happens if you shift an odd number?

Are these R-Type or I-Type instructions?
</div>
<div>

```mips
.text

li $s0, 16

#shift left logical
sll $t0, $s0, 1
sll $t1, $s0, 2

#shift right logical
srl $t2, $s0, 2
```

</div>

# Conditionals

## Branching
- **Branching** allows MIPS programs to skip around to different parts of the program
- Useful for
    - conditional statements (if, if-else, etc.)
    - loops

- continue executing at the line labeled `my_label`
```mips
b my_label
#...
my_label:
```
- 
 continue executing at the line labeled `my_label` if `$s0` and `$s1` are equal
```mips
beq $s0, $s1, my_label
```
- 
 continue executing at the line labeled `my_label` if `$s0` and `$s1` are _not_ equal
```mips
bne $s0, $s1, my_label
```

## 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>

## Exercise

- Run the above program in Mars, observe the output
- Change it so `i` and `j` are equal, run again
- Translate the following Python program into MIPS
```python
    if i == j:
        k = 1
    else:
        k = 2

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

## 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:
```

## Exercise

- Translate this into MIPS
- Hint: can you use `slt` here?

```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
- The other version: `la $t0, a`
	- pseudoinstruction

## 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