wt (Suivi et surveillance des données)

La commande wt exécute l’ensemble de la fonction, puis affiche des statistiques lorsque vous exécutez cette commande au début d’un appel de fonction.

wt [WatchOptions] [= StartAddress] [EndAddress] 

Paramètres

WatchOptions
Spécifie comment modifier l’affichage. Vous pouvez utiliser l’une des options suivantes.

Option	Résultat
-lProfondeur	(Mode utilisateur uniquement) Spécifie la profondeur maximale des appels à afficher. Tous les appels qui sont au moins des niveaux de profondeur plus profonds que le point de départ sont exécutés en mode silencieux.
-mModule	(Mode utilisateur uniquement) Limite l’affichage au code à l’intérieur du module spécifié, plus le premier niveau d’appels effectués à partir de ce module. Vous pouvez inclure plusieurs options -m pour afficher le code de plusieurs modules et aucun autre module.
-iModule	(Mode utilisateur uniquement) Ignore tout code dans le module spécifié. Vous pouvez inclure plusieurs options -i pour ignorer le code de plusieurs modules. Si vous utilisez une option -m, le débogueur ignore toutes les options -i.
-ni	(Mode utilisateur uniquement) N’affiche aucune entrée dans le code ignorée en raison d’une option -m ou -i.
-Nc	N’affiche pas les informations d’appel individuel.
-Ns	N’affiche pas d’informations récapitulatives.
-Nw	N’affiche pas d’avertissements pendant la trace.
-Oa	(Mode utilisateur uniquement) Affiche l’adresse réelle des sites d’appel.
-or	(Mode utilisateur uniquement) Affiche les valeurs de registre de retour de la fonction appelée, en utilisant le radix par défaut comme base.
-Ou	(Mode utilisateur uniquement) Affiche les valeurs de registre de retour de la fonction appelée, dans le type approprié pour chaque valeur de retour.

StartAddress
Spécifie l’adresse où le débogueur commence l’exécution. Si vous n’utilisez pas StartAddress, l’exécution commence à l’instruction vers laquelle pointe le pointeur d’instruction. Pour plus d’informations sur la syntaxe, consultez Address and Address Range Syntax.

EndAddress
Spécifie l’adresse où se termine le suivi. Si vous n’utilisez pas EndAddress, un seul appel d’instruction ou de fonction est exécuté.

Environnement

Modes	Mode utilisateur, mode noyau
Cibles	Débogage actif uniquement
Plateformes	Mode utilisateur :mode tout le noyau : x86 uniquement

Informations supplémentaires

Pour plus d’informations sur l’émission de la commande wt et une vue d’ensemble des commandes associées, consultez Contrôle de la cible.

Remarques

La commande wt est utile si vous souhaitez obtenir des informations sur le comportement d’une fonction spécifique, mais que vous ne souhaitez pas parcourir la fonction. Au lieu de cela, accédez au début de cette fonction, puis émettez la commande wt .

Si le compteur du programme se trouve à un point qui correspond à un symbole (par exemple, le début d’une fonction ou le point d’entrée d’un module), la commande wt effectue le suivi jusqu’à ce qu’elle atteigne l’adresse de retour actuelle. Si le compteur du programme est sur une instruction d’appel , la commande wt suit jusqu’à ce qu’elle retourne à l’emplacement actuel. Ce suivi est profilé dans la fenêtre Commande du débogueur avec la sortie qui décrit les différents appels rencontrés par la commande.

Si la commande wt est émise ailleurs que le début d’une fonction, la commande se comporte comme la commande p (Étape). Toutefois, si vous spécifiez EndAddress, l’exécution continue jusqu’à ce que cette adresse soit atteinte, même si cette exécution implique de nombreuses étapes de programme et appels de fonction.

Lorsque vous déboguez en mode source, vous devez effectuer un suivi dans la fonction uniquement au point où vous voyez le crochet d’ouverture du corps de la fonction. Ensuite, vous pouvez utiliser la commande wt . (Il est généralement plus facile d’insérer un point d’arrêt à la première ligne de la fonction, ou d’utiliser Déboguer | Exécutez sur Curseur, puis utilisez la commande wt .)

Étant donné que la sortie de wt peut être longue, vous pouvez utiliser un fichier journal pour enregistrer votre sortie.

L’exemple suivant montre un fichier journal classique.

0:000> l+                  Source options set to show source lines
Source options are f:
     1/t - Step/trace by source line
     2/l - List source line for LN and prompt
     4/s - List source code at prompt
     8/o - Only show source code at prompt
0:000> p                   Not yet at the function call: use "p"
>  44:       minorVariableOne = 12;
0:000> p
>  45:       variableOne = myFunction(2, minorVariable);
0:000> t                   At the function call: now use "t"
MyModule!ILT+10(_myFunction):
0040100f e9cce60000      jmp     MyModule!myFunction (0040f6e0)
0:000> t
>  231:    { 
0:000> wt                  At the function beginning:  now use "wt"
Tracing MyModule!myFunction to return address 00401137

  105     0 [  0] MyModule!myFunction
    1     0 [  1]   MyModule!ILT+1555(_printf)
    9     0 [  1]   MyModule!printf
    1     0 [  2]     MyModule!ILT+370(__stbuf)
   11     0 [  2]     MyModule!_stbuf
    1     0 [  3]       MyModule!ILT+1440(__isatty)
   14     0 [  3]       MyModule!_isatty
   50    15 [  2]     MyModule!_stbuf
   17    66 [  1]   MyModule!printf
    1     0 [  2]     MyModule!ILT+980(__output)
   59     0 [  2]     MyModule!_output
   39     0 [  3]       MyModule!write_char
  111    39 [  2]     MyModule!_output
   39     0 [  3]       MyModule!write_char

....

   11     0 [  5]           kernel32!__SEH_epilog4
   54 11675 [  4]         kernel32!ReadFile
  165 11729 [  3]       MyModule!_read
  100 11895 [  2]     MyModule!_filbuf
   91 11996 [  1]   MyModule!fgets
54545 83789 [  0] MyModule!myFunction
    1     0 [  1]   MyModule!ILT+1265(__RTC_CheckEsp)
    2     0 [  1]   MyModule!_RTC_CheckEsp
54547 83782 [  0] MyModule!myFunction

112379 instructions were executed in 112378 events (0 from other threads)

Function Name                               Invocations MinInst MaxInst AvgInst
MyModule!ILT+1265(__RTC_CheckEsp)                     1       1       1       1
MyModule!ILT+1440(__isatty)                          21       1       1       1
MyModule!ILT+1540(__ftbuf)                           21       1       1       1
....
ntdll!memcpy                                         24       1      40      19
ntdll!memset                                          2      29      29      29

23 system calls were executed

Calls  System Call
   23  ntdll!KiFastSystemCall

Dans la liste de la trace, le premier nombre spécifie le nombre d’instructions qui ont été exécutées, le deuxième nombre spécifie le nombre d’instructions exécutées par les processus enfants de la fonction et le troisième nombre (entre crochets) spécifie la profondeur de la fonction dans la pile (en prenant la fonction initiale comme zéro). La mise en retrait du nom de la fonction indique la profondeur de l’appel.

Dans l’exemple précédent, MyModule !myFunction exécute 105 instructions avant d’appeler plusieurs sous-routines, y compris printf et fgets, puis exécute 54545 instructions supplémentaires après avoir appelé ces fonctions, mais avant d’émettre quelques appels supplémentaires. Toutefois, dans le décompte final, l’affichage indique que myFunction exécute 112 379 instructions, car ce nombre inclut toutes les instructions exécutées par myFunction et ses enfants. (Les enfants de myFunction sont des fonctions appelées directement ou indirectement à partir de myFunction.)

Dans l’exemple précédent, notez également qu’ILT+1440 (__isatty) est appelé 21 fois. Dans le décompte final, le résumé du comportement de cette fonction indique le nombre de fois où elle a été appelée, le plus petit nombre d’instructions dans une seule exécution, le plus grand nombre d’instructions dans une seule exécution et le nombre moyen d’instructions par exécution.

Si des appels système sont effectués, ils apparaissent dans le compteur et sont réapparaître à la fin de la sortie de la commande.