MIPS: determine if a list of test scores are pass/

Question

I am writing a MiPS program that will examine a list of 15 test scores. And it is going to input from the terminal.Well, the passing criterion is the score of 50. the ouptuts to the terminal will include the scores in each category and the number of students passing and failing. with input prompts and output statements...Below is the program i wrote but it didnt work....Please i need....i dont know if i m doing it wrong..

.globl main
.text

main: li $t0, 0 #counter for passing grades la $t1, pass #pointer for pass array
li $t2, 0 #counter for failing grades la $t3, fail #pointer for pass array li $t4, 0 #overall counter li $t5, 0 li $t6, 0

loop: li $v0, 4 #system call for print string la $a0, prompt #load string syscall

li $v0, 5           #system call for read integer
syscall             #read integer

bltu $v0, 50, else      #if $v0 < 50 branch to else (failing grade)
sw $v0, 0($t1)          #store word in pass array
addi $t1, $t1, 4        #t1 = t1 + 4 (increment pass pointer)
addi $t0, $t0, 1        #t0 = t0 + 1 (increment pass counter)
b l_end             #branch over else statement

else: sw $v0, 0($t3) #store word in fail array addi $t3, $t3, 4 #t3 = t3 + 4 (increment fail pointer) addi $t2, $t2, 1 #t1 = t1 + 1 (increment fail counter)

l_end: addi $t4, $t4, 1 #increment overall counter bltu $t4, 15, loop #if t4 <= 15 branch to loop

output counts

li $v0, 4           #system call for print string
la $a0, o_pasc          #load string
syscall             #output "Number of Passing Scores:

la $v0, 1           #system call for print integer
add $a0, $t0, 0         #load value of pass counter into $a0
syscall             #output value

li $v0, 4           #system call for print string
la $a0, o_fasc          #load string
syscall             #output "Number of Failing Scores: "

la $v0, 1           #system call for print string
add $a0, $t2, 0         #load value of fail counter into $a0
syscall             #output value

output passing scores

li $v0, 4           #setup output   
la $a0, o_pass          #setup text
syscall             #output string o_pass

la $t1, pass            #load address of pass pointer to t1
lw $a0, 0($t1)          #load word at $t1 into $a0
li $v0, 1           #system call for print integer

loop_a: bleu $t0, $t5, lp_a_end #if t0 <= t5 branch to lp_a_end syscall #output single score

li $v0, 4           #system call for print string
la $a0, o_coma          #load string
syscall             #ouput comma and space

li $v0, 1           #setup output
addi $t1, $t1, 4        #move pointer down by 1 word
lw $a0, 0($t1)          #move word at pointer into $a0
addi $t5, $t5, 1        #add 1 to counter

b loop_a            #branch to top

lp_a_end:

output failing scores

la $t5, 0           #clear t5 (counter)
li $v0, 4           #setup output
la $a0, o_fail          #setup text
syscall             #output string o_fail

la $t3, fail            #load address for fail pointer into $t3
lw $a0, 0($t3)          #load word at mem addy $t3 into $a0
li $v0, 1           #system call for print integer

loop_b: bleu $t2, $t5, lp_b_end #if t2 <= t5 branch to lp_a_end syscall #output single score

li $v0, 4           #system call for print string
la $a0, o_coma          #load string
syscall             #output comma and space

li $v0, 1           #setup output
addi $t3, $t3, 4        #move pointer down by 1 word
lw $a0, 0($t3)          #load word from mem addy $t3 to $a0
addi $t5, $t5, 1        #add 1 to counter

b loop_b            #branch to top

lp_b_end:

end

li $v0, 4           #setup output
la $a0, o_brk           #setup text
syscall             #output line break

li $v0, 10          #loads 10 to $v0
syscall             #ends program

Answer 1

"A deja vu is usually a glitch in the Matrix"

Pretty sure i've seen this around:

MIPS program to determine pass/fail for test grades

EDIT: Some advice: Try to simplify things. Build your program bit by bit. For example, try to avoid syscalls, use hardcoded inputs to test your comparing logic. Then, go for syscalls. Are you using arrays correctly? I've seen that you keep two separate counters for indexing the array, and keeping count of the elements inside it. I think that that is error prone. Maybe you should use the counter to index the array (multiplying it by 4). Follow the link, i'll be happy to help if any specific doubts appear.

I don't like SPIM simulator much. I know that many universities use it for their courses, but i think that is a mistake, since it is a very limited environment.

ANOTHER EDIT (by "popular" demand): I've read your code for a while, and i noticed some things.

• You load values into registers for comparison against zero. Don't do this, use the $zero register.

  li $t5,0

  li $t6.0

are used in

bleu $t0,$t5,lp_a_end       #if t0 <= t5 branch to lp_a_end 

should be

bleu $t0,$zero,lp_a_end

• Usage of instructions

  bltu $v0, 50, else #if $v0 < 50 branch to else (failing grade)

branch instructions take two registers and a label. Not register, inmediate, label

Should be:

   li   $t5,50
   bltu $v0,$t5,else

My guess is that you are complicating yourself in vain with the syscalls. Why are you fancying your output when you cant get it to work? In addition to that, once you start preparing for a syscall, execute it. Dont put a branch instruction in the middle, like in

        la $t3, fail                    #load address for fail pointer into $t3
        lw $a0, 0($t3)                  #load word at mem addy $t3 into $a0
        li $v0, 1        
loop_b: bleu $t2, $t5, lp_b_end         #if t2 <= t5 branch to lp_a_end 
        syscall                         #output single score

This is quite confusing. Maybe you should try something like:

#Is there anything to print in the array? If not, goto lp_b_end
bleu $t2,$zero,lp_b_end

#Ok, we know we are not pointing at an invalid position of the array.       
la $t3, fail                    #load address for fail pointer into $t3
lw $a0, 0($t3)                  #load word at mem addy $t3 into $a0
li $v0, 1 
syscall

Finally, try to keep a convention when you use syscalls. For example, use registers $a0 and $v0 only for syscalls. Dont use them for anything else. If you read an integer into $v0, then move it to $t0 before doing anything else.

That's all i can think of right now. As someone said in the dupe post (Rob Kennedy), try asking your instructor as well, that's why he gets paid (i'm not your instructor, just a helping hand).