Intrinsèques ARM

Le compilateur Microsoft C++ (MSVC) rend les intrinsèques suivantes disponibles sur l’architecture ARM. 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 de jeu d’instructions vectorielles NEON pour ARM fournissent des fonctionnalités SIMD (Single Instruction Multiple Data) qui ressemblent à celles 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 arm_neon.h. La prise en charge de MSVC pour les intrinsèques NEON ressemble à celle du compilateur ARM, qui est documentée dans l’annexe G de la chaîne d’outils du compilateur ARM, version 4.1 du compilateur de référence sur le site web ARM Infocenter.

La principale différence entre MSVC et le compilateur ARM est que MSVC ajoute _ex des variantes de la vldX vstX charge vectorielle et des instructions de stockage. Les variantes _ex prennent un paramètre supplémentaire qui spécifie l'alignement de l'argument pointeur. À part cette différence, elles sont identiques à leurs équivalents non-_ex.

Liste des intrinsèques propres à ARM

[Retour en haut]

Restrictions relatives à la barrière 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 _ARM_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

Emplacement
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 mémoire spécifié par Location.

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, mais il 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 des mots clés volatiles).

_MoveFromCoprocessor, _MoveFromCoprocessor2

Ces fonctions intrinsèques lisent des données des coprocesseurs ARM en utilisant les instructions de transfert de données du coprocesseur.

int _MoveFromCoprocessor(
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crn,
      unsigned int crm,
      unsigned int opcode2
);

int _MoveFromCoprocessor2(
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crn,
      unsigned int crm,
      unsigned int opcode2
);

Paramètres

coproc
Nombre de coprocesseurs dans la plage 0 à 15.

opcode1
Opcode spécifique au coprocesseur dans la plage de 0 à 7

crn
Numéro du registre du coprocesseur, dans la plage de 0 à 15, qui spécifie le premier opérande pour l'instruction.

crm
Nombre de registres de coprocesseur, dans la plage 0 à 15, qui spécifie une source ou un opérande de destination supplémentaire.

opcode2
Opcode supplémentaire spécifique au coprocesseur dans la plage de 0 à 7

Valeur retournée

Valeur qui est lue auprès du coprocesseur.

Notes

Les valeurs des cinq paramètres de l’intrinsèque doivent être des expressions constantes connues au moment de la compilation.

_MoveFromCoprocessor utilise l'instruction MRC ; _MoveFromCoprocessor2 utilise MRC2. Les paramètres correspondent aux champs de bits qui sont codés directement dans l'argument word de l'instruction. L'interprétation des paramètres dépend du coprocesseur. Pour plus d'informations, consultez le manuel du coprocesseur en question.

_MoveFromCoprocessor64

Lit les données des coprocesseurs ARM en utilisant les instructions de transfert de données de coprocesseur.

unsigned __int64 _MoveFromCoprocessor64(
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crm,
);

Paramètres

coproc
Nombre de coprocesseurs dans la plage 0 à 15.

opcode1
Opcode spécifique au coprocesseur dans la plage de 0 à 15

crm
Nombre de registres de coprocesseur, dans la plage 0 à 15, qui spécifie une source ou un opérande de destination supplémentaire.

Valeur retournée

Valeur qui est lue auprès du coprocesseur.

Notes

Les valeurs des trois paramètres de l’intrinsèque doivent être des expressions constantes connues au moment de la compilation.

_MoveFromCoprocessor64 utilise l'instruction MRRC. Les paramètres correspondent aux champs de bits qui sont codés directement dans l'argument word de l'instruction. L'interprétation des paramètres dépend du coprocesseur. Pour plus d'informations, consultez le manuel du coprocesseur en question.

_MoveToCoprocessor, _MoveToCoprocessor2

Ces fonctions intrinsèques écrivent des données dans les coprocesseurs ARM en utilisant les instructions de transfert de données de coprocesseur.

void _MoveToCoprocessor(
      unsigned int value,
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crn,
      unsigned int crm,
      unsigned int opcode2
);

void _MoveToCoprocessor2(
      unsigned int value,
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crn,
      unsigned int crm,
      unsigned int opcode2
);

Paramètres

valeur
Valeur à écrire dans le coprocesseur.

coproc
Nombre de coprocesseurs dans la plage 0 à 15.

opcode1
Opcode spécifique au coprocesseur dans la plage de 0 à 7

crn
Numéro du registre du coprocesseur, dans la plage de 0 à 15, qui spécifie le premier opérande pour l'instruction.

crm
Nombre de registres de coprocesseur, dans la plage 0 à 15, qui spécifie une source ou un opérande de destination supplémentaire.

opcode2
Opcode supplémentaire spécifique au coprocesseur dans la plage de 0 à 7

Valeur retournée

Aucune.

Notes

Les valeurs des valeurs de l’intrinsèque coproccrmopcode1crnopcode2 doivent être des expressions constantes connues au moment de la compilation.

_MoveToCoprocessor utilise l'instruction MCR ; _MoveToCoprocessor2 utilise MCR2. Les paramètres correspondent aux champs de bits qui sont codés directement dans l'argument word de l'instruction. L'interprétation des paramètres dépend du coprocesseur. Pour plus d'informations, consultez le manuel du coprocesseur en question.

_MoveToCoprocessor64

Ces fonctions intrinsèques écrivent des données dans les coprocesseurs ARM en utilisant les instructions de transfert de données de coprocesseur.

void _MoveFromCoprocessor64(
      unsigned __int64 value,
      unsigned int coproc,
      unsigned int opcode1,
      unsigned int crm,
);

Paramètres

coproc
Nombre de coprocesseurs dans la plage 0 à 15.

opcode1
Opcode spécifique au coprocesseur dans la plage de 0 à 15

crm
Nombre de registres de coprocesseur, dans la plage 0 à 15, qui spécifie une source ou un opérande de destination supplémentaire.

Valeur retournée

Aucune.

Notes

Les valeurs des valeurs , coprocopcode1et crm les paramètres de l’intrinsèque doivent être des expressions constantes connues au moment de la compilation.

_MoveFromCoprocessor64 utilise l'instruction MCRR. Les paramètres correspondent aux champs de bits qui sont codés directement dans l'argument word de l'instruction. L'interprétation des paramètres dépend du coprocesseur. Pour plus d'informations, consultez le manuel du coprocesseur en question.

Prise en charge arm des intrinsèques à partir d’autres architectures

Le tableau suivant répertorie les intrinsèques d'autres architectures qui sont prises en charge sur les plateformes ARM. Là où le comportement d'une intrinsèque sur ARM diffère de son comportement sur d'autres architectures matérielles, des détails supplémentaires sont donné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, mais parce 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ésume la prise en charge ARM des intrinsèques à blocage sans test au niveau des bits. 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 « no fence » est unique à ARM et est abordé dans la section suivante.

Clé :

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

• Partiel : prend en charge les formes simples et _acq_nf simples.

• 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. ARM ajoute _acq, _relet _nf variantes, qui modifient simplement la sémantique de barrière d’une opération, comme décrit dans _nf (pas de clôture) Suffixe plus haut dans cet article.

[Retour en haut]

Voir aussi

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