> ## 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 > Uso de Clang/LLVM con el Microsoft Game Development Kit (GDK) El desarrollo de títulos del GDK con Clang/LLVM se admite oficialmente con Visual Studio 2019 o 2022 y el conjunto de herramientas *clang/LLVM para Windows* v12 o posterior. Este conjunto de herramientas usa el entorno de ejecución de Visual C/C++ (la biblioteca Universal CRT + la STL de Microsoft). Otras combinaciones de conjuntos de herramientas y entornos de ejecución pueden ejecutarse o superar la certificación del título correctamente, o no. Clang/LLVM para Windows con el conjunto de herramientas de plataforma **LLVM (clang-cl)** (es decir, ClangCL) usa la [biblioteca C++ estándar de Microsoft](https://github.com/microsoft/STL). | Versión de Clang | Actualización 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) | ## Versiones y componentes necesarios de Visual Studio Se requiere Visual Studio versión 16.11 o posterior para usar Clang/LLVM con el Microsoft Game Development Kit (GDK). El componente **C++ Clang Tools for Windows**, dentro de **Desktop Development with C++**, debe estar seleccionado al instalar Visual Studio 2019. Clang Tools para Windows Según la versión de Visual Studio que uses, los componentes de Clang/LLVM necesarios pueden llamarse **C++ Clang Compiler for Windows** y **C++ Clang-cl for v142 build tools (x64/x86)**. Si modificas tu instalación existente de Visual Studio para agregar **C++ Clang Tools for Windows** después de instalar el Microsoft Game Development Kit (GDK), tendrás que reparar la instalación del Microsoft Game Development Kit (GDK) antes de usar Clang/LLVM. Si el componente **C++ Clang Tools for Windows** está instalado, el programa de instalación del Microsoft Game Development Kit (GDK) instalará la compatibilidad con el conjunto de herramientas de plataforma **ClangCl** para las plataformas `Gaming.Desktop.x64`. ## Modificadores del compilador y del enlazador Para las plataformas `Gaming.Desktop.x64`, la línea de comandos de clang/LLVM que se usa con `clang-cl.exe` siempre incluirá: ``` -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-reserved-id-macro -Wno-pragma-pack -Wno-unknown-pragmas -Wno-unused-command-line-argument ``` ## Intrínsecos 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 se consideran tipos opacos en lugar de structs, por lo que no puedes crear funciones sobrecargadas de C++ que usen esos tipos. Esto también significa que el acceso directo a los elementos mediante \_\_m128.m128\_f32\[] no compilará en clang. Ten en cuenta que, para DirectXMath en Clang/LLVM, esto hace que todas las sobrecargas de C++ de XMVECTOR queden deshabilitadas. También puedes optar por este comportamiento en Visual C++ para lograr una mejor portabilidad si defines el símbolo de preprocesador `XM_NO_XMVECTOR_OVERLOADS` antes de incluir los encabezados de DirectXMath. En PC, puedes contar con que SSE y SSE2 son compatibles con todas las CPU nativas x64, ya que forman parte de la definición de la arquitectura. También puedes exigir de forma segura SSE3, ya que es compatible con todas las CPU modernas compatibles con Windows 10. Para DirectXMath, esto significa que puedes definir el símbolo de preprocesador `_XM_SSE3_INTRINSICS_` y debes compilar con clang/LLVM usando `-march=sse3`. Visual C++ te permitirá usar intrínsecos de instrucciones avanzadas incluso si no estás compilando actualmente con /arch:AVX o /arch:AVX2, pero clang/LLVM no podrá compilar en este escenario sin los modificadores de compilador adecuados. Asegúrate de realizar comprobaciones de compatibilidad de la CPU en tiempo de ejecución para todo lo que uses más allá de SSE2 en PC. DirectXMath en el SDK de Windows 10 (18363) o anterior usaba los intrínsecos CPUID incorrectos para implementar `XMVerifyCPUSupport` para Clang/LLVM. Esto está corregido en DirectXMath 3.14 en el SDK de Windows 10 (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, establece **Platform Toolset** en "LLVM (clang-cl)". **Platform Toolset** se encuentra 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 El conjunto de herramientas de Clang/LLVM también se puede establecer directamente asignando a la propiedad de msbuild **PlatformToolset** el valor **ClangCl**, como se muestra en el siguiente ejemplo. ```xml theme={null} ClangCl ``` De forma predeterminada, el compilador Clang/LLVM genera muchas más advertencias informativas que MSVC. Por lo tanto, en los lugares marcados con 'TODO' verás tanto la salida de -W#pragma-messages como una advertencia, además de 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 Las muestras CMakeExample y CMakeGDKExample del Microsoft Game Development Kit (GDK) proporcionan un buen punto de partida para integrar Clang/LLVM en tus proyectos de cmake. Consulta las [muestras del Microsoft Game Development Kit (GDK)](/home/setup-install/samples) para obtener instrucciones de descarga. Asegúrate de que el componente de Visual Studio **C++ CMake tools for Windows** esté instalado antes de intentar agregar compatibilidad con Clang/LLVM a tus proyectos de cmake. Visual Studio 2019 (16.11) incluye CMake 3.20. Visual Studio 2022 incluye CMake 3.21 o posterior. ### Uso de CMakeExample Sigue estos pasos para habilitar Clang/LLVM con el proyecto CMakeExample. 1. Usa la opción **Open Local Folder** de Visual Studio para abrir la carpeta Desktop en la carpeta raíz de CMakeExample. CMakeExample se actualizó en marzo de 2022 para usar `CMakePresets.json` en lugar de la solución anterior basada en `CMakeSettings.json`. Los valores preestablecidos de CMake están integrados con Visual Studio 2019 16.10 o posterior. Consulta [esta entrada de blog](https://devblogs.microsoft.com/cppblog/cmake-presets-integration-in-visual-studio-and-visual-studio-code/). ### Integración de CMakePresets.json 2. Haz doble clic en el archivo CMakePresets.json en el Explorador de soluciones. Edita la variable `XdkEditionTarget` para que coincida con tu edición actual del GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Selecciona el valor preestablecido `x64-Debug-Clang` o `x64-Release-Clang`. ### Integración de CMakeSettings.json 2. Haz doble clic en el archivo CMakeSettings.json en el Explorador de soluciones. 3. Selecciona el icono "PLUS" y elige "x64-Clang-Debug" o "x64-Clang-Release", como se muestra en la siguiente figura. Guarda los cambios. Adición de una configuración de Clang en un proyecto de cmake 4. Haz clic en "Edit Json" y, a continuación, corta y pega la sección de variables de otra configuración en las nuevas configuraciones de Clang, como en el siguiente ejemplo. Establece el valor de XDKEditionTarget en el adecuado para tu versión del GDK, incluido el nivel de QFE. ``` "variables": [ { "name": "XdkEditionTarget", "value": "210400", "type": "STRING" } ] ``` 5. Después de guardar todos los cambios, selecciona x64-Clang-Debug o x64-Clang-Release en la lista desplegable de configuraciones de compilación y compila. ## Uso de CMakeGDKExample Sigue estos pasos para habilitar Clang/LLVM con el proyecto CMakeGDKExample. 1. Usa la opción **Open Local Folder** de Visual Studio para abrir la carpeta CMakeGDKExample. ### Integración de CMakePresets.json 2. Haz doble clic en el archivo CMakePresets.json en el Explorador de soluciones. Edita la variable `XdkEditionTarget` para que coincida con tu edición actual del GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Selecciona el valor preestablecido `x64-Desktop-Clang`. ### Integración de CMakeSettings.json 2. Haz doble clic en el archivo CMakeSettings.json en el Explorador de soluciones. 3. Selecciona la configuración que quieras editar y establece el valor de Toolset en "clang\_cl\_x64". Guarda y cierra. Establecimiento del valor de Toolset en "clang_cl_x64" 4. Para las configuraciones de XBOX One y XBOX Series X|S, selecciona **Edit Json** y asegúrate de que la variable XdkEditionTarget coincide con tu edición del GDK y el nivel de QFE. 5. Selecciona el valor deseado en la lista desplegable de configuraciones y elige **Rebuild All** en el menú **Build**. 6. Usa File -> Open -> Project/Solution para seleccionar la solución o el proyecto generado. Por ejemplo: CMakeGDKExample\out\build\GamingXboxOne-Debug\CMakeGDKExample.sln Ya puedes compilar e implementar tu proyecto. ## Obtención de soporte técnico Para notificar errores del compilador de Visual C++, usa [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, usa [https://bugs.llvm.org/](https://bugs.llvm.org/) Para notificar errores de la biblioteca C++ estándar de Microsoft (también conocida como STL), usa [https://github.com/microsoft/STL/issues](https://github.com/microsoft/STL/issues) ## Problemas conocidos * El conjunto de herramientas de Clang/LLVM es bastante más detallado que Visual C++, especialmente al usar -Wall -Wextra -Wpedantic. Como mínimo, suprime las siguientes advertencias, ya sea en la línea de comandos o como 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 ``` * Las herramientas del Microsoft Game Development Kit (GDK) solo funcionan con PDB de Microsoft para los símbolos de depuración y no admiten la información de depuración CodeView o DWARF emitida en 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++. El código que usa la generación de código en tiempo de vínculo no se puede mezclar entre MSVC y clang/LLVM. * A partir de la versión de octubre de 2022 y el SDK de Windows (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 emitirá una advertencia inofensiva al usar estas bibliotecas: ``` lld-link: warning/error: ignoring unknown debug$S subsection kind 0xFF in file xgameruntime.lib ``` ## Consulte también [Visual Studio](/tools/tools-pc/visualstudio/gr-visualstudio-toc) [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 para consolas](/es/tools/tools-console/visualstudio/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) - [Visualstudio](/es/tools/tools-pc/visualstudio/index.md) - [Visual Studio (contenido)](/es/tools/tools-pc/visualstudio/gr-visualstudio-toc.md)