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

De Wikitronica
Saltar a: navegación, buscar
 
(No se muestran 20 ediciones intermedias de 5 usuarios)
Línea 1: Línea 1:
 +
[[Categoría: EC3731 - Arquitectura del Computador 2]]
 +
[[Categoría:MIPS]]
 +
La arquitectura de programación [[MIPS]] permite al usuario [[Instrucciones de transferencia de datos en el Mips|almacenar y leer]] en [[Registros del camino de datos del Mips|registros]], y sobre esos datos, hacer operaciones aritméticas y lógicas según sea necesario. Los datos pueden tomar diferentes "caminos" dependiendo de las operaciones que se efectúen sobre ellos, éstos pueden ser [[Camino de datos para instrucciones de formato R|para instrucciones de formato R]] y [[Describir el camino de datos para instrucciones de formato J|para instrucciones de formato J]].
 
=='''Instrucciones Aritméticas'''==
 
=='''Instrucciones Aritméticas'''==
  
 
==='''<u>ADD (Add)</u>'''===
 
==='''<u>ADD (Add)</u>'''===
 +
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
  
    ADD rd,rs,rt
+
<syntaxhighlight lang="asm">
 +
    ADD rd,rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
  
    rd=rs+rt
+
    rd=rs+rt
  
 
El contenido del registro rs y el contenido del registro rt se suman y el resultado  
 
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.  
 
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.
+
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.
 
El registro destino (rd) no se modifica cuando ocurre una excepción de desbordamiento.
  
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
 +
<syntaxhighlight lang="asm">
 +
32: 
 +
    GPR[rd] ← GPR[rs] + GPR[rt]
  
32:   GPR[rd] ← GPR[rs] + GPR[rt]
+
64:
 
+
    temp ← GPR[rs] + GPR[rt]
64:  temp ← GPR[rs] + GPR[rt]
+
    GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
      GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
+
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 30: Línea 39:
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
  
    ADDI rt,rs,immediate16
+
<syntaxhighlight lang="asm">
 +
    ADDI rt,rs,immediate16
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 46: Línea 57:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   GPR[rt] ← GPR[rs] + (immediate<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>
+
<syntaxhighlight lang="asm">
 +
32:
 +
    GPR[rt] ← GPR[rs] + (immediate<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>
  
64:   temp ← GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
+
64:
      GPR[rt] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
+
    temp ← GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
 +
    GPR[rt] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 59: Línea 74:
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
  
    ADDIU rt,rs,immediate
+
<syntaxhighlight lang="asm">
 +
    ADDIU rt,rs,immediate
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 74: Línea 91:
  
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
 +
<syntaxhighlight lang="asm">
 +
32: 
 +
    GPR[rt] ← GPR[rs] + (immediate<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>
  
32:   GPR[rt] ← GPR[rs] + (immediate<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>
+
64:
 
+
    temp ← GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
64:  temp ← GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
+
    GPR[rt] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
      GPR[rt] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
+
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 88: Línea 108:
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
  
 +
<syntaxhighlight lang="asm">
 
     ADDU rd,rs,rt
 
     ADDU rd,rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 101: Línea 123:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   GPR[rd] ← GPR[rs] + GPR[rt]  
+
<syntaxhighlight lang="asm">
 +
32:
 +
    GPR[rd] ← GPR[rs] + GPR[rt]  
  
64:   temp ← GPR[rs] + GPR[rt]
+
64:
      GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
+
    temp ← GPR[rs] + GPR[rt]
 +
    GPR[rd] ← (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 113: Línea 139:
  
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
 
+
<syntaxhighlight lang="asm">
 
     DIV rs,rt
 
     DIV rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 131: Línea 158:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   LO ← GPR[rs] div GPR[rt]  
+
<syntaxhighlight lang="asm">
      HI ← GPR[rs] mod GPR[rt]  
+
32:
 +
    LO ← GPR[rs] div GPR[rt]  
 +
    HI ← GPR[rs] mod GPR[rt]  
  
64:   q  ← GPR[rs]31..0 div GPR[rt]31..0  
+
64:
      r  ← GPR[rs]31..0 div GPR[rt]31..0  
+
    q  ← GPR[rs]31..0 div GPR[rt]31..0  
 +
    r  ← GPR[rs]31..0 div GPR[rt]31..0  
 
   
 
   
      LO ← (q <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
+
    LO ← (q <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
 
+
    HI ← (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>
      HI ← (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>
+
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 148: Línea 178:
  
 
El formato de esta instrucción es:
 
El formato de esta instrucción es:
 
+
<syntaxhighlight lang="asm">
 
     DIVU rs,rt
 
     DIVU rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 166: Línea 197:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   LO ← GPR[rs] div GPR[rt]  
+
<syntaxhighlight lang="asm">
      HI ← GPR[rs] mod GPR[rt]  
+
32:  
 +
    LO ← GPR[rs] div GPR[rt]  
 +
    HI ← GPR[rs] mod GPR[rt]  
  
64:   q  ← GPR[rs]31..0 div GPR[rt]31..0  
+
64:
      r  ← GPR[rs]31..0 div GPR[rt]31..0  
+
    q  ← GPR[rs]31..0 div GPR[rt]31..0  
 +
    r  ← GPR[rs]31..0 div GPR[rt]31..0  
 
   
 
   
      LO ← (q <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
+
    LO ← (q <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
 +
    HI ← (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>
 +
</syntaxhighlight>
  
      HI ← (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>
 
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
  
Línea 183: Línea 218:
 
El formato dse esta instrucción es:
 
El formato dse esta instrucción es:
  
 +
<syntaxhighlight lang="asm">
 
     MULT rs,rt
 
     MULT rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
    hi-lo=rs1*s2
 
  
 +
    hi-lo=rs1*s2
  
 
El contenido del registro rs y rt se multiplican, tratando ambos operandos como valores de 32 bits  
 
El contenido del registro rs y rt se multiplican, tratando ambos operandos como valores de 32 bits  
Línea 197: Línea 234:
  
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
32:  t  ← GPR[rs] * GPR[rt]
 
      LO ← t31..0
 
      HI ← t63..32
 
  
64:   t  ← GPR[rs]31..0 * GPR[rt]31..0  
+
<syntaxhighlight lang="asm">
      LO ← (t <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                 
+
32: 
      HI ← (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>   
+
    t  ← GPR[rs] * GPR[rt]
 +
    LO ← t31..0
 +
    HI ← t63..32
 +
 
 +
64:
 +
    t  ← GPR[rs]31..0 * GPR[rt]31..0  
 +
    LO ← (t <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                 
 +
    HI ← (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>   
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 213: Línea 255:
 
El formato dse esta instrucción es:
 
El formato dse esta instrucción es:
  
 +
<syntaxhighlight lang="asm">
 
     MULTU rs,rt
 
     MULTU rs,rt
 +
</syntaxhighlight>
  
 
1. <u>Descripción de la instrucción</u>:  
 
1. <u>Descripción de la instrucción</u>:  
Línea 229: Línea 273:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   t  ← GPR[rs] * GPR[rt]  
+
<syntaxhighlight lang="asm">
      LO ← t31..0  
+
32:
      HI ← t63..32  
+
    t  ← GPR[rs] * GPR[rt]  
 +
    LO ← t31..0  
 +
    HI ← t63..32  
  
64:   t  ← GPR[rs]31..0 * GPR[rt]31..0  
+
64:
      LO ← (t <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                 
+
    t  ← GPR[rs]31..0 * GPR[rt]31..0  
      HI ← (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>   
+
    LO ← (t <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                 
 +
    HI ← (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>   
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 245: Línea 293:
 
El formato dse esta instrucción es:
 
El formato dse esta instrucción es:
  
 +
<syntaxhighlight lang="asm">
 
     SUB rd,rs,rt
 
     SUB rd,rs,rt
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
  
1. <u>Descripción de la instrucción</u>:
 
 
     rd=rs-rt
 
     rd=rs-rt
  
Línea 259: Línea 310:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   GPR[rd] ← GPR[rs] – GPR[rt]  
+
<syntaxhighlight lang="asm">
 +
32:
 +
    GPR[rd] ← GPR[rs] – GPR[rt]  
  
64:   temp ← GPR[rs] – GPR[rt]  
+
64:
      GPR[rd] ← (temp <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>  
+
    temp ← GPR[rs] – GPR[rt]  
 +
    GPR[rd] ← (temp <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 272: Línea 327:
 
El formato dse esta instrucción es:
 
El formato dse esta instrucción es:
  
 +
<syntaxhighlight lang="asm">
 
     SUB rd,rs,rt
 
     SUB rd,rs,rt
 +
</syntaxhighlight>
  
1. <u>Descripción de la instrucción</u>:  
+
1. <u>Descripción de la instrucción</u>:
 +
 
     rd=rs-rt
 
     rd=rs-rt
  
Línea 286: Línea 344:
 
2. <u>Operación</u>:
 
2. <u>Operación</u>:
  
32:   GPR[rd] ← GPR[rs] – GPR[rt]  
+
<syntaxhighlight lang="asm">
 +
32:
 +
    GPR[rd] ← GPR[rs] – GPR[rt]  
  
64:   temp ← GPR[rs] – GPR[rt]  
+
64:
      GPR[rd] ← (temp <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>  
+
    temp ← GPR[rs] – GPR[rt]  
 +
    GPR[rd] ← (temp <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>
 +
</syntaxhighlight>
  
 
3. <u>Excepción</u>:
 
3. <u>Excepción</u>:
Línea 298: Línea 360:
  
 
==='''<u>AND (And)</u>'''===
 
==='''<u>AND (And)</u>'''===
 +
 +
El formato de esta instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    AND rd,rs,rt
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
    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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32:
 +
    GPR[rd] ← GPR[rs] and GPR[rt]
 +
 +
64:
 +
    GPR[rd] ← GPR[rs] and GPR[rt]
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
 +
 +
==='''<u>ANDI (And Immediate)</u>'''===
 +
 +
El formato de la instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    ANDI rt,rs,immediate
 +
</syntaxhighlight>
 +
   
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
    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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
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>)
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
 +
 
==='''<u>OR (Or)</u>'''===
 
==='''<u>OR (Or)</u>'''===
 +
 +
El formato de la instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    OR rd,rs,rt
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
    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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32,64:
 +
    GPR[rd] ← GPR[rs] or GPR[rt]
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
 +
 
==='''<u>NOR (Nor)</u>'''===
 
==='''<u>NOR (Nor)</u>'''===
==='''<u>ANDI (And Immediate)</u>'''===
+
 
 +
El formato de la instrucción es:
 +
 
 +
<syntaxhighlight lang="asm">
 +
    ORI rt,rs,immediate16
 +
</syntaxhighlight>
 +
 
 +
1. <u>Descripción de la instrucción</u>:
 +
 
 +
    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. <u>Operación</u>:
 +
 
 +
<syntaxhighlight lang="asm">
 +
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>)
 +
</syntaxhighlight>
 +
 
 +
3. <u>Excepciones</u>:
 +
 
 +
Ninguna.
 +
 
 
==='''<u>ORI (Or Immediate)</u>'''===
 
==='''<u>ORI (Or Immediate)</u>'''===
 +
 +
El formato de la instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    ORI rt,rs,immediate
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
    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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
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)
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
 +
 
==='''<u>SLL (Shift Left Logical)</u>'''===
 
==='''<u>SLL (Shift Left Logical)</u>'''===
 +
 +
El formato de la instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    SLL rd,rt,sa
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
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
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
 +
 
==='''<u>SRL (Shift Right Logical)</u>'''===
 
==='''<u>SRL (Shift Right Logical)</u>'''===
  
 +
El formato de la instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    SRL rd,rt,sa
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
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
 +
</syntaxhighlight>
 +
 +
3. <u>Excepciones</u>:
 +
 +
Ninguna.
  
 
=='''Salto Incondicional'''==
 
=='''Salto Incondicional'''==
 +
Ver también: [[Instrucciones de salto condicional en el Mips]]
  
 
==='''<u>J (Jump)</u>'''===
 
==='''<u>J (Jump)</u>'''===
 +
 +
El formato de esta instrucción es:
 +
<syntaxhighlight lang="asm">
 +
    J target
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32: 
 +
    temp ← target
 +
    PC  ← PC31..28 || temp || 02
 +
 +
64:
 +
    temp ← target
 +
    PC  ← PC63..28 || temp || 02
 +
</syntaxhighlight>
 +
 +
3. <u>Excepción</u>:
 +
 +
Ninguna.
 +
 
==='''<u>JR (Jump Register)</u>'''===
 
==='''<u>JR (Jump Register)</u>'''===
 +
 +
El formato de esta instrucción es:
 +
<syntaxhighlight lang="asm">
 +
    JR rs
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
    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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32,64:
 +
    temp ← GPR[rs]
 +
    PC ← temp
 +
</syntaxhighlight>
 +
 +
3. <u>Excepción</u>:
 +
 +
Address Error Exception (Error de direccionamiento).
 +
 
==='''<u>JAL (Jump And Link)</u>'''===
 
==='''<u>JAL (Jump And Link)</u>'''===
 +
 +
El formato de esta instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    JAL target
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32: 
 +
    temp ← target
 +
    GPR[31] ← PC + 8
 +
    PC ← PC31..28 || temp || 02
 +
 +
64: 
 +
    temp ← target
 +
    GPR[31] ← PC + 8
 +
    PC ← PC63..28 || temp || 02
 +
</syntaxhighlight>
 +
 +
3. <u>Excepción</u>:
 +
 +
Ninguna.
 +
 +
==='''<u>JALR (Jump And Link Register)</u>'''===
 +
 +
El formato de esta instrucción es:
 +
 +
<syntaxhighlight lang="asm">
 +
    JALR rs,rd
 +
</syntaxhighlight>
 +
 +
1. <u>Descripción de la instrucción</u>:
 +
 +
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. <u>Operación</u>:
 +
 +
<syntaxhighlight lang="asm">
 +
32,64: 
 +
    temp ← GPR[rs]
 +
    GPR[rd] ← PC + 8
 +
    PC ← temp
 +
</syntaxhighlight>
 +
 +
3. <u>Excepción</u>:
 +
 +
Address Error Exception (Error de direccionamiento).
 +
 +
== Enlaces de Interés ==
 +
* [[Medio:MIPS_Green_Card.pdf|Mips Green Card]]
 +
[[Category:MIPS]]

Revisión actual del 16:45 14 dic 2013

La arquitectura de programación MIPS permite al usuario almacenar y leer en registros, y sobre esos datos, hacer operaciones aritméticas y lógicas según sea necesario. Los datos pueden tomar diferentes "caminos" dependiendo de las operaciones que se efectúen sobre ellos, éstos pueden ser para instrucciones de formato R y para instrucciones de formato J.

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]  (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>

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<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>

64:  
    temp  GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
    GPR[rt]  (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>

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<sub>15</sub>)<sup>16</sup> || immediate<sub>15..0</sub>

64:  
    temp  GPR[rs] + (immediate<sub>15</sub>)<sup>48</sup> || immediate<sub>15..0</sub>
    GPR[rt]  (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>

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]  (temp<sub>31</sub>)<sup>32</sup> || temp<sub>31..0</sub>

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 <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
    HI  (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>

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 <sub>31</sub>) <sup>32</sup> || q <sub>31..0</sub>
    HI  (r <sub>31</sub>) <sup>32</sup> || r <sub>31..0</sub>

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 <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                
    HI  (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>

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 <sub>31</sub>) <sup>32</sup> || t <sub>31..0</sub>                
    HI  (t <sub>63</sub>) <sup>32</sup> || t <sub>63..32</sub>

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 <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>

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 <sub>31</sub>) <sup>32</sup> || temp <sub>31..0</sub>

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

Ver también: Instrucciones de salto condicional en el Mips

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).

Enlaces de Interés