Question

I am trying to translate the C code below to MIPS assembly language, I kind of understand most of it however, I am lost as to what the equivalent of the first line is in assembly…

int ary[3] = {2,3,4};

I’d appreciate it if someone can take a look at my C to assembly ‘translation’ and verify I am on the right track.

C Code

int ary[3] = {2,3,4};
int i=0;

//loop to double array values
for(i=0; i < 3; i++){
    ary[i] = ary[i]*2;
}

What I tried:

add $t0, $s0, $zero #get base address of the array 'ary' (dont understand this part)
addi $t1, baseAddress, 8 #cut off point to stop the loop; array[2]
addi $t1, $zero, $zero #initialize i=0


Start:
lw $t2, base(offset)
sll $t2, $t0, 1 #mutiply $t2 by 2  
sw $t2, base(offset)
addi $t0, $t0, 4 # Increment the address to the next element
bne $t0, $t1, Start # $t0 will keep increasing until reaches stopping point $t1
Exit:

Answer 1

If that’s a local array, you allocate space for it on the stack, then initialize it from code.
A possible asm translation of the C code may look like:

    addi $sp, $sp, -12     # allocate space for 3 words, $sp is now the address of the array
    addi $t0, $zero, 2
    sw $t0, ($sp)          # ary[0]=2
    addi $t0, $zero, 3
    sw $t0, 4($sp)         # ary[1]=3
    addi $t0, $zero, 4
    sw $t0, 8($sp)         # ary[2]=4

    addi $t0, $zero, 0     # initialize i=0

Start:
    sll $t1, $t0, 2        # i*4 for element size
    add $t1, $t1, $sp      # add base address of array, $t1 is now &ary[i]
    lw $t2, ($t1)          # load ary[i]
    sll $t2, $t2, 1        # mutiply by 2
    sw $t2, ($t1)          # store back to ary[i]
    addi $t0, $t0, 1       # i++
    addi $t1, $t0, -3      # check if i<3 by doing (i-3)<0
    bltz $t1, Start
    addi $sp, $sp, 12      # free the array

Your asm code was taking a slightly different approach, the C version would have looked like:

int* end = &ary[3];
for(int* ptr = ary; ptr != end; ptr++)
{
    *ptr = *ptr * 2;
}

And the fixed asm version for that is:

    addi $t1, $sp, 12      # end=&ary[3]
    addi $t0, $sp, 0       # ptr=ary

Start:
    lw $t2, ($t0)          # load ary[i]
    sll $t2, $t2, 1        # mutiply by 2
    sw $t2, ($t0)          # store back to ary[i]
    addi $t0, $t0, 4       # ptr++ (note it is incremented by 4 due to element size)
    bne $t0, $t1, Start    # ptr!=end