Différence entre les ajouter et addu

Je suis confus au sujet de la différence entre ajouter et addu.

Le MIPS instruction de référence dit:

  • ajouter (à débordement)
  • ajouter non signé (pas de débordement)

Ma compréhension est d'utiliser ajouter à la signature du opérandes et addu avec unsigned opérandes.

Mais considérons cet exemple (avec seulement 6bit):

débordement 
| 
V 
1 | 1 1 1 <- effectuer 
| 1 1 1 1 0 1 + 
| 1 1 1 1 1 0 = 
----------------- 
| 1 1 1 0 1 1

Et c'est mon raisonnement:

  • si je considère que le premier et le deuxième opérande signé numéros (complément à deux), puis le résultat est correct (-3 + -2 = -5) et je ne veux pas d'une exception de dépassement de capacité. Je voudrais donc utiliser addu pour éviter cette exception, mais, bien que le résultat est le même, le nom suggère d'utiliser des addu est pour les nombres non signés!
  • si je considère que le premier et le deuxième opérande unsigned numéros, alors je veux une exception soulevée (parce 61 + 62 n'est pas égal à 59). Je voudrais donc utiliser ajouter à lever l'exception, et non pas addu, comme son nom l'indique de le faire.

Maintenant mes questions sont:

  • en supposant que les opérandes sont signés (négatif dans l'exemple ci-dessus) doit-je utiliser addu (comme mon raisonnement suggère) ou, devrais-je utiliser la fonction ajouter (comme son nom l'indique)?
  • en supposant que les opérandes ne sont pas signés (positive) des nombres, dois-je utiliser la fonction ajouter (comme mon raisonnement suggère) ou addu (comme son nom l'indique)?
très mal nommée instructions. il ny a pas une telle chose comme un unsigned ajouter ou signé ajouter. il a à voir avec le piégeage ou pas doivent avoir été addut ou quelque chose comme ça...(qui peut encore l'être depuis l'assembleur n'est pas quelque chose de gravé dans la pierre, comme le code machine)

OriginalL'auteur collimarco | 2013-05-19

  1. 10

    L'instruction noms sont trompeurs. Utilisation addu pour les deux signés et non signés opérandes, si vous ne pas souhaitez un piège sur le dépassement.

    Utilisation add si vous avez besoin d'un piège sur le dépassement pour une raison quelconque. La plupart des langues ne veux pas d'un piège signé débordement, donc add est rarement utile.

    OriginalL'auteur markgz

  2. 5

    Si vous utilisez des nombres signés, vous devez utiliser add si vous voulez un piège pour être généré lorsque le résultat déborde.

    Si vous utilisez des nombres non signés, vous devez toujours utiliser addu et vérifier le débordement de l'ajout en comparant le résultat avec des chiffres (si le résultat est inférieur à la opérandes ensuite, l'ajout n'a dépassement de capacité).

    Voici un extrait de code pour montrer comment vous serait de vérifier pour dépassement de capacité dans unsigned plus:

        li $a1, 0xFFFF0FFF
    li $a2, 0x00010000

    addu $a3, $a1, $a2  # This unsigned addition overflows (set $a3 to $a1+$a2)
    bgt $a1, $a3, overflowed
    bgt $a1, $a2, overflowed
    # If you get here, unsigned addition did not overflow
  # your code goes here...
overflowed:
    # If you get here, unsigned addition overflowed
  # your code goes here...
    Merci pour la réponse! mais... Pourquoi voudrais-je à intercepter une exception sur des nombres signés? Il sera augmenté à chaque fois le résultat est un nombre négatif. Deuxièmement, pouvez-vous me donner un exemple de dépassement de vérifier dans le second cas (c'est à dire pour les nombres non signés)? Pourquoi utiliser ce genre de débordement de vérifier quand je peux simplement utiliser un complément?
    Il ne sera pas soulevée à chaque fois le résultat est un nombre négatif. Il sera augmenté si le résultat de l'opération des débordements (c'est à dire le nombre qui en résulte, vu dans A2-compliment n'est pas le bon numéro). Par exemple, si vous ajoutez -3 + -5 le résultat sera négatif (-8) et pas de piège sera soulevée.

    OriginalL'auteur gusbro

  3. 3

    DÉBORDEMENT est PAS comme déclaré dans la question, ce bit n'est PAS un bit de dépassement de capacité, dans l'exemple donné il n'y a PAS de DÉPASSEMENT de, dépassement de capacité, c'est quand:

    MSB1 = 1 && MSB2 = 1 && MSBofRESULT = 0
OR
MSB1 = 0 && MSB2 = 0 && MSBofRESULT = 1

    ainsi bâton avec add il va drapeau de débordement, et le bit de retenue dans votre exemple (qui n'est pas un dépassement de capacité) ne vous dérange pas. addu fait la même chose, sauf qu'aucune exception n'est jamais posées.

    OriginalL'auteur Stack Player

  4. 1

    Fondamentalement, les deux opérateurs sont signés plus. Donc en MIPS ils utilise 31 bits pour stocker des données, le nombre maximum est de (2 élever à 31)-1 et 1 bit est réservé pour stocker le signe du nombre. Comme décrit ci-dessus,La différence fondamentale entre "ajouter" & "addu", c'est que l'ancien déclenche une exception lorsque le nombre de résultat est supérieur au nombre maximal de 31 bits occupent. Ce dernier s'exécute sans montrer le moindre avertissement.

    Par exemple, 3 bits maximale num = (2**(n-1))-1 minumem num = -(2**(n-1))
    dans notre cas, max = 3 et min = -4

    li $t1,3
li $t2,1
add $t3,$t1,$t2 -----> throws an arthimetic overflow exception

addu $t3,$t1,$t2 ------> t3 = -4

    qui est-il.

    OriginalL'auteur Henok Tesfaye

  5. 0

    Il n'est effectivement pas un dépassement de capacité dans votre exemple. Un dépassement de capacité se produit lorsque l'emporter dans le bit de signe n'est pas égal à la réaliser du bit de signe. Dans votre exemple, bien que la effectuer le bit de signe est "1" (apparemment dépassement de capacité), de la transporter, dans bit de signe est aussi "1". Par conséquent, dans cette condition MIPS ne sera pas le considérer comme un dépassement de capacité. Le patron du dépassement de capacité se produit est réellement correspondant afin de savoir si le résultat est correct. C'est, si le résultat est hors de la plage de votre bits peut représenter, un débordement se produit. Par exemple, si vous ajoutez deux 4 bits 0111 (7) et 0010 (2), vous obtenez un dépassement de capacité puisque le résultat (9) est en dehors de la gamme, un 4-nombre de bits peut représenter (-8 à 7). Si vous regardez l'arithmétique:

    0111 (7) + 0010 (2) = 1001 (-7)

    vous pouvez voir que, même si il n'y a pas de report de la bit de signe, le résultat est toujours incorrecte. Donc c'est un dépassement de capacité (et MIPS va le détecter).

    OriginalL'auteur endurancist