3 Isa Armv8-A Brief

Machine Translated by Google
El conjunto de instrucciones A64
El conjunto
Conectar de instrucciones
la guía del usuario A64
Versión
Versión 0.11.0
BRAZO
Copyright © 2017 ARM Limited o sus afiliados. Reservados todos los derechos.
DD1ID113009
Página 1 de 35 BRAZO 100898_0100_es
Información de revisión
Se han realizado las siguientes revisiones a esta Guía del usuario.
Fecha Tema Confidencialidad Cambio
03 marzo 2017 0100 No confidencial Primer lanzamiento
Aviso de propiedad
™
Palabras y logotipos marcados con ® o UE son marcas registradas o marcas comerciales de ARM® en el
y otros países, excepto que se indique lo contrario a continuación en este aviso de propiedad. Otras marcas y nombres
mencionados aquí pueden ser marcas comerciales de sus respectivos propietarios.
Ni la totalidad ni parte de la información contenida en, o el producto descrito en este documento puede ser adaptado o
reproducido en cualquier forma material excepto con el permiso previo por escrito del titular de los derechos de autor.
El producto descrito en este documento está sujeto a continuos desarrollos y mejoras.

Todos los detalles del producto y su uso contenidos en este documento son proporcionados por ARM de buena fe.
Sin embargo, todas las garantías implícitas o expresas, incluidas, entre otras, las garantías implícitas
de comerciabilidad o idoneidad para un propósito, están excluidos.
Este documento está destinado únicamente a ayudar al lector en el uso del producto. ARM no será responsable de
ninguna pérdida o daño que surja del uso de cualquier información en este documento, o cualquier error u omisión en dicha
información, o cualquier uso incorrecto del producto.
Cuando se utiliza el término ARM, significa “ARM o cualquiera de sus subsidiarias, según corresponda”.
Estado de confidencialidad
Este documento es Confidencial. El derecho a usar, copiar y divulgar este documento puede estar sujeto a
restricciones de licencia de acuerdo con los términos del acuerdo celebrado por ARM y la parte a la que ARM entregó
este documento.
El acceso sin restricciones es una clasificación interna de ARM.
Estado del producto
La información de este documento es definitiva, es decir, para un producto desarrollado.
Dirección web
http://www.brazo.com

Contenido
1 El conjunto de instrucciones A64 ........................................... .................................................... ............................................. 5
1.1 Nemotécnicas de instrucción .................................................. .................................................... ...................................... 5
Distinguir entre instrucciones A64 de 32 bits y de 64 bits.................................... .......................................... 5
2 Instrucciones para el procesamiento de datos .................................................. .................................................... ............................... 7
2.1 Operaciones aritméticas y lógicas .................................................. .................................................... ..................... 7
2.2 Instrucciones para multiplicar................................................. .................................................... .......................................... 9
2.3 Dividir instrucciones ................................................. .................................................... .......................................... 10
2.4 Operaciones de cambio................................................. .................................................... .................................................. 11
2.5 Operadores de turno ................................................ .................................................... .................................................... 11
2.6 Instrucciones de manipulación de bytes y campos de bits .................................. .................................................... .... 13
Operadores de extensión................................................. .................................................... .................................................... ...... 15
2.7 Instrucciones condicionales................................................. .................................................... .................................... 17
Operaciones condicionales................................................. .................................................... ............................................. 18
Selección condicional (mover) ............................................... .................................................... .......................................... 18
Conjunto condicional................................................. .................................................... .................................................... .......... 19
Comparación condicional ................................................ .................................................... .......................................................... 19
3 Instrucciones de acceso a la memoria ............................................. .................................................... ............................... 20
3.1 Formato de instrucción de carga .................................................. .................................................... .................................... 20
3.2 Almacenar formato de instrucción .............................................. .................................................... .................................... 21
3.3 SIMD (NEON) y cargas y almacenamientos escalares de coma flotante .................................. ....................................21
3.4 Especificación de la dirección para una instrucción Cargar o Almacenar .................................. .................................... 22
Modos de compensación.................................................. .................................................... .................................................... ............. 23
Modos de índice.................................................. .................................................... .................................................... ............... 23
3.5 Piscinas literales .................................................. .................................................... .................................................... ..... 24
Cargas relativas a la PC ............................................... .................................................... .................................................... ......... 25
3.6 Acceder a varias ubicaciones de memoria.................................................... .................................................... ............ 25
3.7 Acceso no privilegiado .............................................. .................................................... .......................................... 26
3.8 Recuperación previa de la memoria .................................................. .................................................... .......................................... 26
3.9 Par de carga y almacenamiento no temporal ........................................... .................................................... ..................... 27
3.10 Atomicidad de acceso a la memoria........................................... .................................................... .................................... 27
3.11 Instrucciones de la barrera de memoria.................................... .................................................... ............................. 27
3.12 Primitivas de sincronización.................................................... .................................................... ............................... 28
4 Control de flujo ................................................ .................................................... .................................................... ........ 29

5 Control del sistema y otras instrucciones.................................................... .................................................... .......... 31
5.1 Instrucciones de generación de excepciones .................................................. .................................................... .................... 31
5.2 Instrucciones de devolución de excepción ................................. .................................................... ......................... 31
Del estado AArch64 ............................................... .................................................... .................................................... 31
5.3 Acceso al registro del sistema .................................................. .................................................... ...................................... 31
5.4 Instrucciones de depuración ............................................... .................................................... ............................................. 32
5.5 Sugerencias de instrucciones .................................................. .................................................... ............................................... 32
5.6 Instrucciones SIMD................................................... .................................................... ............................................. 33
5.7 Instrucciones de coma flotante.................................................... .................................................... ............................. 33
5.8 Instrucciones criptográficas................................................. .................................................... ............................. 34

1 El conjunto de instrucciones A64

Uno de los cambios más significativos introducidos en la arquitectura ARMv8-A fue la adición de un conjunto de instrucciones para
AArch64, denominado A64. Este conjunto de instrucciones contiene características similares al conjunto de instrucciones de 32 bits
AArch32 (ARMv7-A) existente.
La adición de A64 brinda acceso a registros de enteros de 64 bits de ancho y operaciones de datos, y la capacidad de usar
punteros de memoria de tamaño de 64 bits. Las instrucciones A64 se ejecutan en el estado de ejecución AArch64. ARMv8-A
también incluye el conjunto de instrucciones ARM® original , ahora llamado A32, y el conjunto de instrucciones Thumb® (T32).
Es posible que los programadores que escriben a nivel de aplicación nunca necesiten escribir código en lenguaje ensamblador.
Sin embargo, el código ensamblador puede ser útil en los casos en que se requiere un código altamente optimizado. Este es el
caso cuando se escriben compiladores, o cuando se requiere el uso de funciones de bajo nivel que no están disponibles
directamente en C, por ejemplo:
• Partes del código de inicio.
• Controladores de dispositivo.
• Desarrollo de sistemas operativos.
Leer el código ensamblador puede ser útil para depurar C, en particular para comprender la asignación entre las instrucciones
ensambladoras y las instrucciones C.
1.1 Nemotecnia de instrucciones

El conjunto de instrucciones A64 sobrecarga los mnemotécnicos de instrucciones. Es decir, distingue entre las diferentes
formas de una instrucción, en función de los nombres de registros de operandos que se utilizan. Por ejemplo, las siguientes
instrucciones ADD tienen formas diferentes, pero solo tiene que recordar una instrucción y el ensamblador elige automáticamente
la codificación correcta, según los operandos utilizados.
AGREGAR W0, W1, W2 // agregar registros de 32 bits
AGREGAR X0, X1, X2 // agregar registros de 64 bits
AGREGAR X0, X1, W2, SXTW // agregar registro de signo extendido de 32 bits a 64 bits
// registro extendido
AGREGAR X0, X1, #42 // agregar inmediato al registro de 64 bits
AGREGAR V0.8H, V1.8H, V2.8H // Añadir NEON de 16 bits, en cada uno de los 8 carriles
Distinguir entre instrucciones A64 de 32 bits y 64 bits

La mayoría de las instrucciones de enteros en el conjunto de instrucciones A64 tienen dos formas, que operan en 32-
bit o valores de 64 bits dentro del archivo de registro de propósito general de 64 bits.
Al mirar el nombre del registro que usa la instrucción:
• Si el nombre del registro comienza con X, es un registro de 64 bits.
• Si el nombre del registro comienza con W, es un registro de 32 bits.

Cuando se selecciona un formulario de registro de 32 bits:
• La inyección se desplaza hacia la derecha y gira en el bit 31, en lugar del bit 63.
• Los indicadores de condición, cuando los establece la instrucción, se calculan a partir de los 32 bits inferiores.
• Escribe en el registro W los bits establecidos [63:32] del registro X a cero.
Esta distinción se aplica incluso cuando los resultados de un formulario de registro de 32 bits serían indistinguibles de los 32 bits inferiores
calculados por el formulario de registro equivalente de 64 bits. Por ejemplo, A64 incluye formularios de registro separados de 32 y 64 bits de las
instrucciones ORR . Un ORR bit a bit de 32 bits podría realizarse con la misma facilidad utilizando un ORR de 64 bits e ignorando los 32 bits
superiores del resultado.

2 Instrucciones de procesamiento de datos

Estas son las operaciones aritméticas y lógicas fundamentales del procesador y operan sobre valores en registros de
propósito general, o sobre un registro y un valor inmediato. A64 se ocupa de forma natural de los tipos de datos de 64
bits firmados y sin firmar al ofrecer formas más concisas y eficientes de manipular enteros de 64 bits. Esto puede resultar
ventajoso para todos los lenguajes que proporcionan números enteros de 64 bits, como C o Java. Las instrucciones de
multiplicación pueden considerarse casos especiales de estas instrucciones.
Las instrucciones de procesamiento de datos utilizan principalmente un registro de destino y dos operandos de origen.
El formato general se puede considerar como la instrucción, seguida de los operandos, de la siguiente manera:
Instrucción Rd, Rn, Operando2
Dónde
Rd es el registro de destino.
Rn es el registro sobre el que se opera.
El uso de R aquí indica que los registros pueden ser registros X o W.
El operando2 puede ser un registro, un registro modificado o un valor inmediato.
Las operaciones de procesamiento de datos incluyen:
• Operaciones aritméticas y lógicas.
• Operaciones de movimiento y desplazamiento.
• Instrucciones para extensión de signo y cero.
• Manipulación de bits y campos de bits.
• Comparación condicional y procesamiento de datos.
2.1 Operaciones aritméticas y lógicas

Algunas de las operaciones disponibles se muestran en la siguiente tabla.
Escribe Instrucciones
Aritmética AGREGAR, SUB, ADC, SBC, NEG
Lógico Y, BIC, ORR, ORN, EOR, EON
Comparación CMP, CMN, TST
Muevete MOV, MVN
Algunas de estas instrucciones también tienen un sufijo S , lo que indica que la instrucción establece banderas.
De las instrucciones anteriores, las que llevan el sufijo incluyen ADDS, SUBS, ADCS, SBCS, ANDS y BICS.
Hay otras instrucciones de configuración de banderas, en particular CMP, CMN y TST, pero estas no toman una S
sufijo.

Las operaciones ADC y SBC realizan sumas y restas que también utilizan el indicador de condición de acarreo como entrada.
CAD{S}: Rd = Rn + Rm + C
SBC{S}: Rd = Rn - Rm - 1 + C
Por ejemplo:
Círculo
AGREGAR W0, W1, W2, LSL #3 // W0 = W1 + (W2 << 3)

SUBS X0, X4, X3, ASR #2 // X0 = X4 - (X3 >> 2), establecer banderas
Bucle BGE // Bucle si no es negativo
MOV X0, X1 // Copiar X1 a X0
CMP W3, W4 // Establecer banderas basadas en W3 - W4
AGREGAR W0, W5, #27 // W0 = W5 + 27
Las operaciones lógicas son las mismas que los operadores booleanos correspondientes que operan en bits
individuales del registro.
Por ejemplo:
Y X2, X2, X1
TRO W2, W2, W5
EOR W7, W7, W6
BIC X0, X0, X1
La instrucción BIC (Bitwise bit Clear) (BIC Rd, Rn, Operand2):
•
Invierte operando2.
• Realiza un AND bit a bit con Rn.
• Almacena el resultado en Rd.
Por ejemplo, para borrar el bit [11] del registro X0, utilice:
MOVX1, #0x800
BIC X0, X0, X1
ORN Rd, Rn, Operand2 invierte Operand2 y OR con Rd.
EON Rd, Rn, Operand2 invierte Operand2 y EORs con Rd.
Las instrucciones de comparación solo modifican las banderas y no tienen ningún otro efecto. El rango de valores
inmediatos para estas instrucciones es de 12 bits y el valor inmediato se puede desplazar 12 bits hacia la izquierda.

2.2 Instrucciones de multiplicación
Las instrucciones de multiplicación que se proporcionan son muy similares a las de ARMv7-A, pero tienen la capacidad de realizar
multiplicaciones de 64 bits en una sola instrucción.
Instrucción Descripción
MADD multiplicar sumar
MNEG multiplicar negar
MSUB multiplicar restar
mul Multiplicar
SMADDL Firmado multiplicar-sumar largo
SMNEGL Firmado multiplicar-negar largo
SMSUBL Firmado multiplicar restar largo
SMULH Multiplicación firmada que devuelve la mitad alta
PEQUEÑO Firmado multiplicar largo
UMADDL Sin signo multiplicar-sumar largo
UMNEGL Unsigned multiplicar-negar largo
UMSUBL Sin signo multiplicar restar largo
UMULH Multiplicación sin signo que devuelve la mitad alta
UMULL Multiplicación larga sin signo
Hay instrucciones de multiplicación que operan en valores de 32 o 64 bits y devuelven un resultado del mismo tamaño que los operandos.
Por ejemplo, se pueden multiplicar dos registros de 64 bits para producir un resultado de 64 bits con la instrucción MUL . Cualquier
desbordamiento se ignora y el resultado se toma como los 64 bits inferiores.
MUL X0, X1, X2 // X0 = X1 × X2
También existe la posibilidad de sumar o restar un valor acumulador en un tercer registro fuente, utilizando las instrucciones MADD o MSUB .
La instrucción MNEG se puede utilizar para negar el resultado, por ejemplo:
MNEG X0, X1, X2 // X0 = -(X1 × X2)
Además, hay una variedad de instrucciones de multiplicación que producen un resultado largo, es decir, multiplicar dos números de 32 bits
y generar un resultado de 64 bits. Hay variantes firmadas y no firmadas de estos
multiplicaciones largas (UMULL, SMULL). También hay opciones para acumular un valor de otro registro
(UMADDL, SMADDL) o para negar (UMNEGL, SMNEGL).
La inclusión de la multiplicación de 32 y 64 bits con acumulación opcional da como resultado un tamaño del mismo tamaño que los
operandos. Nuevamente, se ignora cualquier desbordamiento y el resultado se toma como los 64 bits inferiores del cálculo:
• 32 ± (32 × 32) da un resultado de 32 bits.

• ± (32 × 32) da un resultado de 32 bits.
Tanto la ampliación firmada como la no firmada se multiplican con la acumulación y dan un único resultado de 64 bits:
Una multiplicación de 64 × 64 a 128 bits tiene el potencial de generar un resultado mayor que 64 bits.
Esto hace que el registro de resultados de la instrucción MUL estándar se desborde. En este caso, las instrucciones de
multiplicación alta con signo/sin signo (SMULH, UMULH) capturan los bits del resultado perdidos por el desbordamiento en otro
registro.
Por ejemplo, la operación 0xFFFF_FFFF_FFFF_FFFF x 0x2 daría la respuesta

0x1_FFFF_FFFF_FFFF_FFFE que no cabe en un solo registro de 64 bits.
MOVIMIENTO
X0, #0xFFFFFFFFFFFFFFFF
MOVIMIENTO
X1, #0x2
mul X2, X0, X1 // X2 = 0xFFFF_FFFF_FFFF_FFFE

UMULH X3, X0, X1 // X3 = 0x0000_0000_0000_0001
Nota
No puede multiplicar directamente un registro W de 32 bits por un registro X de 64 bits.
2.3 Dividir instrucciones

ARMv8-A admite la división firmada y sin firmar de valores de tamaño de 32 bits y 64 bits.
SDIV división firmada
UDIV división sin firmar
Por ejemplo:
UDIV W0, W1, W2 // W0 = W1 / W2 (sin firmar, división de 32 bits)
SDIV X0, X1, X2 // X0 = X1 / X2 (firmado, división de 64 bits)
El desbordamiento y la división por cero no están atrapados:
• Cualquier división entera por cero devuelve cero.
• El desbordamiento solo puede ocurrir en SDIV:
o INT_MIN / -1 devuelve INT_MIN, donde INT_MIN es el número negativo más pequeño que se puede codificar en los
registros que se utilizan para la operación. El resultado siempre se redondea hacia cero, como en la mayoría de
los dialectos de C/C++.

2.4 Operaciones de turno

Las siguientes instrucciones mueven los patrones de bits dentro de un registro hacia la izquierda o hacia la derecha:
• Desplazamiento lógico a la izquierda (LSL). La instrucción LSL realiza la multiplicación por una potencia de 2.
• Desplazamiento lógico a la derecha (LSR). La instrucción LSR realiza la división por una potencia de 2.
• Desplazamiento aritmético a la derecha (ASR). La instrucción ASR realiza la división por una potencia de 2, conservando
el bit de signo.
• Girar a la derecha (ROR). La instrucción ROR realiza una rotación bit a bit, envolviendo los bits rotados del LSB al MSB.
Desplazamiento lógico LSL a la izquierda Desplazamiento lógico LSR a la derecha
Los bits Los bits

Registro 0 0 Registro
desplazados se pierden desplazados se pierden
Multiplicación por 2n donde n es la cantidad División sin signo por 2n donde n es la

de cambio cantidad de cambio
ASR Desplazamiento aritmético a la derecha ROR Girar a la derecha
bit de signo
Los bits
Registro Registro
desplazados se pierden
División por 2n , donde n es el Rotación de broca con envoltura de

cantidad de cambio, conservando el bit LSB a MSB
de signo
El registro que se especifica para un desplazamiento puede ser de 32 bits o de 64 bits. La cantidad a desplazar puede ser
inmediata, es decir, hasta (Tamaño de registro - 1), o por un registro donde el valor se toma solo de los cinco (módulo-32) o
seis (módulo-64) bits inferiores.
2.5 Operadores de turno

Las instrucciones aritméticas (registro desplazado) aplican un operador de desplazamiento opcional al valor del
registro del operando antes de realizar la operación aritmética. Se pueden usar en algunas instrucciones aritméticas para
permitir la multiplicación o división constante y la manipulación del patrón de bits en el operando. El ancho de registro de
la instrucción controla si los nuevos bits se introducen en el resultado intermedio en un desplazamiento a la derecha o
giran en el bit [63] o el bit [31].
La forma general de estos es
<operación> Rd, Rs, Operando<operación> #imm
Por ejemplo
MOV X0,X0,LSL #8
MOV W0,W0,ASR #2
La siguiente tabla contiene instrucciones aritméticas que pueden contener operandos desplazados:

Agregar
AGREGAR
AÑADE Agregar y establecer banderas
SUB Sustraer
SUBS Restar y establecer banderas
CMN Comparar negativo
CMP Comparar
NEG Negar
NEGROS Negar y establecer banderas
Los operadores de turno LSL, ASR y LSR tienen los mismos nombres y realizan las mismas acciones que las instrucciones de turno.
Los operadores de desplazamiento toman un registro fuente y lo desplazan hacia la izquierda o hacia la derecha el número especificado
de bits, con extensión de signo opcional. Omitir el operador de turno significa que no hay turno. Las operaciones de cambio son en su
mayoría las mismas que en A32 y T32.
La cantidad de cambio está codificada en la instrucción (y por lo tanto es constante). Una diferencia significativa con A32 es que no hay
formularios de registro desplazado por registro. Tales operaciones son posibles en A64, pero como en T32, son instrucciones
independientes con una sintaxis ligeramente diferente.
Para todos los modificadores de desplazamiento, el tamaño del resultado es el mismo que el tamaño de la fuente. No hay una
ampliación o reducción implícita. Estos modificadores son el equivalente A64 del operando flexible que a menudo se llama Operand2 en
A32 y T32.
La forma general de estos operadores es
<operación> #imm
Dónde
operación es uno de los modificadores, y
#imm es opcional y su valor predeterminado es 0.
Por ejemplo
SUBX0, X1, X2, LSR #0 //Restar un registro desplazado

// X0 = X1 - ((uint-t)x2 >> 0)
AGREGAR X5, X6, #10, LSL #12 //Agregar un cambio inmediato

// X5 = X6 + (10 >> 12)
La siguiente tabla muestra los operadores de turno;

LSL Cantidad de desplazamiento inmediato a la izquierda en el rango de 0 a (Tamaño de registro - 1).
ASR Cantidad de desplazamiento aritmético a la derecha en el rango de 0 a (Tamaño de registro - 1).
LSR Cantidad de desplazamiento derecho inmediato en el rango de 0 a (tamaño de registro - 1).
El puntero de pila actual, SP o WSP, no se puede utilizar con esta clase de instrucciones.
2.6 Instrucciones de manipulación de bytes y campos de bits

Hay instrucciones que extienden un byte, media palabra o palabra para registrar el tamaño (aunque solo SXTW
opera sobre una palabra). Estas instrucciones existen en variantes con signo (SXTB, SXTH, SXTW) y sin signo (UXTB,
UXTH) y son alias de la instrucción de manipulación de campo de bits adecuada. La fuente es siempre un registro W.
El registro de destino (excepto SXTW) es un registro X o W.
Por ejemplo:
SXT X0, W1 // Signo extiende el byte menos significativo del // registro //

W1 de 8 bits a 64 bits repitiendo el //bit más a la izquierda
del byte.
Las instrucciones de campo de bits incluyen inserción de campo de bits (BFI) y extracción de campo de bits con y sin signo ((S/
U)BFX). También hay instrucciones de campo de bits adicionales, como BFXIL (Extracción de campo de bits e inserción baja), UBFIZ
(Inserción de campo de bits sin signo en cero) y SBFIZ (Inserción de campo de bits con signo en cero).
También es posible ampliar y desplazar el registro de operandos de una instrucción ADD, SUB, CMN o CMP y el registro de
índice de una instrucción de carga o almacenamiento. Esto da como resultado una implementación eficiente de los cálculos
de índice de matriz utilizando un puntero de matriz de 64 bits y un índice de matriz de 32 bits, como se muestra en la
siguiente figura:

31 0
000000001010110001001 1 1001110100
BFI W0, W0, #9, #6 ;Inserción de campo de bits
31 0
000000001010110001 10100001110100
UBFX W1, W0, #18, #7 ;Extracción de campo de bits
31 0
0000000000000000000000000010101 1
Extensión cero
0
BFC W1, WZR, #3, #4 ;Borrar campo de bits
31 0
0000000000000000000000000000001 1
Nota
• También hay instrucciones BFM, UBFM y SBFM .
• Estas son instrucciones de movimiento de campo de bits.
• Sin embargo, no es necesario utilizar estas instrucciones explícitamente, ya que se proporcionan alias para
todos los casos.
• Estos alias son las operaciones de campo de bits ya descritas: (S/U)XT(B/H/W/X), ASR/LSL/LSR
inmediato, BFI, BFXIL, SBFIZ, SBFX, UBFIZ y UBFX.
Hay otras instrucciones de manipulación de bits:
•
CLZ Cuenta los bits cero iniciales en un registro. Del mismo modo, las mismas instrucciones de manipulación de bytes:
• RBIT Invierte todos los bits.
•
REV Invierte el orden de los bytes de un registro.
•
REV16 Invierte el orden de los bytes de cada media palabra en un registro.
Xn
xd
•
REV32 Invierte el orden de los bytes de cada palabra en un registro.

Xn
xd
Estas operaciones se pueden realizar en registros de tamaño de palabra (32 bits) o doble palabra (64 bits), excepto REV32, que se aplica solo a
registros de 64 bits.
Operadores de extensión
Las instrucciones de registro extendidas proporcionan una extensión de signo opcional o una extensión de cero de una parte del valor
del registro del operando, seguido de un desplazamiento a la izquierda opcional por una cantidad constante de 1-
4, inclusive.
La forma general de estos es:
<operación> Rd, Rs, Operand<operación extendida> #imm
La siguiente tabla enumera las instrucciones aritméticas (registro desplazado):
Agregar
AGREGAR
AÑADE Agregar y establecer banderas
SUB Sustraer
SUBS Restar y establecer banderas
CMN Comparar negativo
CMP Comparar
Los operadores de extensión toman una secuencia de bits consecutivos del registro de origen, luego lo firman o lo extienden a cero para que
tenga el tamaño requerido. Nuevamente, los operadores tienen los mismos nombres y realizan las mismas acciones que la instrucción descrita
en las instrucciones de manipulación de bytes y campos de bits, pero con algunas diferencias. Por ejemplo, no hay instrucciones {S/U}XTW o {S/
U}XTX .
El tamaño del resultado está implícito en el contexto. La mayoría de estas operaciones extendidas existen en A32 y T32, pero son más
flexibles en A64 y, a menudo, se pueden usar como un modificador de operando.
Varios contextos también permiten que los modos extendidos realicen un cambio a la izquierda más inmediato (como LSL). Este desplazamiento
tiene un rango limitado (de 0 a 4 bits) y se aplica después de la operación de extensión. Por ejemplo, SXTB #2
significa que el signo se extiende desde la fuente de 8 bits, luego lo desplaza a la izquierda 2 bits.
Debido a que los operandos extendidos pueden tomar un turno, UXTX y, a veces , UXTW, son funcionalmente idénticos a LSL para los turnos
0-4. Estos son en realidad alias en algunos casos de esquina donde los modos extendidos están disponibles pero los modos de cambio no lo
están. Si no se especifica la cantidad de cambio, la cantidad de cambio predeterminada es
cero.

Recuperar el formato de la instrucción ADD
AGREGAR X0, X1, W2, SXTW // agregar signo registro extendido de 32 bits a // registro
extendido de 64 bits
En este caso, la extensión se aplica al operando y puede tener los siguientes valores:
UXTB Extrae un valor de byte de un registro y cero lo extiende al tamaño del registro.
UXTH Extrae un valor de media palabra de un registro y cero lo extiende al tamaño del registro.
LSL o UXTW Extrae un valor de palabra de un registro y cero lo extiende al tamaño del registro.
UXTX Utilice todo el registro de 64 bits.
sxtb Extrae un valor de byte de un registro y cero lo extiende al tamaño del registro.
SEXTO Extrae un valor de media palabra de un registro y cero lo extiende al tamaño del registro.
SXTW Extrae un valor de palabra de un registro y cero lo extiende al tamaño del registro.
sxtx Utilice todo el registro de 64 bits.
• Cuando la cantidad de turno también es cero, tanto el operador como la cantidad de turno pueden ser
omitido
• Para instrucciones de registro de 64 bits, los operadores adicionales UXTX y SXTX usan los 64 bits del registro de
operandos con un desplazamiento opcional. En ese caso, ARM recomienda UXTX como operador.
• Cuando al menos un registro es SP, ARM recomienda el uso del operador LSL, en lugar de
UXTX.
• Para las instrucciones de registro de 32 bits, los operadores UXTW y SXTW usan los 32 bits del registro de
operandos con un desplazamiento opcional. Una vez más, ARM recomienda a UXTW como operador.
• Cuando un registro es WSP, ARM recomienda el uso del operador LSL, en lugar de UXTW.
En las instrucciones de registro de 64 bits, el operando de registro final se escribe como Wm para todos
excepto los operadores de extensión UXTX/LSL y SXTX.
Por ejemplo:
LDR W10, [X11, W12, SXTW] // Cargar desde una matriz usando un //índice firmado
// W10 = *(uint32_t*)(X11 + (int32_t)W12)

2.7 Instrucciones condicionales

Hay cuatro indicadores de estado, cero (Z), negativo (N), acarreo (C) y desbordamiento (V). La siguiente tabla indica el
valor de estos bits para las operaciones de establecimiento de banderas.
Nota
Los indicadores de condición (NZCV) y los códigos de condición son los mismos en A32 y T32.
Bandera Nombre Descripción
norte
Negativo Establézcalo en el mismo valor que el bit [31] del resultado. Para un entero de 32 bits con
signo, el bit[31] establecido indica que el valor es negativo.
Z Cero Se establece en 1 si el resultado es cero, de lo contrario se establece en 0.
C Llevar Se establece en el valor de realización del resultado, o en el valor del último bit
desplazado de una operación de desplazamiento.
V Desbordamiento Se establece en 1 si se produjo un desbordamiento o subdesbordamiento firmado; de lo contrario, se establece en 0.
El indicador C se establece si el resultado de una operación sin firmar desborda el registro de resultados.
La bandera V opera de la misma manera que la bandera C, pero para operaciones firmadas.
Código Codificación Significado (cuando lo establece CMP) Significado (cuando lo establece FCMP) Banderas de condición
ecualizador 0b0000 Igual a. Igual a. Z=1
nordeste 0b0001 No igual a. Desordenado, o no igual a. Z=0
CS 0b0010 Juego de transporte (idéntico al HS). Mayor que, igual o desordenado C=1
(idéntico a HS).
SA 0b0010 Mayor que, igual a (sin Mayor que, igual o desordenado C=1
signo) (idéntico a CS). (idéntico a CS).
CC 0b0011 Llevar claro (idéntico a LO). Menor que (idéntico a LO). C=0
LO 0b0011 Sin firmar menor que (idéntico a Menor que (idéntico a CC). C=0
CC).
MI 0b0100 Menos, Negativo. Menos que. norte = 1
ES 0b0101 Positivo o cero. Mayor que, igual o desordenado. norte = 0
contra 0b0110 Desbordamiento firmado. desordenado V=1
(Al menos un argumento fue NaN).
VC 0b0111 Sin desbordamiento firmado. No desordenado. V=0
(Ningún argumento fue NaN).
HOLA 0b1000 Mayor que (sin signo). Mayor que o desordenado. (C = 1) &&(Z = 0)
LS 0b1001 Menor o igual que (sin Menos que o igual a. (C = 0) || (Z= 1)

signo).

GE 0b1010 Mayor o igual que (con signo). Mayor qué o igual a. N==V
LT 0b1011 Menos que (firmado). Menos que o desordenado. N!=V
GT 0b1100 Mayor que (firmado). Mas grande que. (Z==0) &&

(N==V)
LE 0b1101 Menor o igual que (firmado). Menor que, igual o desordenado. (Z==1)
||(N!=V)
Alabama
0b1110 Siempre ejecutado. Defecto. Siempre ejecutado. Ningún
NV 0b1111 Siempre ejecutado. Siempre ejecutado. Ningún
Nota
A64 añade NV (0b1111), aunque se comporta igual que su complemento, AL (0b1110). Esto es diferente en ARMv7-A
A32.
Hay un pequeño conjunto de instrucciones de procesamiento de datos condicionales. Estas instrucciones se

ejecutan incondicionalmente, pero utilizan los indicadores de condición (N, Z, C, V) como entrada adicional a la instrucción.
Por ejemplo:
SEÑORA X1, NZCV // copia las banderas N, Z, C y V en uso general x1

MOV X2, #0x30000000
BIC X1, X1, X2 // borra las banderas C y V (bits 29,28)
ORR X1,X1,#0xC0000000 // establece las banderas N y Z (bits 31,30)
MSR NZCV, X1 // copia x1 de nuevo en el registro NZCV para actualizar // los
indicadores de condición
Este conjunto se proporcionó para reemplazar el uso común de la ejecución condicional en el código ARM.
Los tipos de instrucciones que leen los indicadores de condición son:
Sumar/restar con acarreo Las instrucciones ARM tradicionales, por

ejemplo, para aritmética de precisión múltiple y sumas
de verificación.
Selección condicional con incremento, negación o inversión Seleccione condicionalmente entre un registro fuente
opcional y un segundo registro fuente incrementado, negado,
invertido o no modificado.
Nota
Estos son los usos más comunes de las instrucciones condicionales simples en A32 y T32. Los usos típicos incluyen
el conteo condicional o el cálculo del valor absoluto de una cantidad con signo.
Operaciones condicionales
A64 solo permite la ejecución condicional en instrucciones de bifurcación. Esto contrasta con A32 y T32, donde la mayoría de
las instrucciones se pueden usar con un código de condición. Las instrucciones A64 son:
Selección condicional (mover)

• CSEL Selecciona entre dos registros, en función de una condición. Instrucciones incondicionales, seguidas
por una selección condicional, puede reemplazar secuencias condicionales cortas.

Por ejemplo:
CSEL W1,W2,W3,EQ // Devuelve W2 a W0 si W3 y W2 son iguales.
• CSINC Selecciona entre dos registros, en base a una condición. Devuelve el primer registro fuente o el registro del operando
que se incrementa en uno. Esto es útil para controlar bucles de programa.
Por ejemplo:
CSINC X0, X1, X0, NE // Establece el registro de retorno X0 a X1 si Cero //

bandera limpia, de lo contrario incrementa X0
• CSINV Selecciona entre dos registros, en base a una condición. Devolver el primer registro fuente o
el registro de operando invertido.
• CSNEG Selecciona entre dos registros, en función de una condición. Devuelve el primer registro fuente o el registro del operando
negado.
conjunto condicional
Selecciona condicionalmente entre 0 y 1 (CSET) o 0 y -1 (CSETM). Se utiliza, por ejemplo, para establecer los indicadores de
condición como un valor booleano o una máscara en un registro general.
Comparación condicional
CMP y CMN establecen los indicadores de condición en el resultado de una comparación si la condición original es verdadera. Si
no es verdadero, los indicadores condicionales se establecen en un estado de indicador de condición especificado. La instrucción
de comparación condicional es útil para expresar comparaciones anidadas o compuestas.
La selección condicional y la comparación condicional también están disponibles para registros de punto flotante mediante las
instrucciones FCSEL y FCCMP .
Por ejemplo:
CINC X0, X0, LS // Si es menor o igual (LS) entonces X0 = X0 + 1

CSET W0, ecualizador // Si la comparación anterior fue igual
// (Z=1) entonces W0 = 1, si no W0 = 0
CSETM X0, NE // Si no es igual entonces X0 = -1, si no X0 = 0
Esta clase de instrucciones proporciona una forma poderosa de evitar el uso de ramas o instrucciones ejecutadas
condicionalmente. Los compiladores, o programadores ensambladores, pueden adoptar una técnica para realizar las
operaciones para ambas ramas de una instrucción if-then-else. Luego se selecciona el resultado correcto al final.
Por ejemplo, considere el código C:
si (i == 0) r = r + 2; de lo contrario r = r - 1;
Esto podría producir un código ensamblador similar a:
CMP W0, #0 // si (i == 0)
SUBW2, W1, #1 // r = r - 1
AGREGAR W1, W1, #2 // r = r + 2
CSEL W1, W1, W2, EQ // selecciona entre los dos resultados

3 Instrucciones de acceso a la memoria

La arquitectura ARMv8-A es una arquitectura de carga/almacenamiento, como todas las arquitecturas ARM anteriores. Este
significa que las instrucciones de procesamiento de datos no operan directamente sobre los datos en la memoria. Los datos
primero deben cargarse en registros, modificarse y luego almacenarse en la memoria. Una instrucción debe especificar una
dirección, el tamaño de los datos a transferir y un registro de origen o de destino. También hay instrucciones de carga y
almacenamiento que brindan un control adicional sobre cómo se accede a la memoria.
Las instrucciones de memoria pueden acceder a la memoria normal de forma no alineada. Esto no está respaldado por
accesos exclusivos, cargar adquirir o almacenar variantes de liberación. Si no se desean accesos no alineados, se pueden
configurar para fallar; sin embargo, la mayoría de los sistemas operativos reales (incluido Linux) no hacen esto. Los accesos
no alineados pueden ser útiles y muchos programas de espacio de usuario asumen que son posibles.
3.1 Formato de instrucción de carga
La forma general de una instrucción de carga es:
LDR Rt, <dirección>
Para cargas en registros de enteros, puede elegir un tamaño para cargar. Por ejemplo, para cargar un tamaño más pequeño
que el valor de registro especificado, agregue uno de los siguientes sufijos a la instrucción LDR:
• LDRB (8 bits, cero extendido).
• LDRSB (8 bits, signo extendido).
• LDRH (16 bits, cero extendido).
• LDRSH (16 bits, signo extendido).
• LDRSW (32 bits, signo extendido).
También hay formas de desplazamiento sin escala como LDUR<tipo>. Los programadores normalmente no tienen que usar el
formulario LDUR explícitamente, porque la mayoría de los ensambladores pueden seleccionar la versión adecuada, según el
desplazamiento utilizado.
No es necesario especificar una carga ampliada a cero en un registro X, porque al escribir en un registro W, efectivamente, el
cero se extiende a todo el ancho del registro, como se muestra en la siguiente figura:

LDRSB W4, <dirección> 8A Memoria.
firmar extender
00 00 00 00 FF FF FF 8A R4
LDRSB X4, <dirección> 8A Memoria.
firmar extender
FF FF FF FF FF FF FF 8A R4
LDRB W4, <dirección> 8A Memoria.
Extensión cero
00 00 00 00 00 00 00 8A R4
3.2 Formato de instrucciones de almacenamiento
La forma general de una instrucción Store es:
STR Rn, <dirección>
También hay formas de compensación sin escala como STUR<tipo>. Los programadores normalmente no tienen que usar el
formulario STUR explícitamente, ya que la mayoría de los ensambladores pueden seleccionar la versión adecuada, según el
desplazamiento utilizado.
El tamaño a almacenar puede ser más pequeño que el registro. Puede especificar esto agregando una B o una H
sufijo al STR. Siempre es la parte menos significativa del registro la que se almacena en tal caso.
3.3 SIMD (NEON) y cargas escalares de punto flotante y

historias
Las instrucciones de carga y almacenamiento también pueden acceder a registros SIMD y de coma flotante. En este
caso, el tamaño está determinado únicamente por el registro que se carga o almacena. que puede ser cualquiera de los
registros B, H, S, D o Q. Los bits de memoria leídos o escritos en cada caso se resumen en las siguientes tablas.
Para instrucciones de carga:
Carga Xn Wn qn Dn sn hn mil millones
LDR 64 32 128 64 32 dieciséis 9
PLD 128 64 256 128 64 - -
LDRB - 8 - - - - -
LDRH - dieciséis
- - - - -
LDRSB 8 8 - - - - -
LDRSH dieciséis dieciséis

- - - - -

LDRSW 32 - - - - - -
Para las instrucciones de la tienda:
Tienda Xn Wn qn Dn sn hn mil millones
FUERZA 64 32 128 64 32 dieciséis 8
STP 128 64 256 128 64 - -
STRB - 8 - - - - -
STRH - dieciséis
- - - - -
No hay opciones de extensión de signo disponibles para cargas en registros FP/SIMD. Las direcciones para tales cargas
todavía se especifican utilizando los registros de propósito general.
Por ejemplo:
LDR D0, [X0, X1] // Carga el registro D0 con la palabra doble en la // dirección de
memoria a la que apunta X0 más X1.
Las cargas y almacenes SIMD escalares y de punto flotante utilizan los mismos modos de direccionamiento que las cargas y
almacenes de enteros.
Por ejemplo:
LD1R {V1.8B}, [X1]
3.4 Especificación de la dirección para una instrucción Cargar

o Almacenar
Los modos de direccionamiento disponibles para A64 son similares a los de A32 y T32. Hay algunas restricciones
adicionales y algunas características nuevas, pero los modos de direccionamiento disponibles para A64 no sorprenderán a
alguien familiarizado con A32 o T32.
En A64, el registro base de un operando de dirección siempre debe ser un registro X. Sin embargo, varias instrucciones
admiten extensión cero o extensión de signo, de modo que se puede proporcionar un desplazamiento de 32 bits como un
registro W.

Modos de compensación
Los modos de direccionamiento compensado agregan un valor inmediato o un valor de registro modificado opcionalmente a un 64-
registro base de bits para generar una dirección.
Instrucción de ejemplo Descripción
LDR X0, [X1] Cargar desde la dirección en X1
LDR X0, [X1, #8] Cargar desde la dirección X1 + 8
LDR X0, [X1, X2] Cargar desde la dirección X1 + X2
LDR X0, [X1, X2, LSL, #3] Cargar desde la dirección X1 + (X2 << 3)
LDR X0, [X1, W2, SXTW] Cargar desde dirección X1 + extensión de signo (W2)
LDR X0, [X1, W2, SXTW, #3] Carga desde la dirección X1 + (signo extendido (W2) << 3)
Tabla 12 Modos de direccionamiento de compensación
Al especificar una opción de turno o extensión, la cantidad de turno puede ser 0 (el valor predeterminado) o log2
del tamaño de acceso en bytes (de manera que Rn << <shift> multiplica Rn por el tamaño de acceso). Esto admite operaciones
comunes de indexación de matrices.
// Ejemplo de CA que muestra los accesos que es probable que //

genere un compilador.
void ejemplo_dup(int32_t a[], int32_t longitud)

{
int32_t primero = a[0]; // LDR W3, [X0]
para (int32_t i = 1; i <longitud; i++)
{
a[i] = primero; } // FUERZA W3, [X0, W2, SXTW, #2]
Modos de índice
Los modos de índice son similares a los modos de compensación, pero también actualizan el registro base. La sintaxis es la misma
que en A32 y T32, pero el conjunto de operaciones es más restrictivo. Por lo general, solo se pueden proporcionar compensaciones
inmediatas para los modos de índice.
Hay dos variantes:
• Modos de preíndice, que aplican el desplazamiento antes de acceder a la memoria.
• Modos post-índice, que aplican el desplazamiento después de acceder a la memoria.

Los modos de direccionamiento de compensación se muestran en la siguiente tabla:
LDR X0, [X1, #8]! Preíndice: actualice X1 primero (a X1 + #8), luego cargue desde
la nueva dirección
LDR X0, [X1], #8 Post-índice: Cargue primero desde la dirección no modificada en

X1, luego actualice X1 (a X1 + #8)
STP X0, X1, [SP, #-16]! Empuje X0 y X1 a la pila.
LDP X0, X1, [SP], #16 Extraiga X0 y X1 de la pila.
Estas opciones se asignan limpiamente a algunas operaciones comunes de C:
// Ejemplo en C que muestra los accesos que es probable que genere un compilador.
void ejemplo_strcpy(char * dst, const char * src)

{
carácter c;
hacer {
c = *(fuente++); // LDRB W2, [X1], #1

*(dst++) = c; } // STRB W2, [X0], #1
mientras (c != '\0');
}
3.5 Pools literales

Un grupo literal es un área de datos constantes que se encuentra dentro de la sección de código, generalmente después
del final de una función y antes del comienzo de otra. Los grupos no se ejecutan, pero se puede acceder a sus datos
desde el código circundante utilizando direcciones de memoria relativas a la PC. Las agrupaciones literales a menudo se
usan para codificar valores constantes que no encajan en una instrucción simple de movimiento inmediato.
A64 tiene otro modo de direccionamiento específicamente para acceder a grupos literales. En A32 y T32, la PC se puede
leer como un registro de propósito general, por lo que se puede acceder a un grupo literal simplemente especificando PC
como el registro base.

Cargas relativas a PC
En AArch64, la PC no es accesible y se trata de manera diferente a los registros de propósito general; hay un modo de
direccionamiento especial para las instrucciones de carga que accede a una dirección relativa a la PC. Este modo de
direccionamiento de propósito especial tiene un rango mucho mayor que el que podrían lograr las cargas relativas a la PC
en A32 y T32, por lo que puede haber menos grupos literales y más espaciados. El uso de los modos relativos a la PC se
muestra en la siguiente tabla:
LDR W0, <etiqueta> Cargue 4 bytes de <etiqueta> en W0a
LDR X0, <etiqueta> Cargue 8 bytes de <etiqueta> en X0
LDRSW X0, <etiqueta> Cargue 4 bytes desde <label> y firme-extienda en X0
LDR S0, <etiqueta> Cargue 4 bytes de <etiqueta> en S0
LDR D0, <etiqueta> Cargue 8 bytes de <etiqueta> en D0
LDR Q0, <etiqueta> Cargue 16 bytes de <etiqueta> en Q0
Nota
<label> debe tener una alineación de 4 bytes para todas las variantes.
3.6 Acceder a múltiples ubicaciones de memoria

A64 proporciona las instrucciones Cargar par (LDP) y Almacenar par (STP) . Los datos se leen o escriben en o desde
ubicaciones de memoria adyacentes. Las opciones de modo de direccionamiento que se proporcionan para estas
instrucciones son más restrictivas que para otras instrucciones de acceso a la memoria. LDP y STP
Las instrucciones solo pueden usar un registro base con un valor inmediato escalado de 7 bits con signo, con incremento
previo o posterior opcional. Los accesos no alineados son posibles para LDP y STP, a diferencia del LDRD de 32 bits
y STRD como se muestra en la siguiente tabla:
Par de carga y almacenamiento Descripción
LDP W3, W7, [X0] W3 = W3 + X0
W7 = W7 + (X0 + 4)
LDP X8, X2, [X0, #0x10]! X0 = X0 + 0x10
X8 =(X0)
X2 =(X0 + 8)
LDP X8, X2, [X0], #0x10 Carga la palabra doble en la dirección X0 en X8 y la palabra doble en la dirección
X11 + 8 en D2 y agrega 0x10 a X11.
X8 = X0
X2 = (X11 + 8)
X11 = X11 + 0x10
LDPSW X3, X4, [X0] Carga la palabra en la dirección X0 en X3 y la palabra en la dirección X0 + 4

en X4, y el signo se extiende a ambos al tamaño de palabra doble.
STP X9, X8, [X4] Almacena la palabra doble en X9 para la dirección X4 y almacena la
palabra doble en X8 para la dirección X4 + 8.

X0 + 4 X0
4 bytes 4 bytes
63 3231 0
W7 W3
LDP W3, W7 [X0]
X0 + 4 X0
4 bytes 4 bytes
63 3231 0
W7 W3
LDP X8, X2, [X0 + #0x10]!
3.7 Acceso no privilegiado
Las instrucciones A64 LDTR y STTR realizan una carga o almacenamiento sin privilegios:
• En EL0, EL2 o EL3, se comportan como Cargas o Almacenes normales.
• Cuando se ejecutan en EL1, se comportan como si se ejecutaran en el nivel de privilegio EL0. Se pueden usar para eliminar la referencia
de los punteros que se proporcionan con las llamadas al sistema, lo que permite que el sistema operativo se asegure de que solo
se acceda a los datos accesibles para la aplicación.
3.8 Recuperación previa de la memoria
Prefetch from Memory (PRFM) proporciona una pista al sistema de memoria de que el programa utilizará pronto los datos de una
dirección en particular. El efecto de esta sugerencia generalmente da como resultado que se carguen datos o instrucciones en uno
de los cachés.
La sintaxis de la instrucción es:
PRFM <prfop>, <dirección> | etiqueta
Donde prfop es una concatenación de las siguientes opciones:
Escribe PLD o PST (precarga para carga o almacenamiento).
Objetivo L1, L2 o L3 (a qué caché apuntar).

Política MANTENER o STRM (mantener en caché o transmisión de datos).
Por ejemplo, PLDL1KEEP.

3.9 Par de carga y almacenamiento no temporal

ARMv8-A incluye las instrucciones LDNP y STNP, o carga y almacenamiento no temporales. Estas
realizar una lectura o escritura de un par de valores de registro y dar una pista al sistema de memoria de que el almacenamiento en
caché no es útil para estos datos. La sugerencia no prohíbe la actividad del sistema de memoria, como el almacenamiento en caché
de la dirección, la precarga o la recopilación, sino que simplemente indica que es poco probable que el almacenamiento en caché
aumente el rendimiento.
Las cargas y almacenes no temporales relajan los requisitos de ordenación de la memoria. En el siguiente ejemplo, los accesos a la
memoria pueden ser observados en cualquier orden por los demás observadores dentro del dominio de compartibilidad de las direcciones
de memoria a las que se accede.
LDR X0, [X3]

LDNP X2, X1, [X0] // Es posible que los observadores externos no
observen // las cargas en orden (donde todos // los
observadores están en el mismo dominio // interno
compartible.
Para que un observador externo observe las cargas en orden, se debe utilizar una barrera explícita:
LDR X0, [X3]

DMB isld // La barrera obliga a que los accesos anteriores a la
memoria // se completen antes de otros accesos.
LDNP X2, X1, [X0]
3.10 Atomicidad del acceso a la memoria

Se garantiza que un acceso a la memoria alineado, utilizando un solo registro de propósito general, sea atómico. (No se puede interrumpir
una operación de memoria atómica de carga-modificación-almacenamiento). Se garantiza que las instrucciones de par de carga y par de
almacenamiento en un par de registros de propósito general, utilizando una dirección de memoria alineada, aparecerán como dos accesos
atómicos individuales. Los accesos no alineados no son atómicos, ya que normalmente requieren dos accesos separados. Además, no se
garantiza que los accesos a la memoria SIMD y de punto flotante sean atómicos.
3.11 Instrucciones de barrera de memoria

Tanto ARMv7-A como ARMv8-A brindan soporte para diferentes operaciones de barrera.
• Barrera de Memoria de Datos (DMB). Esto obliga a que todos los accesos a la memoria anteriores en el orden del programa se
vuelvan visibles globalmente antes de cualquier acceso posterior.
Por ejemplo:
LDR X0, [X3]

DMB isld // La instrucción de barrera fuerza los accesos previos a la memoria
// para completar antes de más accesos.
LDNP X2, X1, [X0]
• Barrera de sincronización de datos (DSB). Todas las cargas y almacenes pendientes, mantenimiento de caché
instrucciones, se completan antes de que continúe la ejecución del programa. Un DSB se comporta como un DMB, pero es más
restrictivo. La ejecución del código se detiene, mientras que DMB solo detiene el acceso a la memoria.

• Barrera de sincronización de instrucciones (ISB). Esta instrucción vacía la canalización central y

búferes de captación previa, lo que hace que las instrucciones posteriores al ISB se obtengan (o recuperen) de la memoria caché
o la memoria.
ARMv8-A introduce barreras unilaterales, que están asociadas con el modelo de consistencia de lanzamiento.
Se denominan instrucciones Load-Acquire (LDAR) y Store-Release (STLR) y son primitivas de sincronización basadas en direcciones. Solo
se admite el direccionamiento de registro base para estas instrucciones, no se proporcionan compensaciones ni otros tipos de
direccionamiento indexado.
3.12 Primitivas de sincronización

Las arquitecturas ARMv7-A y ARMv8-A brindan soporte para accesos exclusivos a la memoria. En A64, esto se logra con el par
exclusivo Load/Store (LDXR/STXR) .
También hay instrucciones de liberación de adquisición/almacenamiento de carga (LDAXR y STLXR).
La instrucción LDXR carga un valor de una dirección de memoria e intenta reclamar un bloqueo exclusivo en la dirección. La instrucción
Store-Exclusive luego escribe un nuevo valor en esa ubicación, pero solo si el bloqueo se obtuvo y retuvo con éxito.
El emparejamiento LDXR/STXR se utiliza para construir primitivas de sincronización estándar, como spinlocks. Se proporciona un conjunto
emparejado de instrucciones LDXRP y STXRP para permitir que el código actualice atómicamente una ubicación que abarca dos registros.
Las opciones de byte, media palabra, palabra y doble palabra están disponibles. Al igual que el emparejamiento Load Acquire/Store
Release, solo se admite el direccionamiento de registro base, sin compensaciones.
En hardware, el núcleo incluye un dispositivo que se denomina monitor local. Este monitor observa el bus de direcciones. Cuando el núcleo
realiza un acceso de carga exclusivo, registra ese hecho. Cuando realiza un almacenamiento exclusivo, comprueba que se realizó una
carga exclusiva anterior y, de no ser así, falla el almacenamiento exclusivo. La arquitectura permite que las implementaciones individuales
determinen el nivel de verificación realizado por el monitor, como se muestra en la siguiente figura:
STXR FALLAR LDXR LDXR
Abierto Exclusivo
STXRPASS o CLREX
O STXR a la ubicación
monitoreada por otro hilo
La instrucción CLREX borra los monitores, pero a diferencia de ARMv7-A, la entrada o retorno de excepción también hace lo mismo. El
monitor también se puede borrar por error, por ejemplo, por desalojos de caché u otras razones que no están directamente relacionadas
con la aplicación. El software debe evitar tener accesos explícitos a la memoria, actualizaciones de registros de control del sistema o
instrucciones de mantenimiento de caché entre instrucciones LDXR y STXR emparejadas .

4 Control de flujo
Las instrucciones A64 generalmente proporcionan compensaciones más largas, tanto para bifurcaciones relativas a PC como para direccionamiento de
compensaciones.
El rango de ramificación aumentado facilita la gestión de los saltos de intersección. El código generado dinámicamente se
coloca en el montón para que, en la práctica, se pueda ubicar en cualquier lugar. Es mucho más fácil para el sistema de
tiempo de ejecución administrar los saltos de intersección con menos requisitos para insertar carillas (código adicional para
restablecer el contador del programa).
La necesidad de grupos literales (bloques de datos que están incrustados en el flujo de código) ha sido durante mucho
tiempo una característica de los conjuntos de instrucciones ARM. Esto todavía existe en A64. Sin embargo, el mayor
desplazamiento de carga relativo a la PC ayuda considerablemente con la administración de grupos literales, lo que hace
posible usar uno por unidad de compilación. Esto elimina la necesidad de fabricar ubicaciones para múltiples grupos en código largo
secuencias.
El conjunto de instrucciones A64 proporciona varios tipos de instrucciones de bifurcación, como se muestra en la siguiente
tabla. Para bifurcaciones relativas simples, es decir, aquellas a un desplazamiento de la dirección actual, se usa la
instrucción B.
Las bifurcaciones relativas simples incondicionales pueden bifurcarse hacia atrás o hacia adelante hasta 128 MB desde
la ubicación actual del contador del programa. Las ramas relativas simples condicionales, donde se agrega un código de
condición a la B, tienen un rango más pequeño de ± 1 MB.
Las llamadas a subrutinas, donde la dirección de retorno debe almacenarse en el registro de enlace (X30), usan la
instrucción BL . Esto no tiene una versión condicional. BL se comporta como una instrucción B con el efecto adicional de
almacenar la dirección de retorno, que es la dirección de la instrucción después de BL, en el registro X30.
Además de estas instrucciones relativas a PC, A64 incluye dos ramas absolutas. El BR Xn
La instrucción realiza una bifurcación absoluta a la dirección en Xn mientras que BLR Xn tiene el mismo efecto, pero también
almacena la dirección de retorno en X30 (el registro de enlace). La instrucción RET se comporta como BR Xn, pero sugiere a
la lógica de predicción de bifurcación que es un retorno de función. RET se bifurca a la dirección en X30 de forma
predeterminada, aunque se pueden especificar otros registros.

Las instrucciones de bifurcación se muestran en la siguiente tabla:
Instrucciones de rama
B (desplazamiento) Programa rama relativa adelante o atrás 128 MB. Una versión condicional, por ejemplo B.EQ, tiene un rango de 1 MB.
BL (compensación) Como B , pero almacene la dirección de retorno en X30 e insinúe a la lógica de predicción bifurcada que esto
es una llamada de función.
BR Xn Rama absoluta a dirección en Xn.
BLR Xn Como BR , pero almacena la dirección de retorno en X30 y sugiere a la lógica de predicción de bifurcación que se
trata de una llamada de función.
RET{Xn} Como BR, pero sugiera a la lógica de predicción de bifurcación que se trata de un retorno de función. Vuelve a la dirección
en X30 por defecto, pero se puede especificar un registro diferente.
Instrucciones de bifurcación condicional
B.cond Rama condicional hacia adelante o hacia atrás. Por ejemplo B.EQ, tiene un rango de 1 MB. La rama solo se toma si la
condición es verdadera (para el valor actual de NZCV).
A64 incluye algunas ramas condicionales especiales. Estos permiten una densidad de código mejorada porque no es necesaria una
comparación explícita.
CBZ Rt, etiqueta // Comparar y bifurcar si es cero
CBNZ Rt, etiqueta // Comparar y bifurcar si no es cero
Ambas instrucciones comparan el registro fuente, ya sea de 32 bits o de 64 bits, con cero y luego realizan una bifurcación condicional. El
desplazamiento de rama tiene un rango de ± 1 MB. Estas instrucciones no leen ni escriben los indicadores de código de condición (NZCV).
Hay dos instrucciones similares de prueba y bifurcación.
TBZ Rt, bit, etiqueta // Probar y bifurcar si Rt<bit> cero
TBNZ Rt, bit, etiqueta // Probar y bifurcar si Rt<bit> no es cero
Estas instrucciones prueban el bit en el registro de origen en la posición de bit especificada por el valor del bit y se bifurcan
condicionalmente dependiendo de si el bit está establecido o borrado. El desplazamiento de rama tiene un rango de ±32kB. Al igual que con
CBZ y CBNZ, no leen ni escriben los indicadores de código de condición.

5 Control del sistema y otras instrucciones

A64 contiene instrucciones relacionadas con:
• Manejo de excepciones.
• Acceso al registro del sistema.
• Depuración.
• Instrucciones de sugerencias, que en muchos sistemas tienen aplicaciones de administración de energía.
5.1 Instrucciones generadoras de excepciones

Hay tres instrucciones que hacen que se tome una excepción. Estos se utilizan para hacer una llamada.
al código que se ejecuta en un nivel de excepción superior en el sistema operativo (EL1), el hipervisor (EL2) o el monitor
seguro (EL3):
SVC #imm16 // Llamada al supervisor, permite la aplicación

// programa para llamar al kernel (EL1).
HVC #imm16 // Llamada de hipervisor, permite que el código del sistema operativo llame al
// hipervisor (EL2).
SMC #imm16 // llamada Secure Monitor, permite que el sistema operativo o

// hipervisor para llamar a Secure Monitor (EL3).
Cuando la excepción generada se toma en AArch64, el valor #imm16 (inmediato) se pone a disposición del controlador en el
Registro de Síndrome de Excepción.
5.2 Instrucciones de devolución de excepción

La instrucción que se utiliza para generar una devolución de excepción depende del estado de ejecución en el que se
ejecuta la instrucción.
Del estado AArch64

Para generar una devolución de excepción, el software ejecuta la instrucción ERET . El estado del procesador se
restaura copiando SPSR_ELn a PSTATE. Luego, la ejecución comienza en la dirección que se encuentra en el registro
ELR_ELn para el nivel de excepción en el que se ejecutó la instrucción ERET .
5.3 Acceso al registro del sistema

Se proporcionan dos instrucciones para el acceso al registro del sistema:
MRS Xt, <registro del sistema> // Esto copia un registro del sistema en un // registro
de propósito general
Por ejemplo

SEÑORA X4, ELR_EL1 // Copia ELR_EL1 a X4
MSR <registro del sistema>, Xt // Esto copia un registro de propósito general // en un registro
del sistema
Por ejemplo
MSR SPSR_EL1, X0 // Copia X0 a SPSR_EL1
También se puede acceder a campos individuales de PSTATE con MSR o MRS. Por ejemplo, para seleccionar
el puntero de pila asociado con EL0 o el nivel de Excepción actual:
MSR SPSel, #imm // Para el valor #imm #0, SPSEL se establece en 0 //

seleccionando el puntero de pila EL0
// Para el valor #imm #1, SPSEL se establece en 1 //
seleccionando el puntero de pila // del nivel de excepción actual.
Hay formas especiales de estas instrucciones que se pueden usar para borrar o establecer bits de máscara de excepción
individuales.
MSR DAIFClr, #imm4
Conjunto MSR DAIF, #imm4
5.4 Instrucciones de depuración
Hay dos instrucciones relacionadas con la depuración:
Hay dos instrucciones relacionadas con la depuración:
BRK #imm16 // Genera una instrucción de punto de interrupción //

excepción. Establece ESR_ELx en valor EC // 0x3c y
establece ESR_ELx.ISS en #imm16
HLT #imm16 // #imm es ignorado por el hardware ARM pero // puede usarse
para almacenar información sobre // el punto de interrupción para
un depurador
5.5 Instrucciones de sugerencias
Las instrucciones HINT pueden tratarse legalmente como NOP, pero pueden tener efectos específicos de implementación.
HINT tiene la sintaxis:
PISTA #imm
Dónde:

#imm es un valor inmediato sin signo de 7 bits que identifica el tipo de instrucción, como se muestra en la siguiente tabla:
#imm Instrucción Descripción
0 NOP Sin operación: no se garantiza que tarde en ejecutarse
1 RENDIR Sugerencia de que el subproceso actual está realizando una tarea que se puede intercambiar
2 WFE Esperar evento
3 WFI Esperar por interrupción
4 SEV Enviar evento
5 SEVL Enviar evento local
5.6 Instrucciones SIMD

Las instrucciones SIMD (también llamadas instrucciones NEON) tienen varios cambios, algunos de los cuales son
significativos.
• Las instrucciones AArch64 SIMD (NEON) no tienen el prefijo V presente en AArch32 NEON
instrucciones.
• Hay soporte para punto flotante de doble precisión, lo que permite que el código C use doble precisión
punto flotante para ser vectorizado.
Están ahora:
• Instrucciones de coma flotante vectorial y escalar de coma flotante.
• Instrucciones para operar sobre datos escalares que se almacenan en registros NEON.
• Instrucciones para insertar y extraer elementos vectoriales.
• Instrucciones para conversión de tipos y saturación de aritmética de enteros.
• Instrucciones para la normalización de valores de punto flotante.
• Instrucciones de carril cruzado para la reducción de vectores, la suma y la toma del mínimo o máximo
valor.
• Instrucciones para realizar acciones como comparar, sumar, encontrar un valor absoluto y negar, para
operar en elementos enteros de 64 bits.
5.7 Instrucciones de punto flotante

A64 proporciona un conjunto similar de instrucciones de coma flotante a las de la extensión ARMv7-A VFPv4, que proporciona
operaciones matemáticas de precisión simple y doble en valores escalares de coma flotante.
Hay varios cambios y nuevas características:
• Las comparaciones de punto flotante establecen los indicadores de condición (NZCV) directamente. En A64, no hay necesidad de
transfiera explícitamente los resultados de la comparación de banderas de punto flotante a enteros.

• Instrucciones relacionadas con el estándar IEEE754-2008, por ejemplo para calcular el mínimo y
máximo de un par de números.
• Se puede especificar explícitamente un modo de redondeo al convertir formatos de números enteros a puntos flotantes. Ya
no es necesario configurar las banderas FPCR globales cuando se requieren conversiones simples en un modo de
redondeo particular. Algunas de estas opciones también están disponibles para ARMv8-A A32 y T32.
• Instrucciones para admitir conversiones entre enteros de 64 bits y formatos de coma flotante.
• En A64, las operaciones de coma flotante que implican tipos de enteros funcionan directamente en registros de enteros.
No es necesario transferir valores enteros manualmente entre registros de punto flotante y enteros para operaciones
de conversión.
5.8 Instrucciones criptográficas

A medida que se amplía el uso de la tecnología informática, la seguridad se está convirtiendo en una preocupación.
Existen requisitos para garantizar la privacidad, para evitar que la información caiga en manos equivocadas y para permitir prácticas
comerciales seguras y sólidas.
Hay dos aspectos para proporcionar seguridad en un sistema o dispositivo informático moderno:
1. Reforzar un dispositivo informático para evitar el acceso no autorizado a datos o recursos informáticos de
el sistema.
2. Garantizar que los datos o la información que se envía a través de una red permanezcan protegidos en tránsito y solo sean
accesibles para su destino previsto.
La tecnología ARM TrustZone proporciona mecanismos de hardware para garantizar la seguridad a nivel de nodo.
Se han definido varios protocolos y algoritmos en el software para proteger la información y evitar el acceso no autorizado
a los datos confidenciales. La criptografía es la ciencia específica de proteger la información y los algoritmos criptográficos se
utilizan ampliamente en los protocolos de seguridad.
Hay cuatro aspectos principales en un protocolo de comunicación seguro.
Intercambio de llaves El mecanismo de intercambio de claves define cómo se pueden intercambiar las claves
utilizadas para cifrar y descifrar datos.
autenticación de entidad La autenticación de entidad ayuda a afirmar la identidad de las dos partes que se
comunican
Transferencia de mensajes Esta es la fase en la que los datos reales se cifran y transfieren a través del canal de
comunicación.
Autenticación de mensajes Se refiere a los mecanismos empleados para asegurar que el

los datos/información no fueron manipulados mientras estaban en tránsito.
Los algoritmos de cifrado de bloques simétricos como AES se utilizan para el cifrado de datos durante la fase de transferencia de
mensajes y los algoritmos hash como SHA se utilizan para la autenticación de mensajes.
Las instrucciones criptográficas son una extensión opcional para ARMv8-A. Estas instrucciones criptográficas son funciones
de "ayuda" que requieren software para garantizar que lleven a cabo la operación completa.
Mejoran significativamente el rendimiento en tareas como el cifrado AES y el hash SHA1 y SHA256.

Otro aspecto importante de la seguridad es asegurarse de que está ejecutando el código correcto. Para ello,
Trustzone proporciona un arranque seguro. Se establece una cadena de confianza, comenzando con hardware de
confianza implícita.
Cada etapa del arranque utiliza las funciones auxiliares criptográficas para autenticar la siguiente etapa antes de
ejecutar el código. Los proveedores de confianza firman cualquier actualización de código y las instrucciones
criptográficas también se utilizan para mejorar el rendimiento al verificar estas firmas.

3 Isa Armv8-A Brief

Cargado por

Copyright:

Formatos disponibles

3 Isa Armv8-A Brief

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

3 Isa Armv8-A Brief

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

El conjunto de instrucciones A64

El conjunto de instrucciones A64

Se han realizado las siguientes revisiones a esta Guía del usuario.

Fecha Tema Confidencialidad Cambio

03 marzo 2017 0100 No confidencial Primer lanzamiento

El producto descrito en este documento está sujeto a continuos desarrollos y mejoras.

El acceso sin restricciones es una clasificación interna de ARM.

Estado del producto

La información de este documento es definitiva, es decir, para un producto desarrollado.

Página 2 de 35 BRAZO 100898_0100_es

El conjunto de instrucciones A64

1 El conjunto de instrucciones A64 ........................................... .................................................... ............................................. 5

1.1 Nemotécnicas de instrucción .................................................. .................................................... ...................................... 5

Distinguir entre instrucciones A64 de 32 bits y de 64 bits.................................... .......................................... 5

2 Instrucciones para el procesamiento de datos .................................................. .................................................... ............................... 7

2.1 Operaciones aritméticas y lógicas .................................................. .................................................... ..................... 7

2.2 Instrucciones para multiplicar................................................. .................................................... .......................................... 9

2.3 Dividir instrucciones ................................................. .................................................... .......................................... 10

2.4 Operaciones de cambio................................................. .................................................... .................................................. 11

2.5 Operadores de turno ................................................ .................................................... .................................................... 11

2.6 Instrucciones de manipulación de bytes y campos de bits .................................. .................................................... .... 13

Operadores de extensión................................................. .................................................... .................................................... ...... 15

2.7 Instrucciones condicionales................................................. .................................................... .................................... 17

Operaciones condicionales................................................. .................................................... ............................................. 18

Selección condicional (mover) ............................................... .................................................... .......................................... 18

Conjunto condicional................................................. .................................................... .................................................... .......... 19

Comparación condicional ................................................ .................................................... .......................................................... 19

3 Instrucciones de acceso a la memoria ............................................. .................................................... ............................... 20

3.1 Formato de instrucción de carga .................................................. .................................................... .................................... 20

3.2 Almacenar formato de instrucción .............................................. .................................................... .................................... 21

Modos de compensación.................................................. .................................................... .................................................... ............. 23

Modos de índice.................................................. .................................................... .................................................... ............... 23

3.5 Piscinas literales .................................................. .................................................... .................................................... ..... 24

Cargas relativas a la PC ............................................... .................................................... .................................................... ......... 25

3.6 Acceder a varias ubicaciones de memoria.................................................... .................................................... ............ 25

3.7 Acceso no privilegiado .............................................. .................................................... .......................................... 26

3.8 Recuperación previa de la memoria .................................................. .................................................... .......................................... 26

3.9 Par de carga y almacenamiento no temporal ........................................... .................................................... ..................... 27

3.10 Atomicidad de acceso a la memoria........................................... .................................................... .................................... 27

3.11 Instrucciones de la barrera de memoria.................................... .................................................... ............................. 27

3.12 Primitivas de sincronización.................................................... .................................................... ............................... 28

4 Control de flujo ................................................ .................................................... .................................................... ........ 29

Página 3 de 35 BRAZO 100898_0100_es

El conjunto de instrucciones A64

5 Control del sistema y otras instrucciones.................................................... .................................................... .......... 31

5.1 Instrucciones de generación de excepciones .................................................. .................................................... .................... 31

5.2 Instrucciones de devolución de excepción ................................. .................................................... ......................... 31

Del estado AArch64 ............................................... .................................................... .................................................... 31

5.3 Acceso al registro del sistema .................................................. .................................................... ...................................... 31

5.4 Instrucciones de depuración ............................................... .................................................... ............................................. 32

5.5 Sugerencias de instrucciones .................................................. .................................................... ............................................... 32

5.6 Instrucciones SIMD................................................... .................................................... ............................................. 33

5.7 Instrucciones de coma flotante.................................................... .................................................... ............................. 33

5.8 Instrucciones criptográficas................................................. .................................................... ............................. 34

Página 4 de 35 BRAZO 100898_0100_es

El conjunto de instrucciones A64

1 El conjunto de instrucciones A64

• Partes del código de inicio.