Débogage dynamique C++ (Aperçu)

Importante

Le débogage dynamique C++ est actuellement en préversion. Ces informations concernent une fonctionnalité de préversion qui peut être sensiblement modifiée avant la mise en production. Microsoft n’offre aucune garantie, exprimée ou implicite, en ce qui concerne les informations fournies ici.

Cette fonctionnalité en préversion, disponible à partir de Visual Studio 2022 Version 17.14 Preview 2, s’applique uniquement aux projets x64.

Avec le débogage dynamique C++, vous pouvez déboguer du code optimisé comme s’il n’était pas optimisé. Cette fonctionnalité est utile pour les développeurs qui nécessitent les avantages en matière de performances du code optimisé, tels que les développeurs de jeux qui ont besoin de taux d’images élevés. Avec le débogage dynamique C++, vous pouvez profiter de l’expérience de débogage du code non optimisé sans sacrifier les avantages en matière de performances des builds optimisées.

Le débogage du code optimisé présente des défis. Le compilateur repositionne et réorganise les instructions pour optimiser le code. Le résultat est un code plus efficace, mais cela signifie :

L’optimiseur peut supprimer des variables locales ou les déplacer vers des emplacements inconnus du débogueur.
Le code à l’intérieur d’une fonction peut ne plus s’aligner sur le code source lorsque l’optimiseur fusionne des blocs de code.
Les noms de fonctions pour les fonctions sur la pile des appels peuvent être incorrects si l’optimiseur fusionne deux fonctions.

Dans le passé, les développeurs ont traité ces problèmes et d’autres quand ils étaient en train de déboguer du code optimisé. À présent, ces défis sont éliminés, car avec le débogage dynamique C++, vous pouvez passer au code optimisé comme s’il n’était pas optimisé.

Outre la génération des fichiers binaires optimisés, la compilation avec /dynamicdeopt génère des fichiers binaires non optimisés utilisés pendant le débogage. Lorsque vous ajoutez un point d’arrêt ou pénétrez dans une fonction (y compris les fonctions __forceinline), le débogueur charge le binaire non optimisé. Vous pouvez ensuite déboguer le code non optimisé pour la fonction au lieu du code optimisé. Vous pouvez déboguer comme si vous déboguez du code non optimisé alors que vous bénéficiez toujours des avantages en matière de performances du code optimisé dans le reste du programme.

Essayez le débogage dynamique en C++

D'abord, examinons ce que c'est que de déboguer du code optimisé. Vous pouvez ensuite voir comment le débogage dynamique C++ simplifie le processus.

Créez un projet d’application console C++ dans Visual Studio. Remplacez le contenu du fichier ConsoleApplication.cpp par le code suivant :

// Code generated by GitHub Copilot
#include <iostream>
#include <chrono>
#include <thread>

using namespace std;

int step = 0;
const int rows = 20;
const int cols = 40;

void printGrid(int grid[rows][cols])
{
    cout << "Step: " << step << endl;
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            cout << (grid[i][j] ? '*' : ' ');
        }
        cout << endl;
    }
}

int countNeighbors(int grid[rows][cols], int x, int y)
{
    int count = 0;
    for (int i = -1; i <= 1; ++i)
    {
        for (int j = -1; j <= 1; ++j)
        {
            if (i == 0 && j == 0)
            {
                continue;
            }

            int ni = x + i;
            int nj = y + j;
            if (ni >= 0 && ni < rows && nj >= 0 && nj < cols)
            {
                count += grid[ni][nj];
            }
        }
    }
    return count;
}

void updateGrid(int grid[rows][cols])
{
    int newGrid[rows][cols] = { 0 };
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            int neighbors = countNeighbors(grid, i, j);
            if (grid[i][j] == 1)
            {
                newGrid[i][j] = (neighbors < 2 || neighbors > 3) ? 0 : 1;
            }
            else
            {
                newGrid[i][j] = (neighbors == 3) ? 1 : 0;
            }
        }
    }
    // Copy newGrid back to grid
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            grid[i][j] = newGrid[i][j];
        }
    }
}

int main()
{
    int grid[rows][cols] = { 0 };

    // Initial configuration (a simple glider)
    grid[1][2] = 1;
    grid[2][3] = 1;
    grid[3][1] = 1;
    grid[3][2] = 1;
    grid[3][3] = 1;

    while (true)
    {
        printGrid(grid);
        updateGrid(grid);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        cout << "\033[H\033[J"; // Clear the screen
        step++;
    }

    return 0;
}

Changez la liste déroulante Configurations de solution en Mise en production. Vérifiez que la liste déroulante de la plateforme de solutions est définie sur x64 .
Regénérez en sélectionnant Générer>Regénérer la solution.
Définissez un point d’arrêt sur la ligne 55, int neighbors = countNeighbors(grid, i, j); dans updateGrid(). Exécutez le programme.
Quand vous atteignez le point d’arrêt, consultez la fenêtre Variables locales. Dans le menu principal, sélectionnez Déboguer>Fenêtres>Variables locales. Notez que vous ne pouvez pas voir la valeur de i ou de j dans la fenêtre Locals. Le compilateur les a optimisés au point de les éliminer.
Essayez de définir un point d’arrêt sur la ligne 19, cout << (grid[i][j] ? '*' : ' '); dans printGrid(). Vous ne pouvez pas. Ce comportement est attendu, car le compilateur a optimisé le code.

Arrêtez le programme et activez le débogage dynamique C++ et réessayez

Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Propriétés pour ouvrir les pages de propriétés du projet.
Sélectionnez Avancé>Utiliser le débogage dynamique C++, puis changez le paramètre en Oui.

La page des propriétés s’ouvre sur Propriétés de configuration > Avancé > Utiliser le débogage dynamique C++. Cette propriété est définie sur Oui.

Cette étape ajoute le commutateur /dynamicdeopt au compilateur et à l’éditeur de liens. En arrière-plan, il désactive également les commutateurs d’optimisation C++ /GL et /OPT:ICF. Ce paramètre ne remplace pas les commutateurs que vous avez ajoutés manuellement à la ligne de commande ou à d’autres commutateurs d’optimisation définis, tels que /O1.
Regénérez en sélectionnant Générer>Regénérer la solution. Le code de diagnostic de construction MSB8088 apparaît, ce qui indique que le débogage dynamique et l'optimisation de l'ensemble du programme sont incompatibles. Cette erreur signifie que toute l’optimisation du programme (/GL) a été automatiquement désactivée pendant la compilation.

Vous pouvez désactiver manuellement toute l’optimisation du programme dans les propriétés du projet. Sélectionnez Propriétés de configuration>Avancé>Optimisation du programme entier, puis modifiez le paramètre en Désactivé. À présent, MSB8088 est traitée comme un avertissement, mais elle peut être traitée comme une erreur dans une version ultérieure de Visual Studio.
Réexécutez l’application.

Maintenant, quand vous atteignez le point d’arrêt sur la ligne 55, vous voyez les valeurs de i et de j dans la fenêtre Variables locales. La fenêtre Pile des appels indique que updateGrid() est désoptimisé et que le nom de fichier est life.alt.exe. Ce binaire de remplacement est utilisé pour déboguer du code optimisé.

Un point d’arrêt est affiché dans la fonction updateGrid. La pile des appels indique que la fonction est déoptimisée et que le nom de fichier est life.alt.exe. La fenêtre Locals affiche les valeurs d’i et j et les autres variables locales dans la fonction.

La fonction updateGrid() est déoptimisée à la demande, car vous définissez un point d’arrêt dans celui-ci. Si vous passez au-dessus d'une fonction optimisée lors du débogage, elle n'est pas désoptimisée. Si vous effectuez un pas à pas détaillé d’une fonction, elle est désoptimisée. La principale façon de désoptimiser une fonction est de définir un point d’arrêt dans celle-ci ou d’y effectuer un pas à pas détaillé.

Vous pouvez également désoptimiser une fonction dans la fenêtre Pile des appels. Cliquez avec le bouton droit sur la fonction ou un groupe de fonctions sélectionné, puis sélectionnez Déoptimiser lors de l’entrée suivante. Cette fonctionnalité est utile lorsque vous souhaitez afficher les variables locales dans une fonction optimisée pour laquelle vous n’avez pas défini de point d’arrêt ailleurs sur la pile des appels. Les fonctions qui sont déoptimisées de cette façon sont regroupées dans la fenêtre points d’arrêt en tant que groupe de points d’arrêt nommé Fonctions déoptimisées. Si vous supprimez le groupe de points d’arrêt, les fonctions associées reviennent à leur état optimisé.

Utiliser des points d’arrêt conditionnels et dépendants

Essayez de définir à nouveau un point d’arrêt sur la ligne 19, cout << (grid[i][j] ? '*' : ' '); dans printGrid(). Maintenant, ça marche. La définition d’un point d’arrêt dans la fonction la désoptimisera afin que vous puissiez la déboguer normalement.
Cliquez avec le bouton droit sur le point d’arrêt sur la ligne 19, sélectionnez Conditions, puis définissez la condition sur i == 10 && j== 10. Cochez ensuite la case Activer seulement quand le point d’arrêt suivant est atteint :. Sélectionnez le point d’arrêt sur la ligne 55 dans la liste déroulante. Le point d’arrêt sur la ligne 19 n’est pas atteint tant que le point d’arrêt sur la ligne 50 n’est pas d’abord atteint, puis quand grid[10][10] est sur le point d’afficher une sortie sur la console.

Le point est que vous pouvez définir des points d’arrêt conditionnels et dépendants dans une fonction optimisée et utiliser des variables locales et des lignes de code qui, dans une build optimisée, peuvent être indisponibles pour le débogueur.

Un point d’arrêt conditionnel est affiché sur la ligne 19, cout < < (grille[i][j] ? '*' : ' ');. La condition est définie sur i == 10 && j== 10. La case à cocher Activer uniquement lorsque le point d’arrêt suivant est atteint est sélectionnée. La liste déroulante des points d’arrêt est définie sur la ligne 55 de life.cpp.
Continuez à exécuter l’application. Lorsque le point d’arrêt sur la ligne 19 est atteint, vous pouvez cliquer avec le bouton droit sur la ligne 15 et sélectionner Définir l'instruction suivante pour relancer la boucle.

Un point d’arrêt conditionnel et dépendant est atteint sur la ligne 19, cout < < (grid[i][j] ? '*' : ' ');. La fenêtre Locals affiche les valeurs d’i et j et les autres variables locales dans la fonction. La fenêtre Pile des appels indique que la fonction est déoptimisée et que le nom de fichier est life.alt.exe.
Supprimez tous les points d’arrêt pour retourner les fonctions déoptimisées à leur état optimisé. Dans le menu principal de Visual Studio, sélectionnez Déboguer>Supprimer tous les points d’arrêt. Toutes les fonctions retournent ensuite à leur état optimisé.

Si vous ajoutez des points d’arrêt via l’option Désoptimiser à l’entrée suivante de la fenêtre Pile des appels, ce que nous n’avons pas fait dans cette procédure pas à pas, vous pouvez cliquer avec le bouton droit sur le groupe Fonctions désoptimisées, puis sélectionner Supprimer pour rétablir seulement les fonctions de ce groupe à leur état optimisé.

La fenêtre Points d’arrêt affiche le groupe Fonctions déoptimisées. Le groupe est sélectionné et le menu contextuel est ouvert avec l’option Supprimer le groupe de points d’arrêt sélectionnée.

Désactiver le débogage dynamique C++

Vous devrez peut-être déboguer du code optimisé sans qu'il soit désoptimisé, ou placer un point d'arrêt dans du code optimisé et veiller à ce que le code reste optimisé lorsque le point d'arrêt est atteint. Il existe plusieurs façons de désactiver le débogage dynamique ou de ne pas optimiser le code lorsque vous atteignez un point d’arrêt :

Dans le menu principal de Visual Studio, sélectionnez Options d’outils>. Dans le volet Options , développez la section Tous les paramètres>de débogage>général . Décochez la case Désoptimiser automatiquement les fonctions déboguées quand c’est possible (.NET 8+, Débogage dynamique C++). La prochaine fois que le débogueur démarre, le code reste optimisé.

Dans le menu principal de Visual Studio, sélectionnez Options d’outils>. Dans la boîte de dialogue Options , développez la section Débogage>général . Décochez la case Désoptimiser automatiquement les fonctions déboguées quand c’est possible (.NET 8+, Débogage dynamique C++). La prochaine fois que le débogueur démarre, le code reste optimisé.

De nombreux points d’arrêt de débogage dynamique sont deux points d’arrêt : un dans le binaire optimisé et un dans le binaire non optimisé. Dans la fenêtre Points d’arrêt, sélectionnez Afficher les colonnes>Fonction. Supprimez le point d’arrêt associé au fichier binaire alt. L’autre point d’arrêt de la paire s’arrête dans le code optimisé.
Lorsque vous déboguez, dans le menu principal de Visual Studio, sélectionnez Déboguer>Windows>Désassembler. Vérifiez qu’il a bien le focus. Lorsque vous entrez dans une fonction via la fenêtre Désassembler, la fonction ne sera pas désoptimisée.
Désactivez entièrement le débogage dynamique en ne transmettant pas /dynamicdeopt à cl.exe, lib.exeet link.exe. Si vous consommez des bibliothèques de tiers et que vous ne pouvez pas les regénérer, ne passez pas /dynamicdeopt lors de l’exécution finale de link.exe pour désactiver le débogage dynamique pour ce fichier binaire.
Pour désactiver rapidement le débogage dynamique pour un binaire unique (par exemple, test.dll), renommez ou supprimez le fichier binaire alt (par exemple, test.alt.dll).
Pour désactiver le débogage dynamique pour un ou plusieurs fichiers .cpp, ne passez pas /dynamicdeopt lorsque vous les générez. Le reste de votre projet est généré avec le débogage dynamique.

Activer le débogage dynamique C++ pour Unreal Engine 5.6 ou version ultérieure

Unreal Engine 5.6 prend en charge le débogage dynamique en C++ pour l'Unreal Build Tool et l'Unreal Build Accelerator. Il existe deux façons de l’activer. Modifiez le BuildConfiguration.xml fichier ou modifiez le Targets.cs fichier.

Modifier le `BuildConfiguration.xml` fichier

Dans Visual Studio, sélectionnez la configuration de l’Éditeur de développement et modifiez-la BuildConfiguration.xml pour inclure <bDynamicDebugging>true</bDynamicDebugging>. Pour plus d’informations sur BuildConfiguration.xml et son emplacement, consultez Configuration de build.

Une façon de localiser votre fichier BuildConfiguration.xml consiste à exécuter une compilation et à vérifier le journal de compilation. Par exemple, lors de la création du jeu de démarrage Lyra, vous voyez la sortie suivante :

- Running UnrealBuildTool: dotnet "..\..\Engine\Binaries\DotNET\UnrealBuildTool\UnrealBuildTool.dll" LyraEditor Win64 Development -Project="C:\LyraStarterGame\LyraStarterGame.uproject" ...
 14% -   Log file: C:\Users\<user>\AppData\Local\UnrealBuildTool\Log.txt

Recherchez cela Log.txt pour BuildConfiguration.xml. Il doit contenir une ligne comme Reading configuration file from: C:\LyraStarterGame\Saved\UnrealBuildTool\BuildConfiguration.xml

Modifiez ce fichier pour qu’il BuildConfiguration.xml contienne <bDynamicDebugging>true</bDynamicDebugging>:

<?xml version="1.0" encoding="utf-8" ?>
<Configuration xmlns="https://www.unrealengine.com/BuildConfiguration">
    <WindowsPlatform>
        <bDynamicDebugging>true</bDynamicDebugging> <!-- add this line -->
    </WindowsPlatform>
</Configuration>

Modifier le `Targets.cs` fichier

L’autre façon d’activer le débogage dynamique C++ pour Unreal Build Tool et Unreal Build Accelerator consiste à modifier votre Target.cs fichier à contenir WindowsPlatform.bDynamicDebugging = true.

Les projets Unreal Engine ont Target.cs des fichiers associés à plusieurs types cibles, notamment :

{ProjectName}.Target.cs for the game executable.
{ProjectName}Editor.Target.cs for the editor build.

Pour une build d’éditeur, dans le {ProjectName}Editor.Target.cs fichier, ajoutez WindowsPlatform.bDynamicDebugging = true; au constructeur :

public class LyraEditorTarget : TargetRules
{
    public LyraEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        WindowsPlatform.bDynamicDebugging = true; // add this line
        // Other settings...
    }
}

Ou pour une build de jeu, dans le {ProjectName}.Target.cs fichier, ajoutez WindowsPlatform.bDynamicDebugging = true; à ApplyShared{Project name}TargetSettings():

internal static void ApplySharedLyraTargetSettings(TargetRules Target)
{
    ILogger Logger = Target.Logger;
    
    WindowsPlatform.bDynamicDebugging = true; // add this line
    // Other settings...
}

Pour plus d’informations sur les fichiers cibles unreal Engine, consultez Cibles.

Activer le débogage dynamique C++ pour Unreal Engine 5.5 ou version antérieure

Pour Unreal Engine 5.5 ou version antérieure, sélectionnez les modifications apportées à l'Unreal Build Tool à partir de GitHub dans votre référentiel.

Note

Pour accéder aux référentiels Epic sur GitHub, vous avez besoin d’un compte Epic et d’un compte GitHub inscrit.

Après avoir sélectionné les modifications à appliquer à votre référentiel, activez bDynamicDebugging comme décrit précédemment. Vous devez également utiliser Unreal Build Accelerator à partir d’Unreal Engine 5.6. Utilisez les derniers bits de ue5-main ou désactivez UBA en ajoutant les éléments suivants à BuildConfiguration.xml:

<BuildConfiguration>
    <bAllowUBAExecutor>false</bAllowUBAExecutor>
    <bAllowUBALocalExecutor>false</bAllowUBALocalExecutor>
</BuildConfiguration>

Pour plus d’informations sur la configuration de la génération d’Unreal Engine, consultez Configuration de la génération.

Résolution des problèmes

Si des points d’arrêt ne sont pas atteints dans des fonctions désoptimisées :

Si vous sortez d’un bloc [Deoptimized], vous pourriez être dans du code optimisé, à moins que l’appelant ait été désoptimisé en raison d’un point d’arrêt dans celui-ci ou parce que vous ayez effectué un pas à pas détaillé dans l’appelant en suivant votre chemin vers la fonction actuelle.
Vérifiez que les fichiers alt.exe et alt.pdb ont été générés. Pour test.exe et test.pdb, test.alt.exe et test.alt.pdb doivent exister dans le même répertoire. Vérifiez que les commutateurs de build appropriés sont définis conformément à cet article.
Une entrée debug directory existe dans test.exe que le débogueur utilise pour rechercher le fichier binaire alt à utiliser pour le débogage déoptimisé. Ouvrez une invite de commandes Visual Studio native x64 et exécutez link /dump /headers <your executable.exe> pour voir si une entrée deopt existe. Une entrée deopt apparaît dans la colonne Type, comme indiqué dans la dernière ligne de cet exemple :
```
  Debug Directories

        Time Type        Size      RVA  Pointer
    -------- ------- -------- -------- --------
    67CF0DA2 cv            30 00076330    75330    Format: RSDS, {7290497A-E223-4DF6-9D61-2D7F2C9F54A0}, 58, D:\work\shadow\test.pdb
    67CF0DA2 feat          14 00076360    75360    Counts: Pre-VC++ 11.00=0, C/C++=205, /GS=205, /sdl=0, guardN=204
    67CF0DA2 coffgrp      36C 00076374    75374
    67CF0DA2 deopt         22 00076708    75708    Timestamp: 0x67cf0da2, size: 532480, name: test.alt.exe
```
Si l’entrée de répertoire de débogage deopt n’y figure pas, vérifiez que vous passez /dynamicdeopt à cl.exe, lib.exeet link.exe.
La déoptimisation dynamique ne fonctionnera pas de manière cohérente si /dynamicdeopt n’est pas passé à cl.exe, lib.exeet link.exe pour tous les fichiers .cpp, .libet binaires. Vérifiez que les commutateurs appropriés sont définis lorsque vous générez votre projet.

Pour plus d’informations sur les problèmes connus, consultez Débogage Dynamique C++ : débogabilité complète pour les générations optimisées.

Si les choses ne fonctionnent pas comme prévu, ouvrez un ticket à Developer Community. Incluez autant d’informations que possible sur le problème.

Remarques générales

IncrediBuild 10.24 prend en charge les builds de débogage dynamique C++.
FastBuild v1.15 prend en charge les builds de débogage dynamique C++.

Les fonctions insérées en ligne sont déoptimisées à la demande. Si vous définissez un point d’arrêt sur une fonction inline, le débogueur déoptimise la fonction et son appelant. Le point d’arrêt est atteint là où vous l’attendez, comme si votre programme était généré sans optimisations du compilateur.

Une fonction reste désoptimisée même si vous désactivez les points d’arrêt dans celle-ci. Vous devez supprimer le point d’arrêt de la fonction pour revenir à son état optimisé.

De nombreux points d’arrêt de débogage dynamique sont deux points d’arrêt : un dans le binaire optimisé et un dans le binaire non optimisé. Pour cette raison, vous voyez plusieurs points d’arrêt dans la fenêtre Points d’arrêt.

Les indicateurs du compilateur utilisés pour la version déoptimisée sont identiques aux indicateurs utilisés pour la version optimisée, à l’exception des indicateurs d’optimisation et des /dynamicdeopt. Ce comportement signifie que tous les indicateurs que vous définissez pour définir des macros, et ainsi de suite, sont définis dans la version déoptimisée également.

Le code déoptimisé n’est pas identique au code de débogage. Le code déoptimisé est compilé avec les mêmes indicateurs d’optimisation que la version optimisée, de sorte que les assertions et d’autres codes qui s’appuient sur des paramètres spécifiques au débogage ne sont pas inclus.

Créer l’intégration du système

Le débogage dynamique C++ nécessite que les indicateurs du compilateur et de l’éditeur de liens soient définis de manière particulière. Les sections suivantes décrivent comment configurer une configuration dédiée pour le débogage dynamique qui n’a pas de commutateurs en conflit.

Si votre projet est généré avec le système de génération Visual Studio, une bonne façon d’effectuer une configuration de débogage dynamique consiste à utiliser Configuration Manager pour cloner votre configuration Release ou Debug et apporter des modifications pour prendre en charge le débogage dynamique. Les deux sections suivantes décrivent les procédures.

Créer une configuration de mise en production

Dans le menu principal de Visual Studio, sélectionnez Build>Configuration Manager pour ouvrir Configuration Manager.
Sélectionnez la liste déroulante Configuration, puis sélectionnez <Nouveau...>.

Dans Configuration Manager, sous contextes de projet, la liste déroulante Configuration est ouverte et est mise en surbrillance.
La boîte de dialogue nouvelle configuration de solution s’ouvre. Dans le champ Nom, entrez un nom pour la nouvelle configuration, par exemple ReleaseDD. Vérifiez que Copier les paramètres à partir de : est défini sur Mise en production. Sélectionnez ensuite OK pour créer la nouvelle configuration.

Le champ Nom est défini sur ReleaseDD. La liste déroulante « Copier les paramètres à partir de » est définie sur Publication.
La nouvelle configuration apparaît dans la liste déroulante Configuration de la solution active :. Sélectionnez Fermer.
Avec la liste déroulante Configuration définie sur ReleaseDD, cliquez avec le bouton droit sur votre projet dans l’Explorateur de solutions, puis sélectionnez Propriétés.
Dans Propriétés de la configuration>Avancé, définissez Utiliser le débogage dynamique C++ sur Oui.
Vérifiez que Optimisation de l’ensemble du programme est défini sur Non.

La page des propriétés est ouverte sur Propriétés de la configuration > Avancé. Utilisez le débogage dynamique C++. Cette propriété est définie sur Oui. L’optimisation complète du programme est définie sur Non.
Dans Propriétés de la configuration> Éditeur de liens >Optimisation, vérifiez que Activer le pliage COMDAT est défini sur Non (/OPT:NOICF).

La page des propriétés est ouverte sur Propriétés de la configuration > Éditeur de liens > Optimisation > Activer le pliage CMDAT. La propriété a la valeur Non (/OPT :NOICF).

Ce paramètre ajoute le commutateur /dynamicdeopt au compilateur et à l’éditeur de liens. Avec les commutateurs d’optimisation C++ /GL et /OPT:ICF également désactivés, vous pouvez maintenant générer et exécuter votre projet dans la nouvelle configuration lorsque vous souhaitez une build de mise en production optimisée que vous pouvez utiliser avec le débogage dynamique C++.

Vous pouvez ajouter d’autres commutateurs que vous utilisez avec vos builds de vente au détail à cette configuration afin que vous ayez toujours activé ou désactivé exactement les commutateurs que vous attendez lorsque vous utilisez le débogage dynamique. Pour plus d’informations sur les commutateurs que vous ne devez pas utiliser avec le débogage dynamique, consultez Options incompatibles.

Pour plus d’informations sur les configurations dans Visual Studio, consultez Créer et modifier des configurations.

Créer une configuration de débogage

Si vous souhaitez utiliser des fichiers binaires de débogage, mais que vous souhaitez qu’ils s’exécutent plus rapidement, vous pouvez modifier votre configuration de débogage.

Dans le menu principal de Visual Studio, sélectionnez Build>Configuration Manager pour ouvrir Configuration Manager.
Sélectionnez la liste déroulante Configuration, puis sélectionnez <Nouveau...>.

Dans Configuration Manager, dans la partie Contextes du projet de la fenêtre, la liste déroulante Configuration est ouverte et est mise en surbrillance.
La boîte de dialogue nouvelle configuration de projet s’ouvre. Dans le champ Nom, entrez un nom pour la nouvelle configuration, par exemple DebugDD. Vérifiez que Copier les paramètres à partir de : est défini sur Déboguer. Sélectionnez ensuite OK pour créer la nouvelle configuration.

Le champ Nom est défini sur DebugDD. La liste déroulante Copier les paramètres à partir de : est définie sur Déboguer.
La nouvelle configuration apparaît dans la liste déroulante Configuration de la solution active :. Sélectionnez Fermer.
Avec la liste déroulante Configuration définie sur DebugDD, cliquez avec le bouton droit sur votre projet dans Explorateur de solutions, puis sélectionnez Propriétés.
Dans propriétés de configuration>C/C++>Optimisation, activez les optimisations souhaitées. Par exemple, vous pouvez définir Optimisation sur Maximiser la vitesse (/O2).
Dans C/C++>Génération du code, définissez Vérifications de base à l’exécution sur Par défaut.
Dans C/C++>Général, désactivez Prendre en charge seulement le débogage de mon code.
Définissez Format des informations de débogage sur Base de données du programme (/Zi).

Vous pouvez ajouter d’autres commutateurs que vous utilisez avec vos builds de débogage à cette configuration afin que vous ayez toujours activé ou désactivé exactement les commutateurs que vous attendez lorsque vous utilisez le débogage dynamique. Pour plus d’informations sur les commutateurs que vous ne devez pas utiliser avec le débogage dynamique, consultez Options incompatibles.

Pour plus d’informations sur les configurations dans Visual Studio, consultez Créer et modifier des configurations.

Considérations relatives au système de génération personnalisé

Si vous disposez d’un système de génération personnalisé, vérifiez que vous :

Passez /dynamicdeopt à cl.exe, lib.exeet link.exe.
N’utilisez pas /ZI, l’un des indicateurs de /RTC ou /JMC.

Pour les distributeurs de builds :

Pour un projet nommé test, le compilateur produit test.alt.obj, test.alt.exp, test.objet test.exp. L’éditeur de liens produit test.alt.exe, test.alt.pdb, test.exeet test.pdb.
Vous devez déployer le nouveau jeu d’outils binaire c2dd.dll en même temps que c2.dll.

Options incompatibles

Certaines options du compilateur et de l’éditeur de liens sont incompatibles avec le débogage dynamique C++. Si vous activez le débogage dynamique C++ à l’aide des paramètres du projet Visual Studio, les options incompatibles sont automatiquement désactivées, sauf si vous les définissez spécifiquement dans le paramètre d’options de ligne de commande supplémentaires.

Les options de compilateur suivantes sont incompatibles avec le débogage dynamique C++ :

/GH
/GL
/Gh
/RTC1 
/RTCc 
/RTCs 
/RTCu 
/ZI (/Zi is OK)
/ZW 
/clr 
/clr:initialAppDomain
/clr:netcore
/clr:newSyntax
/clr:noAssembly
/clr:pure
/clr:safe
/fastcap
/fsanitize=address
/fsanitize=kernel-address

Les options d’éditeur de liens suivantes sont incompatibles avec le débogage dynamique C++ :

/DEBUG:FASTLINK
/INCREMENTAL
/OPT:ICF  You can specify /OPT:ICF but the debugging experience may be poor

Voir aussi

Indicateur du compilateur /dynamicdeopt (préversion)
Indicateur de l’éditeur de liens /DYNAMICDEOPT (préversion)
Débogage dynamique C++ : Débogabilité complète pour les builds optimisées
Déboguer du code optimisé

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-10-27