Converting a C function to MIPS assembly - c

Question

I'm currently learning MIPS Assembly and I am attempting to convert the following C function into MIPS Assembly:
int count (int a[], int n, int x)
{
int res = 0;
int i = 0;
int j = 0;
int loc[];
for(i = 0; i != n; i++)
if(a[i] == x)
{
res = res + 1;
loc [j] = i;
j = j + 1;
}
return res, loc;
}
I've succeeded in converting most of it, and I believe I have successfully returned res (a value of 1), though I'm uncertain about returning loc (I also get a value of 1, and I don't think that's correct). However, I am having difficulty with this program and I am unsure as to how I can ensure that loc is returning the correct value or how to even code it to do so.
Here is my Assembly code:
.data
a: .word 5,6,7,8,9,10
n: .word
x: .word
res: .word 0
i: .word 0
jj: .word 0
loc: .space 40
.text
main:
la $s0, a
lw $s1, res
lw $s2, x
lw $t0, i
lw $t1, jj
lw $t2, n
la $s3, loc
li $t4, 6
start:
sll $t3, $t0, 2
add $t5, $t3, $s0
lw $t4, 0($t5)
beq $t0, $t4, start
addi $t0, $t0, 1
beq $t0, $t2, exit
addi $s1, $s1, 1
sll $t7, $t1, 2
add $t6, $s3, $t7
sw $t0, 0($t6)
addi $t1, $t1, 1
exit:
li $v0, 1
add $a0, $s1, $zero
syscall
li $v0, 1
add $a1, $s3, $zero
syscall
Any help, pointers, or suggestions would be very much appreciated.
EDIT: I've revised my code and now receive 0 for the res return and "268501028" for loc. Not sure where this number is coming from.
.data
a: .word 5,6,7,8,9,10
n: .word #n
x: .word #x
res: .word 0
i: .word 0
jj: .word 0
loc: .space 40
.text
main:
la $s0, a
lw $s1, res
lw $s2, x
lw $t0, i
lw $t1, jj
lw $t2, n
la $s3, loc
li $t4, 6
start:
beq $t0, $t2, exit #for(i = 0; i != n; i++)
bne $s0, $s2, else #if(a[i] == x)
j start
else:
addi $s1, $s1, 1 #res = res + 1;
sw $t0, ($t1) #loc [j] = i;
addi $t1, $t1, 1 #j = j+1
addi $t0, $t0, 1 #Increment i
addi $s3, $s3, 4 #Setting next element for loc
addi $s0, $s0, 4 #Setting next element for a
j start
exit:
li $v0, 1
move $a0, $s1
syscall
li $v0, 1
move $a0, $s3
syscall

Answer 1

Okay, there were a few bugs. I've annotated the source and added "BUG:" to hightlight them. I then created a cleaned up and corrected version
Here's your original code--no bug fixes, just annotations [please pardon the gratuitous style cleanup]:
# int
# count(int a[], int n, int x)
# {
# int res = 0;
# int i = 0;
# int j = 0;
# int loc[n];
#
# for (i = 0; i != n; i++) {
# if (a[i] == x) {
# res = res + 1;
# loc[j] = i;
# j = j + 1;
# }
# }
#
# return res, loc;
# }
.data
a: .word 5,6,7,8,9,10
n: .word
x: .word
res: .word 0
i: .word 0
jj: .word 0
loc: .space 40
nl: .asciiz "\n"
.text
.globl main
main:
la $s0,a
lw $s1,res
lw $s2,x
lw $t0,i
lw $t1,jj
lw $t2,n
la $s3,loc
li $t4,6 # BUG: extraneous (gets trashed below)
start:
sll $t3,$t0,2 # get i << 2
add $t5,$t3,$s0 # get &a[i]
lw $t4,0($t5) # fetch it
# BUG: we're comparing a[i] against i but we want to compare against x
# _and_ we want to flip the sense of the branch
beq $t0,$t4,start # is it a match? if yes, loop
addi $t0,$t0,1 # increment i
beq $t0,$t2,exit # i == n? if no, loop. if yes, exit
# BUG: the indexing here is wrong
addi $s1,$s1,1 # j += 1
sll $t7,$t1,2 # get jj << j
add $t6,$s3,$t7 # &loc[jj << j] (BUG: we want &loc[j])
sw $t0,0($t6) # set it to i
addi $t1,$t1,1 # jj += 1
# BUG: we should loop here and _not_ fall through
exit:
# print j (with newline)
li $v0,1
add $a0,$s1,$zero
syscall
li $v0,4
la $a0,nl
syscall
# print _address_ of loc[0]
# BUG: if we care to print anything, we should print the _values_ of the
# whole array
li $v0,1
# BUG: this should be a0 and _not_ a1
###add $a1,$s3,$zero
add $a0,$s3,$zero
syscall
li $v0,4
la $a0,nl
syscall
li $v0,10 # exit program
syscall
Here's the cleaned up and corrected version. I had to do a bit of restructuring and simplification to make it work, so it may seem a bit "alien" at first. However, I tried to retain your register usage where possible.
I also increased the size of the a array and added a user prompt for the x value:
# int
# count(int a[], int n, int x)
# {
# int i = 0;
# int j = 0;
# int loc[n];
#
# for (i = 0; i != n; i++) {
# if (a[i] == x) {
# loc[j] = i;
# j += 1;
# }
# }
#
# return j, loc;
# }
.data
a: .word 5,6,7,8,9,10
.word 5,6,7,8,9,10
.word 5,6,7,8,9,10
.word 5,6,7,8,9,10
.word 5,6,7,8,9,10
ae:
loc: .space 1000
prompt: .asciiz "Enter x value: "
msgnl: .asciiz "\n"
msgj: .asciiz "j: "
msgloc: .asciiz "loc: "
.text
# main -- main program
#
# RETURNS [sort of as this is a main program]:
# s1 -- j value (count of elements in "loc")
# loc -- filled in indexes into "a" array of matches to x
#
# registers:
# s0 -- a (base address of "a" array)
# t2 -- n (number of elements in "a" array)
#
# s2 -- x (value to match)
# t0 -- i (current index into "a" array)
# s3 -- loc (base address of "loc" array)
# s1 -- j (current index into "loc" array)
#
# t6 -- quick temporary [reusable]
# t7 -- used in array offset/index calculations [reusable]
.globl main
main:
# prompt for x value
li $v0,4 # syscall: print string
la $a0,prompt
syscall
# read in x value
li $v0,5 # syscall: read integer
syscall
move $s2,$v0
# get address of "a" array and compute length
la $s0,a # get &a[0]
la $t2,ae # get address of &a[n]
sub $t2,$t2,$s0 # get number of bytes in a
srl $t2,$t2,2 # get number of words in a (i.e. n)
li $t0,0 # i = 0
li $s1,0 # j = 0
la $s3,loc # base address of loc array
# main matching loop
loop:
sll $t7,$t0,2 # get i << 2
add $t7,$t7,$s0 # get &a[i]
lw $t6,0($t7) # fetch from it
bne $t6,$s2,next # a[i] == x? if no, advance to next element
# add new "i" value to loc array
sll $t7,$s1,2 # get j << 2
add $t7,$s3,$t7 # &loc[j << 2]
sw $t0,0($t7) # store i into loc
addi $s1,$s1,1 # j += 1
next:
addi $t0,$t0,1 # i += 1
blt $t0,$t2,loop # i < n? if yes, loop (or, we're done)
# done with calculation/fill loop
done:
la $s6,msgj # get prefix string
move $s7,$s1 # get j
jal prtnum # pretty print the number
blez $s1,exit # bug out if _no_ values in loc
# prepare to print all values of loc
la $t6,loc # base address of "loc"
li $t7,0 # initial index
# loop and print all values of loc
prtlocloop:
la $s6,msgloc # prefix string
lw $s7,($t6) # get loc[...]
jal prtnum # pretty print the number
add $t6,$t6,4 # increment address
add $t7,$t7,1 # increment index
blt $t7,$s1,prtlocloop # done? if no, loop
exit:
li $v0,10 # exit program
syscall
# prtnum -- print a number with a prefix string on a single line
#
# arguments:
# s6 -- prefix string
# s7 -- value to print
#
# registers:
# v0 -- syscall number [trashed]
# a0 -- syscall argument [trashed]
prtnum:
li $v0,4 # syscall: print string
move $a0,$s6 # string to print
syscall
li $v0,1 # syscall: print integer
move $a0,$s7 # value to print
syscall
li $v0,4 # syscall: print string
la $a0,msgnl
syscall
jr $ra # return
UPDATE:
What exactly is the difference between print and prtnum?
print is the label for the top of the loop that prints the values in loc. prtnum is subroutine/function that does the printing of a single number.
I added prtnum to demonstrate the use of a function and to avoid needless replication of some code.
Can they not be properly merged?
Sure, with some caveats. I did a slight/cosmetic edit to try to make things clearer. In particular, I renamed print: to prtlocloop: to try and make its role clearer.
The syscall(1) for "print integer" just prints the integer but does not add any whitespace or newline to separate them (i.e. it's exactly like printf("%d",a0)). So, we need something.
Originally, I just had the syscall(print_integer). With that, we get one "very long" number. Then, I added syscall(4) to print a newline. This was fine except the output was a bit confusing as to which value was j and which were the loc values.
(1) So, I added the "prefix" string. So, that became three syscalls for each number.
(2) This was used in two places: To print j and to print the loc values.
Same code in two or more places. That's the standard criterion for "split out code to function" in any language. It's a design/style choice [so there is no absolute answer].
So, with (1) and (2), I moved it to the prtnum function. Actually, I wrote the prtnum function first because I already knew the structure, and added the prefix argument after the output "looked ugly" [to me].
When I first coded it, I used "j: " for j and used a " " prefix for loc. It still looked a little funky. So, I changed the prefix to "loc: " to be consistent.
Could it be inlined? Sure. But, in addition to printing the number itself, we still have to add a separater. So, we need two syscalls per number to do it.
The separater could be a space if we want to put all numbers on the same output line. Fine for short vectors. This would require a slight change to the code as it exists now and we'd have to add a final output of newline to close the line. For longer arrays [that might not fit on a single line], one per line is [probably] tidier.
We only had to print j and loc. If the problem stated that we had to print a, then j, and then loc, I would have gone the other way.
I would have changed prtlocloop into another function (e.g. prtarray), that would loop on the given array and call prtnum for each element.
The first step was getting the calculation loop correct. The second was the printing. But, sometimes, they have to be done together. (i.e.) How can you debug something that you can't see?
So, with calculation correct, you are free to recode the output printing in any way you choose. The prtnum was just my way. But, it is by no means the only way.
Beyond the basic mechanics of working with the asm instructions, the choices are just like in any other language [notably C]. Comment well, choose the simplest and most effective way to architect/split the code, use descriptive variable names, etc. Comments should show "intent", the "what/why". The asm instructions are the "how".
Side note: Some OPs have had serious difficulty understanding how sll [which you already understand] works. They just didn't "get" the fact that a left shift by 2 was like a multiply by 4 and converts an index value into byte/address offset. So, you may already be ahead of the game ...
Yesterday, I gave an answer for a mips question where I went the other way and recommended inlining two functions. The problem was to calculate sin(x) using a Taylor series expansion [summation of terms] of the form: x**(2n)/factorial(2n-1).
With inlining, it was possible to reuse partial results from the previous term in the series without having to recalculate each term from scratch. This would not have been [conveniently] possible with multiple functions.
I didn't write the mips code, but I wrote the C/pseudo-code: mips program to calculate sin(x) The resulting mips code would [probably] have been simpler and would definitely run faster.