Instrucciones de procesamiento de DATOS:
Usamos instrucciones de procesamiento de datos para manipular datos dentro de los registros.
Tipos de instrucciones de procesamiento de datos –
- Instrucciones aritméticas
- Instrucciones lógicas
- Instrucciones para multiplicar
- Instrucciones de comparación
- Mover instrucciones
La mayoría de las instrucciones de procesamiento de datos utilizan un desplazador de barril para preprocesar los datos de uno de sus operandos. Cada operación actualiza diferentes indicadores en el cpsr (para obtener más información sobre ‘CPSR’, busque «CPSR en ARM»).
Vamos a discutir las instrucciones en detalle.
1. Instrucciones aritméticas:
las instrucciones aritméticas implementan principalmente sumas y restas de valores de 32 bits con y sin signo.
Sintaxis: <instrucción>{<cond>}{s} Rd, Rn, N
| ADC | sumar con valores de 32 bits y llevar | Rd=Rn+N+llevar |
| AGREGAR | agregar dos valores de 32 bits | Rd=Rn+N |
| RSB | resta inversa de dos valores de 32 bits | Rd=N-Rn |
| RSC | resta inversa con acarreo de dos valores de 32 bits | Rd=N-Rn-!(Bandera de acarreo) |
| SBC | restar con acarreo de dos valores de 32 bits | Rd=Rn-N-!(Bandera de acarreo) |
| SUB | restar dos valores de 322 bits | Rd=Rn-N |
| N es el resultado de la operación de desplazamiento. |
Ejemplos –
1 . Esta instrucción de resta simple resta un valor almacenado en el registro r2 de un valor almacenado en el registro r1. El resultado se almacena en el registro r0
PRE
r0 = 0x00000000 ; Como este registro es un registro para contener la salida, es por eso que está vacío antes de la ejecución
r1 = 0x000000002; el registro r1 tiene el valor ‘2’
r2 = 0x000000001 ; r2 tiene otro valor ‘1’
SUB r0, r1, r2 ; r0=r1 – r2. Aquí el valor sustraído (r0 – r1) se mueve a r0 después de realizar la operación.
POST
r0 = 0x00000001 ; Esta es la salida de la instrucción anterior movida al registro r0
2. Esta instrucción de resta inversa (RSB) resta r1 del valor constante #0 y escribe el resultado en r0.
La resta inversa es útil para valores enteros para que la instrucción se pueda restar sin complejidad.
PRE
r0 = 0x00000000 ; Registro de salida
r1= 0x00000077 ; valor a restar inversamente
RSB r0, r1, #0 ; Rd = 0x- – r1
POST
r0 = -r1 = 0xffffff89 ; la salida invertida se genera y almacena en el registro r0
Uso de la palanca de cambios de barril con instrucciones aritméticas:
el cambio de barril es una de las potentes características del conjunto de instrucciones ARM.
Preprocesa uno de los operandos/registros antes de realizar la operación en él.
Ejemplo –
PRE
r0 = 0x00000000
r1 = 0x00000005
AGREGAR r0, r1, r1, LSL #1
POST
r0 = 0x0000000f
r1 = 0x00000005
2. Instrucción
lógica: las instrucciones lógicas realizan operaciones lógicas bit a bit en los dos registros de origen.
Sintaxis: <instrucción>{<cond>} {S} Rd, Rn, N
| Y | AND lógico bit a bit de dos valores de 32 bits | Rd = Rn y N |
| TRO | OR lógico bit a bit de dos valores de 32 bits | Rd = Rn | norte |
| EOR | OR exclusivo lógico de dos valores de 32 bits | Rd = Rn^N |
| BIC | bit lógico claro (Y NO) | Rd = Rn &~ N |
Ejemplo:
1. Este ejemplo muestra una operación OR lógica entre los registros r1 y r2, r0 contiene el resultado.
PRE
r0 = 0x00000000
r1 = 0x02040608
r2 = 0x10305070 TRO
r0, r1, r2
POST
r0 = 0x12345678
2.Este ejemplo muestra una instrucción lógica más complicada llamada BIC, que lleva a cabo un borrado de bit lógico.
PRE
r1 = 0b1111
r2 = 0b0101
BIC r0, r1, r2
POST
r0 = 0b1010
3. Instrucción de
multiplicación: las instrucciones de multiplicación multiplican el contenido de un par de registros según la instrucción y acumulan el resultado junto con otro registro. Las multiplicaciones largas se acumulan en un par de registros que representan un valor de 64 bits. El resultado final se coloca en un registro de destino o en un par de registros.
Sintaxis: MLA{<cond>}{S} Rd, Rm, Rs, Rn
MUL{<cond>}{S} Rd, Rm, Rs
| MLA | Multiplicar y acumular | Rd = (Rm * Rs) + Rn |
| mul | multiplicar | Rd = Rm * Rs |
Sintaxis: <instrucción>{<cond>}{S} RdLo, RdHi, Rm, Rs
| PEQUEÑO | firmado multiplicar acumular largo | [RdHi, RdLo] = [RdHi, RdLo] + (Rm * Rs) |
| PEQUEÑO | firmado multiplicar largo | [RdHi, RdLo] = Rm * Rs |
| UMLAL | sin signo multiplicar acumular largo | [RdHi, RdLo] = [RdHi, RdLo] + (Rm * Rs) |
| UMULL | sin signo multiplicar largo | [RdHi, RdLo] = Rm * Rs |
La implementación del procesador maneja el número de ciclos necesarios para ejecutar una instrucción de multiplicación.
Ejemplo 1 –
- Este ejemplo representa la instrucción de multiplicación simple que multiplica los registros r1 y r2 y coloca el resultado en un registro r0.
- El registro r1 es igual al valor 2, y r2 es igual a 2, luego se reemplaza a r0.
PRE
r0 = 0x00000000 ; registrarse para mantener la salida
r1 = 0x00000002; registro que contiene el valor del operando 1
r2 = 0x00000002; registro que contiene el valor del operando 2
MUL r0, r1, r2 ; r0 = r1 * r2
POST
r0 = 0x00000004 ; salida de la operación de multiplicación
r1 = 0x00000002
r2 = 0x00000002 ; operandos
Ejemplo 2 –
PRE
r0 = 0x00000000
r1 = 0x00000000
r2 = 0xf0000002
r3 = 0x00000002
UMULL r0, r1, r2, r3 ; [r1, r0] = r2 * r3
POST
r0 = 0xe0000004; = RdLo
r1 = 0x00000001 ; = RdHi
4. Instrucciones de comparación:
estas instrucciones se utilizan para comparar o probar un registro con un valor de 32 bits. Actualizan los bits de la bandera cpsr según el resultado, pero no afectan a otros registros. Una vez que se han establecido los bits, la información se puede usar para cambiar el flujo del programa mediante la ejecución condicional.
Sintaxis – <instrucción>{<cond>} Rn, N
| CMN | comparar negado | banderas establecidas como resultado de Rn + N |
| CMP | comparar | banderas establecidas como resultado de Rn – N |
| TEQ | prueba de calidad de dos valores de 32 bits | banderas establecidas como resultado de Rn ^ N |
| TST | bits de prueba de un valor de 32 bits | indicadores establecidos como resultado de Rn & N |
| N es el resultado de la operación de cambio. |
Ejemplo –
PRE
cpsr = nzcvqift_USER
r0 = 4 ; registro a comparar
r9 = 4 ; registro a comparar
CMP r0, r9
POST
cpsr = salida nzcvqift_USER generada después de la comparación
5. Instrucciones de movimiento:
Move es la instrucción ARM más simple. Copia N en un registro de destino Rd, donde N es un registro o valor inmediato. Esta instrucción es útil para establecer valores iniciales y transferir datos entre registros.
Sintaxis – <instrucción>{<cond>}{S} Rd, N
| MOVIMIENTO | Mover un valor de 32 bits a un registro | Rd = norte |
| MVN | mover el NOT del valor de 32 bits a un registro | Rd = ~N |
Ejemplo –
PRE
r5 = 5 ; valor de registro
r7 = 8; valor de registro
MOV r7, r5; sea r7 = r5
POST
r5 = 5 ; datos en el registro después de mover los datos r5 a r7
r7 = 5 ; salida después de la operación de movimiento
Barrel Shifter:
es un dispositivo para cambiar una palabra con una cantidad variable. Es uno de los dispositivos lógicos utilizados para preprocesar uno de los operandos/registros antes de operar en las operaciones de la ALU. Y es una de las mejores características de ARM.
Cambiador de barril
| Mnemotécnica | Descripción | Cambio | Resultado | Cantidad de cambio |
| LSL | desplazamiento lógico a la izquierda | xLSLy | x<<y | #0-31 o $ |
| LSR | desplazamiento lógico a la derecha | xLSRy | (sin firmar) x>>y | #1-32 o Rs |
| ASR | desplazamiento aritmético a la derecha | xASRy | (firmado) x>>y | #1-32 o Rs |
| TDR | Gira a la derecha | xROry | ((sin firmar) x>>y) | (x<<(32 – y) | #1-31 o Rs |
| RRX | rotar a la derecha extendido | xRRX | (bandera c << 31) | ((sin firmar) x>>1) | ninguna |
| x representa el registro que se desplaza e y representa la cantidad de desplazamiento |
| N operaciones de cambio | Sintaxis |
| Inmediato | #inmediato |
| Registro | habitación |
| Desplazamiento lógico dejado por inmediato | Rm, LSL #shift_imm |
| Desplazamiento lógico a la izquierda por registro | Rm, LSL Rs |
| Desplazamiento lógico a la derecha por inmediato | Sala, LSR #shift_imm |
| Desplazamiento lógico a la derecha por registro | Rm, LSR RS |
| Desplazamiento aritmético a la derecha por inmediato | Rm, ASR #shift_imm |
| Desplazamiento aritmético a la derecha por registro | Rm, Rs ASR |
| Girar a la derecha inmediatamente | Rm, ROR #shift_imm |
| Girar a la derecha por registro | Rm, ROR Rs |
| rotar a la derecha con extender | Rm, RRX |
Ejemplo –
- Este ejemplo de una instrucción MOVS desplaza el registro r1 un bit a la izquierda.
- Esto multiplica el registro r1 por un valor 2 1
PRE
cpsr = nzcvqiFt_USER
r0 = 0x00000000
r1 = 0x80000004
MOVS r0, r1, LSL #1
POST
cpsr = nzCvqiFt_USER
r0 = 0x00000008
r1 = 0x80000004
- El indicador C se actualiza en el CPSR porque el sufijo S está presente en los mnemotécnicos de instrucción.
Publicación traducida automáticamente
Artículo escrito por jiganrahul01 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA