Option pour forcer 32-bit ou 64-bits avec cmake

Je tiens à offrir une manière qui crée toujours ma cible comme une application 32-bits ou toujours comme 64-bit exécutable exécutable avec cmake indépendant du système hôte (en Ajoutant l'option "-m32" ou "-m64" drapeau pour gcc, vous ne savez pas encore quoi faire pour d'autres compilateurs).

Je pense, de trois façons pour ce faire, lequel dois-je utiliser?

  1. une option (-DUSE32bit=true)
  2. un outil de la chaîne (-DCMAKE_TOOLCHAIN_FILE=64 bits.toolchain)
  3. construire des types (-DCMAKE_BUILD_TYPE=release32)

Dans mon cas, la contrainte de 32 bits par défaut et doit être facile à utiliser. Forcé de 64 bits est également utile pour certains cas et ne devrait pas être trop difficile. Utilisant le peu de largeur du système hôte est rarement intéressant pour mon cas et je ne veux pas le soutenir.

J'ai trouvé une question connexe ici (La bonne façon de forcer une version 32 bits de compiler à l'aide de CMake) mais les réponses surtout discuter de la façon dont il peut être fait à tout, pas la meilleure façon de le rendre configurable.

Pour Visual Studio, vous pouvez le sélectionner via le réglage approprié du générateur, comme par exemple Visual Studio 12 2013 Win64 - Préciser la cible de la plateforme x64, le cmake -A <platform-name> option de ligne de commande ou CMAKE_GENERATOR_PLATFORM.
Merci mais cela doit fonctionner sur Linux.
Ensuite, il y a une 4ème variante: le pré-chargement du cache avec quelque chose comme cmake -C 64bit.cmake .... Je préfère ce sur l'ensemble des outils variante, si je ne fais pas la cross-compilation. Une chaîne de traitement de fichier normalement influences le compilateur de détection lui-même.

OriginalL'auteur Flogo | 2015-06-30

  1. 5

    TL;DR

    Utilisation de la chaîne d'

    En profondeur

    1. une option (-DUSE32bit=true)

    Ce n'est pas extensible, je suppose. Alors, si vous voulez construire N projets? Vous devez ajouter N options.

    1. construire des types (-DCMAKE_BUILD_TYPE=release32)

    Cela peut bien fonctionner. Mais à mon avis, vous êtes de mélange sans rapport avec des trucs. Aussi, je suis sûr que vous avez à s'adapter find_package comportement par la définition de certains *_ROOT variables CMake. Il n'est pas possible de le faire avec CMAKE_BUILD_TYPE (à moins, encore une fois, évolutive de la mode).

    1. un outil de la chaîne (-DCMAKE_TOOLCHAIN_FILE=64 bits.toolchain)

    La meilleure variante. Si vous voulez construire deux projets - il suffit d'utiliser le même ensemble d'outils:

    cmake -Hproj-1 -B_builds/proj-1 -DCMAKE_TOOLCHAIN_FILE=/.../64bit.toolchain
cmake -Hproj-2 -B_builds/proj-2 -DCMAKE_TOOLCHAIN_FILE=/.../64bit.toolchain

    Si vous voulez construire votre 3ème partie ExternalProject_Add avec architecture 64 bits - il suffit de passer la chaîne à CMAKE_ARGS:

    ExternalProject_Add(
    ...
    CMAKE_ARGS ... -DCMAKE_TOOLCHAIN_FILE=/.../64bit.toolchain
    ...
)

    Pouvez adapter find_package - il suffit d'ajouter toutes les variables CMake pour la chaîne de fichier.

    Merci. Je n'ai qu'un projet et qu'aucun tiers les bibliothèques que je construis moi-même. Je préfère garder l'appel à être un peu plus simple, c'est à dire, lorsqu'elle est appelée sans paramètres, la commande cmake devrait générer la version 32 bits. Puis-je par défaut pour les 32 bits de l'outil de la chaîne ou de mauvais style?
    Tout ce que vous appelez avec -D est mis dans le cache. Vous pouvez utiliser le fait que les variables de cache ne sont pas remplacés lors de la régler à nouveau (CMake lui-même utilise ce comportement de certains de ses variables système). Donc, si vous mettez par exemple un set(CMAKE_TOOLCHAIN_FILE ... CACHE INTERNAL "") avant votre project() de commande, il sera par défaut.
    Mais il pourrait être difficile de choisir la bonne valeur par défaut de la chaîne. Vous auriez à le rendre dépendant de la CMAKE_GENERATOR utilisés.
    J'ai particulièrement wan pour éviter le comportement par défaut parce que d'une version 64 bits n'a de sens que dans très peu de cas particuliers pour mon application. Je suis maintenant en se penchant vers une approche différente: je ne vais pas forcer quoi que ce soit dans cmake, mais va vérifier si CMAKE_SIZEOF_VOID_P est 4. Si elle ne l'est pas, je vais vérifier si une option à false par défaut a été définie à true. Si cette option n'est pas définie, je m'arrête avec un message d'erreur expliquant la situation. De cette façon, chacun peut choisir leur propre configuration, mais des versions 64 bits doivent être explicitement confirmé. Qu'en pensez-vous?

    OriginalL'auteur

  2. 12

    Pour Visual Studio et par https://cmake.org/cmake/help/latest/variable/CMAKE_GENERATOR_PLATFORM.html

    Pour Visual Studio Générateurs avec VS 2005 et au-dessus de cette spécifie l'architecture cible.

    cmake . -DCMAKE_GENERATOR_PLATFORM=x64
    Merci, c'était ce que je cherchais!
    Va ce travail pour gcc et d'autres compilateurs?
    pas encore, malheureusement. cmake'docs manque un explation, mais il semble que la documentation de ce qui est réellement dans le -A drapeau ici: cmake.org/cmake/help/v3.2/manual/cmake.1.html, qui dit VS>8. Voir aussi stackoverflow.com/a/28047073/3196753 qui parle de l'ajout de la -m32 drapeau à gcc. Remarque, le -m32 peut ne pas fonctionner pour tous les compilateurs. Le moyen le plus recommandé pour les versions 32 bits sur les systèmes Linux/Unix semble être une Chaîne de traitement de fichier, semblable à la façon dont on pourrait préparer un environnement de construction pour la cross-compilation, également disponible dans le lien ci-dessus.

    OriginalL'auteur tresf