> ## 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 pour les consoles > Utilisation de Clang/LLVM avec le Microsoft Game Development Kit (GDK) pour les consoles Vous pouvez développer des titres Microsoft Game Development Kit (GDK) avec Clang/LLVM en utilisant Visual Studio 2019, Visual Studio 2022 ou Visual Studio 2026 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 risquent de ne pas s'exécuter correctement ou de ne pas 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 v18.1.8 | Visual Studio 2022 (17.12) | | clang v19.1.5 | Visual Studio 2022 (17.14) | | clang v20.1.8 | Visual Studio 2026 (18.0) | ## Versions et composants de Visual Studio requis Vous avez besoin de Visual Studio version 16.11 ou ultérieure pour utiliser Clang/LLVM avec le GDK. Sélectionnez le composant **C++ Clang Compiler for Windows** sous **Composants individuels** lors de l'installation de Visual Studio. 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 Compiler for Windows** après l'installation du GDK, vous devez réparer votre installation du GDK avant d'utiliser Clang/LLVM. Si vous installez le composant **C++ Clang Compiler for Windows**, le programme d'installation du GDK installe la prise en charge de l'ensemble d'outils de plateforme **ClangCl** pour les plateformes `Gaming.Xbox.*.x64`. ## Commutateurs du compilateur et de l'éditeur de liens Pour les plateformes `Gaming.Xbox.*.x64`, la ligne de commande clang/LLVM utilisée avec `clang-cl.exe` inclut toujours les éléments suivants : ``` -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-reserved-id-macro -Wno-pragma-pack -Wno-unknown-pragmas -Wno-unused-command-line-argument ``` Pour `Gaming.Xbox.Scarlett.x64`, elle ajoute également `-march=znver2`. Ce commutateur active AVX2 et quelques autres fonctionnalités propres au processeur Hercules. Pour `Gaming.Xbox.XboxOne.x64`, elle ajoute également `-march=btver2`. Ce commutateur active AVX, F16C et quelques autres fonctionnalités propres au processeur Jaguar. Pour plus d'informations sur les commutateurs recommandés pour le développement avec le GDK, voir [Recommandations relatives aux commutateurs du compilateur et de l'éditeur de liens Visual C++](/fr/tools/tools-console/visualstudio/compiler-switch-recommendations). ## 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 des types opaques plutôt que des structs ; vous ne pouvez donc pas créer de fonctions C++ surchargées utilisant ces types. Cette différence signifie également que l'accès direct aux éléments via \_\_m128.m128\_f32\[] ne se compile pas avec clang. Pour DirectXMath avec Clang/LLVM, cette différence entraîne la désactivation de toutes les surcharges C++ de `XMVECTOR`. Vous pouvez également 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. 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. Lorsque vous utilisez Clang/LLVM, vous devez ajouter le commutateur de compilateur `-march=btver2`, `-march=znver1`, `-march=znver2` ou `-mf16c` pour utiliser les intrinsèques de conversion en demi-précision F16C `_mm_cvtph_ps` ou `_mm_cvtps_ph`. 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 également 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 voyez à 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 GDK constituent un bon point de départ pour intégrer Clang/LLVM à vos projets cmake. Vous pouvez télécharger ces exemples depuis la [page XBOX Developer Downloads](https://aka.ms/gdkdl). 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. 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/). 1. Utilisez l'option **Ouvrir un dossier local** de Visual Studio pour ouvrir le dossier Desktop, XBOX Series X|S ou XboxOne situé dans le dossier racine de CMakeExample. ### Intégration de CMakePresets.json 2. Dans l'Explorateur de solutions, double-cliquez sur le fichier CMakePresets.json. Modifiez la variable `XdkEditionTarget` pour qu'elle corresponde à votre édition actuelle du GDK. ``` "cacheVariables": { "XdkEditionTarget": "260400", "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. Dans l'Explorateur de solutions, double-cliquez sur le fichier CMakeSettings.json. 3. Sélectionnez l'icône **PLUS** et choisissez **x64-Clang-Debug** et **x64-Clang-Release**, comme illustré dans la figure suivante. Enregistrez les modifications. Ajout d'une configuration Clang dans un projet cmake 4. Sélectionnez **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": "260400", "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. Dans l'Explorateur de solutions, double-cliquez sur le fichier CMakePresets.json. Modifiez la variable `XdkEditionTarget` pour qu'elle corresponde à votre édition actuelle du GDK. ``` "cacheVariables": { "XdkEditionTarget": "260400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Sélectionnez le préréglage `x64-Scarlett-Clang` ou `x64-XboxOne-Clang`. ### Intégration de CMakeSettings.json 2. Dans l'Explorateur de solutions, double-cliquez sur le fichier CMakeSettings.json. 3. Sélectionnez la configuration que vous voulez modifier. 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 et le projet générés. 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 (également 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 lorsque vous utilisez `-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 XBOX 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++. Vous ne pouvez pas mélanger entre MSVC et clang/LLVM du code qui utilise la génération de code au moment de l'édition de liens. * 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 lorsque vous utilisez ces bibliothèques : ``` lld-link: warning/error: ignoring unknown debug$S subsection kind 0xFF in file xgameruntime.lib ``` * L'intégration MSBuild du gestionnaire de packages vcpkg ne fonctionne pas correctement avec `lld-link`, car elle utilise des caractères génériques dans les noms de fichiers de bibliothèques. Vous pouvez contourner ce problème en définissant `false` dans le fichier vcxproj. Ce problème n'affecte pas l'intégration CMake de vcpkg avec les générateurs de projets VS. * Lors d'une génération pour XBOX avec clang v18 en mode C++20, deux symboles ne sont pas définis lors de l'utilisation des en-têtes WRL, en raison de modifications de l'évaluation des modèles. ``` wrl\implements.h(115,11): error : no member named 'RoOriginateError' in the global namespace wrl/event.h(681,17): error : no member named 'RoTransformError' in the global namespace wrl/event.h(712,18): error : no member named 'RoTransformError' in the global namespace ``` La solution de contournement suivante résout le problème : ```cpp theme={null} #include #if (__cplusplus >= 202002L) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES) inline BOOL RoOriginateError(HRESULT, HSTRING) { return TRUE; } inline BOOL RoTransformError(HRESULT, HRESULT, HSTRING) { return TRUE; } #endif #include ``` ## Voir aussi [Visual Studio](/fr/tools/tools-console/visualstudio/visualstudio) [Recommandations relatives aux commutateurs du compilateur et de l'éditeur de liens Visual C++](/fr/tools/tools-console/visualstudio/compiler-switch-recommendations) [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](/fr/tools/tools-pc/visualstudio/gr-vs-clang.md) - [Technologie de compilation XBOX](/fr/tools/tools-console/visualstudio/compiler-technology.md) - [Notes de prise en charge du GDK pour Visual Studio 2019](/fr/tools/tools-console/visualstudio/vs-2019-support-notes.md) - [Recommandations relatives aux commutateurs du compilateur et de l'éditeur de liens Visual C++](/fr/tools/tools-console/visualstudio/compiler-switch-recommendations.md) - [Visual Studio (sommaire)](/fr/tools/tools-pc/visualstudio/gr-visualstudio-toc.md)