MIPS Assembly why are these registers loading the same array values?

Question

I'm trying to load in array values in the first and second position but for some reason it's loading in only the value in the first position? Been trying to figure it out for an hour but no luck. This is the code I have. I set $t1 to 0 and $t3 to 4 so I should be loading in the first and second value, yet it only loads in the first value for both $t1 and $t3?

 addi $t1, $zero, 0 
 addi $t3, $zero, 4
 
 
 
 FindLessThenLoop:
 la $t1, myArray # Load first number
 addu $t1, $zero, $t1 # add offset and base together
 lw $t1, ($t1)      # fetch the data 
 
 la $t3, myArray # Load second number
 addu $t3, $zero, $t3 # add offset and base together
 lw $t3, ($t3)      # fetch the data 

Answer 1

The code for the first and the second are essentially the same except using a different register, so, we would expect the same results: the value from array position/index 0.

To get the second element, you can do either:

la $t3, myArray     # Load second number
addiu $t3, $t3, 4   # add offset and base together
lw $t3, ($t3)       # fetch the data 

-or-

la $t3, myArray     # Load second number
lw $t3, 4($t3)      # fetch the data with offset 4

You'll prefer a variation of the first form if you're going to do variable indexing (e.g. a[i]), say in a loop, whereas the second form is for constant indexing (e.g. a[1]).

If you have an integer index, then the following is useful:

# usually done outside of and before a loop:
la $t3, myArray     # Load second number

# this part done inside a loop:
sll $t4, $t2, 2     # scale the integer index by 4
addu $t4, $t3, $t4  # add base and offset
lw $t1, ($t4)       # fetch the data 

Note the following:

1. there is pre-loop setup of $t3
2. inside the loop we preserve $t3 so it can be used each iteration
3. we scale the simple integer index by size of the elements (4x)

---

An alternative is pointers, which are fairly easy in assembly, but suggest to convert your algorithm to pointers in C first, then take to assembly.

A pointer combines into one variable the notion of base + scaled offset.  A pointer can be incremented to refer to the next element.

---

Here's a simple illustrative loop that does max value of array, assuming elements are positive:

    li $t0, array # t0 is the base array address: &array[0]
    li $t1, 0     # t1 is min value variable, initially zero
    li $t2, 0     # t2 is the index, aka loop control variable call it "i"
    li $t3, 10    # where to stop with "i"

loop1:
    beq $t2, $t3, loop1End   # if "i" == 10 we're done

    sll $t4, $t2, 2          # scale index by 4 due to word-sized elements
    add $t4, $t0, $t4        # add base and scaled offset
    lw $t4, 0($t4)           # fetch element from a[i]

    ble $t4, $t1, if1End
    move $t1, $t4            # capture the new max, if larger
if1End:

    addi $t2, $t2, 1         # next index position
    j loop1

loop1End:
    ...                      # t1 holds max value from the array