BCCIOSARM64

De RAD Studio
Aller à : navigation, rechercher

Remonter à Compilateurs C++ améliorés par Clang


BCCIOSARM64 est le compilateur C++ de RAD Studio pour iOS 64 bits.

BCCIOSARM64 est basé sur Clang 3.3.1. Voir Compilateurs C++ améliorés par Clang pour connaître les points communs entre le compilateur BCCIOSARM64 et les autres compilateurs C++ améliorés par Clang.

Remarques :
  • BCCIOSARM64 ne prend pas en charge le simulateur iOS. Le simulateur iOS exécute une version spéciale d'iOS, non-ARM. RAD Studio ne fournit pas de compilateur C++ pour le simulateur iOS.
  • Pour iOS 32 bits, utilisez BCCIOSARM à la place.

Informations générales

Champ Valeur
Conventions d'appel

Apple AAPCS (EN)

Substantypage Itanium (EN) (avec de petites différences)
Bibliothèque standard LLVM libc++ (EN)

Fichiers de sortie

Type de fichier Extension de fichier Format de fichier
Exécutable Mach-O (EN)
Bibliothèque partagée N/A¹
Bibliothèque statique .a ar (EN)
Objet compilé .o Mach-O (EN)
Remarque : iOS ne prend pas en charge les applications contenant des bibliothèques partagées.

Ecriture d'un code C++ pour BCCIOSARM64

Pour écrire un code C++ spécifiquement pour BCCIOSARM64, utilisez :

#if defined(__APPLE__) && defined(__arm64__)
    // Your code.
#endif
Remarque : C'est du code spécifique au compilateur, et ce n'est pas la méthode recommandée pour écrire du code spécifique à iOS. Voir Création d'une app iOS, Ecriture de code pour iOS seulement.

Pour plus d'informations, voir Compilateurs C++ améliorés par Clang, Macros prédéfinies.

Implémentation de certains types de données dans BCCIOSARM64

L'environnement d'exécution 64 bits sous iOS modifie les tailles de nombreux types de données intégrés. Cette section explique comment utiliser les données Delphi suivantes dans les codes C++ pour périphériques iOS 64 bits :

NativeInt

Sur la plate-forme iOS64, le type Delphi NativeInt est implémenté par le biais du type long. Cela peut affecter les codes impliquant des constantes. Pour écarter toute ambiguïté, le code doit utiliser le suffixe L comme indiqué dans l'extrait de code suivant :


NativeInt ni;
#if defined(_PLAT_IOS64)
  if (ni == 99L)
#else
  if (ni == 99)
#endif


Remarque : Dans l'extrait de code ci-dessus, le code qui n'utilise pas le suffixe L pourrait être ambigu pour la plate-forme iOS64.

Typeinfo

Dans les codes Delphi, la fonction TypeInfo renvoie un pointeur au bloc RTTI (Run-time Type Information) qui décrit un type donné. Cependant, cette fonction n'est pas disponible dans C++Builder. Dans les codes C++, vous devez plutôt utiliser le mot-clé __delphirtti.

Pour un type long sous iOS64, la fonction TypeInfo renvoie un typeinfo de type System::tkInt64. Sur d'autres plates-formes, en revanche, elle renvoie un typeinfo de type System::tkInteger. A des fins de clarification, considérons l'extrait de code suivant :

System::Typinfo::PTypeInfo ti;
    ti = __delphirtti(long);
#if defined(_PLAT_IOS64)
    assert(ti->Kind == System::tkInt64);
    assert(pData->MinInt64Value == -9223372036854775808L);
    assert(pData->MaxInt64Value == 9223372036854775807L);
#else
    assert(ti->Kind == System::tkInteger);
    assert(pData->OrdType == System::Typinfo::otSLong);
    assert(pData->MinValue == -2147483648);
    assert(pData->MaxValue == 2147483647);
#endif

Les différences de Typeinfo indiquées ci-dessus peuvent engendrer une incompatibilité entre le code client iOS64 et le serveur avec lequel il interagit. Par exemple, si vous envoyez une variable de type long à la plate-forme iOS64 par le biais de SOAP, celle-ci la sérialisera en tant que type long au format XML, alors que d'autres plates-formes la sérialiseront en tant que type int au format XML.

Par exemple, le tableau suivant représente le code XML produit lors de l'envoi d'un long entre un système Win32 et un client iOS64 :

iOS64   WIN32  
<V xsi:type="xsd:long">-1000</V> <V xsi:type="xsd:int">-1000</V>

De façon transparente, la plupart des environnements d'exécution rétabliront le code XML dans le type approprié au moment de la désérialisation. Cependant, en raison des différences de plages entre un xml:long et xml:int, une valeur envoyée par un client iOS64 pourrait être tronquée par le système WIN32 qui la reçoit.

Voir aussi