En tant que programmeur, que dois-je à vous soucier lors du passage à Windows 64 bits?

StackOverflow https://stackoverflow.com/questions/544296

  •  23-08-2019
  •  | 
  •  

Question

La plupart de ma programmation récente a été sur 32 bits Windows en utilisant C / C ++ / C # / VB6. Ces derniers temps, mes clients demandent si mon code fonctionne sur Windows 64 bits.

Je me demande quelles sont les caractéristiques héritage que je pourrais utiliserai qui brisera sur Windows 64 bits? Quels sont les problèmes réels que je dois penser et se soucier?

De toute évidence, je vais tester mon code sur le système d'exploitation 64 bits, mais je voudrais savoir ce que les questions communes à rechercher. Je plus préoccupé par les binaires existants, mais je suis ouvert aux commentaires sur ce qu'il faut inquiéter quand recompiler (si possible).

EDIT: Voici un belle liste de bugs portage 64 bits.

Autres conseils

En ce qui me concerne, la chose la plus importante sur le portage C / C ++ code pour Windows 64 bits est de tester votre application avec les allocations de MEM_TOP_DOWN activées (valeur de Registre AllocationPreference) comme décrit 4-Gigabyte Tuning :

  

Pour forcer les allocations à allouer des adresses plus élevées avant adresses inférieures à des fins de test, spécifiez MEM_TOP_DOWN lors de l'appel VirtualAlloc ou définir la valeur de Registre suivante à 0x100000:

     

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management\AllocationPreference

Quand est-ce important?

  • Si vous avez déjà EXEs 32 bits qui ont été construits avec le /LARGEADDRESSAWARE option de liaison MSVC (ou qui ont le drapeau IMAGE_FILE_LARGE_ADDRESS_AWARE mis dans leurs en-têtes de PE par d'autres moyens, tels que editbin.exe), ils obtiennent un plein 4 Go d'espace d'adressage virtuel dans Windows 64 bits, et vous devez les tester avec le jeu de valeur de registre AllocationPreference.
  • Si vous avez déjà des DLL 32 bits qui peuvent être chargés par grande adresse EXEs au courant, vous devez les tester avec le jeu de valeur de Registre AllocationPreference.
  • Si vous recompiler votre code C / C ++ dans un EXE ou DLL 64 bits, vous devez le tester avec l'ensemble de valeur de Registre AllocationPreference.

Si votre C / C de la demande tombe dans l'une de ces trois catégories et que vous ne testez pas avec les allocations MEM_TOP_DOWN, le test est très peu probable d'attraper des insectes troncature pointeur / signedness dans votre code.

La deuxième chose la plus importante, si vous utilisez MSVC et vous compilez le code C / C ++ 64 bits, est d'utiliser l'option du compilateur /Wp64 pour votre 64 bits construire :

  • Cela entraînera le compilateur d'émettre des avertissements pour typecasts qui tronquent pointeurs ou étendent les petits types intégrés dans des pointeurs (même lorsque reinterpret_cast ou un plâtre C-style est utilisé), ainsi que quelques autres problèmes de portage 64 bits.
  • Oui, dit qu'au lieu de la compilation avec vous /Wp64 devrait utiliser un compilateur qui cible une plate-forme 64 bits, mais cela ne va pas attraper problèmes troncature pointeur / extension au moment de la compilation. L'utilisation d'un compilateur qui cible 64 bits et activant l'option du compilateur /Wp64 pour la construction de 64 bits va attraper beaucoup de problèmes troncature pointeur / extension au moment de la compilation, et cela vous permettra d'économiser du temps à long terme.
  • Malheureusement, avec MSVC 2008, produira également un « avertissement de ligne de commande » pour chaque unité de traduction en disant que l'option /Wp64 est dépréciée. Je peux voir pourquoi l'option est dépréciée pour 32 bits construit (où il est un bidouille mal qui nécessite annoter beaucoup de vos typedefs), mais il est dommage qu'elle soit aussi dépréciée pour les versions 64 bits (où il est réellement utile).

Il est peut-être plus facile de migrer le code .NET si vous avez 100% « type de code géré en toute sécurité ». Vous pouvez simplement le copier sur la plate-forme 64 bits et l'exécuter avec succès sous le CLR 64 bits. Cochez cette lien MSDN sur la migration code managé 32 bits à 64- bit.

BTW, Hanselman blogué sur le sujet récemment.

Si vous parlez des programmes 32 bits alors vous avez pratiquement rien à craindre puisque leur exécuter Windows 64 sous émulation 32 bits. Un problème avec les futures versions de Windows (Windows 7) par exemple sont susceptibles d'être des incompatibilités plutôt que des problèmes avec un système d'exploitation 64 bits.

Toutefois, si votre code managé est compilé pour la plate-forme cible « Toute CPU » et vous faites des appels en code non managé (PInvoke par exemple), ou dépendent d'autres assemblées puis il y a certaines choses à connaître. Scott Hanselman post sur x86 / x64 CLR couvre cela et est une bonne explication de la CLR sur Win32 / 64.

Lors de l'élaboration de programmes natifs 64 bits alors le Programmation Guide pour Windows 64 bits est un bon guide. Il est en grande partie vers le bas pour les pointeurs et la taille des types de données:)

programmes 32bit fonctionnent très bien sur les 64 fenêtres de bits. Tant que vous ne faites aucune sorte de pilote de périphérique de développement bien sûr.

Si vous compilez votre logiciel en tant que logiciel 64 bits pour la première fois, vous devez prendre soin de ce qui suit:

  • un pointeur est large de 64 bits, tandis qu'un int est de 32 bits. Ne pas stocker des pointeurs dans ints, votre code briseront.
  • 64 processus de bits ont besoin 64 bits DLL. Si vous dépendez tiers DLL partie, assurez-vous qu'ils sont également fournis en 64 bits. Si vous avez besoin de communiquer entre un processus 32 bits et un processus 64 bits, vous aurez besoin d'une des nombreuses façons différentes de l'IPC sous Windows. Appel de fonctions est directement hors de question.
  • Les répertoires du système sur Windows 64 bits sont différentes que sur Windows 32 bits. Si vous avez des chemins codés en dur, vous pourriez avoir besoin de les vérifier de nouveau.

Si vous faites l'injection de DLL pour une raison quelconque, vous aurez du mal.

D'un C / C de point de vue ....

Une chose évidente est que la taille d'un int deviendra 8 octets au lieu de 4 octets. Si l'un de votre code dépend de ce que vous pouvez obtenir des résultats inattendus. Structure et alignements variables peuvent changer. Vous pourriez être en mesure de surmonter avec un #pragma pack, mais je ne suis pas très couramment dans les alignements et l'emballage.

Si vous utilisez des syndicats avec ints en eux, le comportement peut changer.

Si vous utilisez des structures de BITFIELD, sur la base ints les 32 bits supplémentaires peuvent causer de la confusion. Le bit de signe ne sera pas où vous pensiez qu'il était.

Si vous codez des constantes hexagonaux et attendre des signes pour devenir négatifs, vous pouvez avoir des problèmes. Exemple 0x8000000 est un nombre négatif comme un journal, ou 32 nombre entier de bits. 0x80000000 comme un entier sur une plate-forme de 64 bits est un nombre positif. pour régler directement le bit de signe que vous devez utiliser 0x80000000 00000000 (espace intégré pour une meilleure lisibilité seulement)

Aussi j'attends size__t à croître de façon appropriée. Si vous faites des allocations basées sur MAX_INT, ils seront beaucoup plus.

Pour éviter ce type d'anomalies de taille, je tiens généralement désire ardemment au lieu de ints.

L'émulation 32 bits vraiment l'épreuve des balles? J'ai vu que le registre est aménagé un peu différemment. Je me demande ce que les choses typiques ne fonctionnent pas ...

En outre, le répertoire C: \ windows \ system32 ne peut contenir que DLL 64 bits. Si vous avez une DLL 32 bits, vous devez le mettre dans C: \ windows \ SysWOW64 \

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top