Intrinsèques ARM64

Le compilateur Microsoft C++ (MSVC) rend les intrinsèques suivantes disponibles sur l’architecture ARM64. Pour plus d’informations sur ARM, consultez les sections Outils de développement logiciel et d’architecture du site web de la documentation des développeurs ARM.

NÉON

Les extensions du jeu d’instructions vectorielles NEON pour ARM64 fournissent des fonctionnalités SIMD (Single Instruction Multiple Data). Ils ressemblent à ceux des jeux d’instructions vectorielles MMX et SSE communs aux processeurs d’architecture x86 et x64.

Les intrinsèques NEON sont prises en charge telles qu'elles sont fournies dans le fichier d'en-tête arm64_neon.h. La prise en charge de MSVC pour les intrinsèques NEON ressemble à celle du compilateur ARM64, qui est documentée dans la référence intrinsèque ARM NEON sur le site web arm Infocenter.

Liste des intrinsèques propres à ARM64

Les intrinsèques propres à ARM64 sont prises en charge, comme indiqué dans le fichier intrin.hd’en-tête .

[Retour en haut]

Restrictions relatives aux barrières de mémoire

Les fonctions __dmb intrinsèques (barrière de mémoire des données), __dsb (barrière de synchronisation des données) et __isb (barrière de synchronisation des instructions) utilisent les valeurs prédéfinies suivantes pour spécifier la restriction de barrière de mémoire en termes de domaine de partage et le type d’accès affecté par l’opération.

Pour l’intrinsèque __isb , la seule restriction actuellement valide est _ARM64_BARRIER_SY ; toutes les autres valeurs sont réservées par l’architecture.

intrinsèques __iso_volatile_load/store

Ces fonctions intrinsèques effectuent explicitement des charges et des magasins qui ne sont pas soumis à des optimisations du compilateur.

__int16 __iso_volatile_load16(const volatile __int16 * Location);
__int32 __iso_volatile_load32(const volatile __int32 * Location);
__int64 __iso_volatile_load64(const volatile __int64 * Location);
__int8 __iso_volatile_load8(const volatile __int8 * Location);

void __iso_volatile_store16(volatile __int16 * Location, __int16 Value);
void __iso_volatile_store32(volatile __int32 * Location, __int32 Value);
void __iso_volatile_store64(volatile __int64 * Location, __int64 Value);
void __iso_volatile_store8(volatile __int8 * Location, __int8 Value);

Paramètres

Lieu
L'adresse d'un emplacement mémoire où lire ou dans lequel écrire.

Valeur
Valeur à écrire dans l’emplacement de mémoire spécifié (stockez uniquement les intrinsèques).

Valeur de retour (intrinsèques de charge uniquement)

Valeur de l’emplacement de mémoire spécifié par Emplacement.

Notes

Vous pouvez utiliser les __iso_volatile_load8/16/32/64 et __iso_volatile_store8/16/32/64 les intrinsèques pour effectuer explicitement des accès à la mémoire qui ne sont pas soumis à des optimisations du compilateur. Le compilateur ne peut pas supprimer, synthétiser ou modifier l’ordre relatif de ces opérations. Toutefois, elle ne génère pas de barrières de mémoire matérielle implicites. Par conséquent, le matériel peut toujours réorganiser les accès mémoire observables entre plusieurs threads. Plus précisément, ces intrinsèques sont équivalentes aux expressions suivantes, comme compilées sous /volatile :iso.

int a = __iso_volatile_load32(p);    // equivalent to: int a = *(const volatile __int32*)p;
__iso_volatile_store32(p, a);        // equivalent to: *(volatile __int32*)p = a;

Notez que les intrinsèques prennent des pointeurs volatiles de façon à pouvoir traiter des variables volatiles. Toutefois, il n’existe aucune exigence ou recommandation d’utiliser des pointeurs volatiles en tant qu’arguments. La sémantique de ces opérations est exactement la même si un type normal et non volatile est utilisé.

Pour plus d’informations sur l’argument de ligne de commande /volatile :iso , consultez /volatile (interprétation de mot clé volatile).

Prise en charge d’ARM64 pour les intrinsèques d’autres architectures

Le tableau suivant répertorie les intrinsèques d’autres architectures prises en charge sur les plateformes ARM64. Lorsque le comportement d’une intrinsèque sur ARM64 diffère de son comportement sur d’autres architectures matérielles, des détails supplémentaires sont notés.

[Retour en haut]

Intrinsèques verrouillées

Les intrinsèques à blocage sont un ensemble d'intrinsèques qui sont utilisées pour effectuer des opérations de lecture-modification-écriture atomiques. Certaines d'entre elles sont communes à toutes les plateformes. Ils sont répertoriés séparément ici parce qu’il y a un grand nombre d’entre eux. Étant donné que leurs définitions sont principalement redondantes, il est plus facile de les considérer en termes généraux. Leurs noms peuvent être utilisés pour en dériver les comportements exacts.

Le tableau suivant récapitule la prise en charge d’ARM64 des intrinsèques non-bittest interlockées. Chaque cellule du tableau correspond à un nom qui est constitué en ajoutant le nom de l'opération dans la cellule la plus à gauche de la ligne et le nom de type dans la cellule la plus en haut de la colonne à _Interlocked. Par exemple, la cellule à l’intersection de la ligne et de la Xor 8 colonne correspond _InterlockedXor8 et est entièrement prise en charge. La plupart des fonctions prises en charge peuvent comporter ces suffixes facultatifs : _acq, _rel et _nf. Le suffixe _acq indique une sémantique correspondant à « acquérir » et le suffixe _rel indique une sémantique correspondant à « libérer ». Le _nf suffixe ou « sans clôture » est unique à ARM et ARM64 et est abordé dans la section suivante.

Clé :

• Complet : prend en charge les formes simples, _acq, _relet _nf les formulaires.

• Aucun : Non pris en charge

suffixe _nf (aucune clôture)

Le _nf suffixe ou « aucune clôture » indique que l’opération ne se comporte pas comme n’importe quel type de barrière de mémoire, contrairement aux trois autres formes (simples, _acqet _rel), qui se comportent tous comme un type de barrière. L’une des utilisations possibles des _nf formulaires consiste à conserver un compteur de statistiques mis à jour par plusieurs threads en même temps, mais dont la valeur n’est pas utilisée autrement pendant l’exécution de plusieurs threads.

Liste des intrinsèques interblocées

[Retour en haut]

intrinsèques _interlockedbittest

Les intrinsèques de test de bits interblocées simples sont communes à toutes les plateformes. ARM64 ajoute _acq, _relet _nf variantes, qui modifient simplement la sémantique de barrière d’une opération, comme décrit dans _nf (aucune clôture) Suffixe plus haut dans cet article.

[Retour en haut]

Voir aussi

Intrinsèques du compilateur
Intrinsèques ARM
Informations de référence sur l’assembleur ARM
Informations de référence sur le langage C++