Comment dois-je préparer mes programmes Delphi 32 bits pour un éventuel compilateur 64 bits? [dupliquer]

tout D'abord, un avertissement: bien que je travaille pour Amarcadero. Je ne peux pas parler pour mon employeur. Ce que je m'apprête à écrire est basé sur ma propre opinion sur la façon dont un Delphi hypothétique de 64 bits devrait fonctionner, mais il peut y avoir ou non des opinions concurrentes et d'autres incompatibilités prévues ou imprévues et des événements qui causent des décisions de conception alternatives à prendre.

Qui dit:

• il y a deux types entiers, NativeInt et NativeUInt, dont la taille flotter entre 32 et 64 bits selon la plateforme. Ils ont été depuis assez peu de rejets. Aucun autre type d'entier ne changera la taille en fonction du nombre de bits de la cible.

• assurez-vous que tout endroit qui s'appuie sur la fonte d'une valeur de pointeur à un entier ou vice versa utilise NativeInt ou NativeUInt pour l'entier type. TComponent.Tag devrait être NativeInt dans les versions ultérieures de Delphi.

• je suggère de ne pas utiliser NativeInt ou NativeUInt pour les non-pointeur de base de valeurs . Essayez de garder votre code sémantiquement le même entre 32 et 64 bits. Si vous avez besoin de 32 bits de portée, utilisez Integer; si vous avez besoin de 64 bits, utilisez Int64. De cette façon, votre code devrait fonctionner de la même façon sur les deux bitnesses. Vous ne devez utiliser NativeInt que si vous lancez vers et à partir d'une valeur de pointeur quelconque, telle qu'une référence ou un THandle.

• utiliser PByte pour l'arithmétique des aiguilles si possible, de préférence à NativeInt ou NativeUInt . Il suffira pour la plupart des buts, et est plus typesafe parce qu'il ne peut pas être (facilement) confondu avec un type entier normal, et vice versa.

• pointeur-comme les choses doivent suivre des règles similaires à des pointeurs: objet références (évidemment), mais aussi des choses comme HWND, THandle, etc.

• ne s'appuie pas sur les détails internes des chaînes et des tableaux dynamiques, comme leurs données d'en-tête.

• notre politique générale sur les modifications de l'API pour les 64 bits devrait être de conserver les même API entre 32 bits et 64 bits si possible, même si cela signifie que l'API 64 bits ne profite pas nécessairement de la machine. Pour exemple, TList ne manipulera probablement que MaxInt div SizeOf (Pointer) éléments, afin de tenir compte, index etc. en tant qu'Entier. Parce que le Le type entier ne flottera pas (i.e. changer la taille en fonction de bitness), nous ne veulent pas avoir des effets d'entraînement sur le code client: tout index qui round-trébuché à travers une variable entière-typed, ou pour-loop index, serait tronquée et potentiellement causer des bogues subtils.

• lorsque les API sont étendues pour 64 bits, elles seront probablement faites avec une fonction / méthode / propriété supplémentaire pour accéder aux données supplémentaires, et ceci API sera également pris en charge en 32 bits. Par exemple, la norme Length () la routine retournera probablement des valeurs de type entier pour les arguments de tapez string ou dynamic array; si l'on veut traiter avec de très grandes les tableaux dynamiques, il peut y avoir aussi une routine LongLength (), l'implémentation en 32 bits est la même que Length(). Longueur () lancerait une exception en 64 bits si appliquée à un tableau dynamique avec plus de 2^32 élément.

• liée à cela, il sera probablement améliorée vérification des erreurs pour rétrécissement des opérations dans la langue, en particulier rétrécissement des valeurs 64 bits à 32 bits endroits. Cela nuirait à la convivialité de l'attribution des retourner la valeur de la longueur aux emplacements du type entier si la longueur(), retour Int64. D'un autre côté, spécifiquement pour compiler-magic des fonctions comme la Longueur(), il peut y avoir un certain avantage de la magie prises, pour par exemple changer le type de retour en fonction du contexte. Mais l'avantage ne peut pas être de même, pris dans la non-magie API.

• les matrices dynamiques supporteront probablement l'indexation sur 64 bits. Notez que Java les tableaux sont limités à l'indexation 32 bits, même sur les plates-formes 64 bits.

Les chaînes de caractères

• seront probablement limitées à l'indexation sur 32 bits. Nous avons un dur du temps avec des raisons pour les gens qui veulent 4GO+ cordes qui sont vraiment les cordes, et pas seulement réussi gouttes de données, pour lesquels tableaux dynamiques peut servir tout aussi bien.

• peut-être un assembleur intégré, mais avec des restrictions, comme ne pas pouvoir se mélanger librement avec le code Delphi; il y a aussi des règles autour des exceptions et de la disposition des cadres de pile qui doivent être suivies sur x64.

tout d'abord, FreePascal offre déjà un support 64 bits. Ce n'est pas Delphi, cependant.

Second de tous, je m'attends à environ les mêmes problèmes qui existaient au moment Delphi 1 a été mis à niveau à Delphi 2. Le plus gros problème est surtout lié à l'adresse-espace et le problème ici est que les pointeurs seront élargis de 4 bytes à 8 bytes. Dans WIN16 ils utilisent pour être 2 bytes et un tour était nécessaire pour obtenir au-dessus de la limite de 64KB en utilisant des segments et des compensations pour les pointeurs. (Avec la possibilité d'utiliser des segments par défaut pour plusieurs tâches.)

il est également probable que certains types de données deviendront plus grands qu'ils ne le sont actuellement. Le type entier sera de 8 octets, très probablement. (Utilisé pour être seulement 2 bytes dans Windows 2.) Les dénombrements deviendront probablement plus importants aussi. Mais la plupart des autres types de données sont susceptibles de garder leur taille actuelle, donc pas trop de changements ici.

un autre problème sera les exigences de mémoire. Depuis les pointeurs sera de 8 octets de long, une application qui utilise beaucoup d'entre eux mangent aussi beaucoup plus de mémoire. Une liste avec 10.000 pointeurs passera de 40.000 octets à 80.000 octets. Vous pourriez utiliser un peu plus de mémoire que sur un système 32 bits.

la vitesse changera aussi un peu. Comme le processeur traite maintenant 8 octets en même temps, il peut traiter les données beaucoup plus rapidement. Mais puisque les pointeurs et certains types de données deviennent plus grands, les recevoir ou les envoyer à un appareil ou la mémoire sera un peu plus lent. En général, vos applications seront un peu plus rapides en général, mais certaines parties pourraient même devenir plus lentes!

enfin, les modifications de L'API Windows vous obligeront à utiliser les fonctions de l'API 64 bits. Peut-être que le compilateur Delphi fera quelque chose de intelligent pour permettre au code d'appeler des fonctions API 32 bits, mais cela ralentirait les performances parce que le processeur passe maintenant du mode natif 64 bits au mode émulé 32 bits.

selon votre code, vous pouvez essayer de le compiler en utilisant FreePascal, qui supporte à la fois la compilation 32-bit et 64-bit. Le compilateur vous avertira d'éventuelles erreurs dans votre code.

de nombreuses questions similaires ont été posées lorsqu'il a été annoncé que Delphi 2009 ne créerait que des applications Unicode. En fin de compte, il s'est avéré que la plupart du code existant a fonctionné très bien sans changements. Les parties délicates étaient le code qui supposait que SizeOf(Char) = 1 et les composants de tiers qui pourraient faire cela.

Je m'attendrais à ce que le passage à 64-bit Delphi soit une expérience similaire. Tout fonctionne simplement à partir de la boîte de be, sauf pour le code qui joue des trucs avec pointeurs et suppose que SizeOf(Pointer) = 4 ou SizeOf(Pointer) = SizeOf(Integer) . Vous pouvez déjà corriger de tels problèmes aujourd'hui en appelant SizeOf(Pointer) plutôt que le codage dur 4 et en utilisant NativeInt ou NativeUInt quand vous avez besoin de pointeurs entiers de taille.

Vous devez utiliser SizeOf(Pointer) plutôt que SizeOf(NativeInt) si vous voulez que votre code fonctionne avec Delphi 2007. Delphi 2007 a un bug malheureux qui fait que SizeOf(NativeInt) renvoie 8 au lieu de 4 comme il se doit. Ce problème a été résolu à Delphi. 2009.

La grande majorité des applications simples devrait fonctionner parfaitement. Pour autant que je puisse voir, seules les applications qui utilisent manuellement des pointeurs sont à risque. En effet, si un pointeur est maintenant 64 bits, et que vous l'utilisez dans des calculs avec des entiers ou des cardinaux (qui sont encore 32 bits par défaut), vous allez avoir des problèmes. Je pense aussi qu'il est assez courant que les déclarations pour les fonctions API qui prennent des pointeurs comme arguments utilisent cardinal s au lieu de la native (non signée) type entier.

pour faire du code qui fonctionne bien sur n'importe quelle plate-forme, on devrait utiliser NativeUInt s (IIRC, n'ont pas un compilateur Deplhi en ce moment) au lieu de cardinal s en travaillant avec des pointeurs et des entiers simultanément.

aussi longtemps Qu'Amarcadero ne publie pas d'informations officielles sur leur implémentation 64 bits n'est pas facile à dire. Vous devriez vérifier n'importe quelle fonte à/de pointeur, entier et Cardinal en supposant qu'ils sont la taille de plate-forme native, y compris les propriétés d'objet et les références (c.-à-d. stocker un entier dans une propriété TObject, qui est un pointeur, ou en utilisant L'étiquette pour stocker des références et non des nombres).

vous devez également vous assurer qu'aucun code ne repose sur l'effet "wrap-around" lorsque incrémenter (ou décrémenter) une valeur à sa taille maximale (minimale).

cochez n'importe quel code dans les structures qui dépendent de la taille des données, et n'utilisent pas SizeOf() correctement, et dans l'ensemble que SizeOf() est toujours utilisé lorsque les données sont importantes. Cochez le code qui écrit/lit les données dans les fichiers, si les tailles peuvent changer, surtout si les données doivent être échangées entre 32 et 64 bits de code.

vérifiez si Win64 change, si L'application appelle L'API et gère les messages Windows directement. Le code ASM codé à la main doit être vérifié pour la compatibilité 64 bits (il y a une règle beaucoup plus stricte pour écrire assembleur 64 bits).

outre le pointeur évident<-> tâches int: (using intptr/nativeint/ptrint etc)

• Tout ce que vous avez comme blob binaire (DLLs peut-être OCX etc) doit être mis à jour. Cela peut inclure de vieux FDS pour dongles, etc.
• tous les outils qui font quelque chose au niveau binaire (débogueurs,profileurs, outils de la maison de téléphone) pourraient avoir besoin de mises à jour.
• presque tous les monteurs et autres astuces très légères (par ex. dépendant de la mise en page VMT, le format de débogage (tracebacks) les talons de chargement dynamique comme dans Jedi Apilib etc. doivent être mis à jour
• vérifier tous les propres headers créés pour les changements dans l'emballage et les erreurs de traduction qui comptent maintenant pointer<>entier. L'embout d'emballage ne doit pas être sous-estimé
• Interfaçage avec Office et d'autres applications peuvent changer
• TComponent.tag est un longint maintenant, et pourrait donc rester longint, ce qui signifie que les plans qui composant.la balise peut échouer.
• X87 FPU est déprécié sur x64, et en général SSE2 sera utilisé pour point de floraison. ainsi, floating point et sa manipulation d'exception pourraient fonctionner légèrement différemment, et étendu pourrait ne pas être de 80-bit (mais 64-bit ou, moins probable 128-bit). Cela concerne également les changements habituels d'arrondi (copro controlwork) lors de l'interfaçage avec le code C qui attend un mot fpu différent.

le problème de l'emballage des documents est quelque chose que j'ai remarqué en portant des en-têtes existants à win64.

mes 2 cents:

• dans le passé, chaque écrivain asm a été poussé à utiliser BASM

• externe asm64 serait acceptable et l'utilisation de l'ancien inlclude xy.code obj, alors que toute façon une réécriture complète est nécessaire

• Debugger & CPU64: la question sera de savoir si c'est toujours là??

• D64 Float Étendue: est-ce toujours maintenu comme flotteur à 80 bits??

Hp

comme une supposition complète, tout code qui ne dépend pas d'une taille de mot spécifique, ou peut adapter sa taille de mot basé sur ce que le compilateur lui dit, sera très bien.