numero intero sottrazione precisione con 32-bit registri (MIPS)

Question

sto imparando aritmetica computer. L'uso del libro I (Patterson e Hennessey) elenca il sotto domanda.

  

Scrivi codice MIPS per condurre una doppia   precisione integer sottrazione per   dati a 64-bit. Si supponga il primo operando   di essere nei registri $ t4 (hi) e   $ T5 (lo), secondo nel $ T6 (hi) e   $ T7 (lo).

La mia soluzione per la risposta è

sub  $t3, $t5, $t7   # Subtract lo parts of operands. t3 = t5 - t7
sltu $t2, $t5, $t7   # If the lo part of the 1st operand is less than the 2nd,
                     #   it means a borrow must be made from the hi part
add  $t6, $t6, $t2   # Simulate the borrow of the msb-of-low from lsb-of-high
sub  $t2, $t4, $t6   # Subtract the hi's. t2 = t4 - t6

Tuttavia le soluzioni autore dato per questo problema sono le seguenti

Per firmati interi doppia precisione,

subu $t3, $t5, $t7   
sltu $t2, $t5, $t7  
add  $t6, $t6, $t2
sub  $t2, $t4, $t6

Per unsigned interi doppia precisione,

subu $t3, $t5, $t7   
sltu $t2, $t5, $t7  
addu $t6, $t6, $t2
subu $t2, $t4, $t6

La mia comprensione della differenza di funzionamento del sub/add e subu/addu è che di overflow-eccezione viene generata in sub/add e non in subu/addu. Sia sub/add e subu/addu Sottrai / aggiungere i bit degli operandi e l'interpretazione degli operandi essere firmato o marche non firmati alcuna differenza per il risultato a differenza di istruzioni slt e sltu.

Domanda 1
Sto dedurre dalle soluzioni autore dato che il rilevamento di overflow viene gestito mentre io non ci ho pensato la stessa della mia soluzione. Ho ragione? C'è qualche altra cosa che mi manca?

Domanda 2
Supponendo che il mio sopra deduzione è giusto, perché è il rilevamento di overflow spento per le soluzioni autore previsti nel caso di sottrazione di unsigned doppia precisione con l'uso di addu e subu?

Answer 1

Per addizione e la sottrazione, non v'è alcuna differenza tra gli operandi con e senza segno, fatta eccezione per la nozione di troppo pieno. Un overflow è ciò che accade quando il valore numerico del risultato non corrisponde l'interpretazione della sequenza di bit che si ottiene.

Per esempio, consideriamo sequenze di 8 bit (MIPS ha registri a 32 bit, 8 bit ma sono più facili per miei esempi). Supponiamo interpretazione senza segno: una sequenza di 8 bit rappresenta un valore numerico compreso tra 0 e 255 (compreso). Se aggiungo 10.010.011 (valore numerico 147) a 01.110.110 (valore numerico 118) allora ottengo 00.001.001 (valore numerico 9). 9 non è uguale a 147 + 118. Ottengo tale risultato perché il valore matematico è 265, che non può adattarsi a 8 bit. Il risultato aggiunta avrebbe richiesto 9 bit, ma il nono bit superiore è caduto.

Ora, immaginate lo stesso esempio con il firmato interpretazione. 10010011 ha ora valore numerico -109. 01110110 ha ancora un valore numerico 118, e il risultato ottenuto (00.001.001) ha valore 9. La somma matematica -109 e 118 è 9, quindi non c'è trabocco.

Ciò significa che la nozione di troppo pieno dipende da come si interpreta i valori. La meccanica addizione sono identici per entrambe le interpretazioni e senza segno (per le stesse sequenze di input di bit, si ottiene la stessa sequenza di bit di uscita - questo è il punto di utilizzare complemento a due per valori negativi firmato) ma trattando troppopieno differisce <. / p>

L'architettura MIPS fornisce mezzi per innescare le eccezioni di overflow. Concettualmente, ci sono tre le operazioni di eventuale aggiunta di parole a 32 bit:

• aggiunta che ignora automaticamente overflow (risultato viene troncato)
• un'aggiunta che solleva un'eccezione quando si verifica un overflow firmata (c'è un overflow se le sequenze di ingresso e di uscita vengono interpretati come numeri con segno)
• un'aggiunta che solleva un'eccezione quando si verifica un overflow senza segno (c'è un overflow se le sequenze Intput e di uscita vengono interpretati come numeri senza segno)

I MIPS implementa i primi due tipi di aggiunte, con, rispettivamente, le addu e add codici operativi. Nei MIPS documentazioni, essi sono chiamati, rispettivamente, senza segno e aritmetica firmati . Non v'è alcun codice operativo per la raccolta di eccezioni su overflow senza segno. In pratica, i compilatori C utilizzare solo addu, ma potrebbero usare add per i tipi di firma (questa è consentita dallo standard C, ma si rompono un sacco di codice esistente). Ada compilatori usano add perché Ada fa traboccare il controllo obbligatorio.

Detto questo ...

Patterson e Hennessey vogliono implementare aritmetica con e senza segno su interi a 64 bit. Per aritmetica senza segno, non vogliono alcuna eccezione, di conseguenza, essi usano addu e subu. Per aritmetica firmati, vogliono un'eccezione a verificarsi quando il risultato matematico non si adatterebbe su un a 64 bit la sequenza con l'interpretazione firmata. Non vogliono a sollevare un'eccezione a causa di alcuni di overflow-come condizione per l'elaborazione dei bassi metà a 32 bit spuri. Questo è il motivo per cui utilizzano un subu per le parti basse.

La tua soluzione è sbagliata perché può sollevare un'eccezione dove non dovrebbe. Si supponga di voler sottrarre 2000000000 (due miliardi) da -2.000 milioni (meno di due miliardi). Il risultato matematico è 4000000000 (quattro miliardi). I due operandi e il risultato certamente inseriscono in 64 bit (gamma rappresentabile è -9223372036854775808 a 9223372036854775807). Quindi, per aritmetica segno a 64 bit, non c'è overflow: ci dovrebbe essere non fa eccezione. Tuttavia, in questa situazione, il vostro primo sub riporterà un overflow. Che sub lavora con valori a 32 bit e firmato a 32 bit aritmetica. La sua operand saranno 01110111001101011001010000000000 e 10001000110010100110110000000000. Si noti che questi valori sia in forma in 32 bit: l'interpretazione segno a 32 bit di questi valori sono, rispettivamente, più e meno di due miliardi. Il risultato della sottrazione, tuttavia, è di quattro miliardi, e non si adatta a 32 bit (come un numero con segno). Così, il vostro sub solleva un'eccezione.

Come regola generale, il rilevamento di overflow è di fare le cose che dipendono da un'interpretazione signedness, che incide la manipolazione del bit più significativo. Per grandi aritmetica interi, tutte le parole tranne i più significativi sono trattate come unsigned, quindi addu / subu ovunque. Come primo passo, le cose sono più facili da capire se prima concentrarsi su aritmetica senza segno, senza alcuna eccezione (allora basta usare addu e subu, e non add o sub).