Dynamisk felsökning i C++ (förhandsversion)

2025-10-27

Viktigt!

C++ Dynamisk felsökning är för närvarande i förhandsversion. Den här informationen gäller en förhandsversionsfunktion som kan ändras avsevärt före lanseringen. Microsoft lämnar inga garantier, uttryckta eller underförstådda, med avseende på den information som tillhandahålls här.

Den här förhandsgranskningsfunktionen, som är tillgänglig från och med Visual Studio 2022 Version 17.14 Preview 2, gäller endast för x64-projekt.

Med dynamisk C++-felsökning kan du felsöka optimerad kod som om den inte hade optimerats. Den här funktionen är användbar för utvecklare som behöver prestandafördelarna med optimerad kod, till exempel spelutvecklare som behöver höga bildfrekvenser. Med dynamisk C++ felsökning kan du njuta av felsökningsupplevelsen av ooptimerad kod utan att offra prestandafördelarna med optimerade versioner.

Felsökning av optimerad kod medför utmaningar. Kompilatorn ompositionerar och omorganiserar instruktioner för att optimera kod. Resultatet är effektivare kod, men det innebär:

Optimeraren kan ta bort lokala variabler eller flytta dem till platser som är okända för felsökningsprogrammet.
Kod i en funktion kanske inte längre överensstämmer med källkoden när optimeraren sammanfogar kodblock.
Funktionsnamn för funktioner i anropsstacken kan vara fel om optimeraren sammanfogar två funktioner.

Tidigare har utvecklare hanterat dessa problem och andra när de höll på att felsöka optimerad kod. Nu har dessa utmaningar eliminerats eftersom du med dynamisk felsökning i C++ kan gå in i optimerad kod som om den vore ooptimerad.

Förutom att generera de optimerade binärfilerna genererar kompilering med /dynamicdeopt ooptimerade binärfiler som används vid felsökning. När du lägger till en brytpunkt eller går in i en funktion (inklusive __forceinline funktioner) läser felsökningsprogrammet in den ej optimerade binära filen. Sedan kan du felsöka den ooptimerade koden för funktionen i stället för den optimerade koden. Du kan felsöka som om du felsöker ooptimerad kod medan du fortfarande får prestandafördelarna med optimerad kod i resten av programmet.

Prova C++ dynamisk felsökning

Först ska vi gå igenom hur det är att felsöka optimerad kod. Sedan kan du se hur dynamisk felsökning i C++ förenklar processen.

Skapa ett nytt C++-konsolprogramprojekt i Visual Studio. Ersätt innehållet i ConsoleApplication.cpp-filen med följande kod:

// 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;
}

Ändra listrutan Lösningskonfigurationer till Släpp. Kontrollera att listrutan lösningsplattform är inställd på x64.
Återskapa genom att välja Skapa>återskapa lösning.
Ange en brytpunkt på rad 55 i int neighbors = countNeighbors(grid, i, j);updateGrid(). Kör programmet.
När du träffar brytpunkten visar du fönstret Lokal. På huvudmenyn väljer du Felsöka>Windows>Locals. Observera att du inte kan se värdet av i eller j i fönstret Lokala variabler. Kompilatorn har optimerat bort dem.
Försök att ange en brytpunkt på rad 19 i cout << (grid[i][j] ? '*' : ' ');printGrid(). Det kan du inte. Det här beteendet förväntas eftersom kompilatorn optimerade koden.

Stoppa programmet och aktivera dynamisk C++-felsökning och försök igen

Högerklicka på projektet i Solution Explorer och välj Egenskaper för att öppna projektegenskapssidorna.
Välj Avancerad>användning av dynamisk felsökning i C++ och ändra inställningen till Ja.

Egenskapssidan öppnas för Konfigurationsegenskaper > Avancerad > Använd dynamisk felsökning i C++ . Egenskapen är inställd på Ja.

Det här steget lägger till växeln /dynamicdeopt till kompilatorn och länkaren. I bakgrunden inaktiveras även C++-optimeringsväxlarna /GL och /OPT:ICF. Den här inställningen skriver inte över växlar som du lade till manuellt på kommandoraden eller andra optimeringsväxlar som har angetts, till exempel /O1.
Återskapa genom att välja Skapa>återskapa lösning. Kompileringsdiagnostikkod MSB8088 visas, vilket indikerar att dynamisk felsökning och hela programoptimeringen är inkompatibla. Det här felet innebär att hela programoptimeringen (/GL) inaktiverades automatiskt under kompilering.

Du kan inaktivera hela programoptimeringen manuellt i projektegenskaperna. Välj Konfigurationsegenskaper>Avancerad>optimering av hela programmet och ändra inställningen till Av. Nu MSB8088 behandlas som en varning, men det kan behandlas som ett fel i en framtida version av Visual Studio.
Kör appen igen.

Nu när du träffar brytpunkten på rad 55 ser du värdena på i och j i fönstret Lokala. Fönstret Samtalsstack visar att updateGrid() är avoptimerat och filnamnet är life.alt.exe. Den här alternativa binärfilen används för att felsöka optimerad kod.

En brytpunkt visas i funktionen updateGrid. Anropsstacken visar att funktionen är avoptimerad och filnamnet är life.alt.exe. Fönstret Lokala värden visar värdena för i och j och de andra lokala variablerna i funktionen.

Funktionen updateGrid() är avoptimerad på begäran eftersom du anger en brytpunkt i den. Om du kliver över en optimerad funktion under felsökning, blir den inte avoptimerad. Om du går in i en funktion är den deoptimerad. Det huvudsakliga sättet att få en funktion att avoptimeras är om du anger en brytpunkt i den eller går in i den.

Du kan också avoptimera en funktion i fönstret anropsstack. Högerklicka på funktionen eller en vald grupp med funktioner och välj Avoptimera vid nästa post. Den här funktionen är användbar när du vill visa lokala variabler i en optimerad funktion som du inte har angett någon brytpunkt för någon annanstans i anropsstacken för. Funktioner som avoptimeras på det här sättet grupperas tillsammans i fönstret Brytpunkter som en brytpunktsgrupp med namnet Deoptimized Functions. Om du tar bort brytpunktsgruppen återgår de associerade funktionerna till sitt optimerade tillstånd.

Använda villkorsstyrda och beroende brytpunkter

Försök att ange en brytpunkt igen på rad 19 i cout << (grid[i][j] ? '*' : ' ');printGrid(). Nu fungerar det. Om du anger en brytpunkt i funktionen deoptimeras den så att du kan felsöka den normalt.
Högerklicka på brytpunkten på rad 19, välj Villkor och ange villkoret till i == 10 && j== 10. Välj sedan kryssrutan Aktivera endast när följande brytpunkt visas: Välj brytpunkten på rad 55 i listrutan. Brytpunkten på rad 19 når inte förrän brytpunkten på rad 50 slås först och när grid[10][10] är på väg att matas ut till konsolen.

Poängen är att du kan ange villkorsstyrda och beroende brytpunkter i en optimerad funktion och använda lokala variabler och kodrader som i en optimerad version kanske inte är tillgängliga för felsökningsprogrammet.

En villkorsstyrd brytpunkt visas på rad 19, cout < < (grid[i][j] ? '*' : ' ');. Villkoret är inställt på i == 10 && j== 10. Kryssrutan Aktivera endast när följande brytpunkt träffas är vald. Brytpunktslistrutan är inställd på life.cpp rad 55.
Fortsätt att köra appen. När brytpunkten på rad 19 har träffats kan du högerklicka på rad 15 och välja Ange nästa instruktion för att köra loopen igen.

En villkorsstyrd och beroende brytpunkt träffas på rad 19, cout < < (grid[i][j] ? '*' : ' ');. Fönstret Lokala värden visar värdena för i och j och de andra lokala variablerna i funktionen. Fönstret Anropsstack visar att funktionen är avoptimerad och att filnamnet är life.alt.exe.
Ta bort alla brytpunkter för att returnera deoptimerade funktioner till deras optimerade tillstånd. På Huvudmenyn i Visual Studio väljer du Felsöka>Ta bort alla brytpunkter. Alla funktioner återgår sedan till sitt optimerade tillstånd.

Om du lägger till brytpunkter via fönstret Samtalsstack alternativet Avoptimering vid nästa inmatning, som vi inte gjorde i denna genomgång, kan du högerklicka på gruppen Avoptimerade funktioner och välja Ta bort för att endast återställa funktionerna i gruppen till deras optimerade tillstånd.

Fönstret Brytpunkter visar gruppen Deoptimized Functions. Gruppen är markerad och snabbmenyn är öppen med Ta bort brytpunktsgrupp markerad.

Inaktivera dynamisk felsökning av C++

Du kan behöva felsöka optimerad kod utan att den är avoptimerad eller placera en brytpunkt i optimerad kod och låta koden förbli optimerad när brytpunkten når. Det finns flera sätt att inaktivera dynamisk felsökning eller hindra den från att avoptimera kod när du träffar en brytpunkt:

På Huvudmenyn i Visual Studio väljer du Verktygsalternativ>. I fönstret Alternativ expanderar du avsnittet Alla inställningar>felsökning>allmänt . Avmarkera kryssrutan Automatiskt avoptimera debuggade funktioner när det är möjligt (.NET 8+, C++ Dynamisk felsökning). Nästa gång felsökningsprogrammet startar förblir koden optimerad.

På Huvudmenyn i Visual Studio väljer du Verktygsalternativ>. I dialogrutan Alternativ expanderar du avsnittet Felsöka>allmänt . Avmarkera kryssrutan Automatiskt avoptimera debuggade funktioner när det är möjligt (.NET 8+, C++ Dynamisk felsökning). Nästa gång felsökningsprogrammet startar förblir koden optimerad.

Många dynamiska felsöknings brytpunkter är två brytpunkter: en i den optimerade binärfilen och en i den ooptimerade binära filen. I fönstret Brytpunkter väljer du Visa kolumnfunktion>. Rensa brytpunkten som är associerad med binärfilen alt . Den andra brytpunkten i paret bryter i den optimerade koden.
När du felsöker väljer du Felsöka>Windows>Deassembly på Huvudmenyn i Visual Studio. Se till att den har fokus. När du går in i en funktion via fönstret Disassembly kommer funktionen inte att avoptimeras.
Inaktivera dynamisk felsökning helt och hållet genom att inte skicka /dynamicdeopt till cl.exe, lib.exeoch link.exe. Om du använder bibliotek från tredje part och inte kan återskapa dem, ska du inte skicka med /dynamicdeopt under den sista link.exe för att inaktivera dynamisk felsökning för binären.
Om du snabbt vill inaktivera dynamisk felsökning för en enda binär fil (till exempel test.dll), byter du namn på eller tar bort binärfilen alt (till exempel test.alt.dll).
Om du vill inaktivera dynamisk felsökning för en eller flera .cpp filer ska du inte skicka /dynamicdeopt när du skapar dem. Resten av projektet skapas med dynamisk felsökning.

Aktivera C++ dynamisk felsökning för Unreal Engine 5.6 eller senare

Unreal Engine 5.6 stöder dynamisk C++ felsökning för både Unreal Build Tool och Unreal Build Accelerator. Det finns två sätt att aktivera det. Ändra BuildConfiguration.xml filen eller Ändra Targets.cs filen.

`BuildConfiguration.xml` Ändra filen

I Visual Studio väljer du konfigurationen för utvecklingsredigeraren och ändrar BuildConfiguration.xml för att inkludera <bDynamicDebugging>true</bDynamicDebugging>. Mer information om BuildConfiguration.xml och dess plats finns i Skapa konfiguration.

Ett sätt att hitta BuildConfiguration.xml filen är att köra en kompilering och kontrollera byggloggen. När du till exempel skapar Lyra Starter-spelet ser du utdata så här:

- 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

Sök efter Log.txtBuildConfiguration.xml. Den bör innehålla en rad som Reading configuration file from: C:\LyraStarterGame\Saved\UnrealBuildTool\BuildConfiguration.xml

Ändra filen BuildConfiguration.xml så att den innehåller <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>

`Targets.cs` Ändra filen

Det andra sättet att aktivera dynamisk C++-felsökning för både Unreal Build Tool och Unreal Build Accelerator är att ändra filen så att den Target.cs innehåller WindowsPlatform.bDynamicDebugging = true.

Unreal Engine-projekt har Target.cs filer som är associerade med flera måltyper, inklusive:

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

För en editor-bygge, i {ProjectName}Editor.Target.cs-filen, lägg till WindowsPlatform.bDynamicDebugging = true; i konstruktorn:

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

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

Eller, för en spelbyggnation, lägger du till {ProjectName}.Target.cs i WindowsPlatform.bDynamicDebugging = true;-filen till ApplyShared{Project name}TargetSettings():

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

Mer information om Unreal Engine-målfiler finns i Mål.

Aktivera dynamisk C++ felsökning för Unreal Engine 5.5 eller tidigare

För Unreal Engine 5.5 eller tidigare väljer du Unreal Build Tool-ändringarna från GitHub till din lagringsplats.

Anmärkning

För att få åtkomst till Epic-lagringsplatserna på GitHub behöver du ett Epic-konto och ett registrerat GitHub-konto.

När du har valt de ändringar som ska tillämpas på lagringsplatsen aktiverar du bDynamicDebugging enligt beskrivningen tidigare. Du måste också använda Unreal Build Accelerator från Unreal Engine 5.6. Använd antingen de senaste bitarna från ue5-main eller inaktivera UBA genom att lägga till följande i BuildConfiguration.xml:

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

Mer information om hur du konfigurerar hur Unreal Engine skapas finns i Skapa konfiguration.

Felsökning

Om brytpunkter inte triggas i avoptimerade funktioner:

Om du går ut ur en [Deoptimized] ram kan du vara i optimerad kod om inte anroparen avoptimerades på grund av en brytpunkt i den eller om du steg in i anroparen på väg till den aktuella funktionen.
Se till att alt.exe och alt.pdb filerna byggs. För test.exe och test.pdb, test.alt.exe och test.alt.pdb måste finnas i samma katalog. Se till att de rätta byggväxlarna är inställda enligt den här artikeln.

En debug directory post finns i test.exe som felsökaren använder för att hitta binärfilen alt som ska användas för avoptimerad felsökning. Öppna en x64-inföd Visual Studio-kommandotolk och kör link /dump /headers <your executable.exe> för att kontrollera om en deopt-post finns. En deopt post visas i Type kolumnen, som visas på den sista raden i det här exemplet:

  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

deopt Om katalogposten för felsökning inte finns där kontrollerar du att du skickar /dynamicdeopt till cl.exe, lib.exeoch link.exe.

Dynamisk avoptimisering fungerar inte konsekvent om /dynamicdeopt inte skickas till cl.exe, lib.exe, och link.exe för alla .cpp, .lib och binära filer. Bekräfta att rätt växlar har angetts när du skapar projektet.

Mer information om kända problem finns i C++ Dynamisk felsökning: Fullständig felsökning för optimerade versioner.

Om det inte fungerar som förväntat öppnar du ett ärende i Utvecklarcommunityn. Ta med så mycket information som möjligt om problemet.

Allmänna anteckningar

IncrediBuild 10.24 stöder C++ dynamiska felsökningsversioner.
FastBuild v1.15 har stöd för C++ Dynamiska felsökningsversioner.

Funktioner som är inlindade avoptimeras på begäran. Om du anger en brytpunkt för en inlindad funktion avoptimerar felsökningsprogrammet funktionen och dess anropare. Brytpunkten når den punkt där du förväntar dig det, som om programmet skapades utan kompilatoroptimeringar.

En funktion förblir avoptimerad även om du inaktiverar brytpunkterna i den. Du måste ta bort brytpunkten för funktionen för att återgå till dess optimerade tillstånd.

Många dynamiska felsöknings brytpunkter är två brytpunkter: en i den optimerade binärfilen och en i den ooptimerade binära filen. Därför visas mer än en brytpunkt i fönstret Brytpunkter .

Kompilatorflaggor som används för den avoptimerade versionen är samma som flaggorna som används för den optimerade versionen, förutom optimeringsflaggor och /dynamicdeopt. Det här beteendet innebär att alla flaggor som du anger för att definiera makron och så vidare också anges i den avoptimerade versionen.

Avoptimerad kod är inte samma sak som felsökningskod. Den deoptimerade koden kompileras med samma optimeringsflaggor som den optimerade versionen, så assert och annan kod som förlitar sig på felsökningsspecifika inställningar ingår inte.

Skapa systemintegrering

Dynamisk felsökning i C++ kräver att kompilator- och länkflaggor måste anges på ett visst sätt. I följande avsnitt beskrivs hur du konfigurerar en dedikerad konfiguration för dynamisk felsökning som inte har motstridiga växlar.

Om projektet har skapats med Visual Studio-byggsystemet är ett bra sätt att skapa en konfiguration för dynamisk felsökning att använda Configuration Manager för att klona din versions- eller felsökningskonfiguration och göra ändringar för dynamisk felsökning. I följande två avsnitt beskrivs procedurerna.

Skapa en ny versionskonfiguration

På Visual Studio-huvudmenyn väljer du Skapa>Configuration Manager för att öppna Configuration Manager.
Välj listrutan Konfiguration och välj <sedan Ny...>.

Under Projektkontexter i Configuration Manager är listrutan Konfiguration öppen och markerad.
Dialogrutan Ny lösningskonfiguration öppnas. I fältet Namn anger du ett namn för den nya konfigurationen, till exempel ReleaseDD. Kontrollera att Kopieringsinställningarna från: är inställda på Släpp. Välj sedan OK för att skapa den nya konfigurationen.

Fältet Namn är inställt på ReleaseDD. Listrutan Kopiera inställningar från är inställd på Släpp.
Den nya konfigurationen visas i listrutan Aktiv lösningskonfiguration . Välj Stäng.
Med listrutan Konfiguration inställd på ReleaseDD högerklickar du på projektet i Solution Explorer och väljer Egenskaper.
I Avancerade konfigurationsegenskaper> anger du Använd C++ Dynamisk felsökning till Ja.
Se till att Hela programoptimeringen är inställd på Nej.

Egenskapssidan öppnas för Konfigurationsegenskaper > Avancerat. Använd dynamisk felsökning i C++ . Egenskapen är inställd på Ja. Hela programoptimeringen är inställd på Nej.
I Konfigurationsegenskaper>Länkare>Optimering kontrollerar du att Aktivera COMDAT-vikning är inställt på Nej (/OPT:NOICF).

Egenskapssidan öppnas för Konfigurationsegenskaper > Länkare > Optimering > Aktivera CMDAT Folding. Egenskapen är inställd på Nej (/OPT:NOICF).

Den här inställningen lägger till växlingsalternativet /dynamicdeopt till kompilatorn och länkaren. Med C++-optimeringsväxlar /GL och /OPT:ICF även inaktiverat kan du nu skapa och köra projektet i den nya konfigurationen när du vill ha en optimerad versionsversion som du kan använda med dynamisk C++-felsökning.

Du kan lägga till andra växlar som du använder med era retail builds till den här konfigurationen, så att du alltid har exakt de växlar aktiverade eller inaktiverade som du förväntar dig när du använder Dynamisk Debugging. Mer information om växlar som du inte bör använda med dynamisk felsökning finns i Inkompatibla alternativ.

Mer information om konfigurationer i Visual Studio finns i Skapa och redigera konfigurationer.

Skapa en ny felsökningskonfiguration

Om du vill använda binärfiler för felsökning men vill att de ska köras snabbare kan du ändra felsökningskonfigurationen.

På Visual Studio-huvudmenyn väljer du Skapa>Configuration Manager för att öppna Configuration Manager.
Välj listrutan Konfiguration och välj <sedan Ny...>.

I Configuration Manager, i delen för projektkontexter i fönstret, är konfigurationslistrutan öppen och markerad.
Dialogrutan Ny projektkonfiguration öppnas. I fältet Namn anger du ett namn för den nya konfigurationen, till exempel DebugDD. Kontrollera att Kopiera inställningar från: är inställt på Felsök. Välj sedan OK för att skapa den nya konfigurationen.

Namnfältet är inställt på DebugDD. Listrutan Kopiera inställningar från: är inställd på Felsök.
Den nya konfigurationen visas i listrutan Aktiv lösningskonfiguration . Välj Stäng.
Med listrutan Konfiguration inställd på DebugDD högerklickar du på projektet i Solution Explorer och väljer Egenskaper.
I Konfigurationsegenskaper>C/C++>-optimering aktiverar du de optimeringar som du vill använda. Du kan till exempel ange optimering till Maximera hastighet (/O2).
I C/C++>Code Generation anger du Grundläggande körningskontroller till Standard.
I C/C++>Allmänt inaktiverar du Felsökning av bara min kod.
Ange Felsökningsinformationsformat tillProgramdatabas (/Zi).

Du kan lägga till andra växlar som du använder med dina felsökningsversioner i den här konfigurationen så att du alltid har exakt de växlar som du förväntar dig när du använder dynamisk felsökning. Mer information om växlar som du inte bör använda med dynamisk felsökning finns i Inkompatibla alternativ.

Mer information om konfigurationer i Visual Studio finns i Skapa och redigera konfigurationer.

Överväganden för anpassat byggsystem

Om du har ett anpassat byggsystem kontrollerar du att du:

Skicka /dynamicdeopt till cl.exe, lib.exeoch link.exe.
Använd inte /ZI, någon av flaggorna /RTC eller /JMC.

För byggdistributörer:

För ett projekt som heter test skapar kompilatorn test.alt.obj, test.alt.exp, test.obj och test.exp. Länkaren producerar test.alt.exe, test.alt.pdb, test.exeoch test.pdb.
Du måste distribuera binärfilen för den nya verktygssatsen c2dd.dll tillsammans med c2.dll.

Inkompatibla alternativ

Vissa kompilator- och länkalternativ är inte kompatibla med dynamisk felsökning av C++. Om du aktiverar dynamisk C++-felsökning med hjälp av Visual Studio-projektinställningarna inaktiveras inkompatibla alternativ automatiskt om du inte specifikt anger dem i inställningen ytterligare kommandoradsalternativ.

Följande kompilatoralternativ är inte kompatibla med dynamisk C++-felsökning:

/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

Följande länkalternativ är inte kompatibla med dynamisk C++-felsökning:

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

Se även

/dynamicdeopt-kompilatorflagga (förhandsversion)
/DYNAMICDEOPT-länkflagga (förhandsversion)
C++ Dynamisk felsökning: Fullständig felsökning för optimerade versioner
Felsöka optimerad kod

Feedback

Var den här sidan till hjälp?