web-dev-qa-db-fra.com

Différence entre ADD et Addu

Je suis confus à propos de la différence entre Add et Addu.

La référence de l'instruction MIPS indique:

  • ajouter (avec débordement)
  • ajouter non signé (pas trop de débordement)

Ma compréhension consiste à utiliser Ajouter avec des opérandes signés et Addu avec des opérandes non signés.

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

 Overflow [.____] | [.____] V 
 1 | 1 1 1 <- porter 
 | 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 les premier et deuxième opérandes Signé numéros (complément de deux), le résultat est correct (-3 + -2 = -5) et je ne veux pas d'exception de trop-plein. Je voudrais donc utiliser Addu pour éviter cette exception, mais, bien que le résultat soit identique, le nom suggère d'utiliser Addu est pour les numéros non signés!
  • si je considère les numéros de premier et deuxième opérande non signé, je veux que une exception soit soulevée (car 61 + 62 ne soit pas égale à 59). Donc, j'utiliserais Ajouter pour augmenter l'exception et non Addu, comme le nom le suggère de faire.

Maintenant, mes questions sont:

  • en supposant que les opérandes soient signés (négatifs dans l'exemple ci-dessus), devrais-je utiliser Addudu (comme mon raisonnement suggère) ou que je devrais utiliser Ajouter (comme le nom le suggère)?
  • en supposant que les opérandes sont des numéros non signés (positifs), devrais-je utiliser Ajouter (comme mon raisonnement suggère) ou Addu (comme le nom le suggère)?
addmipsisa
15
collimarco

Les noms d'instruction sont trompeurs. Utilisez addu pour les opérandes signés et non signés, si vous le faites non Vous voulez un piège sur le débordement.

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

12
markgz

Si vous utilisez des numéros signés, vous devez utiliser add si vous souhaitez que un piège soit généré lorsque le résultat déborde.

Si vous utilisez des numéros non signés, vous devez toujours utiliser addu et vérifier le débordement de l'addition en comparant le résultat avec les deux chiffres (si le résultat est inférieur à celui des opérandes, l'addition a fait trop de débordement).

Voici un extrait pour montrer comment vous voulez vérifier le débordement de l'addition non signée:

    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...
5
gusbro

Overflow est NON Comme déclaré comme déclaré dans la question, ce bit de transport n'est pas un débit de débordement, dans l'exemple donné, il n'y a pas de débordement, le débordement est quand:

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

alors, stick avec add Il signalera le débordement et le bit de transport dans votre exemple (ce qui n'est pas un débordement) ne vous dérangera pas. addu fait la même chose sauf aucune exception n'est jamais soulevée.

3
Stack Player

Fondamentalement, les deux opcodes sont ajout signés. Donc, dans MIPS, ils utilisent 31 bits pour stocker des données, le nombre maximal est (2 relance à 31) -1 et 1 bit est réservé pour stocker le panneau pour les chiffres. Comme défini ci-dessus, la différence de base entre "Ajouter" et "Addu" est que le premier jette une exception lorsque le numéro de résultat est supérieur au nombre maximal de 31 bits occupant. Ce dernier exécute sans montrer aucun avertissement.

Par exemple, un nombre maximum d'addition 3 bits = (2 ** (N-1)) - 1 Minumem Num = - (2 ** (N-1)), donc 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

c'est ça.

2
Henok Tesfaye

Ce n'est en fait pas un débordement dans votre exemple. Un débordement survient lorsque la maintien dans le bit de signalisation n'est pas égal à la mord de signalisation. Dans votre exemple, bien que le bit de signalisation soit "1" (le débordement apparemment), le bit de la prise en charge est également "1". Par conséquent, dans cette condition, MIPS ne le considérera pas comme un débordement. Le motif de la manière dont le débordement se produit est en fait correspondant à savoir si le résultat est correct. C'est-à-dire que si le résultat est en dehors de la plage, vos bits peuvent représenter, un débordement survient. Par exemple, si vous ajoutez deux numéros de 4 bits 0111 (7) et 0010 (2) ensemble, vous obtenez un débordement car le résultat (9) est en dehors de la plage d'un nombre à 4 bits peut représenter (-8 à 7). . Si vous regardez l'arithmétique:

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

vous pouvez voir que même s'il n'y a pas de mord de signalisation, le résultat est toujours incorrect. Par conséquent, il s'agit d'un débordement (et des mips le détecteront).

0
shengjiex98