Vue d'ensemble du débogage CLR
Le Common Language Runtime (CLR) qui débogue l'API permet aux fournisseurs d'outils d'écrire des débogueurs pour déboguer des applications qui s'exécutent dans l'environnement CLR. Le type de code à déboguer peut être tout type de code pris en charge par le CLR.
L'API de débogage CLR est implémentée principalement avec le code non managé. Par conséquent, l'API de débogage est présentée en tant que jeu d'interfaces COM (Component Object Model). L'API se compose des éléments suivants :
une collection d'objets et d'interfaces COM implémentés par le CLR ;
une collection d'interfaces de rappel COM qui doivent être implémentées par le débogueur.
Cette vue d'ensemble contient les sections suivantes :
Scénarios de débogage CLR
Catégories d'API
Attachement à un programme ou lancement d'un programme
Contrôle de l'exécution
Examen de l'état du programme
Modification de l'état du programme
Utilisation de Modifier & Continuer
Évaluation de fonctions
Injection dynamique de code
Environnements pris en charge
Rubriques connexes
Scénarios de débogage CLR
Les sections suivantes expliquent comment l'API de débogage du Common Language Runtime gère des scénarios de débogage typiques. Notez que le runtime prend en charge certains scénarios directement et interagit avec des méthodes actuelles pour prendre en charge d'autres scénarios.
Débogage Out-of-Process (hors processus)
Dans le débogage out-of-process (hors processus), le débogueur est dans un processus séparé du processus qui est débogué (autrement dit, il est à l'extérieur du programme débogué). Ce scénario réduit les interactions entre le débogueur et le programme débogué. Par conséquent, il permet une image plus exacte du processus.
L'API de débogage CLR prend en charge le débogage out-of-process (hors processus) directement. L'API gère toute la communication entre le débogueur et les parties managées du programme débogué pour prendre en charge le débogage de code managé.
Bien que l'API de débogage CLR soit utilisée hors processus (out-of-process), une partie de la logique de débogage (par exemple, la synchronisation des threads) se produit en cours de processus (in-process) avec le programme débogué. Dans la plupart des cas, c'est un détail d'implémentation qui doit être transparent au débogueur. Pour plus d'informations sur la synchronisation des threads, consultez Architecture du débogage CLR. Un inconvénient est que l'API de débogage ne peut pas être utilisée pour inspecter les vidages sur incident lorsqu'elle est utilisée hors processus (out-of-process).
Débogage In-Process (en cours de processus)
Dans le .NET Framework version 1.0 et 1.1, l'API de débogage CLR prenait en charge un débogage en cours de processus limité, dans lequel un profileur pouvait utiliser les fonctionnalités d'inspection de l'API de débogage. Dans le .NET Framework 2.0, le débogage en cours de processus a été remplacé par un jeu de fonctionnalités qui sont plus cohérentes avec l'API de profilage. Pour plus d'informations sur ces modifications, consultez les fonctionnalités instantané de la pile et inspection de l'objet dans Vue d'ensemble du profilage.
Débogage de processus distant
Dans le débogage de processus distant, l'interface utilisateur du débogueur se trouve sur un ordinateur séparé du processus qui est débogué. Ce scénario peut être utile si le débogueur interfère avec le programme débogué lorsqu'ils s'exécutent sur le même ordinateur. L'interférence peut avoir les causes suivantes :
Ressources limitées.
Dépendances d'emplacement.
Bogues qui interfèrent avec le système d'exploitation.
L'API de débogage CLR ne prend pas en charge le débogage de processus distant directement. Un débogueur qui est basé sur l'API de débogage CLR doit encore exister hors processus (out-of-process) du programme débogué. Par conséquent, cette solution requiert un processus proxy sur l'ordinateur sur lequel se trouve le programme débogué.
Débogage de code non managé
Le code managé et le code non managé coexistent souvent dans le même processus. Le débogage simultané des deux types de codes est un besoin courant.
L'API de débogage du CLR prend en charge le franchissement pas à pas les limites entre managé et code non managé, mais il ne prend pas directement en charge le débogage de code non managé. Toutefois, l'API du débogage du CLR peut coexister avec un débogueur de code non managé en partageant les fonctions de débogage Win32.
En outre, l'API de débogage CLR fournit deux options pour déboguer un processus :
Une option attachement partiel dans laquelle seules les parties managées du processus sont déboguées. Un débogueur qui est partiellement attaché à un processus peut se détacher par la suite du processus.
Une option attachement total dans laquelle les deux parties managées et non managées d'un processus sont déboguées, et tous les événements de débogage Win32 sont exposés via l'API de débogage.
Environnements de langages mixtes
Dans le composant logiciel, différents composants peuvent être construits avec des langages différents. Un débogueur doit comprendre les différences de langage afin de pouvoir afficher les données dans le format correct, évaluer les expressions avec la syntaxe correcte, etc.
L'API de débogage CLR ne fournit pas d'assistance directe pour les environnements de langages mixtes, car le CLR n'a aucun concept de langage source. Les fonctions de mappage source d'un débogueur doivent lui permettre de mapper une fonction donnée dans le langage dans lequel la fonction a été implémentée.
Processus multiples et programmes distribués
Un programme composant peut inclure des composants coopératifs qui s'exécutent dans des processus différents ou même sur d'autres ordinateurs partout dans un réseau. Un débogueur doit être en mesure de suivre l'exécution logique entre processus et ordinateurs afin de fournir une vue logique de ce qui se passe.
L'API de débogage CLR ne fournit pas d'assistance directe pour le débogage de processus multiples. Là encore, un débogueur qui utilise l'API doit fournir une prise en charge directe, et les méthodes existantes pour effectuer cela doivent continuer à fonctionner.
Retour au début
Catégories d'API
L'API de débogage inclut les trois groupes d'interfaces suivantes, toutes utilisées en général par un débogueur CLR et toutes implémentées en tant que code non managé :
Interfaces qui prennent en charge le débogage d'applications CLR.
Interfaces qui donnent accès aux informations de débogage symboliques, qui sont stockées en général dans les fichiers de base de données du programme (PDB).
Interfaces qui prennent en charge l'interrogation des processus et domaines d'application sur un ordinateur.
L'API de débogage compte sur deux jeux supplémentaires d'interfaces :
L'API des métadonnées pour gérer l'inspection des informations des programmes statiques telles que les informations relatives aux types de classes et de méthodes.
L'API du magasin de symboles pour prendre en charge le débogage au niveau code source pour les débogueurs de code managé.
Les interfaces de débogage peuvent également être organisées en catégories fonctionnelles, indiquées dans le tableau suivant.
Catégorie d'API |
Description |
|---|---|
Inscription |
Les interfaces que le débogueur appelle pour l'enregistrement auprès du CLR et la demande de notification lorsque des événements spécifiques se produisent. |
Notification |
Les interfaces de rappel que le CLR utilise pour notifier au débogueur différents événements et retourner les informations demandées. Ces interfaces doivent être implémentées par le débogueur. |
Point d'arrêt |
Les interfaces que le débogueur appelle pour récupérer des informations à propos des points d'arrêt. |
Exécution |
Interfaces que le débogueur appelle pour contrôler l'exécution du programme débogué et accéder aux piles d'appels. |
Information |
Interfaces que le débogueur appelle pour obtenir des informations à propos du programme débogué. |
Énumération |
Interfaces que le débogueur appelle pour énumérer des objets. |
Modification |
Interfaces que le débogueur appelle pour modifier le code qui est débogué. |
Les sections suivantes décrivent les fonctionnalités fournies par les services de débogage du Common Language Runtime (CLR).
Retour au début
Attachement à un programme ou lancement d'un programme
Le CLR vous permet d'attacher le débogueur à un programme en cours d'exécution ou de démarrer un processus. Les services de débogage du CLR prennent en charge le débogage JIT en vous permettant d'attacher le débogueur à un programme qui lève une exception non gérée. Un programme qui n'est pas exécuté en mode débogable peut toutefois disposer d'une quantité moins importante d'informations de débogage. Un programme peut toujours s'exécuter en mode débogable pour éviter ce problème. Pour plus d'informations sur le mode débogable, consultez les éléments suivants :
Retour au début
Contrôle de l'exécution
Les services de débogage du CLR proposent plusieurs modes de contrôle de l'exécution d'un programme. Parmi ceux-ci figurent les points d'arrêt, le pas à pas, la notification d'exceptions, l'évaluation de fonctions, ainsi que d'autres événements en rapport avec le démarrage et l'arrêt d'un programme.
L'API de débogage du CLR n'assure le contrôle d'exécution que dans du code managé. Pour procéder à un contrôle d'exécution dans du code non managé, vous devez implémenter ces fonctionnalités séparément dans le débogueur.
Points d'arrêt
Vous pouvez créer des points d'arrêt en spécifiant le code et l'offset MSIL (Microsoft Intermediate Language) ou l'offset natif de l'emplacement où l'arrêt doit se produire. Le débogueur est ensuite notifié lorsque le point d'arrêt est atteint. L'API de débogage ne prend pas directement en charge les points d'arrêt conditionnels. Toutefois, un débogueur les peut implémenter en évaluant une expression en réponse à un point d'arrêt et en décidant s'il faut informer l'utilisateur de l'arrêt.
Pas à pas
Les services de débogage du CLR proposent de nombreuses fonctionnalités pas à pas. Un programme peut exécuter du code instruction par instruction (pas à pas) ou plage d'instructions par plage d'instructions (plage par plage). Il peut ignorer une fonction, entrer pas à pas dans une fonction ou en sortir pas à pas. Les services de débogage du CLR peuvent également notifier le débogueur en cas d'interruption de l'opération pas à pas par une exception.
Même si les services de débogage ne prennent pas directement en charge le pas à pas dans du code non managé, ils fournissent des rappels lorsqu'une opération pas à pas atteint du code non managé, de manière à rendre le contrôle au débogueur. Ils proposent également des fonctionnalités qui permettent au débogueur de déterminer le passage imminent du code non managé au code managé.
Le CLR n'effectue pas directement le pas à pas au niveau de la source. Un débogueur peut assurer cette fonctionnalité plage par plage en s'appuyant sur ses propres informations de mappage sur la source. Vous pouvez utiliser les interfaces des magasins de symboles pour obtenir des informations au niveau de la source. Pour plus d'informations sur ces interfaces, consultez Magasin de symboles de diagnostics (Référence des API non managées).
Exceptions
Les services de débogage du CLR tiennent un débogueur informé des exceptions de première chance et de seconde chance dans du code managé. L'objet levé peut être inspecté à chaque point.
Le CLR ne prend pas en charge d'exceptions natives dans du code non managé, à moins qu'elles ne se propagent dans du code managé. Vous avez toutefois toujours la possibilité d'utiliser les services de débogage Win32 qui sont partagés avec les services de débogage du CLR pour prendre en charge des exceptions non managées.
Événements
Les services de débogage du CLR notifient un débogueur lorsque plusieurs événements se produisent. Parmi ces événements figurent la création et la sortie de processus, la création et la sortie de threads, la création et la sortie de domaines d'application, le chargement et le déchargement d'assemblys, le chargement et le déchargement de modules et le chargement et le déchargement de classes. Pour assurer de bonnes performances, vous pouvez désactiver les événements de chargement et de déchargement de classes d'un module. Par défaut, les événements de chargement et de déchargement de classes sont désactivés.
Contrôle de threads
Les services de débogage du CLR proposent des interfaces qui permettent d'interrompre et de reprendre des threads individuels (managés).
Retour au début
Examen de l'état du programme
Les services de débogage du CLR permettent d'inspecter en détail les composants d'un processus qui exécutent du code managé lorsque l'état du processus est arrêté. Un processus peut être inspecté pour obtenir une liste de threads physiques.
Un thread peut être examiné en vue d'inspecter la pile de ses appels. La pile des appels d'un thread est composée de deux niveaux : le niveau de la chaîne et le niveau du frame de pile. La pile des appels est en premier lieu composée de chaînes. Une chaîne désigne un segment de pile des appels logique et contigu. Il contient des frames de pile managés ou non managés, mais pas les deux. De plus, tous les frames d'appels managés qui figurent dans une chaîne partagent le même contexte CLR. Une chaîne peut être managée ou non managée.
Chaque chaîne managée peut également être composée de frames de pile seules. Chaque frame de pile représente un appel de méthode. Vous pouvez interroger un frame de pile pour obtenir le code qu'il exécute ou obtenir ses arguments, variables locales et registres natifs.
Une chaîne non managée ne contient pas de frames de pile. Elle fournit à la place la plage d'adresses de piles qui sont allouées au code non managé. Il appartient à un débogueur de code non managé de décoder la partie non managée de la pile et de fournir une trace de la pile.
.gif "Remarque") Remarque |
|---|
Les services de débogage du CLR ne prennent pas en charge le concept de variables locales qui se produisent dans du code source.Il appartient au débogueur de mapper les variables locales à leurs allocations. |
Les services de débogage du CLR donnent également accès à des variables globales, des variables statiques de classe et des variables locales de thread.
Retour au début
Modification de l'état du programme
Les services de débogage du CLR permettent à un débogueur de modifier l'emplacement physique du pointeur d'instruction pendant l'exécution, même s'il peut s'agir d'une opération dangereuse. Le pointeur d'instruction peut être modifié lorsque les conditions suivantes sont remplies :
Le pointeur d'instruction actuel et le pointeur d'instruction cible sont tous deux des points de séquence. Les points de séquence représentent plus ou moins des limites d'instruction.
Le pointeur d'instruction cible ne se trouve pas dans un filtre d'exceptions, ni un bloc catch, ni un bloc finally.
Le pointeur d'instruction actuel se trouve dans un bloc catch, et le pointeur d'instruction cible ne se trouve pas en dehors du bloc catch.
Le pointeur d'instruction cible se trouve dans le même frame que le pointeur d'instruction actuel.
Lorsque l'emplacement physique du pointeur d'instruction change, les variables qui se trouvent à l'emplacement du pointeur d'instruction actuel seront alors mappées aux variables qui se trouvent à l'emplacement du pointeur d'instruction cible. Les références du garbage collection à l'emplacement du pointeur d'instruction cible seront correctement initialisées.
Une fois le pointeur d'instruction modifié, les services de débogage du CLR marquent toutes les informations de pile mises en cache comme étant invalides et actualisent ces informations lors de leur utilisation suivante. Les débogueurs qui mettent en cache des pointeurs pour empiler des informations sur des frames et des chaînes doivent actualiser ces informations une fois le pointeur d'instruction modifié.
Le débogueur peut également modifier les données d'un programme lorsque ce programme est arrêté. Le débogueur peut modifier les arguments et les variables locales d'une fonction lors de l'exécution de la fonction, un peu à la manière de l'inspection. Le débogueur peut également mettre à jour des champs de tableaux et d'objets, ainsi que des champs statiques et des variables globales.
Retour au début
Utilisation de Modifier & Continuer
Pendant une session de débogage, vous pouvez utiliser la fonctionnalité Modifier & Continuer pour effectuer les opérations suivantes :
modifier le code source ;
recompiler la source modifiée ;
conserver le reste de l'état d'exécution de l'exécutable en cours de débogage ;
continuer la session de débogage sans qu'il soit nécessaire de réexécuter l'exécutable depuis le début.
Retour au début
Évaluation de fonctions
Pour évaluer des expressions utilisateur et des propriétés dynamiques d'objets, un débogueur doit pouvoir exécuter le code du processus en cours de débogage. Grâce aux services de débogage du CLR, le débogueur peut appeler une fonction ou une méthode et l'exécuter dans le processus du programme débogué.
Le CLR permet au débogueur d'arrêter une telle opération car elle peut s'avérer dangereuse (par exemple, elle risque de déclencher un interblocage avec le code existant). En cas d'arrêt correct de l'évaluation, le thread est traité comme si l'évaluation n'avait jamais eu lieu, à l'exception des effets secondaires sur les variables locales consécutifs à l'évaluation partielle. Si la fonction appelle du code non managé ou bloque d'une manière ou d'une autre, l'arrêt de l'évaluation risque alors d'être impossible.
Lorsque l'évaluation de la fonction est terminée, le CLR utilise un rappel pour notifier le débogueur que l'évaluation s'est déroulée normalement ou que la fonction a levé une exception. Vous pouvez utiliser les méthodes ICorDebugValue et ICorDebugValue2 pour inspecter les résultats d'une évaluation.
Le thread sur lequel l'évaluation de la fonction va être effectuée doit être arrêté dans du code managé, à un point sans risque pour le garbage collection. (L'évaluation de fonctions est également autorisée pour les exceptions non gérées.) Dans du code non optimisé, ces points sans risque sont très courants ; la plupart des opérations pas à pas au niveau MSIL ou des opérations de point d'arrêt s'effectuent au point un. Ces points peuvent toutefois être rares dans du code optimisé. Une fonction complète peut parfois ne pas disposer de points sans risque. La fréquence des points sans risque pour le garbage collection varie d'une fonction à une autre. Même dans du code non optimisé, il est possible que l'arrêt ne s'effectue pas au point un. Dans du code optimisé comme dans du code non optimisé, la méthode ICorDebugController::Stop aboutit rarement à un point sans risque.
Les services de débogage du CLR définiront une nouvelle chaîne sur le thread pour démarrer une évaluation de la fonction et appeler la fonction demandée. Dès que l'évaluation est démarrée, tous les aspects de l'API de débogage sont disponibles : contrôle d'exécution, inspection, évaluation de fonctions, etc. Les évaluations imbriquées sont prises en charge et les points d'arrêt sont traités normalement.
Retour au début
Injection dynamique de code
Certains débogueurs permettent à l'utilisateur d'entrer des instructions arbitraires dans la fenêtre Exécution et d'exécuter ces instructions. Les services de débogage du CLR prennent en charge ce scénario. Dans la limite du raisonnable, le code que vous pouvez injecter dynamiquement n'est soumis à aucune restriction. (Par exemple, les instructions goto non locales ne sont pas autorisées.)
L'injection dynamique de code s'implémente en combinant des opérations Modifier & Continuer et l'évaluation de fonctions. Le code à injecter est encapsulé dans une fonction et injecté à l'aide de Modifier & Continuer. La fonction injectée est ensuite évaluée. Si vous le souhaitez, vous pouvez fournir des arguments ByRef à la fonction wrapper afin que les effets secondaires soient immédiats et permanents.
Retour au début
Environnements pris en charge
Les fonctionnalités de débogage du CLR sont disponibles sur tous les processeurs et systèmes d'exploitation que le CLR prend en charge, avec les exceptions suivantes :
Modifier & Continuer et le débogage en mode mixte ne sont pas pris en charge sur les systèmes d'exploitation 64 bits. Les méthodes SetIP (ICorDebugILFrame::SetIP et ICorDebugNativeFrame::SetIP) ont des restrictions supplémentaires sur les systèmes d'exploitation 64 bits. Les fonctionnalités restantes sont équivalentes sur tous les processeurs (bien qu'il y ait des représentations de données spécifiques au processeur, telles que les tailles de pointeur, les contextes de registre, etc.).
Modifier & Continuer et le débogage en mode mixte ne sont pas pris en charge sur les systèmes d'exploitation basés sur Win9x. Les fonctionnalités restantes doivent être équivalentes sur tous les systèmes d'exploitation. Il y a toutefois quelques exceptions spécifiques qui sont notées dans la documentation des différentes fonctions.
Retour au début
Rubriques connexes
Titre |
Description |
|---|---|
Décrit comment les différents composants de l'API de débogage CLR interagissent avec le CLR et le débogueur. |
|
Décrit les modifications et améliorations apportées au débogage dans le .NET Framework version 2.0. |
|
Explique comment quelques-unes des interfaces de débogage CLR requièrent que le processus qui est débogué soit dans un état spécifique. |
|
Décrit en détail le débogage d'un processus d'exécution. |
|
Décrit l'utilisation de l'API de débogage du CLR par un débogueur pour définir des points d'arrêt, exécuter pas à pas du code managé et non managé et gérer des exceptions. |
|
Décrit l'utilisation de l'API de débogage du CLR par un débogueur pour accéder à des frames de pile managées et évaluer des expressions. |
|
Décrit l'injection de code dynamique au cours de laquelle le CLR détourne un thread actif pour exécuter du code qui n'était pas présent dans le fichier exécutable portable d'origine. |
|
Récapitule les interfaces de publication de processus du CLR qui énumèrent et fournissent des informations sur les processus et les domaines d'application d'un ordinateur. |
|
Considérations relatives à la sécurité dans l'API de débogage |
Présente les considérations de sécurité liées à l'utilisation de l'API de débogage du CLR. |
Décrit les coclasses non managées utilisées par l'API de débogage. |
|
Décrit les interfaces non managées qui gèrent le débogage d'un programme s'exécutant dans le Common Language Runtime (CLR). |
|
Décrit les fonctions statiques globales non managées utilisées par l'API de débogage. |
|
Décrit les énumérations non managées utilisées par l'API de débogage. |
|
Décrit les structures non managées utilisées par l'API de débogage. |
Retour au début