> ## 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. # Usar o Clang com o Microsoft Game Development Kit (GDK) > Usar Clang/LLVM com o Microsoft Game Development Kit (GDK) O desenvolvimento de títulos do GDK usando Clang/LLVM tem suporte oficial com o Visual Studio 2019 ou 2022 e o conjunto de ferramentas *clang/LLVM for Windows* v12 ou posterior. Esse conjunto de ferramentas usa o Visual C/C++ Runtime (a biblioteca Universal CRT + a Microsoft STL). Outras combinações de conjuntos de ferramentas e runtimes podem ou não ser executadas com êxito ou passar na certificação de títulos. O Clang/LLVM for Windows com o conjunto de ferramentas de plataforma **LLVM (clang-cl)** (ou seja, o ClangCL) usa a [Biblioteca Padrão C++ da Microsoft](https://github.com/microsoft/STL). | Versão do Clang | Atualização do 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) | ## Versões e componentes necessários do Visual Studio O Visual Studio versão 16.11 ou posterior é necessário para usar Clang/LLVM com o Microsoft Game Development Kit (GDK). O componente **C++ Clang Tools for Windows** em **Desenvolvimento para desktop com C++** deve ser selecionado ao instalar o Visual Studio 2019. ![Clang Tools for Windows](https://mintcdn.com/microsoft-4404708b/6TXzXmujKayly5Sf/images/gdk/tools/vs_clang_install_options.png?fit=max\&auto=format\&n=6TXzXmujKayly5Sf\&q=85\&s=c70a80a7305443c1b6a2dd9d1ef8efae) Dependendo da versão do Visual Studio que você está usando, os componentes necessários do Clang/LLVM podem se chamar **C++ Clang Compiler for Windows** e **C++ Clang-cl for v142 build tools (x64/x86)**. > [!NOTE] > > Se você modificar a instalação existente do Visual Studio para adicionar o **C++ Clang Tools for Windows** depois que o Microsoft Game Development Kit (GDK) tiver sido instalado, precisará reparar a instalação do Microsoft Game Development Kit (GDK) antes de usar o Clang/LLVM. Se o componente **C++ Clang Tools for Windows** tiver sido instalado, a instalação do Microsoft Game Development Kit (GDK) instalará o suporte ao conjunto de ferramentas de plataforma **ClangCl** para as plataformas `Gaming.Desktop.x64`. ## Opções do compilador e do vinculador Para as plataformas `Gaming.Desktop.x64`, a linha de comando do clang/LLVM usada com o `clang-cl.exe` sempre 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 compatíveis O Clang/LLVM e o GNUC tratam os tipos SIMD SSE de forma diferente do Visual C++ e do Intel Compiler. Especificamente, os tipos \_\_m128, \_\_m128i e \_\_m128d são considerados tipos opacos em vez de structs, portanto você não pode criar funções C++ sobrecarregadas usando esses tipos. Isso também significa que o acesso direto aos elementos via \_\_m128.m128\_f32\[] não será compilado no clang. Observe que, para o DirectXMath no Clang/LLVM, isso faz com que todas as sobrecargas C++ de XMVECTOR sejam desabilitadas. Você também pode optar por esse comportamento no Visual C++ para obter melhor portabilidade, definindo o símbolo do pré-processador `XM_NO_XMVECTOR_OVERLOADS` antes de incluir os cabeçalhos do DirectXMath. No PC, você pode contar com o suporte a SSE e SSE2 em todas as CPUs nativas x64, pois isso faz parte da definição da arquitetura. Você também pode exigir SSE3 com segurança, pois ele é compatível com todas as CPUs modernas compatíveis com o Windows 10. Para o DirectXMath, isso significa que você pode definir a diretiva de pré-processador `_XM_SSE3_INTRINSICS_` e deve compilar com clang/LLVM usando `-march=sse3`. O Visual C++ permite usar intrínsecos de instruções avançadas mesmo que você não esteja compilando com /arch:AVX ou /arch:AVX2, mas o clang/LLVM falhará ao compilar nesse cenário sem as opções de compilador adequadas. Faça verificações de suporte da CPU em tempo de execução para tudo o que você usar além do SSE2 no PC. O DirectXMath no Windows 10 SDK (18363) ou anterior usava os intrínsecos de CPUID errados para implementar `XMVerifyCPUSupport` para o Clang/LLVM. Isso foi corrigido no DirectXMath 3.14 no Windows 10 SDK (19041) ou posterior. * [https://walbourn.github.io/directxmath-3.14/](https://walbourn.github.io/directxmath-3.14/) ## Usar Clang/LLVM com o msbuild Para usar Clang/LLVM com um projeto msbuild, defina o **Conjunto de Ferramentas da Plataforma** como "LLVM (clang-cl)". O **Conjunto de Ferramentas da Plataforma** pode ser encontrado na guia **Geral** da caixa de diálogo de propriedades do projeto do Visual C++, conforme mostrado na figura a seguir. ![Propriedade do msbuild para Clang/LLVM](https://mintcdn.com/microsoft-4404708b/NsRUQ49ZRpXgoZ9R/images/gdk/tools/vs_gr_clang_msbuild_property.png?fit=max\&auto=format\&n=NsRUQ49ZRpXgoZ9R\&q=85\&s=7b0a16b440e2f0e2aa2aebdae361e799) O conjunto de ferramentas Clang/LLVM também pode ser definido diretamente configurando a propriedade do msbuild **PlatformToolset** como **ClangCl**, conforme mostrado no exemplo a seguir. ```xml theme={null} ClangCl ``` Por padrão, o compilador Clang/LLVM gera significativamente mais avisos informativos em comparação com o MSVC. Portanto, nos locais 'TODO', você verá tanto a saída -W#pragma-messages como um aviso quanto um aviso -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] ``` ## Usar Clang/LLVM com o cmake Os exemplos CMakeExample e CMakeGDKExample do Microsoft Game Development Kit (GDK) fornecem um bom ponto de partida para integrar o Clang/LLVM aos seus projetos cmake. Veja os [exemplos do Microsoft Game Development Kit (GDK)](/pt-BR/home/setup-install/samples) para obter instruções de download. > [!NOTE] > > Verifique se o componente **Ferramentas do CMake C++ para Windows** do Visual Studio está instalado antes de tentar adicionar o suporte ao Clang/LLVM aos seus projetos cmake. O Visual Studio 2019 (16.11) é fornecido com o CMake 3.20. O Visual Studio 2022 é fornecido com o CMake 3.21 ou posterior. ### Usar o CMakeExample Use as etapas a seguir para habilitar o Clang/LLVM com o projeto CMakeExample. 1. Use a opção **Abrir uma pasta local** do Visual Studio para abrir a pasta Desktop na pasta raiz do CMakeExample. O CMakeExample foi atualizado em março de 2022 para usar `CMakePresets.json` em vez da solução `CMakeSettings.json` mais antiga. As predefinições do CMake são integradas ao Visual Studio 2019 16.10 ou posterior. Veja [esta postagem de blog](https://devblogs.microsoft.com/cppblog/cmake-presets-integration-in-visual-studio-and-visual-studio-code/). ### Integração com CMakePresets.json 2. Clique duas vezes no arquivo CMakePresets.json no Gerenciador de Soluções. Edite a variável `XdkEditionTarget` para corresponder à sua edição atual do GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Selecione a predefinição `x64-Debug-Clang` ou `x64-Release-Clang`. ### Integração com CMakeSettings.json 2. Clique duas vezes no arquivo CMakeSettings.json no Gerenciador de Soluções. 3. Selecione o ícone "MAIS" e escolha "x64-Clang-Debug" e/ou "x64-Clang-Release", conforme mostrado na figura a seguir. Salve as alterações. ![Adição de uma configuração do Clang em um projeto cmake](https://mintcdn.com/microsoft-4404708b/6TXzXmujKayly5Sf/images/gdk/tools/vs_clang_cmake_add_config_cmakeexample.png?fit=max\&auto=format\&n=6TXzXmujKayly5Sf\&q=85\&s=94202af0a719e19ce9573f71e1b925a5) 4. Clique em "Editar JSON" e recorte e cole a seção de variáveis de outra configuração nas novas configurações do Clang, como no exemplo a seguir. Defina o valor de XDKEditionTarget como o apropriado para a sua versão do GDK, incluindo o nível de QFE. ``` "variables": [ { "name": "XdkEditionTarget", "value": "210400", "type": "STRING" } ] ``` 5. Depois de salvar todas as alterações, selecione x64-Clang-Debug ou x64-Clang-Release na lista suspensa de configurações de build e compile. ## Usar o CMakeGDKExample Use as etapas a seguir para habilitar o Clang/LLVM com o projeto CMakeGDKExample. 1. Use a opção **Abrir uma pasta local** do Visual Studio para abrir a pasta CMakeGDKExample. ### Integração com CMakePresets.json 2. Clique duas vezes no arquivo CMakePresets.json no Gerenciador de Soluções. Edite a variável `XdkEditionTarget` para corresponder à sua edição atual do GDK. ``` "cacheVariables": { "XdkEditionTarget": "250400", "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}" } ``` 3. Selecione a predefinição `x64-Desktop-Clang`. ### Integração com CMakeSettings.json 2. Clique duas vezes no arquivo CMakeSettings.json no Gerenciador de Soluções. 3. Selecione a configuração que você deseja editar e defina o valor de Toolset como "clang\_cl\_x64". Salve e feche. ![Definição do valor de Toolset como "clang\_cl\_x64"](https://mintcdn.com/microsoft-4404708b/6TXzXmujKayly5Sf/images/gdk/tools/vs_clang_cmake_set_toolsset_cmakegdkexample.png?fit=max\&auto=format\&n=6TXzXmujKayly5Sf\&q=85\&s=dd9392aa02da7d03720e745201a921a1) 4. Para as configurações do XBOX One e do XBOX Series X|S, selecione **Editar JSON** e verifique se a variável XdkEditionTarget corresponde à sua edição do GDK e ao nível de QFE. 5. Selecione o valor desejado na lista suspensa de configurações e escolha **Recompilar Tudo** no menu **Compilar**. 6. Use Arquivo -> Abrir -> Projeto/Solução para selecionar a solução/projeto gerado. Por exemplo: CMakeGDKExample\out\build\GamingXboxOne-Debug\CMakeGDKExample.sln Agora você está pronto para compilar e implantar seu projeto. ## Obter suporte Para relatar bugs do compilador Visual C++, use [Relatar um Problema… no Visual Studio](https://learn.microsoft.com/visualstudio/ide/how-to-report-a-problem-with-visual-studio) Para relatar bugs do compilador clang/LLVM, use [https://bugs.llvm.org/](https://bugs.llvm.org/) Para relatar bugs da Biblioteca Padrão C++ da Microsoft (também conhecida como STL), use [https://github.com/microsoft/STL/issues](https://github.com/microsoft/STL/issues) ## Problemas conhecidos * O conjunto de ferramentas Clang/LLVM é significativamente mais detalhado do que o Visual C++, especialmente ao usar -Wall -Wextra -Wpedantic. No mínimo, suprima os seguintes avisos na linha de comando ou 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 ``` * As ferramentas do Microsoft Game Development Kit (GDK) funcionam apenas com PDBs da Microsoft para símbolos de depuração e não oferecem suporte às informações de depuração CodeView ou DWARF emitidas em arquivos .ld do LLVM. * A implementação da Geração de Código Durante o Tempo de Vinculação do Clang/LLVM é distintamente diferente da solução do Microsoft Visual C++. Códigos que usam a Geração de Código Durante o Tempo de Vinculação não podem ser misturados entre o MSVC e o clang/LLVM. * A partir da versão de outubro de 2022 e do Windows SDK (10.0.22621), as bibliotecas estáticas C++ incluem metadados do eXtended Flow Control Guard (XFG). O vinculador `ld` anterior à versão v15 sempre emitirá um aviso inofensivo ao usar essas bibliotecas: ``` lld-link: warning/error: ignoring unknown debug$S subsection kind 0xFF in file xgameruntime.lib ``` ## Veja também [Visual Studio](/pt-BR/tools/tools-pc/visualstudio/gr-visualstudio-toc) [Usar o CMake com Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-cmake) [Usar o MSBuild com Clang/LLVM](https://learn.microsoft.com/cpp/build/clang-support-msbuild) ## Related topics - [Usar o Clang com o Microsoft Game Development Kit (GDK) para consoles](/pt-BR/tools/tools-console/visualstudio/vs-clang.md) - [Executar tarefa de API do Microsoft Game Development Kit (GDK)](/pt-BR/build/core-features/common/async/async-libraries/async-library-xasync-example-run-gdk-task.md) - [Introdução à rede do Microsoft Game Development Kit (GDK)](/pt-BR/build/console-features/networking/introduction-networking.md) - [Utilizando as ferramentas do Microsoft Game Development Kit (GDK) para instalar e iniciar seu título para PC](/pt-BR/tools/tools-pc/launching-on-pc.md) - [Modelos de projeto no Visual Studio para o desenvolvimento de jogos para PC](/pt-BR/tools/tools-pc/visualstudio/gr-vs-templates.md)