Controllo della destinazione
Durante il debug di un'applicazione di destinazione in modalità utente o in un computer di destinazione in modalità kernel, la destinazione può essere in esecuzione o arrestata.
Quando il debugger si connette a una destinazione in modalità kernel, il debugger lascia la destinazione in esecuzione, a meno che non si usi l'opzione della riga di comando -b, il sistema di destinazione ha smesso di rispondere (ovvero si è arrestato in modo anomalo) o il sistema di destinazione è ancora arrestato a causa di un'azione di debug del kernel precedente.
Quando il debugger viene avviato o si connette a una destinazione in modalità utente, il debugger arresta immediatamente la destinazione, a meno che non si usi l'opzione della riga di comando -g . Per altre informazioni, vedere Punto di interruzione iniziale.
Quando la destinazione è in esecuzione
Quando la destinazione è in esecuzione, la maggior parte delle azioni del debugger non è disponibile.
Se si vuole arrestare una destinazione in esecuzione, è possibile eseguire un comando Interrompi . Questo comando causa l'interruzione del debugger nella destinazione. Ovvero, il debugger arresta la destinazione e tutto il controllo viene assegnato al debugger. L'applicazione potrebbe non interrompersi immediatamente. Ad esempio, se tutti i thread eseguono il codice di sistema o si trovano in un'operazione di attesa, l'applicazione si interrompe solo dopo che il controllo è tornato al codice dell'applicazione.
Se una destinazione in esecuzione rileva un'eccezione, se si verificano determinati eventi , se viene raggiunto un punto di interruzione o se l'applicazione si chiude normalmente, la destinazione si interrompe nel debugger. Questa azione arresta la destinazione e assegna tutto il controllo al debugger. Viene visualizzato un messaggio nella finestra Di comando del debugger e viene descritto l'errore, l'evento o il punto di interruzione.
Quando la destinazione è arrestata
Per avviare o controllare l'esecuzione della destinazione, è possibile eseguire le operazioni seguenti:
Per fare in modo che l'applicazione inizi l'esecuzione, eseguire il comando Go .
Per eseguire un'istruzione alla volta nell'applicazione, usare i comandi Esegui istruzione o Esegui istruzione. Se si verifica una chiamata di funzione, Esegui istruzione entra nella funzione e continua a scorrere ogni istruzione. Step Over considera la chiamata di funzione come un singolo passaggio. Quando il debugger è in modalità assembly, viene eseguita un'istruzione del computer alla volta. Quando il debugger è in modalità origine, l'istruzione viene eseguita una riga di origine alla volta.
Per completare la funzione corrente e arrestarla quando viene restituito, usare i comandi Esci da istruzione o traccia e controllo . Il comando Step Out continua fino al termine della funzione corrente. Trace and Watch continua fino al termine della funzione corrente e visualizza anche un riepilogo delle chiamate della funzione. Tuttavia, è necessario eseguire il comando Trace and Watch sulla prima istruzione della funzione in questione.
Se si verifica un'eccezione, è possibile usare i comandi Go with Exception Handled e Go with Exception Not Handled per riprendere l'esecuzione e controllare lo stato dell'eccezione. Per altre informazioni sulle eccezioni, vedere Controllo di eccezioni ed eventi.
(solo WinDbg) Se si seleziona una riga nella finestra Disassembly o nella finestra Source e quindi si usa il comando Esegui al cursore , il programma viene eseguito fino a quando non rileva la riga selezionata.
(solo modalità utente) Per chiudere l'applicazione di destinazione e riavviarla dall'inizio, usare il comando Riavvia . È possibile usare questo comando solo con un processo creato dal debugger. Dopo il riavvio del processo, il processo si interrompe immediatamente nel debugger.
(solo WinDbg) Per chiudere l'applicazione di destinazione e cancellare il debugger, usare il comando Arresta debug . Questo comando consente di avviare il debug di una destinazione diversa.
Moduli di comando
La maggior parte dei comandi per avviare o controllare l'esecuzione della destinazione esiste come comandi di testo, comandi di menu, pulsanti della barra degli strumenti e tasti di scelta rapida. Come comandi di testo di base, è possibile usare questi comandi in CDB, KD o WinDbg. Il formato di testo dei comandi supporta spesso opzioni aggiuntive, ad esempio la modifica della posizione del contatore del programma o l'esecuzione di un numero fisso di istruzioni. È possibile usare i comandi di menu, i pulsanti della barra degli strumenti e i tasti di scelta rapida in WinDbg.
È possibile usare i comandi nei moduli seguenti.
| Comando | Comando WinDbg | Tasti di scelta rapida winDbg | Effetto |
|---|---|---|---|
Debug | Esegui fino al cursore |
F7 CTRL + F10 |
(solo WinDbg) Viene eseguito fino a raggiungere la riga contrassegnata dal cursore. |
|
Debug | Arresta debug |
MAIUSC + F5 |
Arresta tutto il debug e chiude la destinazione. |
|
(solo CDB/KD) CTRL+C |
Debug | Rompere |
CTRL+INTERR |
L'esecuzione si arresta e il debugger si suddivide nella destinazione. |
Debug | Riavviare |
CTRL + MAIUSC + F5 |
(solo modalità utente) Riavvia l'applicazione di destinazione. |
|
Debug | Andare |
F5 |
La destinazione viene eseguita liberamente. |
|
Riprende l'esecuzione dopo un punto di interruzione condizionale. |
|||
Debug | Eccezione gestita da Go |
Uguale a g (Go), ad eccezione del fatto che l'eccezione corrente viene considerata come gestita. |
||
Debug | Eccezione Go non gestita |
Uguale a g (Go), ad eccezione del fatto che l'eccezione corrente viene considerata come non gestita. |
||
Debug | Esci dall'uscita |
MAIUSC + F11 |
La destinazione viene eseguita fino al completamento della funzione corrente. |
|
Debug | Eseguire il passaggio |
F10 |
La destinazione esegue un'istruzione. Se questa istruzione è una chiamata di funzione, tale funzione viene eseguita come singolo passaggio. |
|
La destinazione viene eseguita fino a raggiungere l'indirizzo specificato. Vengono visualizzati tutti i passaggi di questa funzione ( ma i passaggi in denominati funzioni non sono ). |
|||
La destinazione viene eseguita fino all'istruzione di chiamata successiva. Se l'istruzione corrente è un'istruzione di chiamata, questa chiamata viene eseguita completamente e l'esecuzione continua fino alla chiamata successiva. |
|||
La destinazione viene eseguita fino a raggiungere un'istruzione di chiamata o un'istruzione restituita . |
|||
La destinazione viene eseguita fino a raggiungere qualsiasi tipo di istruzione di diramazione, inclusi rami condizionali o incondizionato, chiamate, restituzioni e chiamate di sistema. |
|||
La destinazione viene eseguita fino a raggiungere un'istruzione restituita . |
|||
Debug | Eseguire l'istruzione in |
F11 F8 |
La destinazione esegue un'istruzione. Se questa istruzione è una chiamata di funzione, il debugger esegue la traccia in tale chiamata. |
|
La destinazione viene eseguita fino a raggiungere l'indirizzo specificato. Vengono visualizzati tutti i passaggi di questa funzione e le funzioni chiamate. |
|||
(Tutte le modalità, ad eccezione della modalità kernel, solo nei sistemi basati su x86) La destinazione viene eseguita fino a raggiungere l'istruzione di ramo successiva. |
|||
La destinazione viene eseguita fino all'istruzione di chiamata successiva. Se l'istruzione corrente è un'istruzione di chiamata , l'istruzione viene tracciata fino a quando non viene raggiunta una nuova chiamata . |
|||
La destinazione viene eseguita fino a raggiungere un'istruzione di chiamata o un'istruzione restituita . Se l'istruzione corrente è un'istruzione di chiamata o un'istruzione return , l'istruzione viene tracciata fino a quando non viene raggiunta una nuova chiamata o restituita . |
|||
La destinazione viene eseguita fino a raggiungere qualsiasi tipo di istruzione di diramazione, inclusi rami condizionali o incondizionato, chiamate, restituzioni e chiamate di sistema. Se l'istruzione corrente è un'istruzione di diramazione, l'istruzione viene tracciata fino a quando non viene raggiunta una nuova istruzione di diramazione. |
|||
La destinazione viene eseguita fino a raggiungere un'istruzione restituita . Se l'istruzione corrente è un'istruzione restituita , l'istruzione viene tracciata in finché non viene raggiunto un nuovo risultato . |
|||
La destinazione viene eseguita fino al completamento dell'intera funzione specificata. Vengono quindi visualizzate le statistiche. |
Per altre informazioni su come riavviare il computer di destinazione, vedere Arresto anomalo e riavvio del computer di destinazione.
Opzioni della riga di comando
Se non si vuole che l'applicazione venga interrotta immediatamente all'avvio o al caricamento, usare CDB o WinDbg insieme all'opzione della riga di comando -g . Per altre informazioni su questa situazione, vedere Punto di interruzione iniziale.
CDB e WinDbg supportano anche l'opzione della riga di comando -G. Questa opzione causa la fine della sessione di debug se l'applicazione viene completata correttamente.
Il comando seguente tenta di eseguire l'applicazione dall'inizio alla fine e il prompt del debugger viene visualizzato solo se si verifica un errore.
cdb -g -G ApplicationName
È possibile usare l'opzione della riga di comando -pt per impostare il timeout dell'interruzione. Esistono alcuni problemi che possono rendere la destinazione incapace di comunicare con il debugger. Se viene eseguito un comando di interruzione e il debugger non può entrare nella destinazione dopo questa volta, il debugger visualizza un messaggio "Timeout di interruzione".
A questo punto, il debugger smette di tentare di eseguire l'interruzione nella destinazione. Il debugger sospende invece la destinazione e consente di esaminare (ma non controllare) l'applicazione di destinazione.
Il timeout predefinito è 30 secondi.