Architettura MIPS
 
 

Formato istruzioni R

31 26
25 21
20 16
15 11
10 6
5 0
op rs rt rd sa fc
6 bit 5 bit 5 bit 5 bit 5 bit 6 bit

Formato istruzioni I

31 26
25 21
20 16
15 0
op rs rt costante
6 bit 5 bit 5 bit 16 bit

Formato istruzioni J

31 26
25 0
op indirizzo
6 bit 26 bit

Istruzioni logico aritmetiche

add

Sintassi: add rd, rs, rt

Semantica: Somma i registri rs e rt ponendo il risultato nel registro rd. In caso di overflow viene generata una opportuna eccezione.

Esempio:

add $s0, $t1, $t2          # $s0 = $t1 + $t2

addu

Sintassi: addu rd, rs, rt

Semantica: Somma i registri rs e rt ponendo il risultato nel registro rd. In caso di overflow non viene generata alcuna eccezione.

Esempio:

addu $s0, $t1, $t2        # $s0 = $t1 + $t2

addi

Sintassi: addi rd, rs, CONST

Semantica: Somma il registro rs col valore costante CONST esteso con segno ponendo il risultato nel registro rd. In caso di overflow viene generata una opportuna eccezione.

Esempio:

addi $s0, $t1, 13         # $s0 = $t1 + 13

addiu

Sintassi: addiu rd, rs, CONST

Semantica: Somma il registro rs col valore costante CONST esteso con segno ponendo il risultato nel registro rd. In caso di overflow non viene generata alcuna eccezione.

Esempio:

addiu $s0, $t1, 13        # $s0 = $t1 + 13

and

Sintassi: and rd, rs, rt

Semantica: Esegue l'AND bitwise tra rt e rs ponendo il risultato nel registro rd.

Esempio:

and $s0, $t1, $t2       # $s0 = $t1 & $t2

andi

Sintassi: and rd, rs, CONST

Semantica: Esegue l'AND bitwise tra rs e CONST ponendo il risultato nel registro rd.

Esempio:

and $s0, $t1, 13       # $s0 = $t1 & 13

div

Sintassi: div rs, rt

Semantica: Esegue la divisione con segno di rs e rt ponendo il resto nel registro speciale hi e il quoziente nel registro specialelo. I registri hi e lo devono essere copiati nei registri general purpose. Viene generata una eccezione in caso di overflow.

Note: A causa della pipeline devono trascorrere due cicli prima di poter rieseguire una moltiplicazione dopo un'istruzione mflo o mfhi.

Esempio:

div $t1, $t2            # $t1 = $t2 * LO + HI
mfhi $s0                # $s0 <--- $t1 % $t2
mflo $s1                # $s1 <--- $t1 / $t2

divu

Sintassi: divu rs, rt

Semantica: Esegue la divisione senza segno di rs e rt ponendo il resto nel registro speciale hi e il quoziente nel registro specialelo. I registri hi e lo devono essere copiati nei registri general purpose. Non viene generata alcuna eccezione.

Note: A causa della pipeline devono trascorrere due cicli prima di poter rieseguire una moltiplicazione dopo un'istruzione mflo o mfhi.

Esempio:

div $t1, $t2            # $t1 = $t2 * LO + HI
mfhi $s0                # $s0 <--- $t1 % $t2
mflo $s1                # $s1 <--- $t1 / $t2

mult

Sintassi: mult rs, rt

Semantica: Esegue la moltiplicazione con segno di rs e rt ponendo la parola alta del risultato nel registro speciale hi e quella bassa nel registro specialelo. I registri hi e lo devono essere copiati nei registri general purpose. Non viene generata alcuna eccezione.

Note: A causa della pipeline devono trascorrere due cicli prima di poter rieseguire una moltiplicazione dopo un'istruzione mflo o mfhi.

Esempio:

mult $t1, $t2           # (HI,LO) = $t1 * $t2
mfhi $s0                # $s0 <--- parte alta del risultato
mflo $s1                # $s1 <--- parte bassa del risultato

multu

Sintassi: multu rs, rt

Semantica: Esegue la moltiplicazione senza segno di rs e rt ponendo la parola alta del risultato nel registro speciale hi e quella bassa nel registro specialelo. I registri hi e lo devono essere copiati nei registri general purpose. Non viene generata alcuna eccezione.

Note: A causa della pipeline devono trascorrere due cicli prima di poter rieseguire una moltiplicazione dopo un'istruzione mflo o mfhi.

Esempio:

multu $t1, $t2          # (HI,LO) = $t1 * $t2
mfhi $s0                # $s0 <--- parte alta del risultato
mflo $s1                # $s1 <--- parte bassa del risultato

nor

Sintassi: nor rd, rs, rt

Semantica: Esegue il NOR bitwise tra rt e rs ponendo il risultato nel registro rd.

Esempio:

# Implementazione del NOT
nor $s0, $s0, $zero       # $s0 = ~ ($s0 | 0x00000000) = ~$s0

or

Sintassi: or rd, rs, rt

Semantica: Esegue l'OR bitwise tra rt e rs ponendo il risultato nel registro rd.

Esempio:

or $s0, $t1, $t2       # $s0 = $t1 | $t2

ori

Sintassi: ori rd, rs, CONST

Semantica: Esegue l'OR bitwise tra rs e CONST ponendo il risultato nel registro rd.

Esempio:

or $s0, $t1, 13       # $s0 = $t1 | 13

sub

Sintassi: sub rd, rs, rt

Semantica: Sottrae rt da rs ponendo il risultato nel registro rd. In caso di overflow viene generata una opportuna eccezione.

Esempio:

sub $s0, $t1, $t2       # $s0 = $t1 - $t2

subu

Sintassi: subu rd, rs, rt

Semantica: Sottrae rt da rs ponendo il risultato nel registro rd. In caso di overflow non viene generata alcuna eccezione.

Esempio:

subu $s0, $t1, $t2      # $s0 = $t1 - $t2

 


Valid XHTML 1.0!

Valid CSS!

home – e-mail
(C) 2003 by Giovanni Costagliola — All Rites Reversed