> ## 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. # Uso de Clang/LLVM con el GDK para consolas > Uso de Clang/LLVM con el Microsoft Game Development Kit (GDK) para consolas Puede desarrollar títulos con el Microsoft Game Development Kit (GDK) mediante Clang/LLVM con Visual Studio 2019, Visual Studio 2022 o Visual Studio 2026 y el conjunto de herramientas *clang/LLVM para Windows* v12 o posterior. Este conjunto de herramientas usa el Visual C/C++ Runtime (la biblioteca Universal CRT + la STL de Microsoft). Otras combinaciones de conjuntos de herramientas y runtime podrían no ejecutarse correctamente ni superar la certificación de títulos. Clang/LLVM para Windows con el conjunto de herramientas de plataforma **LLVM (clang-cl)** (es decir, ClangCL) usa la [biblioteca estándar de C++ de Microsoft](https://github.com/microsoft/STL). | Versión de Clang | Actualización 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) | ## Versiones y componentes de Visual Studio necesarios Necesita Visual Studio versión 16.11 o posterior para usar Clang/LLVM con el GDK. Seleccione el componente **C++ Clang Compiler for Windows** en **Individual Components** al instalar Visual Studio. Herramientas de Clang para Windows Según la versión de Visual Studio que use, los componentes de Clang/LLVM necesarios pueden llamarse **C++ Clang Compiler for Windows** y **C++ Clang-cl for v142 build tools (x64/x86)**. Si modifica su instalación existente de Visual Studio para agregar el **C++ Clang Compiler for Windows** después de instalar el GDK, debe reparar la instalación del GDK antes de usar Clang/LLVM. Si instala el componente **C++ Clang Compiler for Windows**, el programa de instalación del GDK instala la compatibilidad con el conjunto de herramientas de plataforma **ClangCl** para las plataformas `Gaming.Xbox.*.x64`. ## Modificadores del compilador y del enlazador Para las plataformas `Gaming.Xbox.*.x64`, la línea de comandos de clang/LLVM que se usa con `clang-cl.exe` incluye siempre lo siguiente: ``` -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-reserved-id-macro -Wno-pragma-pack -Wno-unknown-pragmas -Wno-unused-command-line-argument ``` Para `Gaming.Xbox.Scarlett.x64`, también agrega `-march=znver2`. Este modificador establece AVX2 y algunas otras características específicas de la CPU Hercules. Para `Gaming.Xbox.XboxOne.x64`, también agrega `-march=btver2`. Este modificador establece AVX, F16C y algunas otras características específicas de la CPU Jaguar. Para obtener más información sobre los modificadores recomendados para el desarrollo con el GDK, consulte [Recomendaciones de modificadores del compilador y del enlazador de Visual C++](/tools/tools-console/visualstudio/compiler-switch-recommendations). ## Funciones intrínsecas de CPU compatibles Clang/LLVM y GNUC tratan los tipos SIMD de SSE de forma diferente a Visual C++ y al compilador de Intel. En concreto, los tipos \_\_m128, \_\_m128i y \_\_m128d son tipos opacos en lugar de structs, por lo que no puede crear funciones de C++ sobrecargadas que usen esos tipos. Esta diferencia también significa que el acceso directo a elementos a través de \_\_m128.m128\_f32\[] no compila en clang. Para DirectXMath en Clang/LLVM, esta diferencia da como resultado que todas las sobrecargas de C++ de `XMVECTOR` estén deshabilitadas. También puede optar por este comportamiento en Visual C++ para lograr una mayor portabilidad definiendo el símbolo de preprocesador `XM_NO_XMVECTOR_OVERLOADS` antes de incluir los encabezados de DirectXMath. Visual C++ le permite usar funciones intrínsecas de instrucciones avanzadas incluso si no está compilando actualmente con /arch:AVX o /arch:AVX2, pero clang/LLVM no compila en este escenario sin los modificadores del compilador adecuados. Cuando use Clang/LLVM, debe agregar el modificador del compilador `-march=btver2`, `-march=znver1`, `-march=znver2` o `-mf16c` para usar las funciones intrínsecas de conversión de media precisión F16C `_mm_cvtph_ps` o `_mm_cvtps_ph`. DirectXMath en el Windows 10 SDK (18363) o anterior usaba las funciones intrínsecas CPUID incorrectas para implementar `XMVerifyCPUSupport` en Clang/LLVM. Este problema está corregido para DirectXMath 3.14 en el Windows 10 SDK (19041) o posterior. * [https://walbourn.github.io/directxmath-3.14/](https://walbourn.github.io/directxmath-3.14/) ## Uso de Clang/LLVM con msbuild Para usar Clang/LLVM con un proyecto de msbuild, establezca el **Platform Toolset** en "LLVM (clang-cl)". Puede encontrar **Platform Toolset** en la pestaña **General** del cuadro de diálogo de propiedades del proyecto de Visual C++, como se muestra en la siguiente figura. Propiedad de msbuild de Clang/LLVM También puede establecer el conjunto de herramientas de Clang/LLVM estableciendo directamente la propiedad de msbuild **PlatformToolset** en **ClangCl**, como se muestra en el siguiente ejemplo. ```xml theme={null} ClangCl ``` De forma predeterminada, el compilador Clang/LLVM genera considerablemente más advertencias informativas en comparación con MSVC. Por lo tanto, para los lugares con 'TODO', verá tanto la salida de `-W#pragma-messages` como advertencia, como una advertencia `-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] ``` ## Uso de Clang/LLVM con cmake Los ejemplos CMakeExample y CMakeGDKExample del GDK proporcionan un buen punto de partida para integrar Clang/LLVM en sus proyectos de cmake. Puede descargar estos ejemplos desde la [página de descargas para desarrolladores de XBOX](https://aka.ms/gdkdl). Asegúrese de que el componente de Visual Studio **C++ CMake tools for Windows** esté instalado antes de intentar agregar compatibilidad con Clang/LLVM a sus proyectos de cmake. Visual Studio 2019 (16.11) se distribuye con CMake 3.20. Visual Studio 2022 se distribuye con CMake 3.21 o posterior. ### Uso de CMakeExample Siga estos pasos para habilitar Clang/LLVM con el proyecto CMakeExample. CMakeExample se actualizó en marzo de 2022 para usar `CMakePresets.json` en lugar de la solución anterior `CMakeSettings.json`. Los valores preestablecidos de CMake están integrados con Visual Studio 2019 16.10 o posterior. Consulte [esta entrada de blog](https://devblogs.microsoft.com/cppblog/cmake-presets-integration-in-visual-studio-and-visual-studio-code/). 1. Use la opción **Open Local Folder** de Visual Studio para abrir la carpeta Desktop, XBOX Series X|S o XboxOne en la carpeta raíz de CMakeExample. ### Integración con CMakePresets.json 2. En el Explorador de soluciones, haga doble clic en el archivo CMakePresets.json. Edite la variable `XdkEditionTarget` para que coincida con su edición actual del GDK. ``` "cacheVariables": { "XdkEditionTarget": "260400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Seleccione el valor preestablecido `x64-Debug-Clang` o `x64-Release-Clang`. ### Integración con CMakeSettings.json 2. En el Explorador de soluciones, haga doble clic en el archivo CMakeSettings.json. 3. Seleccione el icono **PLUS** y elija **x64-Clang-Debug** y **x64-Clang-Release**, como se muestra en la siguiente figura. Guarde los cambios. Adición de una configuración de Clang en un proyecto de cmake 4. Seleccione **Edit Json** y, después, corte y pegue la sección variables de otra configuración en las nuevas configuraciones de Clang, como en el siguiente ejemplo. Establezca el valor de `XDKEditionTarget` en el adecuado para su versión del GDK, incluido el nivel de QFE. ``` "variables": [ { "name": "XdkEditionTarget", "value": "260400", "type": "STRING" } ] ``` 5. Después de guardar todos los cambios, seleccione **x64-Clang-Debug** o **x64-Clang-Release** en la lista desplegable de configuraciones de compilación y compile. ## Uso de CMakeGDKExample Siga estos pasos para habilitar Clang/LLVM con el proyecto CMakeGDKExample. 1. Use la opción **Open Local Folder** de Visual Studio para abrir la carpeta CMakeGDKExample. ### Integración con CMakePresets.json 2. En el Explorador de soluciones, haga doble clic en el archivo CMakePresets.json. Edite la variable `XdkEditionTarget` para que coincida con su edición actual del GDK. ``` "cacheVariables": { "XdkEditionTarget": "260400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Seleccione el valor preestablecido `x64-Scarlett-Clang` o `x64-XboxOne-Clang`. ### Integración con CMakeSettings.json 2. En el Explorador de soluciones, haga doble clic en el archivo CMakeSettings.json. 3. Seleccione la configuración que desea editar. Establezca el valor de Toolset en `clang_cl_x64`. Guarde y cierre. Establecimiento del valor de Toolset en "clang_cl_x64" 4. Para las configuraciones de XBOX One y XBOX Series X|S, seleccione **Edit Json** y asegúrese de que la variable `XdkEditionTarget` coincida con su edición del GDK y nivel de QFE. 5. Seleccione el valor deseado en la lista desplegable de configuraciones y elija **Rebuild All** en el menú **Build**. 6. Use **File** -> **Open** -> **Project/Solution** para seleccionar la solución y el proyecto generados. Por ejemplo: CMakeGDKExample\out\build\GamingXboxOne-Debug\CMakeGDKExample.sln Ahora está listo para compilar e implementar su proyecto. ## Obtención de soporte técnico Para notificar errores del compilador de Visual C++, use [Report a Problem… en Visual Studio](https://learn.microsoft.com/visualstudio/ide/how-to-report-a-problem-with-visual-studio) Para notificar errores del compilador clang/LLVM, use [https://bugs.llvm.org/](https://bugs.llvm.org/) Para los informes de errores de la biblioteca estándar de C++ de Microsoft (también conocida como STL), use [https://github.com/microsoft/STL/issues](https://github.com/microsoft/STL/issues) ## Problemas conocidos * El conjunto de herramientas Clang/LLVM es considerablemente más detallado que Visual C++, especialmente cuando usa `-Wall -Wextra -Wpedantic`. Como mínimo, suprima las siguientes advertencias en la línea de comandos o como `#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 ``` * Las herramientas de XBOX solo funcionan con archivos PDB de Microsoft para los símbolos de depuración, y no admiten la información de depuración CodeView ni DWARF que emiten los archivos `.ld` de LLVM. * La implementación de la generación de código en tiempo de vínculo de Clang/LLVM es claramente diferente de la solución de Microsoft Visual C++. No puede mezclar código que use la generación de código en tiempo de vínculo entre MSVC y clang/LLVM. * A partir de la versión de octubre de 2022 y el Windows SDK (10.0.22621), las bibliotecas estáticas de C++ incluyen metadatos de eXtended Flow Control Guard (XFG). El enlazador `ld` anterior a la versión v15 siempre emite una advertencia inofensiva cuando usa estas bibliotecas: ``` lld-link: warning/error: ignoring unknown debug$S subsection kind 0xFF in file xgameruntime.lib ``` * La integración de MSBuild del administrador de paquetes vcpkg no funciona correctamente con `lld-link`, ya que usa caracteres comodín en los nombres de archivo de las bibliotecas. Puede evitar este problema estableciendo `false` en el vcxproj. Este problema no afecta a la integración de vcpkg con CMake mediante generadores de proyectos de VS. * Al compilar para XBOX con clang v18 en modo C++20, dos símbolos quedan sin definir al usar los encabezados de WRL debido a cambios en la evaluación de plantillas. ``` 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 siguiente solución alternativa resuelve el problema: ```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 ``` ## Consulte también [Visual Studio](/tools/tools-console/visualstudio/visualstudio) [Recomendaciones de modificadores del compilador y del enlazador de Visual C++](/tools/tools-console/visualstudio/compiler-switch-recommendations) [Uso de CMake con Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-cmake) [Uso de MSBuild con Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-msbuild) ## Related topics - [Uso de Clang/LLVM con el GDK](/es/tools/tools-pc/visualstudio/gr-vs-clang.md) - [Notas de compatibilidad del GDK con Visual Studio 2019](/es/tools/tools-console/visualstudio/vs-2019-support-notes.md) - [Notas de compatibilidad de Visual Studio 2019](/es/tools/tools-pc/visualstudio/gr-vs-2019-support-notes.md) - [Índice de temas de NDA para el desarrollo de consolas con el GDK de XBOX](/es/nda/nda-overview.md) - [Visualstudio](/es/tools/tools-pc/visualstudio/index.md)