x (Examiner les symboles)

La commande x affiche les symboles dans tous les contextes qui correspondent au modèle spécifié.

x [Options] Module!Symbol 
x [Options] *

Paramètres

Options Spécifie les options de recherche de symboles. Vous pouvez utiliser une ou plusieurs des options suivantes :

/0
Affiche uniquement l’adresse de chaque symbole.

/1
Affiche uniquement le nom de chaque symbole.

/2
Affiche uniquement l’adresse et le nom de chaque symbole (et non le type de données).

/D
Affiche la sortie à l’aide du langage de balisage du débogueur.

/t
Affiche le type de données de chaque symbole, si le type de données est connu.

/v
Affiche le type de symbole (local, global, paramètre, fonction ou inconnu) de chaque symbole. Cette option affiche également la taille de chaque symbole. La taille d’un symbole de fonction est la taille de la fonction en mémoire. La taille des autres symboles est la taille du type de données que le symbole représente. La taille est toujours mesurée en octets et affichée au format hexadécimal.

/s, taille
Affichez uniquement les symboles dont la taille, en octets, est égale à la valeur Taille. La taille d’un symbole de fonction est la taille de la fonction en mémoire. La taille des autres symboles est la taille du type de données que représente le symbole. Les symboles dont la taille ne peut pas être déterminée sont toujours affichés. La taille doit être un entier différent de zéro.

/q
Affiche les noms de symboles au format entre guillemets.

/p
Omettez l’espace avant la parenthèse ouvrante lorsque le débogueur affiche un nom de fonction et ses arguments. Ce type d’affichage peut faciliter la copie des noms de fonctions et des arguments de l’affichage x vers un autre emplacement.

/f
Affiche la taille des données d’une fonction.

/d
Affiche la taille des données.

/a
Trie l’affichage par adresse, dans l’ordre croissant.

/Un
Trie l’affichage par adresse, dans l’ordre décroissant.

/n
Trie l’affichage par nom, dans l’ordre croissant.

/N
Trie l’affichage par nom, dans l’ordre décroissant.

/z
Trie l’affichage par taille, dans l’ordre croissant.

/Z
Trie l’affichage par taille, dans l’ordre décroissant.

Module
Spécifie le module à rechercher. Ce module peut être un fichier .exe, .dll ou .sys. Module peut contenir une variété de caractères et de spécificateurs génériques carte. Pour plus d’informations sur la syntaxe, consultez la section syntaxe des caractères génériques de chaîne.

Symbole
Spécifie un modèle que le symbole doit contenir. Le symbole peut contenir divers caractères génériques et spécificateurs. Pour plus d’informations sur la syntaxe, consultez la section syntaxe des caractères génériques de chaîne.

Étant donné que ce modèle est mis en correspondance avec un symbole, la correspondance n’est pas sensible à la casse, et un trait de soulignement unique (_) représente n’importe quelle quantité de traits de soulignement de début. Vous pouvez ajouter des espaces dans Symbol, afin de pouvoir spécifier des noms de symboles qui contiennent des espaces (tels que « opérateur nouveau » ou « Modèle<A, B> ») sans utiliser de caractères génériques.

Environnement

Élément	Description
Modes	Mode utilisateur, mode noyau
Targets	Live, vidage de la mémoire
Platforms	Tous

Notes

La commande suivante recherche tous les symboles dans MyModule qui contiennent la chaîne « spin ».

0:000> x mymodule!*spin* 

La commande suivante recherche rapidement les symboles « DownloadMinor » et « DownloadMajor » dans MyModule.

0:000> x mymodule!downloadm??or 

Vous pouvez également afficher tous les symboles dans MyModule à l’aide de la commande suivante.

0:000> x mymodule!* 

Les commandes précédentes forcent également le débogueur à recharger les informations de symbole à partir de MyModule. Si vous souhaitez recharger les symboles dans le module avec un affichage minimal, utilisez la commande suivante.

0:000> x mymodule!*start* 

Quelques symboles contiennent toujours la chaîne « start ». Par conséquent, la commande précédente affiche toujours une sortie pour vérifier que la commande fonctionne. Mais la commande précédente évite la longueur d’affichage excessive de x mymodule !*.

L’affichage affiche l’adresse de départ de chaque symbole et le nom complet du symbole. Si le symbole est un nom de fonction, l’affichage inclut également une liste de ses types d’arguments. Si le symbole est une variable globale, sa valeur actuelle est affichée.

Il existe un autre cas spécial de la commande x . Pour afficher les adresses et les noms de toutes les variables locales pour le contexte actuel, utilisez la commande suivante.

0:000> x * 

Remarque Dans la plupart des cas, vous ne pouvez pas accéder aux variables locales, sauf si des symboles privés ont été chargés. Pour plus d’informations sur cette situation, consultez dbgerr005 : Symboles privés obligatoires. Pour afficher les valeurs des variables locales, utilisez la commande dv (Afficher les variables locales).

L’exemple suivant illustre les options /0, /1 et /2 .

0:000:x86> x /0 MyApp!Add*
00b51410          
00b513d0 
      
0:000:x86> x /1 MyApp!Add*
MyApp!AddThreeIntegers
MyApp!AddTwoIntegers

0:000:x86> x /2 MyApp!Add*
00b51410          MyApp!AddThreeIntegers
00b513d0          MyApp!AddTwoIntegers

Les options /0, /1 et /2 sont utiles si vous souhaitez utiliser la sortie de la commande x comme entrée dans la commande .foreach .

.foreach ( place { x /0 MyApp!*MySym*} ) { .echo ${place}+0x18 }

L’exemple suivant illustre le commutateur /f lorsqu’il est utilisé pour filtrer les fonctions sur le module notepad.exe.

0:000> x /f /v notepad!*main*
prv func   00000001`00003340  249 notepad!WinMain (struct HINSTANCE__ *, struct HINSTANCE__ *, char *, int)
prv func   00000001`0000a7b0   1c notepad!WinMainCRTStartup$filt$0 (void)
prv func   00000001`0000a540  268 notepad!WinMainCRTStartup (void)

Lorsque vous utilisez l’option /v , la première colonne de l’affichage affiche le type de symbole (local, global, paramètre, fonction ou inconnu). La deuxième colonne est l’adresse du symbole. La troisième colonne est la taille du symbole, en octets. La quatrième colonne affiche le nom du module et le nom du symbole. Dans certains cas, cet affichage est suivi d’un signe égal (=), puis du type de données du symbole. La source du symbole (informations sur les symboles publics ou complets) est également affichée.

kd> x /v nt!CmType*
global 806c9e68    0 nt!CmTypeName = struct _UNICODE_STRING []
global 806c9e68  150 nt!CmTypeName = struct _UNICODE_STRING [42]
global 806c9e68    0 nt!CmTypeName = struct _UNICODE_STRING []
global 805bd7b0    0 nt!CmTypeString = unsigned short *[]
global 805bd7b0   a8 nt!CmTypeString = unsigned short *[42]

Dans l’exemple précédent, la taille est donnée au format hexadécimal, tandis que le type de données est donné au format décimal. Par conséquent, dans la dernière ligne de l’exemple précédent, le type de données est un tableau de 42 pointeurs vers des entiers courts non signés. La taille de ce tableau est 42*4 = 168 et 168 est affichée au format hexadécimal comme 0xA8.

Vous pouvez utiliser l’option /sSize pour afficher uniquement les symboles dont la taille, en octets, est une certaine valeur. Par exemple, vous pouvez restreindre la commande dans l’exemple précédent aux symboles qui représentent des objets dont la taille est 0xA8.

kd> x /v /s a8 nt!CmType*
global 805bd7b0   a8 nt!CmTypeString = unsigned short *[42]

Utilisation des types de données

L’option /t permet au débogueur d’afficher des informations sur le type de données de chaque symbole. Notez que pour de nombreux symboles, ces informations sont affichées même sans l’option /t . Lorsque vous utilisez /t, ces symboles ont leurs informations de type de données affichées deux fois.

0:001> x prymes!__n*
00427d84 myModule!__nullstring = 0x00425de8 "(null)"
0042a3c0 myModule!_nstream = 512
Type information missing error for _nh_malloc
004021c1 myModule!MyStructInstance = struct MyStruct
00427d14 myModule!_NLG_Destination = <no type information>

0:001> x /t prymes!__n*
00427d84 char * myModule!__nullstring = 0x00425de8 "(null)"
0042a3c0 int myModule!_nstream = 512
Type information missing error for _nh_malloc
004021c1 struct MyStruct myModule!MyStructInstance = struct MyStruct
00427d14 <NoType> myModule!_NLG_Destination = <no type information>

La commande x affiche une instance d’un type.

0:001> x foo!MyClassInstance
00f4f354          foo!MyClassInstance = 0x00f78768

La commande x n’affiche rien en fonction du nom d’un type.

0:001> x foo!MyClass
0:001>

Pour afficher des informations de type à l’aide du nom d’un type, envisagez d’utiliser dt (Type d’affichage) pour fournir des informations pour les types et les instances de types :

0:001> dt foo!MyClass
   +0x000 IntMemberVariable : Int4B
   +0x004 FloatMemberVariable : Float
   +0x008 BoolMemberVariable : Bool
   +0x00c PtrMemberVariable : Ptr32 MyClass

Utilisation de modèles

Vous pouvez utiliser des caractères génériques avec la commande x pour afficher les classes de modèle comme indiqué dans cet exemple.

0:001>  x Fabric!Common::ConfigEntry*TimeSpan?
000007f6`466a2f9c Fabric!Common::ConfigEntry<Common::TimeSpan>::ConfigEntry<Common::TimeSpan> (void)
000007f6`466a3020 Fabric!Common::ConfigEntry<Common::TimeSpan>::~ConfigEntry<Common::TimeSpan> (void)

Envisagez d’utiliser la commande dt (Type d’affichage) lors de l’utilisation de modèles, car la commande x n’affiche pas d’éléments de classe de modèle individuels.

0:001> dt foo!Common::ConfigEntry<Common::TimeSpan>
   +0x000 __VFN_table : Ptr64 
   +0x008 componentConfig_ : Ptr64 Common::ComponentConfig
   +0x010 section_         : std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >
   +0x038 key_             : std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >

Voir aussi

Vérification des symboles

dv (Afficher les variables locales)