Si d'autre en MIPS

Je suis en train d'apprendre MIPS programmation, dans laquelle je suis en train de mettre en œuvre Si d'autre conditions. Mais le problème est que quand je rentre de 2 pour sélectionner soustraire condition, le programme ne fonctionne pas. Je sais que pourrait avoir utilisé BNE mais je veux apprendre BEQ. S'il vous plaît dites-moi qu'est-ce que le problème est présent code

.text

main:

li $t0,1
li $t1,2
li $t2,3
li $t3,4

li $v0,5
syscall

move $s0,$v0

beq $s0,$t0,ADDTN
ADDTN:


li $a0,40
li $v0,1
syscall

li $v0,5
syscall


move $s1,$v0

li $v0,5
syscall

move $s2,$v0

add $a0,$s1,$s2

li $v0,1
syscall

li $v0,10
syscall



beq $s0,$t1,SUBTN
SUBTN:

li $a0,50
li $v0,1
syscall

li $v0,5
syscall


move $s3,$v0

li $v0,5
syscall

move $s4,$v0

sub $a0,$s3,$s4

li $v0,1
syscall

li $v0,10
syscall

"Ne fonctionne pas" est la meilleure description de l'erreur que vous pouvez donner?

InformationsquelleAutor Alfred James | 2012-09-15

assembly mips

0

par exemple:
```
beq $s0,$t0,ADDTN
ADDTN:
     # code for addition
     # ...
     # some syscalls
beq $s0.$t1,SUBTN
SUBTN:
 .
 .
 .
```
Je n'ai aucune idée de ce que les syscalls faire (j'ai l'habitude de ne pas le code pour MIPS).

Mais vous recherchez un état, j'. e. l'égalité de $s0 et un de $tn, et sur l'égalité de vous sauter à la routine qui convient à son cas. Très bien, mais la routine est immédiatement après le BEQ instruction, de sorte que la branche est absolument superflu ici. Et de plus, si la condition est pas remplies, le programme se poursuit avec le code suivant directement la BEQ instruction.

Le résultat est que les routines (ajouter moins ADDTN) sont exécutée de manière inconditionnelle. Comme dit, je ne sais pas ce que les syscalls faire, mais si plus de travaux, je pense qu'ils sont un peu sauts ou donc.

De toute façon, vous devez réorganiser votre code, de sorte que, en fonction de l'état de l'testé condition d'une autre branche de votre code est exécuté. C'est un générique de "modèle":
```
        beq $s0, $t0, equal
        # this code is executed if $s0 and $t0 differ
         .
         .
        jmp notequal        # avoid also executing the code for equal
equal:
        # code for the case $s0 and $t0 hold the same value
         .
         .
notequal:
        # all that follows executes with no regard of the checked condition
```
Il existe d'autres techniques pour branchement de plusieurs cas comme le vôtre (vous semblez avoir à vérifier les quatre opérations, je suppose), mais vous devriez commencer à comprendre les bases de la première.

[mise à jour: Bien, en fait, il n'est pas si différent, c'est juste que les blocs de code sont répartis plus large... /mise à jour]

Avoir du plaisir...

InformationsquelleAutor IdiotFromOutOfNowhere
0

Que c'est les devoirs:

Si c'est égal, il va passer à l'offset spécifié par l'étiquette. Et si ce n'est pas l'égalité, ce code vous attendez-vous à les exécuter?

InformationsquelleAutor pickypg
0

Si vous allez utiliser la branche est égal à alors votre programme doit effectuent une branche qui fait sens. Examiner votre branche d'instruction:
```
    beq $s0,$t0,ADDTN
ADDTN:
```
En MIPS vous devez vous rappeler que le PC (program counter) sera tout simplement l'avance, ligne par ligne, à moins d'indication contraire. Une branche d'instruction peut ordonner à l'un PC à un autre emplacement dans le programme; cependant, dans votre code les instructions de branchement dire le PC juste à l'avance à la ligne suivante ce qui est exactement ce que le programme ferait sans une branche de l'enseignement.

Aussi, si vous ne souhaitez que certaines de ces étiquettes, ADDTN, SUBTN, pour être exécuté, chaque étiquette doit avoir une instruction de saut à la fin de son exploitation. Par exemple, lorsque ADDTN est terminé, le programme devrait sauter SUBTN, sauf si bien sûr vous voulez SUBTN également exécuter. Voici un exemple de ce que vous pourriez faire. Une série d'instructions de branchement qui détournent le PC à l'opérateur spécifique étiquettes et à la fin de chaque étiquette de saut à la SORTIE de l'étiquette.
```
    beq $s0, $t1, SUBTN    # if(input==2) {goto SUBTN}
    beq $s0, $t0, ADDTN    # if(input==1) {goto ADDTN}
    beq $s0, $t2, MULT     # if(input==3) {goto MULT}
    beq $s0, $t3, DIV      # if(input==4) {goto DIV}


ADDTN:
    # Code for addition
    j EXIT

SUBTN:
    # Code for subtraction
    j EXIT

MULT:
    # Code for multiplication
    j EXIT

DIV:
    # Code for division
    j EXIT

EXIT:
    # Code to exit
    j EXIT
```
Remarque: Vous devez être en mesure de visualiser ce qui va se passer dans cet exemple, si la valeur de $s0 est rien mais 1, 2, 3, ou 4. Si aucun de la branche est égale provoque le PC pour accéder à un label, puis le programme va exécuter le code dans le ADDTN étiquette. Aussi, si chaque étiquette ne produit pas un saut à certaines se terminent étiquette (SORTIE), le programme continuera d'exécuter les étiquettes restantes.

Si vous souhaitez effectuer une explicite else, considérons l'exemple suivant:
```
MAIN:    
    beq $s0, $t0, ADDTN    # if(input==2) {goto ADDTN}
    j SUBTN                # else {goto SUBTN}

ADDTN:
    # Code for addition
    j EXIT

SUBTN:
    # Code for subtraction
    j EXIT

EXIT:
    # Exit the program
```
Dans cet exemple, la première branche va vérifier si l'entrée est en corrélation avec l'ajout de l'étiquette. Si c'est le cas, le PC va sauter à l'étiquette; l'autre, s'avance à la ligne suivante, qui indique un saut à la soustraction de l'étiquette.

InformationsquelleAutor Wilson

Vous devez vous connecter pour publier un commentaire.