La détection 64bit compiler en C
est-il un C macro ou une sorte de façon que je puisse vérifier si ma c programme a été compilé en 64 bits ou 32 bits au moment de la compilation en C?
Compilateur: GCC
Les systèmes d'exploitation que j'ai besoin de faire les vérifications sur: Unix/Linux
Aussi comment ai-je pu vérifier lors de l'exécution de mon programme, si l'OS est capable de 64bit?
- Jetez un oeil à la question suivante. Il décrit l'utilisation de la
__LP__
gcc directive de préprocesseur - Pourquoi voulez-vous savoir?
- Comment détecter si un programme a été compilé (c) (32 ou 64 bits
- Voulez-vous examiner un fichier exécutable binaire et de déterminer ce que les options du compilateur ont été utilisés pour créer ce fichier?
- Un exécutable que j'ai créé. donc, pas l'un qui est déjà compilé
- Attends... tu veux dire que vous avez déjà le binaire et que vous voulez vérifier? (Puisque vous avez mentionné "a été compilé") Ou durant moment de la compilation (Puisque vous avez mentionné C macro) ?
- Désolé de son retard là où je suis maintenant, je men pas que "comment puis-je vérifier si ce fichier c va être compilé en 32 bits ou 64 bits" (COMPILATION)
- Je comprends ce que vous voulez faire, la question est de savoir pourquoi. Votre question n'est pas entièrement valide, car "l'architecture 64 bits" n'est pas très bien défini terme (voulez-vous des registres 64 bits, 64 bits du bus de données 64 bits des pointeurs), sont à votre la programmation que pour x86 ou de façon portable...
- PS: Mabe ajouter plus de détails tels que OS(es) et le compilateur. Par exemple dans gcc, vous pouvez afficher et spécifiques à certains commutateurs qui peuvent donner des conseils si vous n'avez pas besoin de faire certaines vérifier dans le code.
- vérifiez la question encore une fois merci
Vous devez vous connecter pour publier un commentaire.
Depuis que vous avez marqués cette "gcc", essayez de
__LP64__
, mais notez que cela ne fonctionne pas pour certains des plus obscurs les architectures 64 bits qui n'utilisent pas le LP64 modèle._[A-Z]
ou__
est presque certainement la mauvaise réponse._[A-Z]
ou__
sont réservés par la mise en œuvre (c'est à dire le compilateur/preprocessor), ce qui signifie que vous ne pouvez pas définir vous-même, mais vous pouvez certainement tester leur existence à la requête de la mise en œuvre.UINTPTR_MAX
, c'est plus fiable dans toutes les implémentations. (Astuce: valide la mise en œuvre pourrait heureusement prédéfinir__LP64__
sur les machines 32 bits, ou comme encore plus extrêmes exemple, il pourrait traiter tous les noms de macro début avec__
défini, sauf s'ils sont explicitement défini.)stdint.h
types dont les limites que vous avez pu tester.Ici est la bonne et de test portable qui n'assume pas x86 ou quoi que ce soit d'autre:
__STDC_LIMIT_MACROS
défini avant de l'inclure l'en-tête. Comme il peut avoir été déjà inclus, la seule façon de s'assurer de la bonne définition est de forcer le client à toujours inclure un premier en-tête dans le fichier source, ou ajouter-D__STDC_LIMIT_MACROS
à vos options de compilation pour tous les fichiers.uintptr_t
type facultatif. Je soupçonne il serait pervers, bien que pour une version 64 bits de mise en œuvre de l'omettre, depuisunsigned long long
est un assez grand type entier.uintptr_t
probablement a une très bonne raison de le faire (un très pathologique ou au moins atypique modèle de mémoire, par exemple) et que toutes les hypothèses formulées sur la base que c'est "un système 32 bits" ou "un système 64 bits" serait invalide une telle mise en œuvre. En tant que tel, le "wtf" cas dans ma réponse doit probablement contenir#error
ou d'autre hyper-code portable qui est complètement agnostique pour les hypothèses traditionnelles sur la mémoire de modèles, tailles, etc.int
est de 64 bits. De nombreux cas de test pour la version 64 bits sont d'assurer que la version 64 bits de l'arithmétique des nombres entiers est rapide car il n'est pas émulé. Par exemple Emscripten pourrait fournir des pointeurs 64 bits, mais il émule entier 64 bits arithmétique parce que le Javascript de sortie cible ne prend pas en charge les entiers 64 bits.Facile qui va faire de la langue de l'avocat squeem.
Que c'est une constante de l'expression d'un compilateur optimisant va baisser le test et seulement mis le bon code dans le fichier exécutable.
int
est de 64 bits. De nombreux cas de test pour la version 64 bits sont d'assurer que la version 64 bits de l'arithmétique des nombres entiers est rapide car il n'est pas émulé. Par exemple Emscripten pourrait fournir des pointeurs 64 bits, mais il émule entier 64 bits arithmétique parce que le Javascript de sortie cible ne prend pas en charge les entiers 64 bits.int
(en effet, sa taille diffère par exemple, dans le LP64 utilisé dans Linux/BSD vs LLP64 utilisé dans Windows, alors que les deux sont très clairement 64 bits). Il également n'a rien à voir avec la façon dont rapidement un compilateur peut optimiser une opération particulière (ou à quelle vitesse Javascript effectue).long long
est toujours efficace sur les cibles, contrairement à sur 32-bit Cpu, où les entiers 64 bits prendre 2 instructions par opération, et 2 registres.Utiliser un compilateur spécifique de la macro.
Je ne sais pas ce que l'architecture cible, mais puisque vous ne spécifiez pas, je vais supposer run-of-the-mill machines Intel, donc plus probable que vous êtes intéressé dans les tests pour Intel x86 et AMD64.
Par exemple:
Cependant, je préfère les mettre dans l'en-tête distincte et de définir ma propre compilateur neutre macro.
ULONG_MAX
au lieu deUINTPTR_MAX
. Sur toute du monde réel unixy système, ils vont être les mêmes. C'est sûrement beaucoup plus de portable à assumerlong
et les pointeurs sont de la même taille que d'assumer certaines compilateur, les macros sont présents.GLIBC lui-même utilise ce (en
inttypes.h
):Le même programme source peut (et doit pouvoir être compilé en 64 bits, ordinateurs, ordinateurs 32 bits, 36 bits, ordinateurs, ...
Donc, juste en regardant la source, si c'est tout bon, vous ne peut pas savoir comment il sera compilé. Si la source n'est pas très bon, il peut être possible de deviner ce que le programmeur pensaient être utilisé pour compiler sous.
Ma réponse est la suivante:
Il y a un moyen de vérifier le nombre de bits nécessaires pour un fichier source uniquement pour les mauvais programmes.
Vous devez vous efforcer de rendre vos programmes de travail, peu importe combien de morceaux ils seront compilées pour.
Utiliser cette UINTPTR_MAX de la valeur à vérifier le type de build.
La question est ambigu, car il ne précise pas si l'exigence est pour la version 64 bits des pointeurs ou des 64 bits natif de l'arithmétique des nombres entiers, ou les deux.
Certains autres réponses ont indiqué comment détecter les pointeurs 64 bits. Même si la question littéralement stipule "compilés", remarque cela ne garantit pas une version 64 bits de l'adresse de l'espace est disponible.
Pour de nombreux systèmes, la détection des pointeurs 64-bit est équivalent à détecter que la version 64 bits de l'arithmétique n'est pas émulé, mais qui n'est pas garanti pour tous les scénarios possibles. Par exemple, bien que Emscripten émule de la mémoire à l'aide de tableaux Javascript qui ont un taille maximale de 232-1, pour assurer la compatibilité de la compilation de code C/C++ ciblage 64 bits, je crois Emscripten est agnostique sur les limites (bien que je n'ai pas testé). Considérant que, indépendamment des limites prévues par le compilateur, Emscripten toujours utilise 32 bits de l'arithmétique. Il semble donc que Emscripten prendrait LLVM de byte code qui ciblée 64 bits
int
et 64 bits des pointeurs et à les imiter au mieux de Javascript capacité.J'avais proposé à l'origine de la détection 64 bits "native" des nombres entiers comme suit, mais comme Patrick Schlüter l'a souligné, ce ne détecte la de rares cas de ILP64:
Donc la bonne réponse est que, généralement, vous ne devriez pas faire des hypothèses sur l'espace d'adressage ou de calcul de l'efficacité de la nébuleuse "64 bits" un classement basé sur les valeurs des limites le compilateur signale. Votre compilateur peut soutenir non portable préprocesseur drapeaux pour un modèle de données ou l'architecture des microprocesseurs, mais compte tenu de la question des objectifs de GCC et par la Emscripten scénario (où Clang émule de GCC), même ceux-ci pourraient être trompeuses (bien que je n'ai pas testé).
Généralement aucun de ces scénarios ne peut être invoqué pour donner toute indication fiable de si une version 64 bits de l'adresse de l'espace et non émulé arithmétique 64 bits est disponible, donc ils sont fondamentalement inutile (w.r.t. pour dit attributs) sauf dans le contexte d'un système de construction qui n'est pas agnostique. Ainsi, pour dit attributs, il est préférable de définir construire des macros, que si le système de construction peut sélectionner la variante est compilé.
int
arithmétique est de 64 bits n'a pas beaucoup prectical valeur.int
ne garantit pas queuint64_t
arithmétique est émulé avec 32 bits de l'arithmétique. Je vais corriger ma réponse.