Diferencia entre revisiones de «Instrucciones aritméticas, lógicas y de salto incondicional en el Mips»

Revisión del 23:08 11 may 2013

Instrucciones Aritméticas

ADD (Add)

El formato de esta instrucción es:

   ADD rd,rs,rt

1. Descripción de la instrucción:

   rd=rs+rt

El contenido del registro rs y el contenido del registro rt se suman y el resultado se guarda en el registro rd. En modo 64 bits, el bit 31 del resultado se extiende. Ocurre una excepción de desbordamiento si ocurre un “overflow” en complemento a 2. El registro destino (rd) no se modifica cuando ocurre una excepción de desbordamiento.

2. Operación:

32: GPR[rd] ← GPR[rs] + GPR[rt]

64: temp ← GPR[rs] + GPR[rt]

     GPR[rd] ← (temp31)32 || temp31..0

3. Excepción:

Excepción de desbordamiento en complemento a dos. (Integer overflow exception).

ADDI (Add Immediate)

El formato de esta instrucción es:

    ADDI rt,rs,immediate16

1. Descripción de la instrucción:

   rt=rs+ext_signo(inm16,32)

Con el dato inmediato de 16 bits se hace una extensión de signo a 32 ó 64 bits (dependiendo del modo de operación) y ese dato se suma al dato que hay en el registro rs. El resultado se guarda en el registro rt. En modo 64 bits, el bit 31 del resultado se extiende.

Ocurre una excepción de desbordamiento si ocurre un “overflow” en complemento a 2. El registro destino (rt) no se modifica cuando ocurre una excepción de desbordamiento.

2. Operación:

32: GPR[rt] ← GPR[rs] + (immediate₁₅)¹⁶ || immediate_15..0

64: temp ← GPR[rs] + (immediate₁₅)⁴⁸ || immediate_15..0

     GPR[rt] ← (temp31)32 || temp31..0

3. Excepción:

Excepción de desbordamiento en complemento a dos. (Integer overflow exception).

ADDIU (Add Immediate Unsigned)

El formato de esta instrucción es:

    ADDIU rt,rs,immediate

1. Descripción de la instrucción:

   rt=rs+ext_signo(inm16,32)

Con el dato inmediato de 16 bits se hace una extensión de signo a 32 ó 64 bits (dependiendo del modo de operación) y ese dato se suma al dato que hay en el registro rs. El resultado se guarda en el registro rt. En modo 64 bits, el bit 31 del resultado se extiende.

La única diferencia entre esta instrucción y la instrucción ADDI es que ADDIU nunca causa una excepción de desbordamiento (Integer Overflow Exception).

2. Operación:

32: GPR[rt] ← GPR[rs] + (immediate₁₅)¹⁶ || immediate_15..0

64: temp ← GPR[rs] + (immediate₁₅)⁴⁸ || immediate_15..0

     GPR[rt] ← (temp31)32 || temp31..0

3. Excepción:

Ninguna.

ADDU (Add Unsigned)

El formato de esta instrucción es:

   ADDU rd,rs,rt

1. Descripción de la instrucción:

   rd=rs+rt

El contenido del registro rs y el contenido del registro rt se suman y el resultado se guarda en el registro rd. En modo 64 bits, el bit 31 del resultado se extiende. La única diferencia entre esta instrucción y la instrucción ADD es que ADDU nunca causa una excepción de desbordamiento (Integer Overflow Exception).

2. Operación:

32: GPR[rd] ← GPR[rs] + GPR[rt]

64: temp ← GPR[rs] + GPR[rt]

     GPR[rd] ← (temp31)32 || temp31..0

3. Excepción:

Ninguna.

DIV (Divide)

El formato de esta instrucción es:

   DIV rs,rt

1. Descripción de la instrucción:

   lo=rs/rt; hi=rem(rs/rt)

El contenido del registro rs se divide por el contenido del registro rt, tratando ambos operandos como valores en complemento a dos. No ocurre ninguna excepción de desbordamiento, y el resultado de esta operación es indefinido cuando el divisor es cero.

En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

Cuando la operación se completa, el cociente se carga en el registro LO, y el resto se carga en el registro HI.

2. Operación:

32: LO ← GPR[rs] div GPR[rt]

     HI ← GPR[rs] mod GPR[rt] 

64: q ← GPR[rs]31..0 div GPR[rt]31..0

     r  ← GPR[rs]31..0 div GPR[rt]31..0 

     LO ← (q 31) 32 || q 31..0

     HI ← (r 31) 32 || r 31..0

3. Excepción:

Ninguna.

DIVU (Divide Unsigned)

El formato de esta instrucción es:

   DIVU rs,rt

1. Descripción de la instrucción:

   lo=rs/rt; hi=rem(rs/rt)

El contenido del registro rs se divide por el contenido del registro rt, tratando ambos operandos como valores sin signo. No ocurre ninguna excepción de desbordamiento, y el resultado de esta operación es indefinido cuando el divisor es cero.

En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

Cuando la operación se completa, el cociente se carga en el registro LO, y el resto se carga en el registro HI.

2. Operación:

32: LO ← GPR[rs] div GPR[rt]

     HI ← GPR[rs] mod GPR[rt] 

64: q ← GPR[rs]31..0 div GPR[rt]31..0

     r  ← GPR[rs]31..0 div GPR[rt]31..0 

     LO ← (q 31) 32 || q 31..0

     HI ← (r 31) 32 || r 31..0

3. Excepción:

Ninguna.

MULT (Multiply)

El formato dse esta instrucción es:

   MULT rs,rt

1. Descripción de la instrucción:

   hi-lo=rs1*s2

El contenido del registro rs y rt se multiplican, tratando ambos operandos como valores de 32 bits en complemento a dos. No ocurre ninguna “Integer overflow exception”. En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

Cuando la operación se completa, la parte baja del resultado se guarda en el registro LO, y la parte alta del resultado se guarda en el registro HI.

2. Operación: 32: t ← GPR[rs] * GPR[rt]

     LO ← t31..0 
     HI ← t63..32 

64: t ← GPR[rs]31..0 * GPR[rt]31..0

     LO ← (t 31) 32 || t 31..0                
     HI ← (t 63) 32 || t 63..32  

3. Excepción:

Ninguna.

MULTU (Multiply Unsigned)

El formato dse esta instrucción es:

   MULTU rs,rt

1. Descripción de la instrucción:

   hi-lo=rs1*s2 

El contenido del registro rs y el contenido del registro rt se multiplican, tratando ambos operandos como valores sin signo. No ocurre “Integer overflow exception”. En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

Cuando la operación se completa, la parte baja del resultado se guarda en el registro de propósito especial LO, y la parte alta del resultado se guarda en el registro de propósito especial HI.

2. Operación:

32: t ← GPR[rs] * GPR[rt]

     LO ← t31..0 
     HI ← t63..32 

64: t ← GPR[rs]31..0 * GPR[rt]31..0

     LO ← (t 31) 32 || t 31..0                
     HI ← (t 63) 32 || t 63..32  

3. Excepción:

Ninguna.

SUB (Subtract)

El formato dse esta instrucción es:

   SUB rd,rs,rt

1. Descripción de la instrucción:

   rd=rs-rt

El contenido del registro rt se resta con el contenido del registro rs para formar el resultado que se guarda en el registro rd. En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

Ocurre una “Integer overflow exception” si se produce un desbordamiento en complemento a dos. El registro rd no se modifica cuando ocurre esta excepción.

2. Operación:

32: GPR[rd] ← GPR[rs] – GPR[rt]

64: temp ← GPR[rs] – GPR[rt]

     GPR[rd] ← (temp 31) 32 || temp 31..0 

3. Excepción:

Excepción de desbordamiento en complemento a dos. (Integer overflow exception).

SUBU (Subtract Unsigned)

El formato dse esta instrucción es:

   SUB rd,rs,rt

1. Descripción de la instrucción:

   rd=rs-rt

El contenido del registro rt se resta con el contenido del registro rs para formar el resultado que se guarda en el registro rd. En modo 64 bits, los operandos deben ser valores de 32 bits con extensión de signo.

La única diferencia entre esta instrucción y la instrucción SUB es que SUBU nunca causa desbordamiento. No ocurre una “Integer overflow exception”.

2. Operación:

32: GPR[rd] ← GPR[rs] – GPR[rt]

64: temp ← GPR[rs] – GPR[rt]

     GPR[rd] ← (temp 31) 32 || temp 31..0 

3. Excepción:

Ninguna.

Instrucciones Lógicas

AND (And)

El formato de esta instrucción es:

    AND rd,rs,rt

1. Descripción de la instrucción:

   rd = rs·rt

El contenido del registro rs hace la operación lógica AND con el contenido del registro rt, y el resultado es guardado en el registro rd.

2. Operación:

32:
    GPR[rd] ← GPR[rs] and GPR[rt]

64:
    GPR[rd] ← GPR[rs] and GPR[rt]

3. Excepciones:

Ninguna.

ANDI (And Immediate)

El formato de la instrucción es:

    ANDI rt,rs,immediate

1. Descripción de la instrucción:

   rt = rs·imm16

Al dato inmediato de 16 bits se le hace una extensión a 32 bits poniendo los bits 16 al 32 a cero o a 64 bits poniendo los bits 16 a 63 a cero (depende del modo deoperación) y se hace la operación lógica AND con el registro rs. El resultado se guarda en el registro rt.

2. Operación:

32:
    GPR[rt] ← 0<sup>16</sup> || (immediate and GPR[rs]<sub>15..0</sub>)

64:
    GPR[rt] ← 0<sup>48</sup> || (immediate and GPR[rs]<sub>15..0</sub>)

3. Excepciones:

Ninguna.

OR (Or)

El formato de la instrucción es:

    OR rd,rs,rt

1. Descripción de la instrucción:

   rd = rs + rt

El contenido del registro rs se combina con el contenido del registro rt en una operación lógica OR. El resultado se guarda en el registro rd.

2. Operación:

32,64:
    GPR[rd] ← GPR[rs] or GPR[rt]

3. Excepciones:

Ninguna.

NOR (Nor)

El formato de la instrucción es:

    ORI rt,rs,immediate16

1. Descripción de la instrucción:

   rt = rs NOR(imm16)

En el dato inmediato de 16 bits se hace una extensión con ceros y se combina con el contenido del registro rs in una operación lógica OR. El resultado se guarda en el registro rt.

2. Operación:

32:
    GPR[rt] ← GPR[rs]<sub>31..16</sub>||(immediate or GPR[rs]<sub>15..0</sub>)

64:
    GPR[rt] ← GPR[rs]<sub>63..16</sub>||(immediate or GPR[rs]<sub>15..0</sub>)

3. Excepciones:

Ninguna.

ORI (Or Immediate)

El formato de la instrucción es:

    ORI rt,rs,immediate

1. Descripción de la instrucción:

   rt = rs ORI inm

En el dato inmediato de 16 bits se hace una extensión con ceros y se combina con el contenido del registro rs in una operación lógica OR. El resultado se guarda en el registro rt.

2. Operación:

32:
    GPR[rt] ← GPR[rs]31..16||(immediate or GPR[rs]15..0)

64:
    GPR[rt] ← GPR[rs]63..16||(immediate or GPR[rs]15..0)

3. Excepciones:

Ninguna.

SLL (Shift Left Logical)

El formato de la instrucción es:

    SLL rd,rt,sa

1. Descripción de la instrucción:

El contenido del registro rt se desplaza hacia la izquierda sa bits, insertando ceros en los bits de orden bajo. El resultado se guarda en el registro rd.

En modo 64 bits, el resultado de 32 bits hace una extensión de signo cuando se mete en el registro destino.

2. Operación:

32:
    GPR[rd] ← GPR[rt]<sub>31-sa..0</sub> || 0<sup>sa</sup>

64:
    s ← 0 || sa
    temp ← GPR[rt]<sub>31-s..0</sub> || 0<sup>s</sup>
    GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp

3. Excepciones:

Ninguna.

SRL (Shift Right Logical)

El formato de la instrucción es:

    SRL rd,rt,sa

1. Descripción de la instrucción:

El contenido del registro rt se desplaza a la derecha sa bits, insertando ceros en los bits de orden alto. El resultado se guarda en el registro rd.

En modo 64 bits, el operando debe ser un valor de 32 bits con extensión de signo.

2. Operación:

32:
    GPR[rd] ← 0<sup>sa</sup> || GPR[rt]<sub>31..sa</sub>

64:
    s ← 0 || sa
    temp ← 0<sup>s</sup> || GPR[rt]<sub>31..s</sub>
    GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp

3. Excepciones:

Ninguna.

Salto Incondicional

J (Jump)

El formato de esta instrucción es:

   J target

1. Descripción de la instrucción:

La dirección de 26 bits del campo target se desplaza hacia la izquierda dos bits y se combina con los bits de orden alto de la dirección del CP. El programa salta a esta dirección.

2. Operación:

32:

     temp ← target
     PC   ← PC31..28 || temp || 02 

64:

     temp ← target 
     PC   ← PC63..28 || temp || 02

3. Excepción:

Ninguna.

JR (Jump Register)

El formato de esta instrucción es:

   JR rs

1. Descripción de la instrucción:

   PC=rs

El programa salta a la dirección contenida en el registro rs. La dirección contenida en el registro rs debe ser múltiplo de cuatro debido a que las instrucciones están alineadas como palabras. Si la dirección no es múltiplo de cuatro, ocurre una excepción de error de direccionamiento.

2. Operación:

32,64:

   temp ← GPR[rs]
   PC ← temp 

3. Excepción:

Address Error Exception (Error de direccionamiento).

JAL (Jump And Link)

El formato de esta instrucción es:

   JAL target

1. Descripción de la instrucción:

La dirección de 26 bits del campo target se desplaza hacia la izquierda dos bits y se combina con los bits de orden alto de la dirección del CP. El programa salta a esta dirección. La dirección de la instrucción siguiente a la instrucción siguiente a la instrucción de salto se guarda en el registro 31.

2. Operación:

32:

   temp ← target 
   GPR[31] ← PC + 8
   PC ← PC31..28 || temp || 02

64:

   temp ← target 
   GPR[31] ← PC + 8
   PC ← PC63..28 || temp || 02

3. Excepción:

Ninguna.

JALR (Jump And Link Register)

El formato de esta instrucción es:

   JALR rs,rd

1. Descripción de la instrucción:

• El programa salta a la dirección contenida en el registro rs. La dirección de la instrucción siguiente a la instrucción siguiente a la instrucción de salto se guarda en el registro rd. El valor por defecto del registro rd es 31 si el valor del campo rd es cero.

• La dirección contenida en el registro rs debe ser múltiplo de cuatro debido a que las instrucciones están alineadas como palabras. Si la dirección no es múltiplo de cuatro, ocurre una excepción de error de direccionamiento.

2. Operación:

32,64:

   temp ← GPR[rs]
   GPR[rd] ← PC + 8
   PC ← temp

3. Excepción:

Address Error Exception (Error de direccionamiento).