## page was renamed from ASMAritmeticaARM
= Instrucciones Aritméticas/Logicas y de comparación del ARM =
 El ARM posee 16 instrucciones encargadas de realizar las operaciones aritméticas/lógicas y de comparación.

Las mismas se enumeran en la siguiente tabla

|| Opcode || Mnemonico || Operación || Acción || Asembler ||
|| 0000 || AND || AND logica  || Rd = Rn AND Op2 || AND{cond}{S} Rd,Rn,Op2 ||
|| 0001 || EOR || Or Exclusiva  || Rd = Rn EOR Op2 || EOR{cond}{S} Rd,Rn,Op2 ||
|| 0010 || SUB || Resta  || Rd = Rn - Op2 || SUB{cond}{S} Rd,Rn,Op2 ||
|| 0011 || RSB || Resta reversa  || Rd = Op2 - Rn || RSB{cond}{S} Rd,Rn,Op2 ||
|| 0100 || ADD || Suma  || Rd = Rn + Op2 || ADD{cond}{S} Rd,Rn,Op2 ||
|| 0101 || ADC || Suma con Acarreo || Rd = Rn + Op2 + Acarreo || ADC{cond}{S} Rd,Rn,Op2 ||
|| 0110  || SBC || Resta con Acarreo || Rd = Rn - Op2 - NOT(Acarreo) || SBC{cond}{S} Rd,Rn,Op2 ||
|| 0111  || RSC || Resta reversa con Acarreo || Rd = Op2 - Rn - NOT(Acarreo) || RSC{cond}{S} Rd,Rn,Op2 ||
|| 1000 || TST || Test  || Actualiza banderas con el resultado de (Rn AND Op2) || TST{cond} Rn,Op2 ||
|| 1001 || TEQ || Test Equivalente  || Actualiza banderas con el resultado de (Rn EOR Op2) || TEQ{cond} Rn,Op2 ||
|| 1010 || CMP || Comparar  || Actualiza banderas con el resultado de (Rn - Op2) || CMP{cond} Rn,Op2 ||
|| 1011 || CMN || Comparar Negativo || Actualiza banderas con el resultado de (Rn + Op2) || CMN{cond} Rn,Op2 ||
|| 1100 || ORR || Or Inclusiva  || Rd = Rn OR Op2 || ORR{cond}{S} Rd,Rn,Op2 ||
|| 1101 || MOV || Mover  || Rd = Op2 || MOV {cond}{S} Rd,Op2 ||
|| 1110 || BIC || Borrar Bit  || Rd = Rn AND NOT(Op2) || BIC{cond}{S} Rd,Rn,Op2 ||
|| 1111 || MVN || Mover negado  || Rd = NOT(Op2) || MVN{cond}{S} Rd,Op2 ||
== Parámetros usados ==

Los campos utilizados por estas instrucciones son los siguientes 
   * '''{cond}''' Como cualquier otra instrucción ARM, este campo indica la condicional para la ejecución de la instrucción.
   * '''{S}''' Con este campo se indica si la instrucción modifica las banderas del CPSR, solo se utiliza en las operaciones lógicas y aritméticas, no usadas en las de comparación donde es implícita. 
   * '''Rd,Rn,Op2''' son los operadores utilizados en la instrucción.
=== Rd ===
 Operador de destino, donde se guardan los resultados, es cualquier registro de propósitos múltiples 
=== Rn ===
 Operador Nro 1, puede ser también cualquier registro de propósitos múltiples. 
=== Op2 ===

Es el segundo operador, el mismo puede ser un valor inmediato u otro registro de propósitos múltiples, como se explico cuando se describió una instrucción genérica, en el caso de ser un registro se le puede adicionar un corrimiento fijo o a través de otro registro.

Según cuales de estos parámetros requiera, las instrucciones se pueden dividir en:
   * Usan los tres parámetros, son las instrucciones aritméticas o lógicas que realiza el calculo entre los dos operadores (Rn y Op2) y al resultado lo guarda en el registro destino. 
   * Destino y Op2, aquellas instrucciones que solo copian o copian y niegan un valor o registro a un registro destino, al usarse solo un operador fuente, se usa el operador 2 que permite corrimiento. 
   * Rn y OP2, las instrucciones de comparación solo realizan cálculos aritméticos o lógicos para actualizar las banderas, el resultado se pierde, por lo tanto no es utilizado el Rd.

El Op2 puede ser considerado como una segunda instrucción dentro de otra [[/ASMOperador2ARM|Descripción]]
== Instrucción de tres parámetros ==

|| 31 || 30 || 29 || 28 || 27 || 26 || 25 || 24 || 23 || 22 || 21 || 20 || 19 || 18 || 17 || 16 || 15 || 14 || 13 || 12 || 11 || 10 || 09 || 08 || 07 || 06 || 05 || 04 || 03 || 02 || 01 || 00 ||
|||||||| cond  || 0 || 0 || I  |||||||| opcode  || S  |||||||| Rn  |||||||| Rd  |||||||||||||||||||||||| Op2 puede ser el inmediato o el registro  ||

El bit[25] o I indica 0 si el operador 2 es un literal o 0 en caso de que sea un registro con corrimiento en [[/ASMOperador2ARM|Estructura de una Instrucción ARM]] se puede ver con mas detalle cada campo

== Instrucción con Destino y Op2 ==
|| 31 || 30 || 29 || 28 || 27 || 26 || 25 || 24 || 23 || 22 || 21 || 20 || 19 || 18 || 17 || 16 || 15 || 14 || 13 || 12 || 11 || 10 || 09 || 08 || 07 || 06 || 05 || 04 || 03 || 02 || 01 || 00 ||
|||||||| cond  || 0 || 0 || I  |||||||| opcode  || S  |||||||| llenar con 0  |||||||| Rd  |||||||||||||||||||||||| Op2 puede ser el inmediato o el registro  ||

== Instrucción con Rn y Op2 ==
|| 31 || 30 || 29 || 28 || 27 || 26 || 25 || 24 || 23 || 22 || 21 || 20 || 19 || 18 || 17 || 16 || 15 || 14 || 13 || 12 || 11 || 10 || 09 || 08 || 07 || 06 || 05 || 04 || 03 || 02 || 01 || 00 ||
|||||||| cond  || 0 || 0 || I  |||||||| opcode  || 1  |||||||| Rn  |||||||| llenar con 0  |||||||||||||||||||||||| Op2 puede ser el inmediato o el registro  ||

en este caso el bit 20 es siempre 1, al existir solo operaciones que modifican las banderas.
== Descripción de las instrucciones ==
=== Suma (ADD y ADC) ===
 Para realizar una sumar tenemos dos instrucciones Suma sin acarreo (ADD) Suma el primero operador (Rn) con Op2, el resultado es guardado en Rd, se puede además, con el agregado del bit S, podemos cambiar las banderas del CPSR con el resultado obtenido.

Suma con Acarreo (ADC) A la suma de Rn con Op2 le agrega el acarreo de la operación anterior, esto permite realizar suma de números cuya longitudes son de varios word.

ejemplo de sumar dos números de 2 word cada uno Numero 1 = R3 R2 Numero 2 = R1 R0 Resultado = R5 R4
{{{
ADDS R4,R0,R2
ADCS R5,R1,R3
}}}

Como vemos el último adc actualiza también las banderas, con las mismas podemos interpretar el resultado de 64bit.
   * N = 1, el resultado es un numero negativo. 
   * C = 1, se produjo un desborde (considerando al numero sin signo). 
   * V = 1, se produjo un desborde (considerando al numero con signo). 
   * Z = 1, los 32 bits mas altos son ceros. 

Otros ejemplos
{{{
ADD R1, R2, #1  ;Sumar 1 a R1 
ADD R1, R2, R2, LSL 3  ;R1 = R2 + R2 x 2 ^3 = R2 x ( 1 + 2 ^ 3) o R1 = R2 x 9 (multiplicar por una constante)

}}}

=== Resta (SUB, SBC, RSB y RSC) ===

Al igual que la suma, tenemos resta con acarreo y resta sin acarreo.

Resta sin acarreo (SUB) le resta a Rn el valor de Op2 el resultado lo guarda en Rd

Resta con acarreo le resta a Rn el valor de Op2 y el valor del acarreo negado

Si se especifica S en la instrucción se actualizan las banderas, en particular, el acarreo se modifica de la siguiente forma:
   * C = 1; no se a producido préstamo (no borrow). 
   * C = 0; se a producido un préstamo (borrow). 

En otras palabras el acarreo funciona como un NOT(borrow), esto es utilizado en las operación de resta con acarreo, en el cual en lugar de borrow utilizan NOT(Carry).

Las operaciones RSB y RSC son el equivalente a SUB y SBC.

La diferencia es que los operadores se invierten, es decir:
{{{
SUB realiza Rd = Rn - Opc2 
RSB realiza Rd = Opc2 - Rn  
}}}

Esta característica de resta reversa, es utilizada para poder aplicar un corrimiento al minuendo.

Ejemplo de restar dos números de 2 word cada uno

Numero 1 = R3 R2

Numero 2 = R1 R0

Resultado = R5 R4
{{{
SUBS R4,R0,R2
SBC R5,R1,R3
}}}

Ejemplos:
{{{
SUB R1,R1,#1 ; restar uno a R1

SUBS R1,R1,#1 ; se utiliza como loop, al modificar las banderas, se puede verificar la bandera de cero

RSB R1,R1,#0 ; R1 = 0 - R1, calcula el valor negativo

RSB R1, R2, R2, LSL 2 ; R1 = R1 x (2 x 4 - 1); R1 = R1 x 7

}}}

=== Lógicos AND,EOR,ORR,BIC ===
 Realizan las operaciones AND OR exclusivo y OR inclusivo bit a bit entre el operador Rn y el Op2, el resultado lo guarda en Rd.

La instrucción AND, es muy utilizada para realizar mascaras dentro de los registros, esto es por ejemplo poner a 0 todos los bits menos un grupo particular, que interesa analizar.

La instrucción BIC, realiza el AND lógico bit a bit del operador Rn con el complemento de Op2, esto permite al igual que la instrucción AND generar mascaras para borrar o dejar bits

Al igual que las anteriores el agregado de S permite que la instrucción modifique las bandera con el resultado.
{{{
ORR R1,R1,R1 ; borrar todos los bits
AND R1,R1,#3   ; borrar todos los bits, exceptuando los dos bits menos significativos
BIC R1,R1,#3    ; borrar solo los dos bits menos significativos.

}}}

=== Comparación TST,TEQ,CMP,CMN ===

Estas instrucciones, tienen la característica de no poseer registro destino, esto es, porque son para comparar valores sin que esto implique la modificación de un registro con su resultado.

Además, esto explica que la opción S no sea optativa y se encuentre implícita en la instrucción, ya que una operación de este tipo que no modifique las banderas, no tendría sentido.

Comparar (CMP) compara un registro de propósitos múltiples con Op2, esta comparación es una resta cuyo resultado modifica las banderas, de esta forma es posible detectar si un numero es mayo a otro (N=1) si dos números son iguales (Z=1), etc.

Comparar Negado (CMN) compara dos registro, realizando la resta del primero con el complemento a dos del segundo.

Test (TST) realiza una comparación a través de un AND lógico bit a bit entre dos los dos operadores, es muy utilizado para probar el estado de uno o varios bits dentro de un registro.

Test Equivalente (TEQ) realiza un OR exclusivo lógico bit a bit de los dos operadores, es utilizado para comprobar si dos numero son iguales sin afectar la bandera de desborde (V) o por ejemplo, para ver si dos números tienen el mismo signo, ( N tendrá el OR exclusivo de los dos bit de signo)

{{{
CMP R1,R2 ; comparar dos registros
}}}

=== Mover MOV,MVN ===

Copian el valor del Op2 al registro destino Rd

Estas instrucciones, no poseen Operador 1 o Rn, utilizan como operador fuente el Op2, con las ventajas que tienen este operador de poder cargar desde un literal o desde otro registro desplazado.

Mover (MOV) esta instrucción solo copia el valor de Op2 a Rd, esta instrucción se la suele usar para:

   * Copiar el valor de un registro a otro

   * Copiar una constante a un registro.

   * Realizar una operación de corrimiento a un registro.

   * Copiar el PC al LR para guardar la dirección de retorno de una subrutina.