MIPS: déterminer si une liste de résultats de tests est réussite/échec

Question

J'écris un programme MiPS qui examinera une liste de 15 résultats de test. Et il va entrer à partir du terminal. Eh bien, le critère de réussite est le score de 50. Les ouptuts vers le terminal inclura les scores dans chaque catégorie et le nombre d'étudiants passant et échouant. avec des invites d'entrée et des déclarations de sortie ... Ci-dessous est le programme que j'ai écrit, mais il n'a pas travaillé .... S'il vous plaît j'ai besoin .... je ne sais pas si je me trompe ..

.globl main 
.text 

principale: li t0 $, 0 #counter pour les élèves passant la t1 $, passez #pointer pour le tableau de passe
li t2 $, 0 #counter pour les élèves de ne pas la $ t3, ne parviennent # pointeur pour le tableau de passe li $ t4, 0 #overall contre li $ t5, 0 li $ t6, 0

boucle: li $ v0, 4 #system appel à la chaîne d'impression la $ a0, prompt # chaîne de chargement 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 

autre: sw v0 $, 0 ($ t3) #store mot dans la matrice fail Addi t3 $, t3 $, 4 # t3 = t3 + 4 (incrément échoue pointeur) Addi t2 $, t2 $, 1 # t1 = t1 + 1 (incrément échec compteur)

l_end: Addi $ t4, t4 $, 1 #increment compteur global bltu t4 $, 15, boucle #if t4 < = 15 branche à boucle

comptes de sortie

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 

notes de passage de sortie

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 < = branche t5 à lp_a_end syscall #output score unique

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:

sortie des scores d'échec

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 < = branche t5 à lp_a_end syscall #output score unique

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:

fin

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

"Un déjà vu est généralement un petit problème dans la matrice"

assez sûr que je l'ai vu autour de:

MIPS program to determine pass/fail for test grades

EDIT: Quelques conseils: Essayez de simplifier les choses. Construisez votre programme petit à petit. Par exemple, essayez d'éviter les appels système, utilisez des entrées codées en dur pour tester votre logique de comparaison. Ensuite, allez pour les appels système. Utilisez-vous des tableaux correctement? J'ai vu que vous gardez deux compteurs séparés pour l'indexation du tableau, et en gardant le compte des éléments à l'intérieur. Je pense que c'est une erreur. Peut-être que vous devriez utiliser le compteur pour indexer le tableau (en le multipliant par 4). Suivez le lien, je serai heureux de vous aider si des doutes spécifiques apparaissent.

Je n'aime pas beaucoup le simulateur SPIM. Je sais que de nombreuses universités l'utilisent pour leurs cours, mais je pense que c'est une erreur, car c'est un environnement très limité.

AUTRE EDIT (par la demande « populaire »): J'ai lu votre code pendant un certain temps, et je remarquai certaines choses.

• Vous chargez des valeurs dans des registres pour comparaison par rapport à zéro. Ne faites pas cela, utilisez le registre $ zéro.

  li $ t5,0

  li $ t6.0

sont utilisés dans

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

devrait être

bleu $t0,$zero,lp_a_end 

• Utilisation des instructions

  bltu v0 $, 50, sinon #if $ v0 < 50 branche à autre (note d'échec)

instructions de branchement prennent deux registres et une étiquette. inscrivez pas, Modérée, étiquette

devrait être:

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

Je pense que vous vous compliquez en vain avec les syscalls. Pourquoi imaginez-vous votre sortie quand vous ne pouvez pas le faire fonctionner? En plus de cela, une fois que vous commencez à préparer un appel système, exécutez-le. Ne mettez pas une instruction de branchement au milieu, comme dans

 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 

Ceci est assez déroutant. Peut-être que vous devriez essayer quelque chose comme:

#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 

Enfin, essayez de garder une convention lorsque vous utilisez syscalls. Par exemple, utilisez les registres $ a0 et $ v0 uniquement pour les appels système. Ne les utilisez pas pour autre chose. Si vous lisez un entier dans $ v0, alors déplacez-le vers $ t0 avant de faire quoi que ce soit d'autre.

C'est tout ce que je peux penser en ce moment. Comme quelqu'un l'a dit dans le poste de dupe (Rob Kennedy), essayez de demander à votre instructeur aussi, c'est pourquoi il est payé (je ne suis pas votre instructeur, juste un coup de main).