Outils

Article
06/13/2023

Cette rubrique décrit les outils à votre disposition pour rendre votre application prête 64 bits. Windows 10 est disponible pour les processeurs x64 et ARM64.

Fichiers include

Les éléments d’API sont pratiquement identiques entre Windows 32 et 64 bits. Les fichiers d’en-tête Windows ont été modifiés afin qu’ils puissent être utilisés pour du code 32 et 64 bits. Les nouveaux types et macros 64 bits sont définis dans un nouveau fichier d’en-tête, Basetsd.h, qui se trouve dans l’ensemble des fichiers d’en-tête inclus par Windows.h. Basetsd.h inclut les nouvelles définitions de type de données pour faciliter l’indépendance de la taille du mot du code source.

Nouveaux types de données

Les fichiers d’en-tête Windows contiennent de nouveaux types de données. Ces types sont principalement destinés à la compatibilité de type avec les types de données 32 bits. Les nouveaux types fournissent exactement le même type de frappe que les types existants, tout en assurant la prise en charge de Windows 64 bits. Pour plus d’informations, consultez Les nouveaux types de données ou le fichier d’en-tête Basetsd.h.

Macros prédéfinies

Le compilateur définit les macros suivantes pour identifier la plateforme.

Macro	Signification
_WIN64	Plateforme 64 bits. Cela inclut à la fois x64 et ARM64.
_WIN32	Plateforme 32 bits. Cette valeur est également définie par le compilateur 64 bits pour la compatibilité descendante.
_WIN16	Une plateforme 16 bits

Les macros suivantes sont spécifiques à l’architecture.

Macro	Signification
_M_IA64	Plateforme Intel Itanium
_M_IX86	Plateforme x86
_M_X64	Plateforme x64
_M_ARM64	Plateforme ARM64

N’utilisez pas ces macros, sauf avec du code spécifique à l’architecture, utilisez _WIN64, _WIN32 et _WIN16 chaque fois que possible.

Fonctions d’assistance

Les fonctions inline suivantes (définies dans Basetsd.h) peuvent vous aider à convertir des valeurs d’un type à un autre en toute sécurité.

void            * Handle64ToHandle( const void * POINTER_64 h ) 
void * POINTER_64 HandleToHandle64( const void *h )
long              HandleToLong(     const void *h )
unsigned long     HandleToUlong(    const void *h )
void            * IntToPtr(         const int i )
void            * LongToHandle(     const long h )
void            * LongToPtr(        const long l )
void            * Ptr64ToPtr(       const void * POINTER_64 p )
int               PtrToInt(         const void *p )
long              PtrToLong(        const void *p )
void * POINTER_64 PtrToPtr64(       const void *p )
short             PtrToShort(       const void *p )
unsigned int      PtrToUint(        const void *p )
unsigned long     PtrToUlong(       const void *p )
unsigned short    PtrToUshort(      const void *p )
void            * UIntToPtr(        const unsigned int ui )
void            * ULongToPtr(       const unsigned long ul )

Avertissement

IntToPtr sign-étend la valeur int , UIntToPtr zéro-étend la valeur int non signée , LongToPtr sign-étend la valeur long et ULongToPtr zero-étend la valeur longue non signée .

Compilateur 64 bits

Les compilateurs 64 bits peuvent être utilisés pour identifier la troncation de pointeur, les casts de type incorrects et d’autres problèmes spécifiques aux 64 bits.

Lors de la première exécution du compilateur, il génère probablement de nombreux avertissements de troncation de pointeur ou d’incompatibilité de type, tels que les suivants :

warning C4311: 'type cast' : pointer truncation from 'unsigned char *' to 'unsigned long '

Utilisez ces avertissements comme guide pour rendre le code plus robuste. Il est recommandé d’éliminer tous les avertissements, en particulier les avertissements de troncation de pointeur.

Commutateurs et avertissements du compilateur 64 bits

Notez que ce compilateur active le modèle de données LLP64.

Il existe une option d’avertissement pour faciliter le portage vers LLP64. Le commutateur -Wp64 -W3 active les avertissements suivants :

C4305 : avertissement de troncation. Par exemple, « return » : troncation de « unsigned int64 » à « long ».
C4311 : avertissement de troncation. Par exemple, « type cast » : troncation du pointeur de « int*_ptr64 » vers « int ».
C4312 : conversion en avertissement de taille plus grande. Par exemple, « type cast » : conversion de « int » en « int*_ptr64 » de plus grande taille.
C4318 : longueur de transmission de zéro. Par exemple, passer la constante zéro comme longueur à la fonction memset .
C4319 : opérateur non. Par exemple, « ~ » : zéro qui étend « unsigned long » à « unsigned _int64 » de plus grande taille.
C4313 : Appel de la famille printf de fonctions avec des spécificateurs et des arguments de type de conversion en conflit. Par exemple, « printf » : « %p » dans la chaîne de format est en conflit avec l’argument 2 de type « _int64 ». Un autre exemple est l’appel printf(« %x », pointer_value); cela provoque une troncation des 32 bits supérieurs. L’appel correct est printf(« %p », pointer_value).
C4244 : identique à l’avertissement existant C4242. Par exemple, « return » : conversion de « _int64 » en « int non signé », perte possible de données.

Éditeur de liens et bibliothèques 64 bits

Pour créer des applications, utilisez l’éditeur de liens et les bibliothèques fournis par le KIT de développement logiciel (SDK) Windows. La plupart des bibliothèques 32 bits ont une version 64 bits correspondante, mais certaines bibliothèques héritées ne sont disponibles que dans les versions 32 bits. Le code qui appelle ces bibliothèques ne sera pas lié lorsque l’application est générée pour Windows 64 bits.

Partager via