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, la maggior parte delle azioni del debugger non sono disponibili.
Se desideri arrestare una destinazione in esecuzione, puoi eseguire un comando Interrompi. Questo comando fa sì che il debugger si interrompa sulla 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 entra nel debugger. Questa azione arresta la destinazione e assegna il completo 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.
Per avviare o controllare l'esecuzione dell'obiettivo, è possibile eseguire le operazioni seguenti:
Per fare in modo che l'applicazione inizi l'esecuzione, eseguire il comando Go .
Per eseguire l'applicazione un'istruzione alla volta, usare i comandi Entra o Esci. Se si verifica una chiamata di funzione, Entra passo-passo nella funzione e continua a eseguire 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, si procede una riga di codice alla volta.
Per terminare la funzione corrente e interrompere l'esecuzione al ritorno, usare i comandi Esci dalla funzione o Traccia e Osserva. 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, entra 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.
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 | Interrompi il debug |
MAIUSC + F5 |
Arresta tutto il processo di debug e chiude l'obiettivo. |
|
(solo CDB/KD) CTRL+C |
Debug | Rompere |
CTRL + Pausa/Interr |
L'esecuzione si arresta e il debugger interrompe l'esecuzione nel target. |
Debug | Riavviare |
CTRL + MAIUSC + F5 |
(solo modalità utente) Riavvia l'applicazione di destinazione. |
|
Debug | Vai |
F5 |
L'obiettivo si realizza 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 dal passo |
MAIUSC + F11 |
L'obiettivo viene eseguito fino al completamento della funzione corrente. |
|
Debug | Passaggio avanti |
F10 |
La destinazione esegue un'istruzione. Se questa istruzione è una chiamata di funzione, tale funzione viene eseguita come singolo passaggio. |
|
Il target continua fino a raggiungere l'indirizzo specificato. Vengono visualizzati tutti i passaggi di questa funzione (ma i passaggi nelle funzioni chiamate non lo 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. |
|||
Il target viene eseguito fino a raggiungere un'istruzione di chiamata o un'istruzione di ritorno. |
|||
Il target viene eseguito fino a raggiungere qualsiasi tipo di istruzione di diramazione, inclusi rami condizionali e incondizionati, chiamate, ritorni e chiamate di sistema. |
|||
La destinazione viene eseguita fino a raggiungere un'istruzione return. |
|||
Debug | Passo nell'istruzione |
F11 F8 |
Target esegue un'istruzione. Se questa istruzione è una chiamata di funzione, il debugger effettua il tracciamento su tale chiamata. |
|
Il target si esegue 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) Il target si esegue fino a raggiungere l'istruzione di ramo successiva. |
|||
Il target continua fino all'istruzione di chiamata successiva. Se l'istruzione corrente è un'istruzione di chiamata, l'istruzione viene seguita fino a raggiungere una nuova chiamata. |
|||
L'obiettivo viene eseguito fino a raggiungere un'istruzione di chiamata o un'istruzione di ritorno. Se l'istruzione corrente è un'istruzione di chiamata o di return, l'istruzione viene tracciata finché non si raggiunge una nuova chiamata o un nuovo ritorno. |
|||
Il bersaglio viene eseguito fino a raggiungere qualsiasi tipo di istruzione di diramazione, inclusi rami condizionali o incondizionati, chiamate, ritorni 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. |
|||
L'obiettivo viene eseguito fino a raggiungere un'istruzione return. Se l'istruzione corrente è un'istruzione return, l'istruzione viene monitorata fino a che non viene raggiunto un nuovo return. |
|||
L'obiettivo viene eseguito 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.
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 -ptl'opzione della riga di comando per impostare il timeout di interruzione. Esistono alcuni problemi che possono rendere il bersaglio 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 interrompere il target. Invece, il debugger sospende il target e ti permette di esaminare (ma non controllare) l'applicazione.
Il timeout predefinito è 30 secondi.