> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Utiliser Clang/LLVM avec le GDK > Utilisation de Clang/LLVM avec le Microsoft Game Development Kit (GDK) Le développement de titres GDK avec Clang/LLVM est officiellement pris en charge avec Visual Studio 2019 ou 2022 et l'ensemble d'outils *clang/LLVM pour Windows* v12 ou ultérieur. Cet ensemble d'outils utilise le runtime Visual C/C++ (la bibliothèque Universal CRT + la STL Microsoft). Les autres combinaisons d'ensembles d'outils et de runtimes peuvent ou non s'exécuter correctement ou réussir la certification des titres. Clang/LLVM pour Windows avec l'ensemble d'outils de plateforme **LLVM (clang-cl)** (c'est-à-dire ClangCL) utilise la [bibliothèque C++ standard Microsoft](https://github.com/microsoft/STL). | Version de Clang | Mise à jour de Visual Studio | | - | - | | clang v12 | Visual Studio 2019 (16.11) | | clang v12 | Visual Studio 2022 (17.0) | | clang v13 | Visual Studio 2022 (17.1) | | clang v13.0.1 | Visual Studio 2022 (17.2) | | clang v14 | Visual Studio 2022 (17.3) | | clang v15.0.1 | Visual Studio 2022 (17.4) | | clang v16.0.5 | Visual Studio 2022 (17.7) | | clang v17.0.3 | Visual Studio 2022 (17.9) | | clang v18.1.8 | Visual Studio 2022 (17.12) | | clang v19.1.1 | Visual Studio 2022 (17.13) | | clang v19.1.5 | Visual Studio 2022 (17.14) | ## Versions et composants de Visual Studio requis Visual Studio version 16.11 ou ultérieure est requis pour utiliser Clang/LLVM avec le Microsoft Game Development Kit (GDK). Le composant **C++ Clang Tools for Windows** sous **Développement Desktop en C++** doit être sélectionné lors de l'installation de Visual Studio 2019. Clang Tools for Windows Selon la version de Visual Studio que vous utilisez, les composants Clang/LLVM requis peuvent s'appeler **C++ Clang Compiler for Windows** et **C++ Clang-cl for v142 build tools (x64/x86)**. Si vous modifiez votre installation existante de Visual Studio pour ajouter **C++ Clang Tools for Windows** après l'installation du Microsoft Game Development Kit (GDK), vous devrez réparer votre installation du Microsoft Game Development Kit (GDK) avant d'utiliser Clang/LLVM. Si le composant **C++ Clang Tools for Windows** a été installé, le programme d'installation du Microsoft Game Development Kit (GDK) installe la prise en charge de l'ensemble d'outils de plateforme **ClangCl** pour les plateformes `Gaming.Desktop.x64`. ## Commutateurs du compilateur et de l'éditeur de liens Pour les plateformes `Gaming.Desktop.x64`, la ligne de commande clang/LLVM utilisée avec `clang-cl.exe` inclut toujours : ``` -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-reserved-id-macro -Wno-pragma-pack -Wno-unknown-pragmas -Wno-unused-command-line-argument ``` ## Intrinsèques CPU prises en charge Clang/LLVM et GNUC traitent les types SIMD SSE différemment de Visual C++ et du compilateur Intel. Plus précisément, les types \_\_m128, \_\_m128i et \_\_m128d sont considérés comme des types opaques plutôt que comme des structs; vous ne pouvez donc pas créer de fonctions C++ surchargées utilisant ces types. Cela signifie aussi que l'accès direct aux éléments par \_\_m128.m128\_f32\[] ne se compile pas avec clang. Notez que pour DirectXMath avec Clang/LLVM, toutes les surcharges C++ de XMVECTOR sont alors désactivées. Vous pouvez aussi adopter ce comportement avec Visual C++ pour une meilleure portabilité en définissant le symbole de préprocesseur `XM_NO_XMVECTOR_OVERLOADS` avant d'inclure les en-têtes DirectXMath. Sur PC, vous pouvez compter sur la prise en charge de SSE et SSE2 par tous les processeurs x64 natifs, car cela fait partie de la définition de l'architecture. Vous pouvez aussi exiger SSE3 sans risque, car il est pris en charge par tous les processeurs modernes pris en charge par Windows 10. Pour DirectXMath, cela signifie que vous pouvez définir le symbole de préprocesseur `_XM_SSE3_INTRINSICS_` et que vous devez générer avec clang/LLVM en utilisant `-march=sse3`. Visual C++ vous permet d'utiliser des intrinsèques d'instructions avancées même si vous ne générez pas actuellement avec /arch:AVX ou /arch:AVX2, mais avec clang/LLVM, la build échoue dans ce scénario sans les commutateurs de compilateur appropriés. Veillez à effectuer des vérifications de prise en charge du processeur à l'exécution pour tout ce que vous utilisez au-delà de SSE2 sur PC. DirectXMath dans le Windows 10 SDK (18363) ou version antérieure utilisait les mauvaises intrinsèques CPUID pour implémenter `XMVerifyCPUSupport` pour Clang/LLVM. Ce problème est corrigé dans DirectXMath 3.14 du Windows 10 SDK (19041) ou version ultérieure. * [https://walbourn.github.io/directxmath-3.14/](https://walbourn.github.io/directxmath-3.14/) ## Utilisation de Clang/LLVM avec msbuild Pour utiliser Clang/LLVM avec un projet msbuild, définissez l'**Ensemble d'outils de plateforme** sur "LLVM (clang-cl)". L'**Ensemble d'outils de plateforme** se trouve sous l'onglet **Général** de la boîte de dialogue des propriétés du projet Visual C++, comme illustré dans la figure suivante. Propriété msbuild Clang/LLVM Vous pouvez aussi définir l'ensemble d'outils Clang/LLVM en définissant directement la propriété msbuild **PlatformToolset** sur **ClangCl**, comme illustré dans l'exemple suivant. ```xml theme={null} ClangCl ``` Par défaut, le compilateur Clang/LLVM génère beaucoup plus d'avertissements informatifs que MSVC. Ainsi, aux emplacements 'TODO', vous verrez à la fois la sortie -W#pragma-messages sous forme d'avertissement et un avertissement -Wunused-value : ``` 1>Game.cpp(56,13): warning : Game.cpp: TODO in Update [-W#pragma-messages] 1>Game.cpp(58,5): warning : expression result unused [-Wunused-value] 1>Game.cpp(79,13): warning : Game.cpp: TODO in Render [-W#pragma-messages] 1>Game.cpp(81,5): warning : expression result unused [-Wunused-value] 1>Game.cpp(137,13): warning : Game.cpp: TODO in CreateDeviceDependentResources [-W#pragma-messages] 1>Game.cpp(139,5): warning : expression result unused [-Wunused-value] 1>Game.cpp(145,13): warning : Game.cpp: TODO in CreateWindowSizeDependentResources [-W#pragma-messages] ``` ## Utilisation de Clang/LLVM avec cmake Les exemples CMakeExample et CMakeGDKExample du Microsoft Game Development Kit (GDK) constituent un bon point de départ pour intégrer Clang/LLVM à vos projets cmake. Consultez les [exemples du Microsoft Game Development Kit (GDK)](/fr-CA/home/setup-install/samples) pour les instructions de téléchargement. Assurez-vous que le composant Visual Studio **C++ CMake tools for Windows** est installé avant de tenter d'ajouter la prise en charge de Clang/LLVM à vos projets cmake. Visual Studio 2019 (16.11) est fourni avec CMake 3.20. Visual Studio 2022 est fourni avec CMake 3.21 ou version ultérieure. ### Utilisation de CMakeExample Procédez comme suit pour activer Clang/LLVM avec le projet CMakeExample. 1. Utilisez l'option **Ouvrir un dossier local** de Visual Studio pour ouvrir le dossier Desktop situé dans le dossier racine de CMakeExample. CMakeExample a été mis à jour en mars 2022 pour utiliser `CMakePresets.json` au lieu de l'ancienne solution `CMakeSettings.json`. Les préréglages CMake sont intégrés à Visual Studio 2019 16.10 ou version ultérieure. Voir [ce billet de blog](https://devblogs.microsoft.com/cppblog/cmake-presets-integration-in-visual-studio-and-visual-studio-code/). ### Intégration de CMakePresets.json 2. Double-cliquez sur le fichier CMakePresets.json dans l'Explorateur de solutions. Modifiez la variable `XdkEditionTarget` pour qu'elle corresponde à votre édition actuelle du GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Sélectionnez le préréglage `x64-Debug-Clang` ou `x64-Release-Clang`. ### Intégration de CMakeSettings.json 2. Double-cliquez sur le fichier CMakeSettings.json dans l'Explorateur de solutions. 3. Sélectionnez l'icône "PLUS" et choisissez "x64-Clang-Debug" et/ou "x64-Clang-Release", comme illustré dans la figure suivante. Enregistrez les modifications. Ajout d'une configuration Clang dans un projet cmake 4. Cliquez sur "Edit Json", puis coupez-collez la section des variables d'une autre configuration vers les nouvelles configurations Clang, comme dans l'exemple suivant. Définissez la valeur de XDKEditionTarget sur celle qui correspond à votre version du GDK, y compris le niveau de QFE. ``` "variables": [ { "name": "XdkEditionTarget", "value": "210400", "type": "STRING" } ] ``` 5. Après avoir enregistré toutes les modifications, sélectionnez x64-Clang-Debug ou x64-Clang-Release dans la liste déroulante de configuration de build, puis lancez la génération. ## Utilisation de CMakeGDKExample Procédez comme suit pour activer Clang/LLVM avec le projet CMakeGDKExample. 1. Utilisez l'option **Ouvrir un dossier local** de Visual Studio pour ouvrir le dossier CMakeGDKExample. ### Intégration de CMakePresets.json 2. Double-cliquez sur le fichier CMakePresets.json dans l'Explorateur de solutions. Modifiez la variable `XdkEditionTarget` pour qu'elle corresponde à votre édition actuelle du GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Sélectionnez le préréglage `x64-Desktop-Clang`. ### Intégration de CMakeSettings.json 2. Double-cliquez sur le fichier CMakeSettings.json dans l'Explorateur de solutions. 3. Sélectionnez la configuration que vous voulez modifier et définissez la valeur de Toolset sur "clang\_cl\_x64". Enregistrez et fermez. Définition de la valeur de Toolset sur "clang_cl_x64" 4. Pour les configurations XBOX One et XBOX Series X|S, sélectionnez **Edit Json** et assurez-vous que la variable XdkEditionTarget correspond à votre édition du GDK et à votre niveau de QFE. 5. Sélectionnez la valeur souhaitée dans la liste déroulante de configuration et choisissez **Régénérer tout** dans le menu **Générer**. 6. Utilisez Fichier -> Ouvrir -> Projet/Solution pour sélectionner la solution ou le projet généré. Par exemple : CMakeGDKExample\out\build\GamingXboxOne-Debug\CMakeGDKExample.sln Vous êtes maintenant prêt à générer et à déployer votre projet. ## Obtenir de l'aide Pour signaler des bogues du compilateur Visual C++, utilisez [Signaler un problème… dans Visual Studio](https://learn.microsoft.com/visualstudio/ide/how-to-report-a-problem-with-visual-studio) Pour signaler des bogues du compilateur clang/LLVM, utilisez [https://bugs.llvm.org/](https://bugs.llvm.org/) Pour signaler des bogues de la bibliothèque C++ standard Microsoft (aussi appelée STL), utilisez [https://github.com/microsoft/STL/issues](https://github.com/microsoft/STL/issues) ## Problèmes connus * L'ensemble d'outils Clang/LLVM est beaucoup plus verbeux que Visual C++, en particulier avec -Wall -Wextra -Wpedantic. Au minimum, supprimez les avertissements suivants, soit sur la ligne de commande, soit à l'aide d'un #pragma : ``` #ifdef __clang__ #pragma clang diagnostic ignored "-Wc++98-compat" #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" #pragma clang diagnostic ignored "-Wgnu-anonymous-struct" #pragma clang diagnostic ignored "-Wlanguage-extension-token" #pragma clang diagnostic ignored "-Wnested-anon-types" #pragma clang diagnostic ignored "-Wreserved-id-macro" #pragma clang diagnostic ignored "-Wunknown-pragmas" #endif ``` * Les outils du Microsoft Game Development Kit (GDK) fonctionnent uniquement avec les PDB Microsoft pour les symboles de débogage, et ne prennent pas en charge les informations de débogage CodeView ou DWARF émises dans les fichiers .ld de LLVM. * L'implémentation de la génération de code au moment de l'édition de liens de Clang/LLVM est nettement différente de la solution Microsoft Visual C++. Le code qui utilise la génération de code au moment de l'édition de liens ne peut pas être mélangé entre MSVC et clang/LLVM. * Depuis la version d'octobre 2022 et le Windows SDK (10.0.22621), les bibliothèques statiques C++ incluent des métadonnées eXtended Flow Control Guard (XFG). L'éditeur de liens `ld` antérieur à la version v15 émet toujours un avertissement sans conséquence lors de l'utilisation de ces bibliothèques : ``` lld-link: warning/error: ignoring unknown debug$S subsection kind 0xFF in file xgameruntime.lib ``` ## Voir aussi [Visual Studio](/fr-CA/tools/tools-pc/visualstudio/gr-visualstudio-toc) [Utilisation de CMake avec Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-cmake) [Utilisation de MSBuild avec Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-msbuild) ## Related topics - [Utiliser Clang/LLVM avec le GDK pour les consoles](/fr-CA/tools/tools-console/visualstudio/vs-clang.md) - [Utiliser le GDK avec Godot](/fr-CA/build/gdk-and-engines/godot.md) - [Utiliser le GDK avec Unity](/fr-CA/build/gdk-and-engines/unity/unity.md) - [Utiliser le GDK avec Unreal Engine](/fr-CA/build/gdk-and-engines/unreal/unreal.md) - [Utiliser le GDK avec GameMaker](/fr-CA/build/gdk-and-engines/gamemaker.md)