Commande dbx

Objectif

Fournit un environnement permettant de déboguer et d'exécuter des programmes.

Syntaxe

dbx [-a ProcessID] [-B DebugFile] [-c CommandFile] [-I Répertoire] [-E DebugEnvironment] [-p oldpath=newpath: ... | pathfile] [-u] [-F] [-L ] [-r] [-x] [-v] [-C CoreFile | ObjectFile [CoreFile] ]

Descriptif

La commande dbx fournit un programme de débogage symbolique pour les programmes C, C + + et Fortran , vous permettant d'effectuer les opérations suivantes:

Examinez les objets et les fichiers core.
Fournissez un environnement contrôlé pour l'exécution d'un programme.
Définissez des points d'arrêt pour les instructions sélectionnées ou exécutez le programme une ligne à la fois.
Déboguez à l'aide de variables symboliques et affichez-les dans leur format correct.

Le paramètre ObjectFile est un fichier objet (exécutable) produit par un compilateur. Utilisez l'indicateur -g (générer une table de symboles) lors de la compilation de votre programme pour produire les informations dont la commande dbx a besoin.

Remarque: l'indicateur -g de la commande cc doit être utilisé lors de la compilation du fichier objet. Si l'indicateur -g n'est pas utilisé ou si des références de symbole sont supprimées du fichier xcoff à l'aide de la commande strip , les capacités symboliques de la commande dbx sont limitées. En outre, n'utilisez pas l'option de compilation -O pour optimiser un exécutable que vous prévoyez de déboguer avec dbx. L'optimisation réorganise le code et compromet les données de débogage, ce qui limite encore la valeur du débogage du programme exécutable à l'aide de la commande dbx .

Si l'indicateur -c n'est pas spécifié, la commande dbx recherche un fichier .dbxinit dans le répertoire $HOME de l'utilisateur. Il recherche ensuite un fichier .dbxinit dans le répertoire en cours de l'utilisateur. Si un fichier .dbxinit existe dans le répertoire de travail, ce fichier remplace le fichier .dbxinit dans le répertoire $HOME de l'utilisateur. Si un fichier .dbxinit existe dans le répertoire $HOME de l'utilisateur ou dans le répertoire de travail, les sous-commandes de ce fichier s'exécutent au début de la session de débogage. Utilisez un éditeur pour créer un fichier .dbxinit .

Si ObjectFile n'est pas spécifié, dbx demande le nom du fichier objet à examiner. La valeur par défaut est a.out. Si le fichier core existe dans le répertoire en cours ou si un paramètre CoreFile est spécifié, dbx signale l'emplacement où le programme a échoué. Les variables, les registres et la mémoire conservés dans l'image principale peuvent être examinés jusqu'à ce que l'exécution de ObjectFile commence. A ce stade, le programme de débogage dbx vous invite à entrer des commandes.

L'indicateur -B est utilisé pour spécifier un autre fichier objet ou un fichier .stab distinct contenant des informations de débogage sur le démarrage. Le fichier objet de remplacement peut être spécifié uniquement lors de l'association à un processus. Les informations de débogage sont lues à partir de ce fichier objet de remplacement ou du fichier de débogage .stab à la place de la copie disque du processus en cours d'exécution. Ce fichier objet de remplacement doit être la copie non supprimée du fichier objet d'origine ; sinon, il sera ignoré. Utilisez l'indicateur -B lorsque la taille de la section de débogage est importante. Utilisez la copie supprimée du fichier objet lors de l'exécution et une copie non supprimée lors du débogage. Le fichier de débogage .stab peut être généré via l'option d'éditeur de liens -bstabsplit . Si l'indicateur -B n'est pas spécifié pour un exécutable stabsplit, la commande dbx tente d'acquérir le fichier .stab correspondant à partir du répertoire de l'exécutable.

Traitement des expressions

Le programme dbx peut afficher un large éventail d'expressions. Vous pouvez spécifier des expressions dans le programme de débogage dbx avec la syntaxe C, avec certaines extensions Fortran .

Les opérateurs suivants sont valides dans le programme de débogage:

Article	Descriptif
* (astérisque) ou ^ (caret)	Indique le déréférencement de l'indirection ou du pointeur.
[ ] (crochets) ou () (parenthèses)	Indique les expressions de tableau d'indice.
. (point)	Utilisez cet opérateur de référence de zone avec des pointeurs et des structures. Cet opérateur rend l'opérateur C-> (flèche) inutile, bien qu'il soit autorisé.
& (perluète)	Extrait l'adresse d'une variable.
.. (deux points)	Sépare les limites supérieure et inférieure lors de la spécification d'une sous-section d'un tableau. Par exemple: n [ 1 .. 4 ].

Les types d'opération suivants sont valides dans les expressions du programme de débogage:

Article	Descriptif
Algébrique	=, -, , / (division flottante), div* (division intégrale), mod, exp (exponentiation)
Au niveau du bit	-, I, bitand, xor, ~. < <, > >
Logique	ou, et, pas, II, & &
Comparaison	<, >, < =, > =, < > ou ! =, = ou ==
Autre	(typename), taille de

Les expressions logiques et de comparaison sont autorisées en tant que conditions dans stop et trace.

Les types d'expression sont vérifiés. Vous remplacez un type d'expression à l'aide d'un opérateur de changement de nom ou de transtypage. Les trois formes de renommage de type sont Typename (Expression), Expression|Typenameet (Typename) Expression. Voici un exemple où la variable x est un entier avec la valeur 97:

(dbx) print x
97
(dbx) print char (x), x \ char, (char) x, x
'a' 'a' 'a' 97

Edition via la ligne de commande

La commande dbx fournit une fonction d'édition de ligne de commande similaire aux fonctions fournies par Korn Shell. Le mode vi fournit des fonctions d'édition vi-like , tandis que le mode emacs fournit des commandes similaires à emacs.

Ces fonctions peuvent être activées à l'aide de la sous-commande dbx set -o ou set edit. Pour activer l'édition de ligne de commande vi-style, entrez la sous-commande set edit vi ou set -o vi.

Vous pouvez également utiliser la variable d'environnement EDITOR pour définir le mode d'édition.

La commande dbx sauvegarde l'historique des commandes, qui sont entrées sur la ligne de commande, dans le fichier d'historique .dbxhist . Si la variable d'environnement DBXHISTFILE n'est pas définie, le fichier d'historique $HOME/.dbxhist est utilisé.

Par défaut, dbx enregistre le texte des 128 dernières commandes entrées. La variable d'environnement DBXHISTSIZE peut être utilisée pour augmenter cette limite.

Indicateurs

Article	Descriptif
-a `ProcessID`	Associe le programme de débogage à un processus en cours d'exécution. Pour connecter le programme de débogage, vous devez disposer des droits nécessaires pour envoyer des signaux à ce processus. Utilisez la commande ps pour déterminer l'ID de processus. Si vous disposez des droits nécessaires, le programme dbx interrompt le processus à l'aide de l'appel système ptrace pour envoyer un signal SIGTRAP au processus, qui ne peut pas ignorer le signal SIGTRAP . Il détermine ensuite le nom complet du fichier objet, lit les informations symboliques et demande des commandes.
-B`DebugFile`	Cet indicateur vous permet de spécifier un autre fichier de débogage au démarrage.
-c `CommandFile`	Exécute les sous-commandes dbx dans le fichier avant de lire l'entrée standard. Le fichier spécifié dans le répertoire $HOME est traité en premier, puis le fichier dans le répertoire en cours est traité. Le fichier de commandes du répertoire en cours remplace le fichier de commandes du répertoire $HOME . Si le fichier spécifié n'existe pas dans le répertoire $HOME ou dans le répertoire de travail, un message d'avertissement s'affiche. La sous-commande source peut être utilisée une fois le programme dbx démarré.
-C `CoreFile`	Analyse le fichier core sans spécifier le fichier objet. Dans ce cas, la commande dbx utilise le fichier objet mentionné dans le fichier core s'il existe dans le répertoire en cours et correspond au fichier core. Sinon, elle se poursuit sans le fichier objet. Cet indicateur est ignoré si vous l'utilisez après l'indicateur -r ou -a .
-E `DebugEnvironment`	Indique la variable d'environnement du programme de débogage.
-p `oldpath=newpath: ... \| pathfile`	Indique une substitution pour les chemins de bibliothèque lors de l'examen de fichiers core ou de l'association à un processus, au format `oldpath=newpath`. La variable `oldpath` indique la valeur à remplacer (telle qu'elle est stockée dans le fichier core ou dans la section du chargeur du processus lors de l'association). La variable `newpath` indique par quoi elle doit être remplacée. La variable `oldpath` et la variable `newpath` peuvent être des chemins complets, des chemins partiels, des chemins relatifs ou des chemins absolus. Les substitutions multiples sont séparées par des deux-points. L'indicateur -p peut également spécifier le nom d'un fichier à partir duquel les mappages au format décrit précédemment doivent être lus. Un seul mappage par ligne est autorisé lorsque les mappages sont lus à partir d'un fichier. Si vous utilisez l'indicateur -p lors de l'association à un processus, les informations de débogage sont lues à partir des fichiers de chemin d'accès remplacés. Les fichiers de chemin doivent correspondre à la copie en cours de la bibliothèque.
-F	Peut être utilisé pour désactiver le mode de lecture paresseuse et faire en sorte que la commande dbx lise tous les symboles au moment du démarrage. Par défaut, le mode de lecture paresseuse est activé: il ne lit que les informations de table de symboles requises sur le lancement de la session dbx . Dans ce mode, dbx ne lit pas les variables et les types locaux dont les informations symboliques ne sont pas lues. Par conséquent, les commandes telles que whereis i peuvent ne pas répertorier toutes les instances de la variable locale i dans chaque fonction.
-L	Conserver les symboles de liaison.
-I `Répertoire`	(Majuscules i) Inclut le répertoire spécifié par la variable `Répertoire` dans la liste des répertoires recherchés pour les fichiers source. La valeur par défaut consiste à rechercher les fichiers source dans les répertoires suivants: Répertoire dans lequel se trouvait le fichier source lors de sa compilation. Ce répertoire est recherché uniquement si le compilateur a placé le chemin source dans l'objet. Répertoire en cours. Répertoire dans lequel se trouve actuellement le programme.
-r	Exécute le fichier objet immédiatement. S'il s'arrête correctement, le programme de débogage dbx est fermé. Sinon, le programme de débogage est entré et le motif de l'arrêt est signalé. Remarque: sauf si -r est spécifié, la commande dbx invite l'utilisateur et attend une commande.
-u	Indique à la commande dbx de faire précéder les symboles de nom de fichier d'un @ (arobase). Cet indicateur réduit la possibilité de noms de symbole ambigus.
-v	Permet à la commande dbx d'ignorer la vérification de validité du fichier core. Cet indicateur vous permet d'analyser les sections valides du fichier core même si certaines sections ne sont pas valides.
-x	Empêche la commande dbx de décomposer les caractères _ (trait de soulignement de fin) des symboles provenant du code source Fortran . Cet indicateur permet à dbx de faire la distinction entre les symboles identiques, à l'exception d'un trait de soulignement, tel que`xxx`et`xxx_`.

Exemples

L'exemple suivant explique comment démarrer le programme de débogage dbx en même temps qu'un processus. L'exemple utilise un programme appelé samp.c. Ce programme C est d'abord compilé avec l'indicateur -g pour générer un fichier objet qui inclut des références de table symboliques. Dans ce cas, le programme est nommé samp:
```
$ cc -g samp.c -o samp
```
Lorsque le programme samp est exécuté, le système d'exploitation signale une erreur de bus et écrit une image de base dans votre répertoire de travail en cours comme suit:
```
$ samp
Bus Error - core dumped
```
Pour déterminer l'emplacement où l'erreur s'est produite, entrez:
```
$ dbx samp
```
Le système renvoie le message suivant:
```
dbx version 3.1
Type 'help' for help.
reading symbolic information . . . [
using memory image in core]
  25   x[i] = 0;
(dbx) quit
```
Cet exemple explique comment associer dbx à un processus. Cet exemple utilise le programme suivant, looper.c:
```
main()
{
      int i,x[10];
       
      for (i = 0; i < 10;);
}
```
Le programme ne s'arrête jamais car i n'est jamais incrémenté. Compilez looper.c avec l'indicateur -g pour obtenir la fonction de débogage symbolique:
```
$ cc -g looper.c -o looper
```
Exécutez looper à partir de la ligne de commande et effectuez les étapes suivantes pour associer dbx au programme alors qu'il est en cours d'exécution:
1. Pour associer dbx à looper, vous devez déterminer l'ID de processus. Si vous n'avez pas exécuté looper en tant que processus d'arrière-plan, vous devez avoir une autre Xwindow ouverte. Dans cette fenêtre Xwindow, entrez:
```
ps -u UserID
```
  où UserID est votre ID de connexion. Tous les processus actifs qui vous appartiennent s'affichent comme suit:
```
PID     TTY      TIME    COMMAND
68      console   0:04    sh
467     lft3     10:48    looper
```
  Dans cet exemple, l'ID de processus associé à looper est467.
2. Pour associer dbx à looper, entrez:
```
$ dbx -a 467
```
  Le système renvoie le message suivant:
```
Waiting to attach to process 467 . . .
Successfully attached to /tmp/looper.
dbx is initializing
Type 'help' for help.
reading symbolic information . . .
 
attached in main at line 5
5     for (i = 0; i < 10;);
(dbx)
```
  Vous pouvez maintenant interroger et déboguer le processus comme s'il avait été démarré à l'origine avec dbx.
Pour ajouter des répertoires à la liste des répertoires dans lesquels rechercher le fichier source d'un fichier exécutable objfile, vous pouvez entrer:
```
$dbx -I /home/user/src -I /home/group/src 
objfile
```
La sous-commande use peut être utilisée pour cette fonction une fois que dbx est démarré. La commande use réinitialise la liste des répertoires, tandis que l'indicateur -I ajoute un répertoire à la liste.
Pour utiliser l'indicateur -r , entrez:
```
$ dbx -r samp 
```
Le système renvoie le message suivant:
```
Entering debug program . . .
dbx version 3.1
Type 'help' for help.
reading symbolic information . . .
bus error in main at line 25
  25   x[i] = 0;
(dbx) quit
```
L'indicateur -r vous permet d'examiner l'état de votre processus en mémoire même si une image de base n'est pas prise.
Pour spécifier les variables d'environnement du programme de débogage, entrez:
```
dbx -E LIBPATH=/home/user/lib -E LANG=Ja_JP objfile
```
Pour spécifier un autre fichier objet et des bibliothèques lors de la connexion au processus, entrez:
```
dbx –a 467 –B debug_samp –p /usr/lib/=./dir/debug_libs/
```
Pour spécifier le fichier de débogage séparé au démarrage, entrez:
```
 dbx –B /usr/debug_samp.stab debug_samp
```

Sous-commandes dbx

Remarque: Les sous-commandes peuvent être utilisées uniquement lors de l'exécution du programme de débogage dbx .

Article	Descriptif
/	Recherche un modèle dans le fichier source en cours.
?	Recherche un modèle dans le fichier source en cours.
addcmd	Ajoute les sous-commandes dbx aux numéros d'événement spécifiés.
alias	Crée des alias pour les sous-commandes dbx .
assign	Affecte une valeur à une variable.
attribute	Affiche des informations sur tous les objets d'attributs ou sur les objets d'attributs sélectionnés.
call	Exécute le code objet associé à la procédure ou à la fonction nommée.
case	Modifie la façon dont le programme de débogage dbx interprète les symboles.
catch	Commence à piéger un signal avant qu'il ne soit envoyé au programme d'application.
clear	Supprime tous les arrêts sur une ligne source particulière.
cleari	Supprime tous les points d'arrêt d'une adresse.
condition	Affiche des informations sur toutes les variables de condition ou sur les variables de condition sélectionnées.
cont	Poursuit l'exécution du programme d'application à partir du point d'arrêt en cours jusqu'à ce que le programme se termine ou qu'un autre point d'arrêt soit détecté.
corefile	Affiche des données de haut niveau sur un fichier core.
coremap	Affiche le mappage d'une région d'espace adresse particulière.
delcmd	Supprime les sous-commandes dbx associées au numéro d'événement spécifié.
delete	Supprime les traces et les arrêts correspondant aux numéros d'événement spécifiés et aux nombres de tskip pour une unité d'exécution.
detach	Poursuit l'exécution de l'application et quitte le programme de débogage.
disable	Désactive les traces et les arrêts correspondant aux numéros d'événement spécifiés.
display memory	Affiche le contenu de la mémoire.
down	Déplace la fonction en cours vers le bas de la pile.
dump	Affiche les noms et les valeurs des variables dans la procédure spécifiée.
edit	Démarre un éditeur sur le fichier spécifié.
enable	Active les traces et les arrêts correspondant aux numéros d'événement spécifiés.
fd	Affiche les informations de descripteur de fichier.
file	Remplace le fichier source en cours par le fichier spécifié.
frame	Remplace la fonction en cours par la fonction correspondant au numéro de cadre de pile indiqué.
func	Remplace la fonction en cours par la procédure ou la fonction indiquée.
goto	Fait en sorte que la ligne source spécifiée soit la ligne suivante.
gotoi	Modifie l'adresse du compteur du programme.
handler	Affiche des informations sur les gestionnaires de nettoyage pthreads atfork ou cancelation.
help	Affiche des informations d'aide pour les sous-commandes ou les rubriques dbx .
ignore	Arrête de piéger un signal avant qu'il ne soit envoyé au programme d'application.
kthread	Affiche des informations sur les unités d'exécution du noyau.
limitbp	Limite le nombre de fois où un point d'arrêt peut être exécuté.
list	Affiche les lignes du fichier source en cours.
listi	Répertorie les instructions du programme d'application.
malloc	Affiche des informations sur l'utilisation du programme du sous-système malloc.
map	Affiche des informations sur les caractéristiques de charge de l'application.
move	Modifie la ligne suivante à afficher.
multproc	Active ou désactive le débogage multiprocessus.
mutex	Affiche des informations sur tous les mutex ou sur les mutex sélectionnés.
next	Exécute le programme d'application jusqu'à la ligne source suivante.
nexti	Exécute le programme d'application jusqu'à l'instruction machine suivante.
onceblock	Affiche des informations sur les blocs une fois.
plugin	Appelle une sous-commande de plug-in ou affiche les noms des plug-in disponibles.
pluginload	Charge un plug-in.
pluginunload	Décharge un plug-in.
print	Imprime la valeur d'une expression ou exécute une procédure et imprime le code retour de cette procédure.
printbp	Imprime le nombre de fois où un point d'arrêt est exécuté.
proc	Affiche des informations sur le processus.
prompt	Modifie l'invite de commande dbx .
quit	Arrête le programme de débogage dbx .
registers	Affiche les valeurs de tous les registres à usage général, les registres de contrôle du système, les registres à virgule flottante et le registre d'instruction en cours.
réexécution	Commence l'exécution d'une application avec les arguments précédents.
resource	Affiche des informations sur les ressources détenues ou en attente par pthreads.
return	Poursuit l'exécution du programme d'application jusqu'à ce qu'un retour à la procédure spécifiée soit atteint.
rwlock	Affiche des informations sur les rwlocks.
run	Démarre l'exécution d'une application.
screen	Ouvre une Xwindow pour l'interaction de la commande dbx .
set	Définit une valeur pour une variable de programme de débogage dbx .
sh	Transmet une commande au shell à exécuter.
skip	Poursuit l'exécution du programme d'application à partir du point d'arrêt en cours.
source	Lit les sous-commandes dbx à partir d'un fichier.
status	Imprime les détails relatifs à un point d'arrêt. Il affiche également la trace active, les sous-commandes stop et le nombre d'unités d'exécution restantes tskip .
step	Exécute une ligne source.
stepi	Exécute une instruction machine.
stophwp	Définit un arrêt de point de contrôle matériel.
stop	Arrête l'exécution du programme d'application.
stopi	Définit un arrêt à un emplacement spécifié.
thdata	Affiche des données spécifiques à l'unité d'exécution.
thread	Affiche et contrôle les unités d'exécution.
tls	Affiche des informations sur le modèle d'initialisation TLS.
tm_status	Affiche et interprète la valeur stockée dans la variable `$texasr` .
tnext	Exécute une unité d'exécution jusqu'à la ligne source suivante.
tnexti	Exécute une unité d'exécution jusqu'à l'instruction machine suivante.
trace	Imprime les informations de trace.
tracehwp	Définit une trace de point de contrôle matériel.
tracei	Active le traçage.
tskip	Ignore les points d'arrêt d'une unité d'exécution.
tstep	Exécute une unité d'exécution pour une ligne source.
tstepi	Exécute une unité d'exécution pour une instruction machine.
tstop	Définit un arrêt de point d'arrêt de niveau source pour une unité d'exécution.
tstophwp	Définit un arrêt de point de contrôle matériel au niveau de l'unité d'exécution.
tstopi	Définit un arrêt de point d'arrêt de niveau instruction pour une unité d'exécution.
ttrace	Définit une trace de niveau source pour une unité d'exécution.
ttracehwp	Définit une trace de point de contrôle matériel de niveau unité d'exécution.
ttracei	Définit une trace de niveau instruction pour une unité d'exécution.
unalias	Supprime un alias.
unset	Supprime une variable.
up	Déplace la fonction en cours vers le haut de la pile.
use	Définit la liste des répertoires à rechercher lors de la recherche de fichiers source.
whatis	Affiche la déclaration des composants du programme d'application.
where	Affiche la liste des procédures et des fonctions actives.
whereis	Affiche les qualifications complètes de tous les symboles dont les noms correspondent à l'identificateur spécifié.
which	Affiche la qualification complète de l'identificateur spécifié.

/ Sous-commande

/ [ RegularExpression [ / ] ]

La sous-commande / recherche dans le fichier source en cours le modèle spécifié par le paramètre RegularExpression . Si vous entrez la sous-commande / sans arguments, dbx recherche en avant l'expression régulière précédente. La recherche passe à la fin du fichier.

Exemples

Pour rechercher le numéro 12 dans le fichier source en cours, entrez:
```
/ 12
```
Pour répéter la recherche précédente, entrez:
```
/
```

Voir la sous-commande ? (search) et la sous-routine regcmp .

? Sous-commande

? [ RegularExpression [ ? ] ]

La sous-commande ? recherche dans le fichier source en cours le modèle spécifié par le paramètre RegularExpression . Si vous entrez la sous-commande ? sans argument, la commande dbx effectue une recherche en amont de l'expression régulière précédente. La recherche passe à la fin du fichier.

Exemples

Pour rechercher la lettre dans le fichier source en coursz, entrez:
```
?z
```
Pour répéter la recherche précédente, entrez:
```
?
```

Voir la sous-commande / (search) et la sous-routine regcmp .

sous-commande addcmd

addcmd { Nombre... | all } "chaîne_commandes"

La sous-commande addcmd ajoute des sous-commandes dbx à l'événement spécifié. Cet événement spécifié est exécuté chaque fois que le point d'arrêt, le point de trace ou le point de contrôle correspondant à l'événement est exécuté. Les sous-commandes dbx peuvent être spécifiées via le paramètre "chaîne_commandes", qui est un groupe de sous-commandes dbx séparées par un point-virgule (;). L'événement auquel les sous-commandes dbx doivent être ajoutées peut être spécifié via le paramètre Nombre ou les sous-commandes dbx peuvent être ajoutées à tous les événements à l'aide de l'indicateur all .

Flags

Article	Descriptif
all	Ajoute des sous-commandes dbx à tous les événements.

Exemples

Pour ajouter la sous-commande where à l'événement numéro 1, entrez:
```
addcmd 1 "where"
```
Pour ajouter la sous-commande registers à l'événement numéro 2, entrez:
```
addcmd 2 "registers"
```
Pour ajouter les sous-commandes where et registers à l'événement numéro 3, entrez:
```
addcmd 3 "where;registers"
```

Voir la sous-commande clear , la sous-commande delcmd , la sous-commande delete , la sous-commande disable , la sous-commande enable , la sous-commande stop , la sous-commande status et la sous-commande trace . Voir aussi Définition et suppression de points d'arrêt dans dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande alias

alias [ Nom [ [ (Arglist) ] Chaîne | Sous-commande ] ]

La sous-commande alias crée des alias pour les sous-commandes dbx . Le paramètre Nom correspond à l'alias en cours de création. Le paramètre String est une série de sous-commandes dbx qui, après l'exécution de cette sous-commande, peuvent être référencées par Name. Si la sous-commande alias est utilisée sans paramètres, elle affiche tous les alias en cours.

Exemples

Pour remplacerrrpourrerun, entrez:
```
alias rr rerun
```
Pour exécuter les deux sous-commandesprint netstepchaque fois queprintandstepest entré sur la ligne de commande, entrez:
```
alias printandstep "print n; step"
```
LealiasLa sous-commande peut également être utilisée en tant que fonction de macro limitée. Par exemple :
```
(dbx) alias px(n) "set $hexints; print n; unset $hexints"
(dbx) alias a(x,y) "print symname[x]->symvalue._n_n.name.Id[y]"
(dbx) px(126)
0x7e
```
Dans cet exemple, l'aliaspximprime une valeur hexadécimale sans affecter définitivement l'environnement de débogage.

affecter une sous-commande

assign Variable=Expression

La sous-commande assign affecte la valeur spécifiée par le paramètre Expression à la variable spécifiée par le paramètre Variable .

Exemples

Pour affecter une valeur de5à laxvariable, entrez:
```
assign x = 5
```
Pour affecter la valeur duyà la variablexvariable, entrez:
```
assign x =  y
```
Pour affecter la valeur de caractère'z'à lazvariable, entrez:
```
assign  z  =  'z'
```
Pour affecter la valeur booléennefalseà la variable de type logiqueB, entrez:
```
assign  B  =  false
```
Pour affecter le"Hello World"chaîne vers un pointeur de caractèreY, entrez:
```
assign  Y  =  "Hello  World"
```
Pour désactiver la vérification de type, définissez la variable de programme de débogage dbx$unsafeassignen entrant:
```
set $unsafeassign
```

Voir Affichage et modification des variables.

attribut Sous-commande

attribute [ AttributeNumber ... ]

La sous-commande attribute affiche des informations sur les objets d'unité d'exécution utilisateur, mutex ou attributs de condition définis par les paramètres AttributeNumber . Si aucun paramètre n'est spécifié, tous les objets d'attribut sont répertoriés.

Pour chaque objet d'attribut répertorié, les informations suivantes s'affichent:

Article	Descriptif
`attr`	Indique le nom symbolique de l'objet d'attributs, sous la forme`$aAttributeNumber`.
`obj_addr`	Indique l'adresse de l'objet d'attributs.
`type`	Indique le type de l'objet d'attributs ; cette valeur peut être`thr`,`mutex`ou`cond`pour les unités d'exécution utilisateur, les exclusions mutuelles et les variables de condition respectivement.
`state`	Indique l'état de l'objet d'attributs. Cette valeur peut être`valid`ou`inval`.
`stack`	Indique l'attribut stacksize d'un objet d'attributs d'unité d'exécution.
`scope`	Indique l'attribut de portée d'un objet d'attributs d'unité d'exécution. Cette valeur détermine la portée des conflits de l'unité d'exécution et définit l'ensemble des unités d'exécution avec lesquelles elle doit composer pour traiter les ressources. La valeur peut être`sys`ou`pro`pour la portée des conflits de système ou de processus.
`prio`	Indique l'attribut de priorité d'un objet d'attributs d'unité d'exécution.
`sched`	Indique l'attribut schedpolicy d'un objet d'attributs d'unité d'exécution. Cet attribut contrôle la règle de planification et peut être`fifo`,`rr`(round robin), ou`other`.
`p-shar`	Indique l'attribut process-shared d'un objet d'attribut mutex ou de condition. Un processus mutex ou une condition est partagé s'il est accessible par des unités d'exécution appartenant à des processus différents. La valeur peut être`yes`ou`no`.
`protocol`	Indique l'attribut de protocole d'un mutex. Cet attribut détermine l'effet de la conservation du mutex sur une priorité d'unités d'exécution. La valeur peut être`no_prio`,`prio`ou`protect`.
`clock`	Indique l'attribut d'horloge d'un objet d'attribut de condition. Cet attribut détermine l'horloge à utiliser lorsqu'une unité d'exécution attend la variable de condition spécifiée comme délai d'attente. La valeur peut être `realtime` ou `monotonic`.

Remarque :

La sous-commande print du programme de débogage dbx reconnaît les noms d'attribut symboliques et peut être utilisée pour afficher l'état de l'objet correspondant.
Les attributs disponibles dépendent de l'implémentation des options POSIX .

Exemples

Pour répertorier les informations sur tous les attributs, entrez:

attribute

La sortie est similaire à la suivante:

attr   obj_addr   type  state  stack   scope    prio 
sched p-shar
$a1   0x200035c8  mutex valid                                no 
$a2   0x20003628  cond  valid                                no
$a3   0x200037c8  thr   valid  57344    sys      126 other
$a4   0x200050f8  thr   valid  57344    pro      126 other

Pour répertorier les informations sur les attributs 1 et 3, entrez:

attribute 1 3

La sortie est similaire à la suivante:

attr   obj_addr   type  state  stack   scope    prio 
sched p-shar
$a1   0x200035c8  mutex valid                                no 
$a3   0x200037c8  thr   valid  57344    sys      126 other

Voir la sous-commande condition , la sous-commande mutex , la sous-commande print et la sous-commande thread pour la commande dbx .

Voir également Création d'unités d'exécution, Utilisation de Mutexeset Utilisation de variables de condition dans Concepts généraux de programmation: Ecriture et débogage de programmes.

call Subcommand

call Procédure ([ Paramètres ])

La sous-commande call exécute la procédure spécifiée par le paramètre Procédure . Le code retour n'est pas imprimé. Si des paramètres sont spécifiés, ils sont transmis à la procédure en cours d'exécution.

Remarque: La sous-commande call ne peut pas être utilisée pour appeler des fonctions qui prennent des paramètres de vecteur.

Exemple

Pour appeler une commande lors de l'exécution de la commande dbx , entrez:

(dbx) call printf("hello")
hello

printf est renvoyé avec succès.

Sous-commande case

case [ par défaut | mixte | inférieur | supérieur ]

La sous-commande case modifie la façon dont le programme de débogage dbx interprète les symboles. Le traitement par défaut des symboles est basé sur la langue en cours. Si la langue en cours est C, C + + ou non définie, les symboles ne sont pas pliés ; si la langue en cours est Fortran, les symboles sont pliés en minuscules. Utilisez cette sous-commande si un symbole doit être interprété de manière non cohérente avec la langue en cours.

La saisie de la sous-commande case sans paramètre affiche le mode de cas en cours.

Flags

Article	Descriptif
valeur par défaut	Varie en fonction de la langue en cours.
Mixte	Fait en sorte que les symboles soient interprétés tels qu'ils apparaissent réellement.
lower	Provoque l'interprétation des symboles en minuscules.
upper	Provoque l'interprétation des symboles en majuscules.

Exemples

Pour afficher le mode de cas en cours, entrez:
```
case
```
Pour demander à dbx d'interpréter les symboles tels qu'ils apparaissent, entrez:
```
case mixed
```
Pour indiquer à dbx d'interpréter les symboles en majuscules, entrez:
```
case upper
```

Voir Folding Variables to Lowercase and Uppercase.

Sous-commande catch

catch [ SignalNumber | SignalName ]

La sous-commande catch démarre l'interception d'un signal spécifié avant que ce signal ne soit envoyé au programme d'application. Cette sous-commande est utile lorsque le programme d'application en cours de débogage gère des signaux tels que des interruptions. Le signal à piéger peut être spécifié par numéro ou par nom à l'aide du paramètre SignalNumber ou du paramètre SignalName , respectivement. Les noms de signal sont insensibles à la casse et le préfixe SIG est facultatif. Si les paramètres SignalNumber et SignalName ne sont pas spécifiés, tous les signaux sont interceptés par défaut à l'exception des signaux SIGHUP, SIGCLD, SIGALARMet SIGKILL . Si aucun argument n'est spécifié, la liste en cours des signaux à capturer est affichée.

Exemples

Pour afficher la liste en cours des signaux devant être interceptés par la commande dbx , entrez:
```
catch
```
Pour intercepter le signalSIGALARM, entrez:
```
catch SIGALARM
```

Voir la sous-commande ignore et Handling Signals.

sous-commande clear

clear SourceLine

La sous-commande clear supprime tous les arrêts sur une ligne de source particulière. Le paramètre SourceLine peut être spécifié dans deux formats:

En tant qu'entier
En tant que chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier

Exemples

Pour supprimer des points d'arrêt définis à la ligne19, entrez:

clear 19

La sous-commande cleari et la sous-commande delete . Voir aussi Définition et suppression de points d'arrêt dans dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande cleari

cleari Adresse

La sous-commande cleari efface tous les points d'arrêt à l'adresse spécifiée par le paramètre Adresse .

Exemples

Pour supprimer un point d'arrêt défini à l'adresse0x100001b4, entrez:
```
cleari 0x100001b4
```
Pour supprimer un point d'arrêt défini sur lemain()adresse de la procédure, entrez:
```
cleari &main
```

Voir la sous-commande clear , la sous-commande delete et la section Définition et suppression de points d'arrêt dans dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

Sous-commande de condition

condition [ wait | nowait | ConditionNumber ... ]

La sous-commande condition affiche des informations sur une ou plusieurs variables de condition. Si un ou plusieurs paramètres ConditionNumber sont indiqués, la sous-commande condition affiche des informations sur les variables de condition spécifiées. Si aucun indicateur ou paramètre n'est spécifié, la sous-commande condition répertorie toutes les variables de condition.

Les informations répertoriées pour chaque condition sont les suivantes:

Article	Descriptif
`cv`	Indique le nom symbolique de la variable de condition, sous la forme`$cConditionNumber`.
`obj_addr`	Indique l'adresse mémoire de la variable de condition.
`clock`	Indique l'attribut d'horloge de la variable de condition.
`num_wait`	Indique le nombre d'unités d'exécution en attente de la variable de condition.
`waiters`	Répertorie les unités d'exécution utilisateur qui attendent la variable de condition.

Remarque: La sous-commande print du programme de débogage dbx reconnaît les noms de variable de condition symbolique et peut être utilisée pour afficher le statut de l'objet correspondant.

Flags

Article	Descriptif
wait	Affiche les variables de condition ayant des unités d'exécution en attente.
PAS D'ATTENTE	Affiche les variables de condition qui n'ont pas d'unités d'exécution en attente.

Exemples

Pour afficher des informations sur toutes les variables de condition, entrez:
```
condition
```
Pour afficher des informations sur toutes les variables de condition ayant des unités d'exécution en attente, entrez:
condition wait
Pour afficher des informations sur la variable de condition 3, entrez:
```
condition 3
```
La sortie est similaire à la suivante:
```
cv      obj_addr     num_wait  waiters
$c3     0x20003290         0
```

Voir la sous-commande attribute , la sous-commande mutex , la sous-commande print et la sous-commande thread .

Voir aussi Utilisation des variables de condition dans Concepts de programmation généraux: Ecriture et débogage des programmes.

sous-commande cont

cont [ SignalNumber | SignalName ]

La sous-commande cont poursuit l'exécution du programme d'application à partir du point d'arrêt en cours jusqu'à ce que le programme se termine ou qu'un autre point d'arrêt soit atteint. Si un signal est spécifié, soit par le numéro spécifié dans le paramètre SignalNumber , soit par le nom spécifié dans le paramètre SignalName , le programme continue comme si ce signal était reçu. Les noms de signal ne sont pas sensibles à la casse et le préfixe SIG est facultatif. Si aucun signal n'est indiqué, le programme continue comme s'il n'était pas arrêté.

Exemples

Pour continuer l'exécution du programme à partir du point d'arrêt en cours, entrez:
```
cont
```
Pour continuer l'exécution du programme comme s'il avait reçu le signal SIGQUIT, entrez:
```
cont SIGQUIT
```

Voir la sous-commande detach pour la commande dbx , la sous-commande goto pour la commande dbx , la sous-commande next pour la commande dbx , la sous-commande skip pour la commande dbx , la sous-commande step pour la commande dbx .

sous-commande corefile

La sous-commande corefile affiche les informations de l'en-tête d'un fichier core, notamment le nom de l'exécutable, les informations de version du format du fichier core, les indicateurs indiquant les données disponibles, le signal à l'origine de la panne et le mode d'exécution du processus qui a effectué le vidage du fichier core.

coremap Subcommand

La sous-commande coremap affiche le mappage d'une région d'espace adresse particulière. Si vous ne spécifiez pas le nom de région, la sous-commande coremap affiche tous les mappages disponibles.

Exemples

Pour afficher le mappage d'une région de mémoire partagée, entrez:
```
coremap shm
```
Pour afficher le mappage d'une région mappée en mémoire, entrez:
```
coremap mmap
```
Pour afficher les mappages de toutes les régions décrites par les entrées du chargeur, entrez:
```
coremap loader
```
Pour afficher tous les mappages disponibles, entrez:
```
coremap
```

Voir la sous-commande corefile .

Sous-commande delcmd

delcmd EventNumber { Numéro ... | all }

La sous-commande delcmd supprime les sous-commandes dbx associées à l'événement spécifié. Les sous-commandes dbx à supprimer peuvent être spécifiées via les paramètres Nombre ou toutes les sous-commandes dbx associées à l'événement spécifié peuvent être supprimées à l'aide de l'indicateur all . Le paramètre EventNumber indique l'événement à partir duquel les sous-commandes dbx doivent être supprimées.

Flags

Article	Descriptif
all	Supprime toutes les sous-commandes dbx associées à l'événement spécifié.

Exemples

Pour supprimer toutes les sous-commandes dbx de l'événement numéro 2, entrez:
```
delcmd 2 all
```
Pour supprimer la sous-commande dbx numéro 1 de l'événement numéro 3, entrez:
```
delcmd 3 1
```
Pour supprimer les sous-commandes dbx numéros 1 et 2 de l'événement numéro 2, entrez:
```
delcmd 2 1 2
```

Voir la sous-commande addcmd , la sous-commande clear , la sous-commande delete , la sous-commande disable , la sous-commande enable , la sous-commande stop , la sous-commande status et la sous-commande trace . Voir aussi Définition et suppression de points d'arrêt dans dans General Programming Concepts: Writing and Debugging Programs.

Supprimer une sous-commande

delete { Nombre ... | all | tskip [for $tnuméro_unité d'exécution] }

La sous-commande delete supprime les traces et s'arrête du programme d'application et des comptages tskip pour une unité d'exécution. Les traces et les arrêts à supprimer peuvent être spécifiés à l'aide des paramètres Nombre ou toutes les traces et tous les arrêts peuvent être supprimés à l'aide de l'indicateur all . Utilisez la sous-commande status pour afficher les numéros associés par le programme de débogage dbx avec une trace ou un arrêt.

Le nombre tskip restant, qui a été défini à l'aide de la sous-commande tskip pour une unité d'exécution, peut être supprimé à l'aide de l'indicateur tskip . Utilisez la sous-commande status pour afficher le nombre d'unités d'exécution restantes tskip . Si aucune unité d'exécution n'est spécifiée, l'unité d'exécution en cours est utilisée.

Indicateur

Article	Descriptif
all	Supprime toutes les traces et s'arrête.
pour $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.

Exemples

Pour supprimer toutes les traces et les arrêts du programme d'application, entrez:
```
delete all
```
Pour supprimer des traces et des arrêts pour l'événement numéro 4, entrez:
```
delete 4
```
Pour supprimer le nombre de tskip pour l'unité d'exécution 3, entrez:
```
delete tskip for $t3
```
Pour supprimer le nombre de tskip pour l'unité d'exécution en cours, entrez:
```
delete tskip 
```

Voir la sous-commande clear , la sous-commande cleari , la sous-commande status , la sous-commande tskip et Définition et suppression de points d'arrêt dans dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

Sous-commande detach

detach [ SignalNumber | SignalName ]

La sous-commande detach poursuit l'exécution du programme d'application et quitte le programme de débogage. Un signal peut être spécifié par:

Nom, à l'aide du paramètre SignalName
Nombre, à l'aide du paramètre SignalNumber
Les noms de signal ne sont pas sensibles à la casse et le préfixe SIG est facultatif.

Si un signal est spécifié, le programme continue comme s'il avait reçu ce signal. Si aucun signal n'est indiqué, le programme continue comme si aucun arrêt n'avait eu lieu.

Exemples

Pour continuer l'exécution de l'application et quitter dbx, entrez:
```
detach
```
Pour quitter dbx et continuer l'exécution de l'application comme si elle avait reçu le signalSIGREQUEST, entrez:
```
detach SIGREQUEST
```

Voir Utilisation du programme de débogage dbx .

désactiver la sous-commande

disable { nombre ... tout }

La sous-commande disable désactive les traces et les arrêts associés aux événements de débogage. Les traces et les arrêts à désactiver peuvent être spécifiés à l'aide des paramètres Nombre , ou toutes les traces et tous les arrêts peuvent être désactivés à l'aide de l'indicateur all . Utilisez la sous-commande status pour afficher les numéros d'événement associés par le programme de débogage dbx avec une trace ou un arrêt.

Flags

Article	Descriptif
all	Supprime toutes les traces et s'arrête.

Exemples

Pour désactiver toutes les traces et les arrêts du programme d'application, entrez:
```
disable all
```
Pour désactiver les traces et les arrêts pour le numéro d'événement 4, entrez:
```
disable 4
```

Pour plus d'informations, voir enable subcommand, delete subcommandet status subcommand.

Voir aussi Définition et suppression de points d'arrêt dans General Programming Concepts: Writing and Debugging Programs.

Afficher la sous-commande de mémoire

{ Adresse, Adresse/ | Adresse / [ Nombre ] } [ Mode ] [ >Fichier ]

La sous-commande display memory , qui ne comporte pas de mot clé pour lancer la commande, affiche une partie de la mémoire contrôlée par les facteurs suivants:

La plage de mémoire affichée est contrôlée en spécifiant l'une des options suivantes:

Deux paramètres Adresse , où toutes les lignes entre ces deux adresses sont affichées,
OR
Un paramètre Adresse où l'affichage commence et un paramètre Nombre qui détermine le nombre de lignes affichées à partir de Adresse.

Indiquez des adresses symboliques en faisant précéder le nom d'une & (perluète). Les adresses peuvent être des expressions composées d'autres adresses et des opérateurs + (signe plus),-(signe moins) et * (adressage indirect). Toute expression entre parenthèses est interprétée comme une adresse.

Le format d'affichage de la mémoire est contrôlé par le paramètre Mode . La valeur par défaut du paramètre Mode est le mode en cours. La valeur initiale de Mode est X. Les modes possibles sont les suivants:

Article	Descriptif
B	Imprime un octet en octal.
c	Imprime un octet en tant que caractère.
d	Imprime un mot court en décimal.
D	Imprime un mot long en décimal.
df	Imprime un nombre décimal à virgule flottante à double précision.
ddl	Imprime un nombre décimal à virgule flottante quadruple précision.
F	Imprime un nombre réel de précision unique.
g	Imprime un nombre réel à double précision.
h	Imprime un octet au format hexadécimal.
Hf	Imprime un nombre décimal à virgule flottante simple précision.
i	Imprime l'instruction machine.
lld	Imprime un nombre décimal signé de 8 octets.
LLU	Imprime un nombre décimal non signé de 8 octets.
llx	Imprime un nombre hexadécimal non signé de 8 octets.
llo	Imprime un nombre octal non signé de 8 octets.
o	Imprime un mot court en octal
O	Imprime un long mot en octal.
p	Imprime l'adresse/le pointeur au format hexadécimal.
q	Imprime un nombre en virgule flottante à précision étendue.
s	Imprime une chaîne de caractères se terminant par un octet nul.
x	Imprime un mot court en hexadécimal.
X	Imprime un mot long en hexadécimal.

Indicateur

Article	Descriptif
>`File`	Redirige la sortie vers le fichier spécifié.

Exemples

Pour afficher un mot long du contenu de la mémoire au format hexadécimal à partir de l'adresse0x3fffe460, entrez:
```
0x3fffe460 / X
```
Pour afficher deux octets de contenu de mémoire en tant que caractères à partir de la variableyadresse, entrez:
```
&y / 2c
```
Pour afficher les sixième à huitième éléments de la chaîne de caractères Fortran a_string, entrez:
```
&a_string + 5, &a_string + 7/c
```

Voir Examen des adresses mémoire dans General Programming Concepts: Writing and Debugging Programs.

sous-commande down

down [ Nombre ]

La sous-commande down déplace la fonction en cours vers le bas de la pile Nombre de niveaux. La fonction en cours est utilisée pour la résolution des noms. La valeur par défaut du paramètre Nombre est 1.

Exemples

Pour déplacer un niveau vers le bas de la pile, entrez:
```
down
```
Pour déplacer trois niveaux vers le bas de la pile, entrez:
```
down 3
```

Voir la sous-commande up , la sous-commande where et Affichage d'une trace de pile dans General Programming Concepts: Writing and Debugging Programmes.

Sous-commande dump

dump [ Procédure | "PATTERN" ] [ >Fichier ]

La sous-commande dump affiche les noms et les valeurs de toutes les variables de la procédure spécifiée ou des variables qui correspondent au modèle spécifié. Si le paramètre Procédure est un point (.), toutes les variables actives sont affichées. Si le paramètre Procédure ou "PATTERN" est spécifié, la procédure en cours est utilisée. Le paramètre "PATTERN" est une expression générique comportant les métacaractères *, ?et [] . Lorsque "PATTERN" est utilisé, il affiche tous les symboles correspondants dans l'espace global (à partir de toutes les procédures). Si l'indicateur >Fichier est utilisé, la sortie est redirigée vers le fichier spécifié.

Flags

Article	Descriptif
>`File`	Redirige la sortie vers le fichier spécifié.

Exemples

Pour afficher les noms et les valeurs des variables dans la procédure en cours, entrez:
```
dump
```
Pour afficher les noms et les valeurs des variables dans la procédure add_count , entrez:
```
dump add_count
```
Pour afficher les noms et les valeurs des variables commençant par le caractère s, entrez:
```
dump "s*"
```
Pour rediriger les noms et les valeurs des variables de la procédure en cours vers le fichier var.list , entrez:
```
dump > var.list
```

Voir Affichage et modification des variables dans General Programming Concepts: Writing and Debugging Programs.

Editer la sous-commande

edit [ Procédure | Fichier ]

La sous-commande edit démarre un éditeur sur le fichier spécifié. Le fichier peut être spécifié via le paramètre Fichier ou en spécifiant le paramètre Procédure , où l'éditeur est démarré sur le fichier contenant cette procédure. Si aucun fichier n'est spécifié, l'éditeur est démarré sur le fichier source en cours. La valeur par défaut est l'éditeur vi . Remplacez la valeur par défaut en réinitialisant la variable d'environnement EDITOR sur le nom de l'éditeur requis.

Exemples

Pour démarrer un éditeur sur le fichier source en cours, entrez:
```
edit
```
Pour démarrer un éditeur sur lemain.cfichier, entrez:
```
edit main.c
```
Pour démarrer un éditeur sur le fichier contenant ledo_count()procédure, entrez:
```
edit do_count
```

Voir la sous-commande list , la vi ou la commande vedit .

activer la sous-commande

enable { nombre ... tout }

La sous-commande enable active les traces et les arrêts associés aux événements de débogage. Les traces et les arrêts à activer peuvent être spécifiés à l'aide des paramètres Nombre ou toutes les traces et tous les arrêts peuvent être activés à l'aide de l'indicateur all . Utilisez la sous-commande status pour afficher les numéros d'événement associés par le programme de débogage dbx avec une trace ou un arrêt.

Flags

Article	Descriptif
all	Supprime toutes les traces et s'arrête.

Exemples

Pour activer toutes les traces et tous les arrêts à partir du programme d'application, entrez:
```
enable all
```
Pour activer les traces et les arrêts pour le numéro d'événement 4, entrez:
```
enable 4
```

Pour plus d'informations, voir disable subcommand, delete subcommand, status subcommand.

Voir aussi Définition et suppression de points d'arrêt dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande fd

fd [ brut ] [ début [ fin ] ]

La sous-commande fd affiche les informations de descripteur de fichier. L'utilisation de l'option raw entraîne l'affichage de la sortie au format hexadécimal brut. Les autres arguments facultatifs incluent les index start et end . Si aucun index n'est indiqué, des informations sur tous les descripteurs de fichier disponibles sont affichées. L'utilisation d'un index affiche un descripteur de fichier unique ; deux une plage inclusive.

Exemples

Pour afficher des informations sur tous les descripteurs de fichier au format hexadécimal, entrez:
```
fd raw
```
Pour afficher des informations sur les descripteurs de fichiers compris entre 3 et 5, entrez:
```
fd 3 5
```

sous-commande de fichier

file [ Fichier ]

La sous-commande file remplace le fichier source en cours par le fichier spécifié par le paramètre Fichier ; elle n'écrit pas dans ce fichier. Le paramètre Fichier peut spécifier un chemin d'accès complet au fichier. Si le paramètre Fichier ne spécifie pas de chemin, le programme dbx tente de trouver le fichier en recherchant le chemin d'utilisation. Si le paramètre Fichier n'est pas spécifié, la sous-commande file affiche le nom du fichier source en cours. La sous-commande file affiche également le nom de chemin complet ou relatif du fichier si le chemin est connu.

Exemples

Pour remplacer le fichier source en cours par lemain.cfichier, entrez:
```
file main.c
```
Pour afficher le nom du fichier source en cours, entrez:
```
file
```

Voir la sous-commande func . Voir aussi Modification du fichier ou de la procédure en cours et affichage du fichier en cours dans General Programming Concepts: Writing and Debugging Programmes.

Sous-commande frame

frame [ num ]

La sous-commande frame remplace la fonction en cours par la fonction correspondant au numéro de cadre de pile spécifié num. La fonction en cours est utilisée pour la résolution des noms. La numérotation des cadres de pile commence à partir du cadre de pile de fonction actuellement actif (le cadre de fonction actuellement actif est toujours numéroté 0). S'il existe n cadres, le cadre de la fonction main est numéroté n-1. Lorsqu'aucun numéro de trame n'est indiqué, des informations sur la fonction associée au cadre en cours sont affichées.

Exemples

Pour passer au numéro de cadre2, entrez:
```
frame 2
```
Pour afficher la fonction en cours sur la pile, entrez:
```
frame
```

Voir les sous-commandes up et down . Voir aussi Modification du fichier ou de la procédure en cours et Affichage d'une trace de pile dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

func Subcommand

func [ Procédure ]

La sous-commande func remplace la fonction en cours par la procédure ou la fonction spécifiée par le paramètre Procédure . Si le paramètre Procédure n'est pas spécifié, la fonction en cours par défaut est affichée. La modification de la fonction en cours modifie implicitement le fichier source en cours dans le fichier contenant la nouvelle fonction ; la portée en cours utilisée pour la résolution de nom est également modifiée.

Exemples

Pour remplacer la fonction en cours par lado_countprocédure, entrez:
```
func do_count
```
Pour afficher le nom de la fonction en cours, entrez:
```
func
```

Voir la sous-commande file . Voir aussi Modification du fichier ou de la procédure en cours dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande goto

goto SourceLine

La sous-commande goto entraîne l'exécution suivante de la ligne source spécifiée. Normalement, la ligne source doit avoir la même fonction que la ligne source en cours. Pour remplacer cette restriction, utilisez la sous-commande set avec l'indicateur $unsafegoto .

Exemple

Pour remplacer la ligne suivante à exécuter par la ligne 6, entrez:

goto 6

Voir la sous-commande cont , la sous-commande gotoi et la sous-commande set .

Sous-commande gotoi

gotoi Adresse

La sous-commande gotoi remplace l'adresse du compteur de programme par l'adresse spécifiée par le paramètre Adresse .

Exemple

Pour modifier l'adresse du compteur du programme en adresse0x100002b4, entrez:

gotoi 0x100002b4

Voir la sous-commande goto .

Sous-commande de gestionnaire

handler { atfork | cancel_cleanup [ all | id pthread ] }

La sous-commande handler affiche des informations sur les gestionnaires de nettoyage d'atfork ou d'annulation enregistrés à l'aide de pthread_atforket de pthread_cleanup_push, respectivement. A l'aide de l'option atfork , les noms des routines enregistrées en tant que gestionnaires atfork pre, parent et child sont affichés (avec leurs arguments respectifs dans le cas de gestionnaires atfork non conformes à posix). L'option cancel_cleanup permet d'afficher tous les gestionnaires de nettoyage d'annulation enregistrés, avec un paramètre facultatif pthread id spécifiant un pthread particulier, ou all spécifiant tous les pthreads. Si aucun n'est indiqué, les gestionnaires de nettoyage d'annulation pour l'unité d'exécution de programme en cours sont affichés, s'il en existe.

Exemples

Pour afficher des informations sur tous les gestionnaires atfork enregistrés, entrez:
```
handler atfork
```
Pour afficher des informations sur les gestionnaires de nettoyage d'annulation enregistrés pour le pthread en cours, entrez:
```
handler cancel_cleanup
```
Pour afficher des informations sur les gestionnaires de nettoyage d'annulation enregistrés pour l'objet pthread appelé $t2, entrez:
```
handler cancel_cleanup 2
```

sous-commande help

help [ Sous-commande | Rubrique ]

La sous-commande help affiche des informations d'aide pour les sous-commandes ou les rubriques dbx , en fonction du paramètre que vous spécifiez. La saisie de la sous-commande help avec le paramètre Sous-commande affiche l'instruction de syntaxe et la description de la sous-commande spécifiée. La saisie de la sous-commande help avec le paramètre Topic affiche une description détaillée de la rubrique spécifiée. Vous n'avez pas besoin de fournir l'intégralité de la chaîne de rubrique avec la sous-commande help . Le programme dbx peut reconnaître la rubrique si vous fournissez une sous-chaîne à partir du début de la rubrique. Les rubriques suivantes sont disponibles:

Article	Descriptif
startup	Répertorie les options de démarrage de dbx .
execution	Répertorie les sous-commandes dbx liées à l'exécution du programme.
breakpoints	Répertorie les sous-commandes dbx associées aux points d'arrêt et aux traces.
files	Répertorie les sous-commandes dbx permettant d'accéder aux fichiers source.
data	Répertorie les sous-commandes dbx permettant d'accéder aux variables de programme et aux données.
machine	Répertorie les descriptions des sous-commandes dbx pour le débogage au niveau de la machine.
environment	Répertorie les sous-commandes dbx pour la définition de la configuration et de l'environnement dbx .
threads	Répertorie les sous-commandes dbx permettant d'accéder aux objets liés aux unités d'exécution.
expressions	Décrit la syntaxe et les opérateurs de l'expression dbx .
scope	Décrit comment dbx résout les noms de différentes portées.
set_variables	Répertorie les variables de débogage dbx avec une description de l'utilisation.
usage	Répertorie les sous-commandes dbx communes avec de brèves descriptions.

Exemples

Pour répertorier toutes les sous-commandes et rubriques dbx disponibles, entrez:
```
help
```
Pour afficher la description de la dbx sous-commande liste, entrez:
```
help list
```
Pour afficher la description de la rubrique dbx set_variables, entrez:
```
help set_variables
```

Sous-commande ignore

ignore [ SignalNumber | SignalName ]

La sous-commande ignore arrête l'interception d'un signal spécifié avant qu'il ne soit envoyé au programme d'application. Cette sous-commande est utile lorsque le programme d'application en cours de débogage gère des signaux tels que des interruptions.

Le signal à piéger peut être spécifié par:

Number, avec le paramètre SignalNumber
Name, avec le paramètre SignalName

Les noms de signal ne sont pas sensibles à la casse. Le préfixe SIG est facultatif.

Si les paramètres SignalNumber et SignalName sont spécifiés, tous les signaux à l'exception des signaux SIGHUP, SIGCLD, SIGALRMet SIGKILL sont interceptés par défaut. Le programme de débogage dbx ne peut pas ignorer le signal SIGTRAP s'il provient d'un processus en dehors du débogueur. Si aucun argument n'est indiqué, la liste des signaux actuellement ignorés s'affiche.

Exemple

Pour que dbx ignore les signaux de délai d'attente de l'horloge d'alarme envoyés au programme d'application, entrez:

ignore alrm

Voir la sous-commande catch . Voir également Handling Signals dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande kthread

kthread [ brut ] [ info | ru ] [ tid ]

La sous-commande kthread affiche des informations sur les unités d'exécution du noyau. L'utilisation de l'option raw entraîne l'affichage de toutes les sorties au format hexadécimal, qu'elles puissent ou non être affichées dans un format plus lisible par l'utilisateur. En l'absence d'arguments, des informations récapitulatives sur toutes les unités d'exécution du noyau sont imprimées. Lorsque vous indiquez un ID d'unité d'exécution numérique, la commande dbx affiche des informations sur une seule unité d'exécution. L'option info génère une sortie plus détaillée sur une unité d'exécution, à partir de la structure de l'unité d'exécution utilisateur. L'utilisation de l'option ru affiche le membre de données ti_ru , qui contient des informations sur l'utilisation des ressources.

Pour plus d'informations sur les unités d'exécution utilisateur, voir thread subcommand.

Exemples

Pour trouver des informations sur l'unité d'exécution en cours d'exécution, vous devez d'abord obtenir des informations sur toutes les unités d'exécution en entrant la commande suivante sur la ligne de commande:
```
kthread
```
Les unités d'exécution qui étaient en cours d'exécution (ou exécutables) juste avant l'arrêt de la commande dbx sont signalées par un astérisque. Choisissez l'ID d'unité d'exécution correct en fonction de la sortie et du type:
```
kthread info tid
```
Pour afficher les informations de ressource au format hexadécimal sur toutes les unités d'exécution, entrez:
```
kthread raw ru
```

Sous-commande limitbp

limitbp ( bp1, Limite ) [ ( bp2, [ + ] Limite ) ... ]

La sous-commande limitbp indique à la commande dbx d'arrêter d'exécuter le programme de débogage uniquement lorsque le point d'arrêt est exécuté un certain nombre de fois. Si le caractère'+'précède la limite, la limite de cet événement est remplacée par la somme de la limite spécifiée dans la sous-commande et du nombre de fois où l'événement est déjà exécuté. C'est-à-dire que la commande dbx arrête l'exécution du programme de débogage lorsque le point d'arrêt est sur le point d'être exécuté pour la Limite spécifiée après l'exécution de la sous-commande limitbp .

Exemples

Pour demander à la commande dbx d'arrêter l'exécution du programme de débogage lorsque le point d'arrêt 1 est sur le point d'être exécuté la 10e fois, entrez:
```
limitbp (1, 10)
```
Pour demander à la commande dbx d'arrêter l'exécution du programme de débogage lorsque l'un des points d'arrêt 1 est sur le point d'être exécuté, la 15ième fois ou le point d'arrêt 2 est sur le point d'être exécuté la 20ième fois ou les deux, entrez:
```
limitbp (1, 15) (2, 20)
```
Pour demander à la commande dbx d'arrêter l'exécution du programme de débogage lorsque le point d'arrêt 1 est sur le point d'être exécuté la 20e fois après l'exécution de la sous-commande limitbp , entrez:
```
limitbp (1, +20)
```

sous-commande list

list [ Procédure | SourceLine-Expression [ ,Expression-Ligne-Source ] | 'at Adresse ]

La sous-commande list affiche un nombre spécifié de lignes du fichier source. Le nombre de lignes affichées est indiqué de l'une des manières suivantes:

En spécifiant une procédure à l'aide du paramètre Procédure .
Dans ce cas, la sous-commande list affiche les lignes commençant quelques lignes avant le début de la procédure spécifiée et jusqu'à ce que la fenêtre de liste soit remplie.
En spécifiant un numéro de ligne source de début et de fin à l'aide du paramètre SourceLine-Expression
Le paramètre SourceLine-Expression doit être composé d'un numéro de ligne valide suivi d'un signe + (signe plus) ou - (signe moins) et d'un nombre entier. En outre, une SourceLine de $ (signe dollar) peut être utilisée pour indiquer le numéro de ligne en cours ; une SourceLine de @ (signe arobase) peut être utilisée pour indiquer le numéro de ligne suivant à répertorier.
En spécifiant la variable $listwindow interne dbx .
Si la sous-commande list est utilisée sans paramètres, le nombre de lignes spécifié par la variable $listwindow est imprimé, en commençant par la ligne source en cours. Pour modifier le nombre de lignes par défaut, définissez la variable $listwindow sur le nombre de lignes requis. La variable $listwindow est une variable de programme de débogage spéciale. Initialement, la variable $listwindow est définie sur 10.

Si la deuxième ligne source est omise, seule la première ligne est imprimée.

Toutes les lignes du numéro de la première ligne indiqué au numéro de la deuxième ligne indiqué, inclus, sont alors affichées.

Lorsque vous spécifiez une adresse après le paramètre at dans la sous-commande list , la sous-commande list affiche les lignes source qui correspondent à l'adresse spécifiée. L'adresse peut être spécifiée sous la forme d'un entier décimal ou hexadécimal non signé, ou d'un mnémonique correspondant à des registres, tels que $iar, $tfiaret $tfhar ou des variables de débogage.

Exemples

Pour répertorier les lignes1grâce à10dans le fichier en cours, entrez:
```
list 1,10
```
A la liste10ou$listwindow, lignes autour de lamainprocédure, entrez:
```
list main
```
Pour répertorier 11 lignes autour de la ligne en cours, entrez:
```
list $-5,$+5
```

Vous pouvez utiliser des expressions simples de nombres entiers impliquant l'addition et la soustraction dans les expressions SourceLineExpression. Par exemple :

(dbx) list $
4 {

(dbx) list 5
5 char i = '4';

(dbx) list sub
23 char *sub(s,a,k)
24 int a;
25 enum status k;  .  .  .  

(dbx) move 
25
(dbx) list @ -2
23 char *sub(s,a,k)

Vous pouvez afficher les lignes source qui correspondent à une adresse spécifique. Par exemple :

(dbx) r
[1] stopped in main at line 5
    5 int i, sum = 0;

(dbx) list at $iar
source file: "tt.c"
    5 int i, sum = 0;
    6 int last = 0;
    7
    8 scanf("%d", &last);
    9 
    10 for ( i = 1; i &lt;=last; i++ ) { 
    11 sum += i; 
    12 } 
    13 printf("sum = %d\n", sum); 
    14 

(dbx) list at ($iar+16) 
source file: "tt.c" 
    8 scanf("%d", &last); 
    9 
    10 for ( i = 1; i <= last; i++ ) { 
    11 sum += i; 
    12 } 
    13 printf("sum = %d\n", sum); 
    14 
    15 return 0; 
    16 }

Voir la sous-commande edit , la sous-commande listi et la sous-commande move . Voir aussi Affichage du fichier en cours dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande listi

listi [ Procédure | at SourceLine | Adresse [ , Adresse ] ]

La sous-commande listi affiche un ensemble spécifié d'instructions du fichier source. Les instructions affichées sont spécifiées par:

Ajout du paramètre Procédure , où la sous-commande listi répertorie les instructions depuis le début de la procédure spécifiée jusqu'à ce que la fenêtre de liste soit remplie.
Utilisation de l'indicateur at SourceLine , où la sous-commande listi affiche les instructions commençant à la ligne source spécifiée et se poursuivant jusqu'à ce que la fenêtre de liste soit remplie. La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier.
Indication d'une adresse de début et d'une adresse de fin à l'aide des paramètres Adresse , où toutes les instructions entre les deux adresses, inclusives, sont affichées.

Si la sous-commande listi est utilisée sans indicateurs ni paramètres, les instructions $listwindow suivantes s'affichent. Pour modifier la taille actuelle de la fenêtre de liste, utilisez la sous-commande set $listwindow=Value .

Modes de désassemblage

Le programme 'dbx peut désassembler les instructions de la famille POWER® ou de l'architecture PowerPC®. Dans le mode par défaut, le programme dbx affiche les instructions pour l'architecture sur laquelle il s'exécute.

Les variables $instructionset et $mnemonics de la sous-commande set de la commande dbx vous permettent de remplacer le mode de désassemblage par défaut. Pour plus d'informations, voir la sous-commande set de la commande dbx .

Indicateur

Article	Descriptif
sur `SourceLine`	Indique une ligne source de début pour la liste.

Exemples

Pour répertorier les 10 suivants, ou$listwindow, instructions, entrez:
```
listi
```
Pour répertorier les instructions machine à partir de la ligne source10, entrez:
```
listi at 10
```
Pour répertorier les instructions machine à partir de la ligne source5dans le fichiersample.c, entrez:
```
listi at "sample.c":5
```
Pour répertorier les instructions entre les adresses0x10000400et0x10000420, entrez:
```
listi 0x10000400, 0x10000420
```

Voir la sous-commande list et la sous-commande set . Voir également Débogage au niveau de la machine avec dbx dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande malloc

malloc [ > Fichier ]

La sous-commande malloc sans option affiche une liste des options activées et des règles d'allocation, ainsi qu'un récapitulatif statistique de l'utilisation de malloc depuis le démarrage du processus.

malloc [ allocation [ { adresse | taille | segment de mémoire | pid | tid | heure } { "<" | "==" | ">" "!=" | “~=” ]} Valeur ] ] [ > Fichier ]

L'option allocation de la sous-commande malloc affiche une liste triée de toutes les allocations actuellement détenues par le processus. L'utilisation d'un argument attribute RELOP value facultatif permet une sélection plus étroite des allocations actives.

malloc [ espace libre [ { adresse | taille | segment de mémoire } { "<" | "==" | ">" | "!=" | “~=”]} Valeur ] ] [ > Fichier ]

L'option freespace de la sous-commande malloc affiche une liste triée de tout l'espace disponible dans le segment de mémoire du processus. L'utilisation d'un argument attribute RELOP value facultatif permet une sélection plus étroite des noeuds d'espace disponible.

Remarque: l'opérateur ~ = ne peut être utilisé qu'avec l'option d'adresse. Cet opérateur est utilisé pour extraire l'espace disponible ou le noeud d'allocation auquel appartient l'adresse spécifiée.

malloc adresse

La sous-commande malloc avec adresse affiche les détails des noeuds de l'adresse. Il n'est pas nécessaire que l'adresse soit une adresse de début d'un noeud alloué ou disponible.

Flags

Article	Descriptif
> `Fichier`	Redirige la sortie vers le fichier spécifié.

Pour plus d'informations, voir System Memory Allocation Using the malloc Subsystem dans General Programming Concepts: Writing and Debugging Programs.

sous-commande map

map { [Format] [ entrée ModuleNumber [, ModuleNumber ] | Adresse | nom_symbole ] [pour $tnuméro_unité d'exécution] [ > Fichier ] }

La sous-commande map affiche les caractéristiques des parties chargées de l'application. Ces informations peuvent inclure le nom du module, le nom du membre, l'origine du texte, la fin du texte, la longueur du texte, l'origine des données, la fin des données, la longueur des données, l'origine des données TLS , la fin des données TLS, la longueur des données TLS, et le descripteur de fichier pour chaque module chargé. Les entrées à afficher peuvent être spécifiées de l'une des manières suivantes:

En spécifiant une entrée unique à l'aide du paramètre ModuleNumber .
En spécifiant une plage d'entrées à l'aide de deux paramètres ModuleNumber séparés par des virgules.
En spécifiant une adresse à résoudre dans un module chargé à l'aide du paramètre Adresse .
En spécifiant un nom de symbole à résoudre dans un module chargé à l'aide du paramètre SymbolName .

Lorsqu'elle est appelée sans l'une des spécifications ci-dessus, la sous-commande map affiche des informations pour toutes les parties chargées de l'application.

L'argument Format indique le mode de sortie pour les descriptions de module chargées. La liste suivante contient les valeurs possibles pour l'argument Format :

Article	Descriptif
Abr	Indique le mode de sortie abrégé, qui se compose d'une ligne unique pour chaque module chargé contenant le numéro d'entrée, le nom de module et le nom de membre facultatif pour ce module.
normale	Indique le mode de sortie normal, qui se compose du numéro d'entrée, du nom du module, du nom de membre, de l'origine du texte, de la longueur du texte, de l'origine des données, de la longueur des données et du descripteur de fichier pour chaque module chargé. Si le module chargé contient des données TLS, l'origine des données TLS et la longueur des données TLS sont également affichées.
brutes	Indique le mode de sortie brute, qui se compose d'une seule ligne non formatée pour chaque module contenant les zones séparées par un espace suivantes: numéro d'entrée, nom de module avec nom de membre facultatif, origine du texte, fin du texte, longueur du texte, origine des données, fin des données, longueur des données et descripteur de fichier. Si le module chargé contient des données TLS, l'origine des données TLS, la fin des données TLS et la longueur des données TLS sont également affichées.
verbose	Indique le mode de sortie prolixe, qui comprend le numéro d'entrée, le nom du module, le nom du membre, l'origine du texte, la fin du texte, la longueur du texte, l'origine des données, la fin des données, la longueur des données et le descripteur de fichier pour chaque module chargé. Si le module chargé contient des données TLS, l'origine des données TLS, la fin des données TLS et la longueur des données TLS sont également affichées.

Si aucun paramètre Format n'est spécifié, la commande dbx utilise la valeur de la variable interne $mapformat . Si aucun paramètre Format n'est spécifié et que $mapformat n'est pas défini, la commande dbx affiche les informations du module chargé en mode normal.

Les informations de données TLS de l'unité d'exécution spécifiée s'affichent si le module chargé contient des données TLS. Si aucune unité d'exécution n'est spécifiée, l'unité d'exécution en cours est utilisée.

Flags

Article	Descriptif
> `Fichier`	Redirige la sortie vers le fichier spécifié.
entry `ModuleNumber` [, `ModuleNumber` ]	Indique le module ou la plage de modules à afficher.
pour $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.

Exemples

Pour répertorier tous les modules chargés en mode abrégé, entrez:
```
map abbr
```
Pour répertorier les modules 3 à 5 chargés en mode prolixe, entrez:
```
map verbose entry 3,5
```
Pour répertorier le module chargé qui contient l'adresse 0x20001000, entrez:
```
map 0x20001000
```
Pour répertorier le module chargé qui contient la variable example, entrez:
```
map example
```
Pour répertorier les modules chargés en mode normal avec les informations de données TLS des modules de l'unité d'exécution 2, entrez:
```
map normal for $t2
```

Pour plus d'informations, voir la variable interne $mapformat . Voir aussi Débogage au niveau de la machine avec dbx dans General Programming Concepts: Writing and Debugging Programs.

déplacer la sous-commande

move SourceLine

La sous-commande move modifie la ligne suivante à afficher sur la ligne spécifiée par le paramètre SourceLine . Cette sous-commande modifie la valeur de la variable @ (signe arobase).

La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier.

Exemples

Pour modifier la ligne suivante à afficher en ligne12, entrez:
```
move 12
```
Pour modifier la ligne suivante à afficher en ligne5dans le fichiersample.c, entrez:
```
move "sample.c":5
```

Voir la sous-commande list . Voir aussi Affichage du fichier en cours dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande multproc

multproc [ sous | parent| Enfant| hors fonction ]

La sous-commande multproc indique le comportement du programme de débogage dbx lorsque des processus de bifurquage et de dépassement sont créés. L'indicateur on est utilisé pour indiquer qu'une nouvelle session dbx est créée pour déboguer le chemin enfant d'une bifurcation. Le dbx d'origine continue de déboguer le chemin parent. Les indicateurs parent et enfant sont utilisés pour spécifier un chemin unique d'une bifurcation à suivre. Tous les indicateurs sauf off permettent à dbx de suivre un processus de dépassement. L'indicateur off désactive le débogage multiprocessus. Si aucun indicateur n'est spécifié, la sous-commande multproc renvoie le statut du débogage multiprocessus.

Le programme dbx utilise le système X-Window pour le débogage multiprocessus. Le programme dbx ouvre autant de fenêtres que nécessaire pour le multitraitement. Le titre de chaque fenêtre enfant est l'ID de processus (pid) du processus enfant. Pour passer d'un processus à un autre, utilisez les techniques de gestion du système X-Window pour activer la fenêtre dans laquelle la session de commande dbx est affichée. Si le système ne dispose pas de la prise en charge du système X-Window, un message d'avertissement est émis lorsque le programme de débogage bifurque et le programme dbx poursuit le débogage uniquement du processus parent. Le débogage multiprocessus peut également échouer pour les raisons suivantes:

Le programme dbx n'est pas en cours d'exécution dans l'environnement X Window System.
Le système X-Window est en cours d'exécution, mais la variable dbx globale $xdisplay n'est pas définie sur un nom d'affichage valide. La variable $xdisplay est initialisée sur la variable d'environnement DISPLAY du shell. La sous-commande set Name=Expression dbx peut être utilisée pour modifier la valeur du nom d'affichage.
Le répertoire /tmp ne permet pas d'accéder en lecture ou en écriture au programme de débogage. Le programme dbx requiert une petite quantité d'espace dans ce répertoire lors du contrôle d'un environnement Xwindow.
Le système ne dispose pas de suffisamment de ressources pour accueillir une nouvelle fenêtre Xwindow.

Si $xdisplay est défini sur un affichage distant, il se peut que l'utilisateur ne puisse pas voir la Xwindow qui vient d'être créée. Si le paramètre $xdisplay est incorrect, le système X-Window ou d'autres ressources système signalent la cause de l'échec.

Le programme dbx ne fait pas la distinction entre les différents types d'échec, mais le message suivant est envoyé lorsque la sous-commande échoue:

Warning: dbx subcommand multiproc fails. dbx 
continued with multproc disabled.

La configuration définie par l'utilisateur de la fenêtre qui vient d'être créée peut être définie sous le nom d'application dbx_term dans .Fichier Xdefaults.

Flags

Article	Descriptif
sur	Active le débogage multiprocessus.
off	Désactive le débogage multiprocessus.

Exemples

Pour vérifier le statut du débogage multiprocessus, entrez:
```
multproc
```
Pour activer le débogage multiprocessus, entrez:
```
multproc on
```
Pour désactiver le débogage multiprocessus, entrez:
```
multproc off 
```

Voir la sous-commande screen et la sous-routine fork . Consultez également la section relative au débogage des programmes impliquant plusieurs processus dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande mutex

mutex [ lock | unlock | thnum | utid | MutexNumber ... ]

La sous-commande mutex affiche des informations sur les exclusions mutuelles. Si le paramètre MutexNumber est indiqué, la sous-commande mutex affiche des informations sur les exclusions mutuelles spécifiées. Si aucun indicateur ou paramètre n'est spécifié, la sous-commande mutex affiche des informations sur tous les mutexes.

Les informations répertoriées pour chaque mutex sont les suivantes:

Article	Descriptif
`mutex`	Indique le nom symbolique du mutex, sous la forme`$mMutexNumber`.
`type`	Indique le type de l'exclusion mutuelle:`non-rec`(non récursif),`recursi`(récursif) ou`fast`.
`obj_addr`	Indique l'adresse mémoire du processus mutex.
`lock`	Indique l'état de verrouillage de l'exclusion mutuelle:`yes`si le mutex est verrouillé,`no`dans le cas contraire.
`owner`	Si l'exclusion mutuelle est verrouillée, indique le nom symbolique de l'unité d'exécution utilisateur qui contient l'exclusion mutuelle.
`blockers`	Répertorie les unités d'exécution utilisateur qui sont bloquées sur cette variable mutex.

Remarque: La sous-commande print du programme de débogage dbx reconnaît les noms mutex symboliques et peut être utilisée pour afficher le statut de l'objet correspondant.

Flags

Article	Descriptif
verrou	Affiche des informations sur les exclusions mutuelles verrouillées.
déverrouiller	Affiche des informations sur les exclusions mutuelles déverrouillées.
thnum	Affiche des informations sur tous les mutex détenus par une unité d'exécution particulière.
ID utilisateur	Affiche des informations sur tous les mutex détenus par une unité d'exécution utilisateur dont l'ID correspond à l'ID unité d'exécution utilisateur.

Exemples

Pour afficher des informations sur tous les mutex, entrez:
```
mutex
```
Pour afficher des informations sur tous les mutex verrouillés, entrez:
mutex lock

Pour afficher des informations sur les mutex numéro quatre, cinq et six, entrez:

mutex 4 5 6

La sortie est similaire à la suivante:

mutex   obj_addr         type     lock owner  blockers
$m4    0x20003274        non-rec   no
$m5    0x20003280        recursi   no
$m6    0x2000328a        fast      no

Pour afficher des informations sur tous les mutex détenus par l'unité d'exécution 1, entrez:
```
mutex thnum 1
```
Pour afficher des informations sur tous les mutex détenus par une unité d'exécution dont l'ID d'unité d'exécution utilisateur est 0x0001, entrez:
```
mutex utid 0x0001
```

Voir la sous-commande attribute , la sous-commande condition , la sous-commande print et la sous-commande thread .

Voir aussi. Utilisation de Mutexes Concepts de programmation généraux: écriture et débogage de programmes.

Sous-commande suivante

next [ Nombre ]

La sous-commande next exécute le programme d'application jusqu'à la ligne source suivante. Le paramètre Number indique le nombre d'exécutions de la sous-commande next . Si le paramètre Nombre n'est pas spécifié, next s'exécute une seule fois.

Si vous utilisez la sous-commande next dans un programme d'application à unités d'exécution multiples, toutes les unités d'exécution utilisateur s'exécutent pendant l'opération, mais le programme poursuit son exécution jusqu'à ce que l'unité d'exécution en cours atteigne la ligne source spécifiée. Si vous souhaitez exécuter uniquement l'unité d'exécution en cours d'exécution, utilisez la sous-commande set pour définir la variable $hold_next. La définition de cette variable peut entraîner un interblocage car l'unité d'exécution en cours d'exécution peut attendre un verrou détenu par l'une des unités d'exécution bloquées.

Exemples

Pour continuer l'exécution jusqu'à la ligne source suivante, entrez:
```
next
```
Pour continuer l'exécution jusqu'à la troisième ligne source suivant la ligne source en cours, entrez:
```
next 3
```

Voir la sous-commande cont , la sous-commande goto , la sous-commande nexti , la sous-commande set et la sous-commande step .

Sous-commande nexti

nexti [ Nombre ]

La sous-commande nexti exécute le programme d'application jusqu'à l'instruction suivante. Le paramètre Number indique le nombre d'exécutions de la sous-commande nexti . Si le paramètre Nombre n'est pas spécifié, nexti s'exécute une seule fois.

Si vous utilisez la sous-commande nexti dans un programme d'application à unités d'exécution multiples, toutes les unités d'exécution utilisateur s'exécutent pendant l'opération, mais le programme poursuit son exécution jusqu'à ce que l'unité d'exécution en cours d'exécution atteigne l'instruction machine spécifiée. Si vous souhaitez exécuter uniquement l'unité d'exécution en cours d'exécution, utilisez la sous-commande set pour définir la variable $hold_next. La définition de cette variable peut entraîner un interblocage car l'unité d'exécution en cours d'exécution peut attendre un verrou détenu par l'une des unités d'exécution bloquées.

Exemples

Pour continuer l'exécution jusqu'à l'instruction machine suivante, entrez:
```
nexti
```
Pour continuer l'exécution jusqu'à la troisième instruction machine suivant l'instruction machine en cours, entrez:
```
nexti 3
```

Voir la sous-commande gotoi , la sous-commande next , la sous-commande set et la sous-commande stepi . Voir également Exécution d'un programme au niveau de la machine dans Concepts de programmation généraux: Ecriture et débogage de programmes.

Sous-commande onceblock

onceblock [ uninit | terminé ]

La sous-commande onceblock affiche des informations sur les blocs de code d'initialisation enregistrés à l'aide de la routine pthread_once . Sans arguments, les informations sur tous les blocs enregistrés une fois sont affichées. Les indicateurs uninit et done facultatifs affichent uniquement les blocs uniques qui n'ont pas ou qui ont déjà été exécutés, respectivement, tout en fournissant un ID unique numérique qui affiche des informations pour un bloc unique.

Remarque: pour que la sous-commande onceblock puisse fonctionner lors du débogage d'un processus actif, la variable d'environnement AIXTHREAD_ONCE_DEBUG doit être définie sur ON. De même, en cas de débogage d'un fichier core, si la variable n'était pas définie lors de l'exécution du processus, la sous-commande onceblock ne peut pas obtenir d'informations.

Exemples

Pour savoir si des blocs d'une seule fois ne sont pas encore exécutés, entrez:
```
onceblock uninit
```

Sous-commande de plug-in

plugin [ Nom [ Commande ] ]

La sous-commande plugin transmet la commande spécifiée par le paramètre Command au plug-in spécifié par le paramètre Name . Si aucun paramètre n'est spécifié, les noms de tous les plug-in disponibles sont affichés.

Exemples

Pour répertorier tous les plug-in disponibles, entrez:
```
plugin
```
Pour démarrer la sous-commande "help" d'un plug-in nommé "sample", entrez:
```
plugin sample help
```
Pour démarrer la sous-commande "interpret 0x20000688" d'un plug-in nommé "xyz", entrez:
```
plugin xyz interpret 0x20000688
```

Voir la sous-commande pluginload et la sous-commande pluginunload . Voir également Développement pour dbx Plug-in Framework dans General Programming Concepts.

Sous-commande pluginload

pluginload Fichier

La sous-commande pluginload charge le plug-in spécifié par le paramètre Fichier . Le paramètre Fichier doit spécifier un chemin d'accès au plug-in.

Remarque: Etant donné que la commande dbx par défaut est un processus 64 bits, vous devez utiliser la version 32 bits de la commande dbx , nommée dbx32, pour charger les plug-in 32 bits.

Exemples

Pour charger le plug-in nommé "sample" dans "/home/user/dbx_plugins/libdbx_sample.so", entrez:

pluginload /home/user/dbx_plugins/libdbx_sample.so

Voir la sous-commande plugin et la sous-commande pluginunload . Voir également Développement pour dbx Plug-in Framework dans General Programming Concepts.

Sous-commande pluginunload

pluginunload Nom

La sous-commande pluginunload décharge le plug-in spécifié par le paramètre Nom .

Exemples

Pour décharger le plug-in nommé "sample", entrez:

pluginunload sample

Voir la sous-commande plugin et la sous-commande pluginload . Voir également Développement pour dbx Plug-in Framework dans General Programming Concepts.

sous-commande print

print Expression ...

print Procédure ([ Paramètres ])

La sous-commande print effectue l'une des opérations suivantes:

Imprime la valeur d'une liste d'expressions, spécifiée par les paramètres Expression .
Exécute une procédure, spécifiée par le paramètre Procédure et imprime la valeur de retour de cette procédure. Les paramètres inclus sont transmis à la procédure.

Exemples

Pour afficher la valeur dexet la valeur deydécalé vers la gauche de deux bits, entrez:
```
print x, y << 2
```
Pour afficher la valeur renvoyée en appelant lesbrkroutine avec un argument 0, entrez:
```
print sbrk(0)
```

Voir la sous-commande assign , la sous-commande call et la sous-commande set .

Sous-commande printbp

printbp [ bp1 ] [ bp2 ] ... | all

La sous-commande printbp demande à la commande dbx d'imprimer le nombre de fois où chacun des points d'arrêt ou toutes les sous-commandes ont été exécutés, ainsi que les détails de la limite sur le point d'arrêt, si une limite a été définie sur celui-ci.

Exemples

Pour demander à la commande dbx d'imprimer le nombre de fois où le point d'arrêt 1 est exécuté et les détails de l'ensemble de limites, entrez:
```
printbp 1
```
Pour indiquer à la commande dbx d'imprimer le nombre de fois où les points d'arrêt 1 et 2 sont exécutés et de limiter le nombre de fois où les points d'arrêt 1 et 2 peuvent être autorisés à s'exécuter si une limite leur est fixée, entrez:
```
printbp 1, 2
```
Pour indiquer à la commande dbx d'imprimer le nombre de fois où tous les points d'arrêt sont exécutés et les détails d'une limite sur un point d'arrêt, le cas échéant, entrez:
```
printbp all
```

sous-commande proc

proc [ brut ] [ cred | cru | ru | sigflags | signal ]

La sous-commande proc affiche des informations sur le processus. L'utilisation de l'option raw entraîne l'affichage de la sortie en hexadécimal brut, au lieu d'interpréter les valeurs de manière plus lisible par l'utilisateur. L'utilisation de la sous-commande proc sans arguments supplémentaires génère des informations générales sur le processus, telles qu'elles sont stockées dans la structure de données du processus utilisateur. L'option cred affiche le contenu du membre de données pi_cred , qui décrit les données d'identification du processus. Les options cru et ru affichent respectivement les membres de données pi_cru et pi_ru , qui contiennent des informations sur l'utilisation des ressources. Les options sigflags et signal affichent des informations relatives au statut du signal en cours et aux gestionnaires de signaux enregistrés, tels qu'ils se trouvent dans les membres de données pi_sigflags et pi_signal .

Exemples

Pour afficher les informations d'utilisation des ressources pour le processus en cours (ou le fichier core) en hexadécimal brut, entrez:
```
proc raw ru
```
Pour afficher les informations du gestionnaire de signaux, entrez:
```
proc signal
```

sous-commande prompt

prompt [ "Chaîne" ]

La sous-commande prompt remplace l'invite de commande dbx par la chaîne spécifiée par le paramètre String .

Exemple

Pour remplacer l'invite par dbx>, entrez:

prompt "dbx>"

Voir Définition d'une nouvelle invite dbx dans General Programming Concepts: Writing and Debugging Programs.

sous-commande quit

quit

La sous-commande quit arrête tous les processus en cours d'exécution dans la session de débogage dbx .

Voir la sous-commande detach .

enregistre la sous-commande

registers [ ALL | $tnuméro d'unité d'exécution ... ] [ >Fichier ]

La sous-commande registers affiche les valeurs des registres généraux, des registres de contrôle du système, des registres à virgule flottante, des registres de vecteurs et du registre d'instructions en cours.

Les registres à usage général sont désignés par la variable $rNumber , où le paramètre Number indique le numéro du registre.
Remarque: La valeur de registre peut être définie sur la valeur hexadécimale 0xdeadbeef . La valeur hexadécimale 0xdeadbeef est une valeur d'initialisation affectée aux registres à usage général lors de l'initialisation du processus.
Les registres à virgule flottante sont désignés par la variable $frNumber . Par défaut, les registres à virgule flottante ne sont pas affichés. Pour afficher les registres à virgule flottante, utilisez la sous-commande unset $noflregs dbx .
Les registres de vecteurs sont désignés par la variable $vrNumber . La variable interne $novregs contrôle si les registres de vecteurs sont affichés. La variable $novregs est définie par défaut et les registres de vecteurs ne sont pas affichés. Lorsque $novregs n'est pas défini et que les registres de vecteurs sont valides (débogage d'un programme sur un processeur compatible avec les vecteurs ou analyse d'un fichier core contenant l'état des registres de vecteurs), tous les registres de vecteurs sont affichés (vr0–vr31, vrsave, vscr). Les registres de vecteurs peuvent également être référencés par type. Par exemple, les variables de registre de vecteurs $vrNf (float), $vrNs (short) et $vrNc (char) peuvent être utilisées avec les sous-commandes print et assign pour afficher et définir des registres de vecteurs par type.
Les registres scalaires vectoriels sont désignés par la variable $vsrNumber . Par défaut, les registres scalaires vectoriels ne sont pas affichés. Annulez la définition de la variable $novsregs pour afficher les registres scalaires de vecteurs chaque fois que les registres scalaires de vecteurs sont valides (soit pour déboguer un programme sur un processeur compatible avec les scalaires de vecteurs, soit pour analyser un fichier core contenant l'état des registres scalaires de vecteurs). Comme les registres scalaires de vecteurs sont un sur-ensemble de registres à virgule flottante et de registres de vecteurs existants, la variable de débogage $novsregs , lorsqu'elle n'est pas définie, est prioritaire sur $noflregs et $novsregs , chaque fois que l'état des registres scalaires de vecteurs est valide. La sous-commande registres affiche ensuite les registres scalaires vectoriels avec les alias de registre existants et les accolades. Les alias du registre à virgule flottante correspondent uniquement aux 64 bits bas. Les registres scalaires vectoriels peuvent également être référencés par type comme similaires aux registres vectoriels. Par exemple, les variables de registre scalaire vectoriel $vsrNf (float), $vsrNs (short), $vsrNc ( char), $vsrNg (double) et $vsrNll ( long long) peuvent être utilisées avec les sous-commandes print et assign pour afficher et définir les registres scalaires vectoriels par type.
Dans l'option d'environnement à unités d'exécution multiples, ALL affiche les détails d'enregistrement de toutes les unités d'exécution disponibles. Les détails du registre des unités d'exécution individuelles sont affichés en spécifiant le numéro de l'unité d'exécution avec la sous-commande des registres. L'utilisation de la sous-commande Registres sans option permet d'afficher les registres de l'unité d'exécution en cours.

Remarque: La sous-commande registers ne peut pas afficher les registres si l'unité d'exécution en cours est en mode noyau.

Indicateur

Article	Descriptif
>`File`	Redirige la sortie vers le fichier spécifié.

Voir la sous-commande set et la sous-commande unset . Voir aussi Using Machine Registers dans General Programming Concepts: Writing and Debugging Programs.

Exemple

Pour afficher les détails d'enregistrement des unités d'exécution $t1, $t2 et $t3, entrez:

registers $t1 $t2 $t3

Voir la sous-commande set et la sous-commande unset . Voir aussi Using Machine Registers dans General Programming Concepts: Writing and Debugging Programs.

réexécuter la sous-commande

rerun [ Arguments ] [ < Fichier ] [ > Fichier ] [ > Fichier ] [ 2 > Fichier ] [ 2 > > Fichier ] [ > & Fichier ] [ > > & Fichier ]

La sous-commande rerun commence l'exécution du fichier objet. Les Arguments sont transmis en tant qu'arguments de ligne de commande. Si le paramètre Arguments n'est pas spécifié, les arguments de la dernière sous-commande run ou rerun sont réutilisés.

Flags

Article	Descriptif
<`File`	Redirige l'entrée de sorte que l'entrée soit reçue à partir de `Fichier`.
>`File`	Redirige la sortie vers `Fichier`.
> >`File`	Ajoute la sortie redirigée dans `Fichier`.
2 >`Fichier`	Redirige l'erreur standard vers `Fichier`.
2 > >`Fichier`	Ajoute l'erreur standard redirigée au `fichier`.
> &`Fichier`	Redirige la sortie et l'erreur standard vers `Fichier`.
> > &`Fichier`	Ajoute la sortie et l'erreur standard au `fichier`.

Voir la sous-commande run .

sous-commande de ressource

resource { owner | unité en attente } [ all | ID pthread ]

La sous-commande resource affiche des informations sur les unités d'exécution de ressource actuellement en attente ou en attente. Le premier argument, qui est requis, indique si vous êtes intéressé par l'affichage des unités d'exécution qui possèdent des ressources ou si vous les attendez. Le deuxième argument peut être utilisé pour indiquer toutes les unités d'exécution ou une unité d'exécution spécifique. Si aucun n'est indiqué, seules les informations relatives au pthread en cours sont affichées, le cas échéant.

Remarque: La sous-commande resource n'est utile que pour le débogage des processus qui s'exécutent avec plusieurs variables d'environnement de débogage définies sur ON. Il s'agit notamment de AIXTHREAD_MUTEX_DEBUG, AIXTHREAD_COND_DEBUG, AIXTHREAD_RWLOCK_DEBUG, AIXTHREAD_READ_OWNER et AIXTHREAD_WAITLIST_DEBUG. Si ces variables ne sont pas activées lors du débogage d'un processus actif ou n'étaient pas activées lors de la génération d'un fichier core de débogage, la sous-commande resource pourra extraire moins d'informations ou aucune. Etant donné que l'utilisation de ces fonctions peut dégrader les performances, il est recommandé de les activer uniquement à des fins de débogage.

Exemples

Pour vérifier si le pthread en cours contient des ressources, entrez:
```
resource owner
```
Pour afficher les ressources sur lesquelles des unités d'exécution pthreads sont en attente, entrez:
```
resource waiter all
```

sous-commande return

return [ Procédure ]

La sous-commande return entraîne l'exécution du programme d'application jusqu'à ce qu'un retour à la procédure spécifiée par le paramètre Procédure soit atteint. Si le paramètre Procédure n'est pas spécifié, l'exécution cesse lorsque la procédure en cours est renvoyée.

Exemples

Pour continuer l'exécution de la routine appelante, entrez:
```
return
```
Pour continuer l'exécution de lamainprocédure, entrez:
```
return main 
```

Sous-commande rwlock

rwlock [ read | write | RwlockNumber.... ]

La sous-commande rwlock affiche des informations sur rwlocks. Si le paramètre RwlockNumber est indiqué, la sous-commande rwlock affiche des informations sur les rwlocks spécifiés. Si aucun indicateur ou paramètre n'est spécifié, la sous-commande rwlock affiche des informations sur tous les rwlocks.

Les informations de chaque rwlock sont les suivantes:

Article	Descriptif
`rwl`	Indique le nom symbolique du rwlock, au format $rw `RwlockNumber`.
`flag_value`	Indique la valeur de l'indicateur.
`owner`	Indique le propriétaire du rwlock
`status`	Indique qui détient le rwlock. Les valeurs sont lues (si elles sont conservées par le lecteur), écrites (si elles sont conservées par le programme d'écriture), libres (si elles sont disponibles).
`wsleep[#]`	Indique le blocage des unités d'exécution en écriture. # indique le nombre total d'unités d'exécution bloquant en écriture.
`rsleep[#]`	Indique le blocage des unités d'exécution en lecture. # indique le nombre total d'unités d'exécution bloquant en lecture.

Remarque: La sous-commande print du programme de débogage dbx reconnaît les noms de rwlock symboliques et peut être utilisée pour afficher l'état de l'objet correspondant.

Flags

Article	Descriptif
read	Affiche des informations sur tous les rwlocks dont le statut est en mode lecture.
écriture	Affiche des informations sur tous les rwlocks dont le statut est en mode écriture.

Exemples

Pour afficher des informations sur tous les rwlocks, entrez:

rwlock

La sortie est similaire à la suivante:

rwl     flag_value    owner status
$rwl        1         $t1    write
        rsleeps[     0]:
        wsleeps[     0]:

Pour afficher des informations sur tous les rwlocks en mode écriture:

rwlock write

La sortie est similaire à la suivante:

rwl     flag_value    owner status
$rwl        1         $t1    write
        rsleeps[     0]:
        wsleeps[     0]:

Voir la sous-commande attribute , la sous-commande condition , la sous-commande mutex , la sous-commande print et la sous-commande thread

exécuter la sous-commande

run [ Arguments ] [ <Fichier ] [ >Fichier ] [ > >Fichier ] [ 2 >Fichier ] [ 2 > >Fichier ] [ > &Fichier ] [ > > &Fichier ]

La sous-commande run démarre le fichier objet. Les Arguments sont transmis en tant qu'arguments de ligne de commande.

Flags

Article	Descriptif
<`File`	Redirige l'entrée de sorte que l'entrée soit reçue à partir de `Fichier`.
>`File`	Redirige la sortie vers `Fichier`.
2 >`Fichier`	Redirige l'erreur standard vers `Fichier`.
> >`File`	Ajoute la sortie redirigée dans `Fichier`.
2 > >`Fichier`	Ajoute l'erreur standard redirigée au `fichier`.
> &`Fichier`	Redirige la sortie et l'erreur standard vers `Fichier`.
> > &`Fichier`	Ajoute la sortie et l'erreur standard au `fichier`.

Exemple

Pour exécuter l'application avec les argumentsblueet12, entrez:

run blue 12

Voir la sous-commande rerun .

sous-commande d'écran

screen

La sous-commande screen ouvre une Xwindow pour l'interaction de la commande dbx . Vous continuez à travailler dans la fenêtre d'où provient le processus.

La sous-commande screen doit être exécutée alors que le programme de débogage dbx est en cours d'exécution dans l'environnement X Window System. Si la sous-commande screen est émise dans un environnement non Xwindow, le programme dbx affiche un message d'avertissement et reprend le débogage comme si la sous-commande screen n'avait pas été indiquée. La sous-commande screen peut également échouer dans les situations suivantes:

Le programme dbx n'est pas en cours d'exécution dans l'environnement X Window System.
Le système X-Window est en cours d'exécution, mais la variable dbx globale $xdisplay n'est pas définie sur un nom d'affichage valide. La variable $xdisplay est initialisée avec la variable d'environnement DISPLAY . La sous-commande dbx set Name=Expression modifie la valeur du nom d'affichage.
Le système X-Window est en cours d'exécution, mais la variable d'environnement TERM n'est pas définie sur un nom de commande valide pour démarrer une nouvelle fenêtre.
Le répertoire /tmp ne permet pas d'accéder en lecture ou en écriture au programme. Le programme dbx requiert une petite quantité d'espace dans ce répertoire lorsque la commande d'écran est exécutée.
Le système ne dispose pas de suffisamment de ressources pour accueillir une nouvelle Xwindow.

Le programme dbx ne fait pas la distinction entre les différents types d'échec, mais il envoie le message suivant:

Warning: dbx subcommand screen fails. dbx 
continues.

Si $xdisplay est défini sur un affichage distant, il se peut que vous ne puissiez pas voir la Xwindow nouvellement créée. Si le paramètre $xdisplay n'est pas correct, le système X-Window ou d'autres ressources système signalent l'incident.

La configuration définie par l'utilisateur de la fenêtre qui vient d'être créée peut être définie sous le nom d'application dbx_term dans .Fichier Xdefaults.

Exemple

Pour ouvrir une interaction de commande Xwindow for dbx , entrez:

screen

Définir la sous-commande

set [ Variable=Expression ]

La sous-commande set définit une valeur pour la variable de programme de débogage dbx . La valeur est spécifiée par le paramètre Expression ; la variable de programme est spécifiée par le paramètre Variable . Le nom de la variable ne doit pas entrer en conflit avec les noms du programme en cours de débogage. Une variable est étendue à l'expression correspondante dans d'autres commandes. Si la sous-commande set est utilisée sans arguments, les variables actuellement définies sont affichées.

Variables	Descriptif
$catchbp	Intercepte les points d'arrêt lors de l'exécution de la commande suivante.
$page de codes	Indique le jeu de codes à utiliser pour l'interprétation des caractères dans le programme. Lorsqu'il est spécifié avec une page de codes valide, tous les caractères sont lus à partir du jeu de codes spécifié et convertis dans le jeu de codes utilisé par l'environnement en cours.
$compact_bt_ident	Indique le nombre maximal de caractères dans les noms d'identificateur pouvant être imprimés dans une trace de pile. La limite spécifiée doit être un nombre entier positif compris entre 4 et 128. Si cette variable est définie sans spécifier de valeur limite, le nombre par défaut de caractères pouvant être imprimés est 8. Si la variable est définie et que le nom de l'identificateur dépasse de quatre caractères ou plus la limite spécifiée, la commande dbx imprime le nombre spécifié de caractères du nom de l'identificateur d'origine dans la trace de pile, suivi de trois points (...). Par exemple, si le nom de l'identificateur est `variable_example`, qui comporte 16 caractères, et que la limite spécifiée est 7, le nom de l'identificateur est imprimé sous la forme `variabl...`. Toutefois, si le nom de l'identificateur est `variable_1`, qui comporte 10 caractères et que la limite spécifiée est 7, la commande dbx ne réduit pas le nom de l'identificateur à sept caractères suivis de trois points. Il est imprimé sous la forme `variable_1`.
$compact_bt_string	Indique la limite du nombre de caractères dans les chaînes d'argument de fonction pouvant être imprimées dans une trace de pile. La limite spécifiée doit être un nombre entier positif compris entre 4 et 128. Si cette variable est définie sans spécifier de valeur limite, le nombre par défaut de caractères pouvant être imprimés est 8. Si la variable est définie et que la longueur de la chaîne est supérieure de quatre caractères ou plus à la limite spécifiée, la commande dbx imprime le nombre spécifié de caractères de la chaîne d'origine dans la trace de pile, suivi de trois points (...). Par exemple, si la chaîne est `string_example`, qui comporte 14 caractères et que la limite spécifiée est 5, la chaîne est imprimée sous la forme `strin...`. Toutefois, si la chaîne est `string_1`, d'une longueur de 8 caractères, et que la limite spécifiée est 5, la commande dbx ne raccourcit pas la chaîne à cinq caractères suivis de trois points. Il est imprimé sous la forme `string_1`.
$deferevents	Active la fonction d'événements différés.
$display_address_name	Affiche les identificateurs de variable de membre et l'adresse mémoire que l'identificateur occupe lors de l'examen d'un ensemble d'adresses mémoire qui utilisent la commande dbx .
$unions d'extension	Affiche les valeurs de chaque partie des enregistrements de variante ou des unions.
$trame	Utilise le cadre de pile désigné par l'adresse désignée par la valeur de $frame pour effectuer des traces de pile et accéder aux variables locales.
$hexchars	Imprime les caractères sous forme de valeurs hexadécimales.
$hexin	Interprète les adresses au format hexadécimal.
$hexints	Imprime des entiers sous forme de valeurs hexadécimales.
$hexchaînes	Imprime les pointeurs de caractères au format hexadécimal.
$hold_suivant	Contient toutes les unités d'exécution, à l'exception de l'unité d'exécution en cours d'exécution, pendant les sous-commandes cont, next, nextiet step . La définition de cette variable peut entraîner un interblocage car l'unité d'exécution en cours d'exécution peut attendre un verrou détenu par l'une des unités d'exécution bloquées.
$ignoreifhandler	Ne s'arrête pas lorsque votre programme reçoit un signal comportant un gestionnaire enregistré.
$ignoreload	Ne s'arrête pas lorsque votre programme exécute la sous-routine load, unloadou loadbind .
$ignorenonbptrap	Ne s'arrête pas lorsque votre programme rencontre une instruction d'interruption de point d'arrêt et dispose d'un gestionnaire SIGTRAP enregistré.
$instructionset	Remplace le mode de désassemblage par défaut. La liste suivante contient les valeurs possibles pour le paramètre `Expression` : "par défaut" Indique l'architecture sur laquelle le programme dbx s'exécute. "com" Indique le jeu d'instructions pour le mode d'intersection commun des architectures PowerPC et POWER family . Le programme dbx utilise par défaut les mnémoniques basées sur le processeur POWER . "pwr" Indique le jeu d'instructions et les mnémoniques pour l'architecture de la famille POWER . "pwrx" Spécifie le jeu d'instructions et les mnémoniques pour l'implémentation POWER2 de l'architecture de la famille POWER pour AIX® 5.1 et antérieur. "pwr6" Indique le jeu d'instructions et les mnémoniques pour l'implémentation POWER6 de l'architecture PowerPC . "pwr7" Indique le jeu d'instructions et les mnémoniques pour l'implémentation POWER7 de l'architecture PowerPC . "pwr8" Indique le jeu d'instructions et les mnémoniques pour l'implémentation POWER8 de l'architecture PowerPC . "pwr9" Indique le jeu d'instructions et les mnémoniques pour l'implémentation POWER9 de l'architecture PowerPC . "pwr10" Spécifie le jeu d'instructions et les mnémoniques pour l'implémentation POWER10 de l'architecture PowerPC. "601" Indique le jeu d'instructions et les mnémoniques du PowerPC 601 RISC Microprocessor for AIX 5.1 et versions antérieures. "603" Indique le jeu d'instructions et les mnémoniques du PowerPC 603 RISC Microprocessor for AIX 5.1 et versions antérieures. "604" Indique le jeu d'instructions et les mnémoniques du PowerPC 604 RISC Microprocessor. "970" Indique le jeu d'instructions et les mnémoniques du microprocesseur PowerPC 970 . "ppc" Indique le jeu d'instructions et les mnémoniques définis dans l'architecture POWER processor-based , à l'exclusion des instructions facultatives. Ces instructions sont disponibles dans toutes les implémentations Basé sur le processeur POWER à l'exception de PowerPC 601 RISC Microprocesseur dans AIX 5.1 et les versions antérieures. "tout" Indique toute instruction POWER processor-based ou POWER family valide. Pour les jeux d'instructions qui se chevauchent, la valeur par défaut est la mnémonique basée sur le processeur POWER . Si aucune valeur n'est définie pour le paramètre `Expression` , le programme dbx utilise le mode de désassemblage par défaut.
$java	Lorsqu'elle est définie, elle définit également les variables suivantes, en plaçant la commande dbx dans un mode permettant de déboguer les applications Java. Lorsque cette option est dédéfinie, elle annule également la définition des variables suivantes: $ignorenonbptrap Supprime la notification des instructions d'alerte générées par le compilateur JIT (Java Just-In-Time).
$listwindow	Indique le nombre de lignes à répertorier autour d'une fonction et le nombre à répertorier lorsque la sous-commande list est utilisée sans paramètres. La valeur par défaut est 10 lignes.
$mapaddrs	Démarre le mappage des adresses. L'annulation de la définition de $mapaddrs arrête le mappage d'adresse.
$format_mappe	Indique le mode de sortie par défaut de la sous-commande map . "abbr" Indique le mode de sortie abrégé, qui se compose d'une ligne unique pour chaque module chargé contenant le numéro d'entrée, le nom de module et le nom de membre facultatif pour ce module. "normal" Indique le mode de sortie normal, qui se compose du numéro d'entrée, du nom du module, du nom de membre, de l'origine du texte, de la longueur du texte, de l'origine des données, de la longueur des données et du descripteur de fichier pour chaque module chargé. Si le module chargé contient des données TLS, l'origine des données TLS et la longueur des données TLS sont également affichées. "brut" Indique le mode de sortie brute, qui se compose d'une seule ligne non formatée pour chaque module contenant les zones séparées par un espace suivantes: numéro d'entrée, nom de module avec nom de membre facultatif, origine du texte, fin du texte, longueur du texte, origine des données, fin des données, longueur des données et descripteur de fichier. Si le module chargé contient des données TLS, l'origine des données TLS, la fin des données TLS et la longueur des données TLS sont également affichées. "prolixe" Indique le mode de sortie prolixe, qui comprend le numéro d'entrée, le nom du module, le nom du membre, l'origine du texte, la fin du texte, la longueur du texte, l'origine des données, la fin des données, la longueur des données et le descripteur de fichier pour chaque module chargé. Si le module chargé contient des données TLS, l'origine des données TLS, la fin des données TLS et la longueur des données TLS sont également affichées. Si aucune valeur n'est définie pour le paramètre `Expression` , le programme dbx utilise le mode de sortie normal.
$mnémoniques	Modifie l'ensemble de mnémoniques à utiliser par le programme dbx lors du démontage. "par défaut" Indique les mnémoniques qui correspondent le mieux au jeu d'instructions spécifié. "pwr" Indique les mnémoniques de l'architecture de la famille POWER . "ppc" Indique les mnémoniques définies dans le manuel d'architecture POWER processor-based , à l'exception des instructions facultatives. Si aucune valeur n'est définie pour le paramètre `Expression` , le programme dbx utilise les mnémoniques qui correspondent le plus au jeu d'instructions spécifié.
$noargs	Omet les arguments des sous-commandes, telles que `où`, `up`, `down`et `dump`.
$noflregs	Omet l'affichage des registres à virgule flottante de la sous-commande registers .
$novregs	Omet l'affichage des registres de vecteurs de la sous-commande registers .
$novsregs	Omet l'affichage des registres scalaires vectoriels de la sous-commande registers
$octint	Interprète les adresses en octal.
$octints	Imprime des entiers en octal.
$jolie	Affiche des valeurs de structure de données C et C++ complexes (struts, unions, tableaux) dans un format `joli imprimé` à l'aide de la sous-commande print . "on" Indique une impression de grande qualité avec chaque valeur sur sa propre ligne et avec une indentation pour représenter la portée statique de chaque valeur. "prolixe" Indique une impression avec chaque valeur sur sa propre ligne et avec des noms qualifiés pour représenter la portée statique de chaque valeur. Un nom qualifié se compose d'une liste séparée par des points des blocs externes auxquels la valeur est associée. "hors fonction" Indique que la fonction d'impression est désactivée. Il s'agit de la valeur par défaut.
$print_dynamique	Affiche le type dynamique des objets C++ avec la commande print / dump. Par défaut, cette variable n'est pas définie.
$répétition	Répète la commande précédente si aucune commande n'a été entrée.
$sigblock	Bloque les signaux à votre programme.
$show_vft	Affiche la table de fonctions virtuelles lors de l'impression d'objets C++ à l'aide de la commande print / dump. Par défaut, il n'est pas défini.
$stack_détails	Affiche le numéro de trame et le registre défini pour chaque fonction ou procédure active affichée par la sous-commande where .
$stepignore	Contrôle le comportement de la commande dbx lorsque la sous-commande step/tstep s'exécute sur une ligne source qui appelle une autre routine pour laquelle aucune information de débogage n'est disponible. Cette variable permet à la sous-commande step/tstep de dépasser les routines de grande taille pour lesquelles aucune information de débogage n'est disponible. La liste suivante contient les valeurs possibles pour le paramètre `Expression` : "fonction" Exécute la fonction de la sous-commande next/tnext pour la commande dbx . Il s'agit de la valeur par défaut. "module" Exécute la fonction de la sous-commande next/tnext si la fonction se trouve dans un module de chargement pour lequel aucune information de débogage n'est disponible (par exemple, une bibliothèque système). "aucun" Exécute la fonction de la sous-commande stepi/tstepi de la commande dbx en arrière-plan jusqu'à ce qu'elle atteigne une instruction pour laquelle des informations source sont disponibles. A ce stade, dbx indique où l'exécution s'est arrêtée.
$trace_good_transaction	Demande à la commande dbx d'afficher le message suivant chaque fois qu'une transaction de mémoire transactionnelle (TM) est exécutée avec succès. `Process {PID} may have performed a transaction - $texasr, $tfiar, $tfhar are valid and may be inspected` Les transactions réussies ne sont pas signalées car cette variable est désactivée par défaut.
$thcomp	Lorsque $thcomp est défini, les informations affichées par la commande d'unité d'exécution th- sont affichées dans un format compressé.
$unsafeassign	Désactive la vérification stricte du type entre les deux côtés d'une instruction assign . Même si la variable $unsafeassign est définie, les deux côtés d'une instruction assign peuvent ne pas contenir de types de stockage de tailles différentes.
$unsafebounds	Désactive la vérification des indices sur les tableaux.
$unsafecall	Désactive la vérification de type stricte pour les arguments des sous-routines ou des appels de fonction.
$unsafegoto	Désactive la vérification de la destination de la sous-commande goto .
$vardim	Indique la longueur de dimension à utiliser lors de l'impression de tableaux avec des limites inconnues. La valeur par défaut est 10.
$xaffichage	Indique le nom d'affichage du système X-Window à utiliser avec la sous-commande multproc ou screen . La valeur par défaut est la valeur de la variable DISPLAY du shell.

Les variables $dangereuse limitent l'utilité du programme de débogage dbx pour la détection des erreurs.

Exemples

Pour modifier le nombre de lignes par défaut à afficher20, entrez:
```
set $listwindow=20
```
Pour désactiver la vérification des types sur leassignsous-commande, entrez:
```
set $unsafeassign
```
Pour désassembler les instructions de machine pour le processeur POWER7 , entrez:
```
set $instructionset="pwr7"
```
Pour afficher les chaînes codées dans le jeu de codes -eucCN, entrez :
```
set $codepage="IBM-eucCN"
```
Pour spécifier une limite de quatre caractères dans les identificateurs et une limite de douze caractères dans les chaînes affichées dans une trace de pile, entrez la commande suivante:
```
set $compact_bt_ident=6
set $compact_bt_string=12
```
La trace de pile qui utilise des identificateurs tels que long_identifier, long_variable_name_stret recursive_fun, et une chaîne telle que this_is_a_really_long_string , ressemble à la sortie suivante:
```
long_i...(a = 11, long_v... = "this_is_a_re..."), line 3 in "example.c"
recurs...(), line 13 in "example.c"
```

Voir la sous-commande unset . Voir aussi Changing Print Output with Special Debug Program Variables dans General Programming Concepts: Writing and Debugging Programmes.

set edit [vi, emacs] ou set -o [vi, emacs] Sous-commande

La sous-commande set avec l'option -o ou edit peut être utilisée pour activer l'un des modes d'édition de ligne. Si la commande set-o vi ou set edit vi est indiquée, vous êtes placé en mode d'entrée de l'éditeur de ligne vi . Si la commande set -o emacs ou set edit emacs est indiquée, vous êtes placé en mode d'entrée de l'éditeur de ligne emacs .

Exemple

Pour activer l'éditeur de ligne vi, entrez:
```
set-o vi
```
ou
```
set edit vi
```

Sous-commande sh

sh [ Commande ]

La sous-commande sh transmet la commande spécifiée par le paramètre Command au shell pour exécution. La variable d'environnement SHELL détermine quel interpréteur de commandes est utilisé. La valeur par défaut est le shell sh . Si aucun argument n'est spécifié, le contrôle est transféré à l'interpréteur de commandes.

Exemples

Pour exécuter le lscommande, entrez:
```
sh ls
```
Pour échapper vers un shell, entrez:
```
sh
```
Pour utiliser leSHELLvariable d'environnement, entrez:
```
sh echo $SHELL
```

Voir Running Shell Commands from dbx dans General Programming Concepts: Writing and Debugging Programs.

ignorer la sous-commande

skip [ Nombre ]

La sous-commande skip poursuit l'exécution du programme d'application à partir du point d'arrêt en cours. Un nombre de points d'arrêt égal à la valeur du paramètre Nombre est ignoré et l'exécution s'arrête lorsque le point d'arrêt suivant est atteint ou lorsque le programme se termine. Si le paramètre Nombre n'est pas spécifié, sa valeur par défaut est 1.

Exemple

Pour continuer l'exécution jusqu'à ce que le deuxième point d'arrêt soit rencontré, entrez:

skip 1

Voir aussi la sous-commande cont .

Sous-commande source

source Fichier

La sous-commande source lit les sous-commandes dbx à partir du fichier spécifié par le paramètre Fichier .

Exemple

Pour lire les sous-commandes dbx dans lecmdfilefichier, entrez:

source cmdfile

Voir Reading dbx Subcommands from a File dans General Programming Concepts: Writing and Debugging Programs.

status Subcommand

status [ more ] [ >Fichier ]

La sous-commande status affiche tous les points d'arrêt, points de trace et points de contrôle définis par l'utilisateur, en plus du nombre d'unités d'exécution tskip restantes (défini à l'aide de la sous-commande tskip ). Si le paramètre more est spécifié, la sous-commande status affiche également les sous-commandes dbx associées aux points d'arrêt, aux points de trace et aux points de contrôle. La sous-commande status répertorie les événements activés avec des crochets ([ ]) entourant le numéro d'événement, les événements désactivés avec des points (..) entourant le numéro d'événement et les événements différés avec des crochets (< >) entourant le numéro d'événement.

L'indicateur > envoie la sortie de la sous-commande status à un fichier spécifié dans le paramètre Fichier .

Indicateur

Article	Descriptif
>`File`	Redirige la sortie vers `Fichier`.

Exemples

Pour afficher tous les points d'arrêt, points de trace et points de contrôle définis par l'utilisateur, ainsi que les nombres d'unités d'exécution tskip restants, entrez:
```
status
```
La sortie est similaire à la suivante:
```
[1] stop at 13
[2] stop at 14
.3. stop at 15
.4. stop at 16
[5] stop at 17 ( count = 0, limit = 3 )
<6> stop at 18 if g > 10
<7> stop in func

Remaining tskip counts:
tskip 2 for $t1
tskip 1 for $t5
```
Dans l'exemple de sortie, les événements 3 et 4 sont désactivés et les événements 6 et 7 sont différés.

Pour afficher tous les points d'arrêt, points de trace et points de contrôle définis par l'utilisateur avec les sous-commandes dbx associées, entrez:

status more

La sortie est similaire à la suivante:

       [1] stop at 13
           [1] where 
       .2. stop at 14
           [1] where
           [2] registers        
       <3> stop at 15 if g > 10
           [1] where; registers

Voir la sous-commande addcmd , la sous-commande clear , la sous-commande delete , la sous-commande delcmd , la sous-commande tskip , la sous-commande stop et la sous-commande trace pour la commande dbx .

Voir aussi Définition et suppression de points d'arrêt dans Concepts généraux de la programmation: Ecriture et débogage de programmes.

sous-commande d'étape

step [ Nombre ]

La sous-commande step exécute les lignes source du programme d'application. Indiquez le nombre de lignes à exécuter avec le paramètre Nombre . Si le paramètre Nombre est omis, la valeur par défaut est 1.

Si vous utilisez la sous-commande step sur un programme d'application à unités d'exécution multiples, toutes les unités d'exécution utilisateur s'exécutent pendant l'opération, mais le programme poursuit son exécution jusqu'à ce que l'unité d'exécution en cours d'exécution atteigne la ligne source spécifiée. Si vous souhaitez exécuter uniquement l'unité d'exécution en cours d'exécution, utilisez la sous-commande set pour définir la variable $hold_next. La définition de cette variable peut entraîner un interblocage car l'unité d'exécution en cours d'exécution peut attendre un verrou détenu par l'une des unités d'exécution bloquées.

Remarque: utilisez la variable $stepignore de la sous-commande set pour contrôler le comportement de la sous-commande step . La variable $stepignore permet à la sous-commande step de passer outre les routines de grande taille pour lesquelles aucune information de débogage n'est disponible.

Exemples

Pour continuer l'exécution pour une ligne source, entrez:
```
step
```
Pour continuer l'exécution pour cinq lignes source, entrez:
```
step 5
```
Pour empêcher le programme dbx d'exécuter une seule étape de la fonction printf , comme illustré dans l'exemple de code suivant:
```
60 printf ("hello world \n");
```
Entrez :
```
set $stepignore="function"; step
```

Voir la sous-commande cont , la sous-commande goto , la sous-commande next , la sous-commande set et la sous-commande stepi .

Sous-commande stepi

stepi [ Nombre ]

La sous-commande stepi exécute les instructions du programme d'application. Indiquez le nombre d'instructions à exécuter dans le paramètre Nombre . Si le paramètre Number est omis, la valeur par défaut est 1.

Si elle est utilisée sur un programme d'application à unités d'exécution multiples, la sous-commande stepi n'exécute que l'unité d'exécution en cours d'exécution. Toutes les autres unités d'exécution utilisateur restent arrêtées.

Exemples

Pour continuer l'exécution d'une instruction machine, entrez:
```
stepi 
```
Pour continuer l'exécution de 5 instructions machine, entrez:
```
stepi 5
```

Voir la sous-commande gotoi , la sous-commande nexti et la sous-commande step .

Arrêter la sous-commande

stop { [Variable ] [ at SourceLine | in Procédure | on load [ "nom_module" ] ] [ if Condition ] } [ "{"Limite"}" ]

La sous-commande stop arrête le programme d'application lorsque certaines conditions sont remplies. Le programme est arrêté lorsque:

La Condition est vraie lorsque l'indicateur if Condition est utilisé.
La procédure est appelée si l'indicateur dans Procédure est utilisé.
La Variable est modifiée si le paramètre Variable est spécifié.
Le numéro de ligne SourceLine est atteint si l'indicateur at SourceLine est utilisé.
La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier.
Le module ModuleName chargé est chargé ou déchargé si l'indicateur on load est utilisé et que le paramètre ModuleName est spécifié.
La variable facultative ModuleName peut être spécifiée en tant que nom de module unique ou en tant que nom de module associé à un nom de membre au format suivant:
```
ModuleName(MemberName)
```
Tout module chargé est chargé ou déchargé si l'indicateur on load est utilisé et que le paramètre ModuleName n'est pas spécifié.

Vous pouvez définir le paramètre Limit pour demander à la commande dbx d'ignorer une condition pour un nombre de fois spécifié. En d'autres termes, le paramètre Limite indique le nombre de fois où la condition spécifiée doit être remplie avant l'arrêt de l'exécution du programme de débogage.

Après l'une de ces commandes, le programme de débogage dbx répond par un message signalant l'événement généré suite à votre commande. Le message inclut l'ID d'événement associé à votre point d'arrêt ainsi qu'une interprétation de votre commande. La syntaxe de l'interprétation peut être différente de celle de votre commande. Par exemple :

stop in main
[1] stop in main
stop at 19 if x == 3
[2] stop at "hello.c":19 if x = 3
stop in func
<3> stop in func
stop g 
<4> stop g
stop in getdata {3} 
[5] stop in getdata ( count = 0, limit = 3 )

Les nombres entre crochets ([ ]) sont les identificateurs d'événement associés aux points d'arrêt. Le programme de débogage dbx associe des numéros d'événement à chaque sous-commande stop . Lorsque le programme est arrêté suite à l'un des événements, l'identificateur d'événement est affiché avec la ligne en cours pour indiquer l'événement à l'origine de l'arrêt du programme. Les chiffres entre crochets (< >) sont les identificateurs d'événement pour les événements différés. Un événement différé est un événement auquel aucun point d'arrêt, point de trace ou point de contrôle n'est associé. Il est créé chaque fois que la commande d'entrée implique les symboles qui ne sont pas actuellement chargés dans la mémoire. Un événement normal affiché entre crochets ([ ]) est également converti en événement différé à chaque fois que le module correspondant est déchargé. Chaque fois que le module correspondant à l'événement différé est chargé dans la mémoire, l'événement différé est converti en événement normal et le point d'arrêt, le point de trace ou le point de contrôle correspondant est créé. Les événements que vous créez coexistent avec les événements internes créés par la commande dbx , de sorte que les numéros d'événement peuvent ne pas toujours être séquentiels.

Une limite peut être associée à un événement après sa création à l'aide de la sous-commande limitbp . Pour afficher la limite associée à un événement, vous pouvez utiliser la sous-commande printbp .

Utilisez la sous-commande status pour afficher ces nombres. Vous pouvez rediriger la sortie de status vers un fichier. Utilisez la sous-commande delete ou clear pour désactiver la sous-commande stop ou utilisez les sous-commandes enable ou disable . Utilisez la sous-commande addcmd pour ajouter des sous-commandes dbx au numéro d'événement spécifié et la sous-commande delcmd pour supprimer les sous-commandes dbx associées du numéro d'événement spécifié.

Dans un programme d'application à unités d'exécution multiples, toutes les unités d'exécution utilisateur sont arrêtées lorsqu'une unité d'exécution utilisateur atteint un point d'arrêt. Un point d'arrêt défini sur une ligne ou une fonction source est atteint par toute unité d'exécution utilisateur qui exécute la ligne ou la fonction, sauf si vous spécifiez des conditions (comme dans l' exemple 9). Les alias suivants spécifient automatiquement les conditions:

b12th(Fonction, ThreadNumber)
blth(SourceLine, ThreadNumber)

ThreadNumber est la partie numéro du nom d'unité d'exécution symbolique tel qu'indiqué par la sous-commande thread (par exemple, 5 est le ThreadNumber pour le nom d'unité d'exécution $t5). Ces alias sont en fait des macros qui produisent les sous-commandes développées présentées dans l'exemple suivant:

stopi at &Function if ($running_thread == ThreadNumber)
stop at SourceLine if ($running_thread == ThreadNumber)

Flags

Article	Descriptif
sur `SourceLine`	Indique le numéro de ligne.
if `Condition`	Indique la condition, telle que true.
dans `Procédure`	Indique la procédure à appeler.
lors du chargement `ModuleName`	Indique le module chargé à surveiller.

Exemples

Pour arrêter l'exécution à la première instruction de lamainprocédure, entrez:
```
stop in main
```
Pour arrêter l'exécution lorsque la valeur dexla variable est modifiée sur la ligne12de l'exécution, entrez:
```
stop x at 12
```
Pour arrêter l'exécution à la ligne 5 du fichiersample.c, entrez:
```
stop at "sample.c":5
```
Pour vérifier la valeur dexchaque fois que la commande dbx exécute une sous-routine dansfunc1, entrez:
```
stop in func1 if x = 22
```
Pour vérifier la valeur dexchaque fois que la commande dbx commence à s'exécuterfunc1, entrez:
```
stopi at &func1 if x = 22
```
Pour arrêter le programme lorsque la valeur de Variable change, entrez:
```
stop Variable
```
Pour arrêter le programme chaque fois que Condition a pour résultat true, entrez:
```
stop if (x > y) and (x < 2000)
```
L'exemple suivant montre comment afficher les événements actifs et les supprimer:
```
status
[1] stop in main
[2] stop at "hello.c":19 if x = 3
delete 1
status
[2] stop at "hello.c":19 if x = 3
clear 19
status
(dbx)
```
La commande delete élimine les événements par identificateur d'événement. La commande clear supprime les points d'arrêt par numéro de ligne.
Pour placer un point d'arrêt au début defunc1uniquement lorsqu'il est exécuté par une unité d'exécution$t5, entrez l'une des commandes équivalentes suivantes:
```
stopi at &func1 if ($running_thread == 5)
```
ou
```
bfth(func1, 5)
```
Pour arrêter le programme lorsqu'un module est chargé ou déchargé, entrez:
```
stop on load
```
Pour arrêter le programme chaque fois que le module Module est chargé ou déchargé, entrez:
```
stop on load "Module"
```
Pour arrêter le programme chaque fois que le membre Member du module Module est chargé ou déchargé, entrez:
```
stop on load "Module(Member)"
```
Pour arrêter le programme dans une fonction getdata lorsqu'elle est appelée pour la troisième fois, entrez:
```
stop in getdata {3}
```

Voir la sous-commande addcmd , la sous-commande clear , la sous-commande delete , la sous-commande delcmd , la sous-commande disable , la sous-commande enable , la sous-commande limitbp , la sous-commande printbp , la sous-commande status , la sous-commande stopi , et la sous-commande trace . Voir aussi Définition et suppression de points d'arrêt dans Concepts généraux de la programmation: Ecriture et débogage de programmes.

Sous-commande stophwp

stophwp Taille de l'adresse

La sous-commande stophwp définit un arrêt de point de contrôle matériel pour la région de mémoire spécifiée. Le programme s'arrête lorsque le contenu de la région est modifié.

Remarque :

La réussite de la sous-commande stophwp dépend du matériel. Cette fonction est disponible uniquement sur les systèmes POWER630 et POWER4 et suivants.
En raison de la limitation matérielle qui consiste à ne pouvoir définir qu'un seul point de contrôle, un événement de point de contrôle actif se comporte comme un conflit lors de la tentative de création d'un autre événement de point de contrôle matériel avec stophwp et tracehwp. En tant que tel, l'événement précédent doit être supprimé avant d'en créer un nouveau. De plus, comme l'existence d'un point de contrôle logiciel actif (créé par certains appels des sous-commandes stop et trace ) annule les gains de performances des points de contrôle matériel, ces types d'événements agissent également comme des conflits qui doivent être supprimés avant la création d'un point de contrôle matériel.

Exemple

Pour arrêter le programme lorsque le contenu de la région de mémoire à 4 octets commençant à l'adresse 0x200004e8 change, entrez:
```
stophwp 0x200004e8 4
```

Voir la sous-commande tracehwp .

Sous-commande stopi

stopi { [Adresse] [ at Adresse | dans Procédure ] [ if Condition ] }

La sous-commande stopi définit un arrêt à l'emplacement spécifié:

Avec l'indicateur if Condition , le programme s'arrête lorsque la condition true est spécifiée.
Avec le paramètre Adresse , le programme s'arrête lorsque le contenu de Adresse est modifié.
Avec l'indicateur at Address , un arrêt est défini à l'adresse spécifiée.
Avec l'indicateur dans Procédure , le programme s'arrête lorsque la Procédure est appelée.

Flags

Article	Descriptif
if `Condition`	Indique la condition, telle que true.
dans `Procédure`	Indique la procédure à appeler.
at `Adresse`	Indique l'adresse de l'instruction machine.

Exemples

Pour arrêter l'exécution à l'adresse0x100020f0, entrez:
```
stopi at 0x100020f0
```
Pour arrêter l'exécution lorsque le contenu de l'adresse0x100020f0modifier, entrez:
```
stopi 0x100020f0
```
Pour arrêter l'exécution lorsque le contenu de l'adresse 0x100020f0 est modifié par l'unité d'exécution$t1, entrez:
```
stopi 0x200020f0 if ($running_thread == 1)
```

Voir la sous-commande stop . Voir également Débogage au niveau de la machine avec dbx dans General Programming Concepts: Writing and Debugging Programs.

sous-commande thdata

thdata [ $tthreadnumber [ all | key1 ... ] … ] | [ tout ]

La sous-commande thdata imprime les données spécifiques à l'unité d'exécution qui sont associées à différentes clés, qui sont créées à l'aide de la fonction pthread_key_create () . Vous pouvez utiliser la sous-commande thdata des manières suivantes.

Commande	Opération
thdata [ tout ]	Imprime les données spécifiques à l'unité d'exécution qui sont associées à toutes les clés pour toutes les unités d'exécution disponibles.
thdata $t1 [ tout ]	Imprime les données spécifiques à l'unité d'exécution qui sont associées à toutes les clés de l'unité d'exécution `$t1` .
thdata $t1 key1 key2	Imprime les données spécifiques à l'unité d'exécution associées aux clés key1 et key2 pour l'unité d'exécution $t1 .
thdata $t1 key1 key2 $t2 key1	Imprime les données spécifiques à l'unité d'exécution associées aux clés key1 et key2 pour l'unité d'exécution $t1 et les données spécifiques à l'unité d'exécution associées à la clé key1 pour l'unité d'exécution $t2 .

Exemples

Pour imprimer les données associées à l'unité d'exécution en cours avec toutes les clés disponibles, entrez:

(dbx) thdata $t1
Thread  :  1
	Key : 1 Data pointer : 0x200f7a28
	Key : 2  Data pointer : 0x200f7aa8
	Key : 3 Data pointer : 0x200f7ac4
(dbx)

Pour imprimer les données associées à plusieurs unités d'exécution et à plusieurs clés, entrez:

(dbx) thdata $t1 2 3 $t2
Thread  :  1
	Key : 2  Data pointer : 0x200f7aa8
	Key : 3 Data pointer : 0x200f7ac4
Thread : 2
	Key : 2  Data pointer : 0x200f7b24
	Key : 3 Data pointer : 0x200f7ba4
(dbx)

Voir Thread-Specific Data dans General Programming Concepts: Writing and Debugging Programs

Sous-commande d'unité d'exécution

Afficher les unités d'exécution sélectionnées

thread { [ info ] [ - ] [ ThreadNumber ... ] } | current | run | susp | term | wait

Sélectionner une unité d'exécution individuelle

thread en cours [-] ThreadNumber

Unités d'exécution de mise en attente ou de libération

thread { hold | unhold } [-] [ ThreadNumber ... ]

Aide sur les options affichées

thread { aide}

La sous-commande thread affiche et contrôle les unités d'exécution utilisateur.

La première forme de la sous-commande thread peut afficher les informations dans deux formats. Si la sous-commande thread est th, les informations affichées sont au premier format. Si la sous-commande thread est th-, les informations affichées sont au second format. Si aucun paramètre n'est indiqué, des informations sur toutes les unités d'exécution utilisateur sont affichées. Si un ou plusieurs paramètres ThreadNumber sont indiqués, des informations sur les unités d'exécution utilisateur correspondantes sont affichées. Lorsque la sous-commande thread affiche des unités d'exécution, la ligne d'unité d'exécution en cours est précédée de >. Si l'unité d'exécution en cours n'est pas la même que l'unité d'exécution en cours, sa ligne est précédée d'un *. Les informations affichées par la sous-commande thread dans les deux formats sont décrites ci-dessous.

Les informations affichées par la sous-commande thread dans le premier format sont les suivantes:

Article	Descriptif
`thread`	Indique le nom symbolique de l'unité d'exécution utilisateur, sous la forme`$tThreadNumber`.
`state-k`	Indique l'état de l'unité d'exécution du noyau (si l'unité d'exécution de l'utilisateur est connectée à une unité d'exécution du noyau). Cela peut être`run`,`wait`,`susp`ou`term`, pour l'exécution, l'attente, l'interruption ou l'arrêt.
`wchan`	Indique l'événement auquel l'unité d'exécution du noyau est en attente ou en veille (si l'unité d'exécution de l'utilisateur est connectée à une unité d'exécution du noyau).
`state-u`	Indique l'état de l'unité d'exécution utilisateur. Les états possibles sont:`running`,`blocked`ou`terminated`.
`k-tid`	Indique l'identificateur de l'unité d'exécution du noyau (si l'unité d'exécution de l'utilisateur est connectée à une unité d'exécution du noyau).
`mode`	Indique le mode (noyau ou utilisateur) dans lequel l'unité d'exécution utilisateur est arrêtée (si l'unité d'exécution utilisateur est connectée à une unité d'exécution de noyau).
`held`	Indique si l'unité d'exécution utilisateur a été suspendue.
`scope`	Indique la portée des conflits de l'unité d'exécution utilisateur ; cela peut être`sys`ou`pro`pour la portée des conflits de système ou de processus.
`function`	Indique le nom de la fonction d'unité d'exécution utilisateur.

Les informations affichées par la sous-commande thread dans le deuxième format sont indiquées ci-dessous. Par défaut, pour la sous-commande thread th-, les informations sont affichées au format long.

Article	Descriptif
`thread`	Indique le nom symbolique de l'unité d'exécution utilisateur, sous la forme`$tThreadNumber`.

Informations relatives aux unités d'exécution du noyau

Article	Descriptif
`tid`	Indique l'identificateur de l'unité d'exécution utilisateur (si l'unité d'exécution utilisateur est connectée à une unité d'exécution du noyau).
`pri`	Indique la priorité de l'unité d'exécution du noyau.
`sched`	Indique la règle de planification de l'unité d'exécution du noyau. Cette valeur peut être fif, oth, rr, pour les règles de planification fifo, other ou round robin.
`state`	Indique l'état de l'unité d'exécution du noyau (si l'unité d'exécution de l'utilisateur est connectée à une unité d'exécution du noyau). Cette valeur peut être run, wait, susp ou zomb, pour running, waiting, suspended ou zombie.

Informations relatives aux unités d'exécution utilisateur

Article	Descriptif
`tid`	Indique l'identificateur de l'unité d'exécution utilisateur.
`pri`	Indique la priorité de l'unité d'exécution userl.
`sched`	Indique la règle de planification de l'unité d'exécution utilisateur. Cette valeur peut être fif, oth, rr, pour les règles de planification fifo, other ou round-robin.
`state`	Indique l'état de l'unité d'exécution utilisateur. Cette valeur peut être en cours d'exécution, de création, suspendue, bloquée, exécutable ou arrêtée.
`state`	Indique l'état de l'utilisateur au format hexadécimal.
`flags`	Indique les valeurs des indicateurs pthread au format hexadécimal.
`wchan`	Indique l'événement auquel l'unité d'exécution du noyau est en attente ou en veille (si l'unité d'exécution de l'utilisateur est connectée à une unité d'exécution du noyau).
`mode`	Indique le mode (noyau ou utilisateur) dans lequel l'unité d'exécution utilisateur est arrêtée (si l'unité d'exécution utilisateur est connectée à une unité d'exécution de noyau).
`held`	Indique si l'unité d'exécution utilisateur est suspendue.
`scope`	Indique la portée des conflits de l'unité d'exécution utilisateur ; cette valeur peut être sys ou pro pour la portée des conflits de système ou de processus.
`cancelation`	`pending` Indique si l'annulation est en attente ou non. `state` Indique le mode et l'état de l'annulation. Si l'annulation n'est pas en attente et que l'état et le mode sont respectivement activés et différés, elle est représentée par ed, si l'état et le mode d'annulation sont activés et asynchrones, elle est représentée par ea, et si le mode n'est pas activé, elle est représentée par d. Si l'annulation est en attente et que l'état et le mode d'annulation sont respectivement activés et différés, il est représenté par ED, si l'état et le mode d'annulation sont activés et asynchrones, il est représenté par EA, et si le mode n'est pas activé, il est représenté par D.

Article	Descriptif
`joinable`	Indique si l'unité d'exécution peut être jointe ou non.
`boosted`	Indique la valeur promo de l'unité d'exécution.
`function`	Indique le nom de la fonction d'unité d'exécution utilisateur.
`cursig`	Indique la valeur du signal en cours.

Si l'option est définie$thcompest définie, puis les informations sont affichées sous forme compressée, comme illustré dans l'exemple suivant.

m           mode           (k)ernel (u)ser
k           k-state        (r)unning (w)aiting (s)uspended (z)ombie
u           u-state        (r)unning (R)unnable (s)uspended (t)erminated

                           (b)locked (c)reating
h           held           (yes) (n)o
s           scope          (s)ystem (p)rocess
c           cancellation   not pending:  (e)nabled & (d)eferred,
                                         (e)nabled & (a)sync, (d)isabled
                           pending    :  (E)nabled & (D)eferred,
                                         (E)nabled & (A)sync, (D)isabled
j           joinable       (yes) (n)o
b           boosted        value of boosted field in pthread structure
plk         kernel thread  (oth)er  (fif)o  (rr)-> round-robin
            policy
plu         user thread    (oth)er  (fif)o  (rr)-> round-robin
            policy
prk         kernel thread  hex number
            policy
pru         user thread    hex number
            policy
k-tid                      kernel thread id in hex
u-tid                      pthread id in hex
fl                         value of flags field in pthread structure in hex
sta                        value of state field in pthread structure in hex
cs                         value of the current signal
wchan                      event for which thread is waiting
function                   function name

La deuxième forme de la sous-commande thread est utilisée pour sélectionner l'unité d'exécution en cours. Les sous-commandes print, registerset where du programme de débogage dbx fonctionnent toutes dans le contexte de l'unité d'exécution en cours. La sous-commande registers ne peut pas afficher les registres si l'unité d'exécution en cours est en mode noyau.

La troisième forme de la sous-commande thread est utilisée pour contrôler l'exécution des unités d'exécution. Les unités d'exécution peuvent être retenues à l'aide de l'indicateur hold ou libérées à l'aide de l'indicateur unhold . Une unité d'exécution suspendue n'est pas reprise tant qu'elle n'est pas libérée.

Remarque: La sous-commande print du programme de débogage dbx reconnaît les noms d'unité d'exécution symboliques et peut être utilisée pour afficher l'état de l'objet correspondant.

Flags

Article	Descriptif
En cours	Si le paramètre `ThreadNumber` n'est pas indiqué, affiche l'unité d'exécution en cours. Si le paramètre `ThreadNumber` est indiqué, sélectionne l'unité d'exécution utilisateur spécifiée comme unité d'exécution en cours.
Aide	Affiche toutes les informations sur les options d'unité d'exécution affichées lorsque la commande th- est utilisée.
mise en attente	Si le paramètre `ThreadNumber` n'est pas indiqué, il met en attente et affiche toutes les unités d'exécution utilisateur. Si un ou plusieurs paramètres `ThreadNumber` sont indiqués, ils contiennent et affichent les unités d'exécution utilisateur spécifiées.
annuler la mise en attente	Si le paramètre `ThreadNumber` n'est pas indiqué, libère et affiche toutes les unités d'exécution utilisateur précédemment détenues. Si un ou plusieurs paramètres `ThreadNumber` sont indiqués, libère et affiche les unités d'exécution utilisateur spécifiées.
info	Si le paramètre `ThreadNumber` n'est pas indiqué, affiche une liste au format long de toutes les unités d'exécution utilisateur. Si un ou plusieurs paramètres `ThreadNumber` sont indiqués, affiche un format long répertoriant les unités d'exécution utilisateur spécifiées. Tous les indicateurs précédents prennent l'option [-]. Si cette option est indiquée, les informations d'unité d'exécution affichées sont au deuxième format et au format long, sauf si le`set $thcomp`est définie.
Exécution	Affiche les unités d'exécution qui se trouvent dans le`run`à l'état Wrap Up.
Sup	Affiche les unités d'exécution qui se trouvent dans le`susp`à l'état Wrap Up.
terme	Affiche les unités d'exécution qui se trouvent dans le`term`à l'état Wrap Up.
wait	Affiche les unités d'exécution qui se trouvent dans le`wait`à l'état Wrap Up.

Exemples

Pour afficher des informations sur les unités d'exécution en attente, entrez:

thread wait

La sortie est similaire à la suivante:

thread  state-k   wchan state-u   k-tid mode held scope function 
 $t1     wait            running   17381   u   no   pro  main
 $t3     wait            running    8169   u   no   pro  iothread

Pour afficher des informations sur plusieurs unités d'exécution données, entrez:

thread 1 3 4

La sortie est similaire à la suivante:

thread  state-k   wchan state-u   k-tid mode held scope function
 $t1     wait           running   17381   u   no   pro  main
 $t3     wait           running    8169   u   no   pro  iothread
>$t4     run            running    9669   u   no   pro  save_thr

Pour faire de l'unité d'exécution 4 l'unité d'exécution en cours, entrez:
thread current 4
Pour suspendre l'unité d'exécution numéro 2, entrez:
thread hold 2

Pour afficher des informations sur les unités d'exécution qui sont à l'état d'attente, dans le second format, entrez:

thread wait -

La sortie est similaire à la suivante:

thread m k u h s c  j b  kpl  upl  kpr upr k_tid   u_tid   fl  sta wchan  function
*$t1   u r w n p ed y 0  oth  oth  61   1  0043e5  000001  51  004        main
 $t3   u r w n p ed y 0  oth  oth  61   1  001fe9  000102  51  004        iothread
>$t4   u r r n p ed y 0  oth  oth  61   1  0025c5  000203  50  064        save_thr

Pour afficher des informations sur plusieurs unités d'exécution données dans le second format, entrez:

thread - 1 2 3

La sortie est similaire à la suivante:

thread m k u h s c  j b  kpl  upl  kpr upr k_tid   u_tid   fl  sta wchan function
*$t1   u r w n p ed y 0  oth  oth  61   1  0043e5  000001  51  004       main
 $t3   u r w n p ed y 0  oth  oth  61   1  00fe9   000102  51  004       iothread
>$t4   u r r n p ed y 0  oth  oth  61   1  0025c5  000203  50  064       save_thr

Voir la sous-commande attribute , la sous-commande condition , la sous-commande mutex , la sous-commande print , la sous-commande registers et la sous-commande where .

Voir aussi Création d'unités d'exécution dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

Sous-commande tls

tls map

La sous-commande tls prend un seul indicateur qu'elle utilise pour afficher l'origine et la longueur du modèle d'initialisation TLS pour chaque module TLS chargé.

Sous-commande tm_status

tm_status

La sous-commande tm_status affiche le contenu de la variable $texasr (exception de transaction et registre récapitulatif) et l'interprète pour déterminer la cause et la nature d'un échec de transaction.

Exemple

Pour afficher et interpréter les valeurs stockées dans la variable $texasr , entrez la commande suivante:

(dbx) tm_status

Une sortie similaire à l'exemple suivant s'affiche :

REGISTER : TEXASR = 0x100000018C000001
Bit(s)   |Field                     |Meaning
_________________________________________________________________________________
0-7      Failure Code                TM_SIG_DELIVERED | Failed due to signal delivery
7        Failure Persistent          Failure is transient
31       Abort                       Execution of TM instruction caused Abort
32       Suspended                   Failure while in Suspended State
34-35    Privilege                   During Failure process-thread privilege state was 0
36       Failure                     Summary Failure recording has been performed
37       TFIAR (in)exact             TFIAR is exact
38       Rollback Only Transaction   non-ROT tbegin. initiated
52-63    Transaction Level           1

Sous-commande tnext

tnext [Nombre]

La sous-commande tnext exécute l'unité d'exécution en cours d'exécution jusqu'à la ligne source suivante. Le paramètre Nombre indique le nombre de fois où la sous-commande tnext s'exécute. Si le paramètre Nombre n'est pas spécifié, tnext s'exécute une seule fois. Cette sous-commande ne peut être démarrée que sur des unités d'exécution de portée système.

Toutes les unités d'exécution sont exécutées au cours de cette opération. Pour intercepter les points d'arrêt lors de cette opération, définissez la variable $catchbp dbx . Si la variable $catchbp est définie et qu'un point d'arrêt est atteint pour une autre unité d'exécution, la sous-commande tnext n'est pas répétée pour le nombre de fois restant.

Exemples

Pour continuer l'exécution de l'unité d'exécution jusqu'à la ligne source suivante, entrez:
```
tnext
```
Pour continuer l'exécution de l'unité d'exécution en cours jusqu'à la troisième ligne source suivant la ligne source en cours, entrez:
```
tnext 3
```

Voir la sous-commande tnexti . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tnexti

tnexti [Nombre]

La sous-commande tnexti exécute l'unité d'exécution en cours d'exécution jusqu'à l'instruction suivante. Le paramètre Nombre indique le nombre de fois où la sous-commande tnexti s'exécute. Si le paramètre Nombre n'est pas spécifié, tnexti s'exécute une seule fois. Cette sous-commande ne peut être démarrée que sur des unités d'exécution de portée système.

Toutes les unités d'exécution sont exécutées au cours de cette opération. Pour intercepter les points d'arrêt lors de cette opération, définissez la variable $catchbp dbx . Si la variable $catchbp est définie et qu'un point d'arrêt est atteint pour une autre unité d'exécution, la sous-commande tnexti n'est pas répétée pour le nombre de fois restant.

Exemples

Pour continuer l'exécution de l'unité d'exécution jusqu'à l'instruction machine suivante, entrez:
```
tnexti
```
Pour continuer l'exécution de l'unité d'exécution jusqu'à la troisième instruction machine suivant l'instruction machine en cours, entrez:
```
tnexti 3
```

Voir la sous-commande tnext . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande de trace

La sous-commande trace imprime les informations de trace pour la procédure, la fonction, la ligne source, l'expression ou la variable spécifiée lors de l'exécution du programme. La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier. Une condition peut être spécifiée. Le programme de débogage dbx associe un nombre à chaque sous-commande trace . Utilisez la sous-commande status pour afficher ces nombres. Utilisez la sous-commande delete pour désactiver le traçage. Vous pouvez activer et désactiver les traces à l'aide des sous-commandes enable et disable , respectivement.

La sous-commande trace peut afficher des informations de trace lorsque des modules sont chargés ou déchargés par le processus débogué. Le paramètre facultatif ModuleName peut être spécifié en tant que nom de module unique ou en tant que nom de module associé à un nom de membre au format suivant:

ModuleName(MemberName)

Si l'indicateur on load est utilisé sans le paramètre ModuleName , la commande dbx trace le chargement et le déchargement de tous les modules.

Par défaut, la fonction de trace est basée sur les processus. Pour créer une trace basée sur une unité d'exécution, spécifiez l'unité d'exécution dans une condition (comme dans l' exemple 8).

Flags

Article	Descriptif
at `SourceLine`	Indique la ligne source où se trouve l'expression tracée.
if `Condition`	Indique une condition pour le début de la trace. La trace commence uniquement par if `Condition` . La valeur est true.
in `Procédure`	Indique la procédure à utiliser pour rechercher la procédure ou la variable tracée.
on load `ModuleName`	Indique le module de chargement à surveiller.

Exemples

Pour tracer chaque appel à la procédure printf , entrez:
```
trace printf
```
Pour tracer chaque exécution de la ligne 22 dans le fichier hello.c , entrez:
```
trace "hello.c":22
```
Pour tracer les modifications apportées à la variable x dans la procédure main , entrez:
```
trace x in main
```
Pour tracer l'adresse de données 0x2004000, entrez:
```
set $A=0x2004000
trace $A
```
Remarque: La sous-commande tracei est conçue pour les adresses de trace.
Vous pouvez limiter l'impression des lignes source lorsque la procédure spécifiée est active. Vous pouvez également spécifier une Condition facultative pour contrôler le moment où les informations de trace doivent être générées. Par exemple :
```
(dbx) trace in sub2
[1] trace in sub2
(dbx) run
trace in hellosub.c:  8  printf("%s",s);
trace in hellosub.c:  9  i = '5';
trace in hellosub.c:  10  }
```
Vous pouvez afficher un message chaque fois qu'une procédure est appelée ou renvoyée. Lorsqu'une procédure est appelée, les informations incluent les paramètres transmis et le nom de la routine appelante. Lors d'un retour, les informations incluent la valeur de retour de Procédure. Par exemple :
```
(dbx) trace sub
[1] trace sub
(dbx) run
calling sub(s = "hello", a = -1, k = delete) from function main
returning "hello" from sub
```

Vous pouvez imprimer la valeur de Expression lorsque le programme atteint la ligne source spécifiée. Le numéro de ligne et le fichier sont imprimés, mais pas la ligne source. Par exemple :

(dbx) trace x*17 at "hellosub.c":8 if (x > 0)
[1] trace x*17 at "hellosub.c":8 if x > 0
(dbx) run
at line 8 in file "hellosub.c": x*17 = 51
 
(dbx) trace x
[1] trace x
initially (at line 4 in "hello.c"):  x = 0
after line 17 in "hello.c":  x = 3

Pour tracer les modifications apportées à la variable x par l'unité d'exécution $t1, entrez la commande suivante:
```
(dbx) trace x if ($running_thread == 1)
```
Pour tracer le chargement ou le déchargement de tous les modules, entrez la commande suivante:
```
trace on load
```
Pour tracer le chargement ou le déchargement du module Module, entrez la commande suivante:
```
trace on load "Module"
```
Pour tracer le chargement ou le déchargement du membre Member dans le module Module, entrez la commande suivante:
```
trace on load "Module(Member)"
```

Voir aussi la sous-commande tracei .

Sous-commande tracehwp

tracehwp Taille de l'adresse

La sous-commande tracehwp définit un arrêt de point de contrôle matériel pour la région de mémoire spécifiée. Le programme de débogage dbx imprime les informations de trace lorsque le contenu de la région change.

Remarque :

La réussite de la sous-commande tracehwp dépend du matériel. Cette fonction est disponible uniquement sur les systèmes POWER630 et POWER4 et suivants.
En raison de la limitation matérielle qui consiste à ne pouvoir définir qu'un seul point de contrôle, un événement de point de contrôle actif se comporte comme un conflit lors de la tentative de création d'un autre événement de point de contrôle matériel avec stophwp et tracehwp. En tant que tel, l'événement précédent doit être supprimé avant d'en créer un nouveau. De plus, comme l'existence d'un point de contrôle logiciel actif (créé par certains appels des sous-commandes stop et trace ) annule les gains de performances des points de contrôle matériel, ces types d'événements agissent également comme des conflits qui doivent être supprimés avant la création d'un point de contrôle matériel.

Exemples

Pour tracer chaque fois que le contenu de la région de mémoire à 4 octets commençant à l'adresse 0x200004e8 change, entrez la commande suivante:
```
 tracehwp 0x200004e8 4 
```

Voir la sous-commande stophwp .

Sous-commande tracei

tracei [ [Adresse] [at Adresse | in Procédure] | Expression at Adresse] [if Condition]

La sous-commande tracei active le traçage lorsque:

Le contenu de l'adresse spécifiée par le paramètre Adresse change si l'indicateur Adresse est inclus.
L'instruction à l'adresse Address est exécutée si le paramètre Address de at est spécifié.
La procédure spécifiée par Procédure est active si l'indicateur in Procédure est inclus.
La condition spécifiée par le paramètre Condition est vraie si l'indicateur if Condition est inclus.

Flags

Article	Descriptif
at `Adresse`	Indique une adresse. La fonction de trace est activée lors de l'exécution de l'instruction à cette adresse.
if `Condition`	Indique une condition. La fonction de trace est activée lorsque cette condition est remplie.
in `Procédure`	Indique une procédure. La fonction de trace est activée lorsque cette procédure est active.

Exemples

Pour tracer chaque instruction exécutée, entrez la commande suivante:
```
tracei
```
Pour tracer chaque fois que l'instruction à l'adresse 0x100020f0 est exécutée, entrez la commande suivante:
```
tracei at 0x100020f0
```
Pour tracer chaque fois que le contenu de l'emplacement de mémoire 0x20004020 change alors que la procédure main est active, entrez la commande suivante:
```
tracei 0x20004020 in main
```
Pour tracer chaque fois que l'instruction à l'adresse 0x100020f0 est exécutée par l'unité d'exécution $t4, entrez la commande suivante:
```
tracei at 0x100020f0 if ($running_thread == 4)
```

Voir la sous-commande trace . Voir aussi Débogage au niveau de la machine avec dbx dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

Sous-commande tskip

tskip [Nombre]

La sous-commande tskip poursuit l'exécution de l'unité d'exécution en cours à partir du point d'arrêt en cours. Le nombre de points d'arrêt de niveau unité d'exécution spécifié par le paramètre Nombre est ignoré pour l'unité d'exécution en cours d'exécution. Cette sous-commande peut être démarrée pour les unités d'exécution de portée système uniquement.

Toutes les autres unités d'exécution sont exécutées au cours de cette opération et tous les points d'arrêt et les points de contrôle spécifiés par l'utilisateur sont interceptés. L'exécution peut s'arrêter lorsqu'une unité d'exécution atteint un point d'arrêt ou un point de contrôle. Même si l'exécution démarrée par la sous-commande tskip peut s'arrêter en raison d'un événement pour une autre unité d'exécution, le nombre tskip spécifié pour l'unité d'exécution précédente est toujours actif et le nombre de points d'arrêt de niveau unité d'exécution spécifié par le nombre tskip est ignoré pour cette unité d'exécution lorsque le processus se poursuit. A la fin de l'unité d'exécution, le nombre tskip qui lui est associé est supprimé.

Utilisez la sous-commande status pour afficher le nombre tskip restant pour les unités d'exécution. Utilisez la sous-commande delete pour supprimer le nombre tskip restant pour les unités d'exécution.

Exemple

Pour continuer l'exécution jusqu'à ce que le deuxième point d'arrêt de niveau unité d'exécution soit détecté à partir du point d'arrêt en cours de l'unité d'exécution en cours, entrez:

tskip 1

Voir la sous-commande cont . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tstep

tstep [Numéro]

La sous-commande tstep exécute le nombre spécifié de lignes source à partir de la ligne source en cours pour l'unité d'exécution en cours. Le paramètre Nombre indique le nombre de fois où la sous-commande tstep s'exécute. Si le paramètre Nombre n'est pas spécifié, tstep s'exécute une seule fois. Cette sous-commande ne peut être démarrée que sur des unités d'exécution de portée système.

Toutes les unités d'exécution sont exécutées au cours de cette opération. Si $hold_next est défini, toutes les unités d'exécution à l'exception de l'unité d'exécution en cours d'exécution sont conservées.

Remarque: utilisez la variable $stepignore de la sous-commande set pour contrôler le comportement de la sous-commande tstep . La variable $stepignore permet à la sous-commande tstep de passer par des routines de grande taille pour lesquelles aucune information de débogage n'est disponible.

Exemples

Pour continuer l'exécution de l'unité d'exécution en cours d'exécution pour une ligne source, entrez:
```
tstep
```
Pour continuer l'exécution de l'unité d'exécution pour cinq lignes source, entrez:
```
tstep 5
```
Pour empêcher le programme dbx d'exécuter une seule étape de la fonction printf , comme illustré dans l'exemple de code:
```
60 printf ("hello world /n");
```
Entrez :
```
set $stepignore="function"; step
```

Voir la sous-commande cont , la sous-commande goto , la sous-commande tnext , la sous-commande set et la sous-commande tstepi . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tstepi

tstepi [Nombre]

La sous-commande tstepi exécute le nombre d'instructions spécifié à partir de l'instruction en cours pour l'unité d'exécution en cours d'exécution. Le paramètre Nombre indique le nombre de fois où la sous-commande tstepi s'exécute. Si le paramètre Nombre n'est pas spécifié, tstepi s'exécute une seule fois. Cette sous-commande ne peut être démarrée que sur des unités d'exécution de portée système.

Exemples

Pour continuer l'exécution de l'unité d'exécution en cours d'exécution pour une instruction machine, entrez:
```
tstepi
```
Pour continuer l'exécution de l'unité d'exécution en cours d'exécution pour cinq instructions de machine, entrez:
```
tstepi 5
```

Voir la sous-commande gotoi , la sous-commande tnexti et la sous-commande tstep . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tstop

tstop { in Procédure | [Variable] at SourceLine [ if Condition ] } [for $tnuméro_unité d'exécution]

La sous-commande tstop définit un arrêt de point d'arrêt de niveau source pour une unité d'exécution et arrête le programme d'application lorsque l'unité d'exécution spécifiée atteint le point d'arrêt. L'unité d'exécution spécifiée doit exister en même temps que la création de l'événement. L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. L'unité d'exécution spécifiée est arrêtée lorsque l'une des situations suivantes se produit:

L'indicateur if Condition est utilisé et la Condition est true.
L'indicateur in Procédure est utilisé et la procédure est appelée.
L'indicateur at SourceLine est utilisé et le numéro de ligne SourceLine est atteint. La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier.

Les points d'arrêt de niveau unité d'exécution ne peuvent être définis que sur les unités d'exécution de portée système. Lorsqu'un point d'arrêt de niveau unité d'exécution et de niveau processus est atteint en même temps, les deux points d'arrêt sont traités et le point d'arrêt de niveau unité d'exécution est porté. Lorsque l'unité d'exécution s'arrête, les événements qui lui sont associés sont supprimés.

Flags

Article	Descriptif
sur `SourceLine`	Indique le numéro de ligne.
pour $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.
if `Condition`	Indique la condition (par exemple, `true`).
dans `Procédure`	Indique la procédure à appeler.

Exemples

Pour arrêter l'exécution à la première instruction de la procédure func lors de l'exécution de l'unité d'exécution 2, entrez:
```
tstop in func for $t2
```
Pour arrêter l'exécution de l'unité d'exécution en cours lorsque la valeur de la variable x est modifiée sur la ligne 12 de l'exécution, entrez:
```
tstop x at 12
```

Voir la sous-commande ttrace . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tstophwp

tstophwp address size [pour $tnuméro_unité d'exécution]

La sous-commande tstophwp définit un arrêt de point de contrôle matériel de niveau unité d'exécution pour la région de mémoire spécifiée. Le programme s'arrête lorsque le contenu de la région change lors de l'exécution de l'unité d'exécution spécifiée. L'unité d'exécution spécifiée doit exister en même temps que la création de l'événement. L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. Les événements de point de contrôle de niveau unité d'exécution ne peuvent être définis que pour les unités d'exécution de portée système. Lorsque l'unité d'exécution s'arrête, les événements qui lui sont associés sont supprimés.

Remarque :

La réussite de la sous-commande tstophwp dépend du matériel. Cette fonction est disponible uniquement sur les systèmes POWER630 et POWER4 et suivants.
En raison de la limitation matérielle autorisant la définition d'un seul point de contrôle, un événement de point de contrôle d'unité d'exécution actif agit comme un conflit lors de la tentative de création d'un autre événement de point de contrôle matériel pour la même unité d'exécution à l'aide de tstophwp et ttracehwp. Pour éviter cela, l'événement précédent doit être supprimé avant d'en créer un nouveau. Etant donné que l'existence d'un point de contrôle logiciel actif (créé par certains appels des sous-commandes stop et trace ) peut annuler les gains de performances des points de contrôle matériel, ces types d'événement doivent également être supprimés avant la création d'un point de contrôle matériel pour éviter les conflits.
Lorsqu'un point de contrôle de niveau processus existe, une unité d'exécution n'ayant pas de point de contrôle de niveau unité d'exécution surveille l'emplacement du point de contrôle de processus. Si une unité d'exécution possède un point de contrôle au niveau de l'unité d'exécution, l'unité d'exécution surveille l'emplacement du point de contrôle de l'unité d'exécution.
Un point de contrôle matériel de niveau unité d'exécution et un point de contrôle matériel de niveau processus peuvent coexister et ne sont pas en conflit les uns avec les autres.
Si un point de contrôle de niveau processus et un point de contrôle de niveau unité d'exécution existent pour la même adresse, l'événement de point de contrôle de niveau processus est signalé.

Flags

Article	Descriptif
pour $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.

Exemple

Pour arrêter le programme lorsque l'unité d'exécution 2 est en cours d'exécution et que le contenu de la région de mémoire à 4 octets commençant à l'adresse 0x200004e8 change, entrez:

tstophwp 0x200004e8 4 for $t2

Voir la sous-commande ttracehwp . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande tstopi

tstopi { in Procédure | [Adresse] at Adresse [ if Condition ] } [for $tnuméro_unité d'exécution]

La sous-commande tstopi définit un arrêt de point d'arrêt de niveau instruction pour une unité d'exécution. L'unité d'exécution spécifiée doit exister en même temps que la création de l'événement. L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. L'unité d'exécution spécifiée est arrêtée lorsque l'une des situations suivantes se produit:

L'indicateur if Condition est utilisé et la Condition est true.
L'indicateur in Procédure est utilisé et la procédure est appelée.
L'indicateur at Adresse est utilisé et l' Adresse est atteinte.

Les points d'arrêt de niveau unité d'exécution ne peuvent être définis que sur les unités d'exécution de portée système. Lorsqu'un point d'arrêt de niveau unité d'exécution et de niveau processus est atteint en même temps, les deux points d'arrêt sont traités et le point d'arrêt de niveau unité d'exécution est signalé. Lorsque l'unité d'exécution s'arrête, les événements qui lui sont associés sont supprimés.

Flags

Article	Descriptif
at `Adresse`	Indique l'adresse de l'instruction machine.
pour $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.
if `Condition`	Indique la condition.
dans `Procédure`	Indique la procédure à appeler.

Exemple

Pour arrêter l'exécution à l'adresse 0x100020f0 lors de l'exécution de l'unité d'exécution 2, entrez:
```
tstopi at 0x100020f0 for $t2
```
Pour arrêter l'exécution lorsque la procédure func est entrée lors de l'exécution de l'unité d'exécution en cours, entrez:
```
tstopi in func
```

Voir la sous-commande ttracei . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande ttrace

ttrace { [Variable] at SourceLine | Procédure } [ if Condition ] [for $tnuméro_unité d'exécution]

La sous-commande ttrace imprime les informations de trace lorsque l'unité d'exécution spécifiée s'exécute pour la procédure, la fonction, la ligne source et la variable spécifiées. La variable SourceLine peut être spécifiée sous la forme d'un entier ou d'une chaîne de nom de fichier suivie d'un signe deux-points (:) et d'un entier. Le programme de débogage dbx associe un nombre à chaque sous-commande ttrace . Utilisez la sous-commande status pour afficher ces nombres. Utilisez la sous-commande delete pour désactiver le traçage. Vous pouvez activer et désactiver les traces à l'aide des sous-commandes enable et disable , respectivement.

L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. La trace de niveau unité d'exécution ne peut être définie que pour les unités d'exécution de portée système. L'unité d'exécution spécifiée doit exister en même temps que la création de l'événement. Lorsque l'unité d'exécution se termine, les événements qui lui sont associés sont supprimés.

Flags

Article	Descriptif
at `SourceLine`	Indique la ligne source où se trouve l'expression tracée.
for $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.
if `Condition`	Indique une condition pour le début de la trace. La trace commence uniquement si Condition est définie sur true.
in `Procédure`	Indique la procédure de recherche de la procédure ou de la variable tracée.

Exemples

Pour tracer chaque appel à la procédure printf lors de l'exécution de l'unité d'exécution 2, entrez:
```
ttrace printf for $t2
```
Pour tracer chaque exécution de la ligne 22 dans le fichier hello.c/ pendant l'exécution de l'unité d'exécution en cours, entrez:
```
ttrace "hello.c":22
```

Sous-commande ttracei

ttracei [Adresse] at Adresse [if Condition] } [for $tnuméro d'unité d'exécution]

La sous-commande ttracei active la fonction de trace pour l'unité d'exécution spécifiée lorsque l'une des situations suivantes se produit:

L'indicateur if Condition est inclus et la Condition est true.
L'indicateur at Adresse est spécifié et l'instruction sur Adresse est exécutée.

L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. La trace de niveau unité d'exécution ne peut être définie que pour les unités d'exécution de portée système. L'unité d'exécution indiquée doit exister au moment de la création de l'événement. Lorsque l'unité d'exécution se termine, les événements qui lui sont associés sont supprimés.

Flags

Article	Descriptif
at `Adresse`	Indique une adresse. La fonction de trace est activée lors de l'exécution de l'instruction à cette adresse.
for $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.
if `Condition`	Indique une condition. La fonction de trace est activée lorsque cette condition est remplie.

Exemple

Pour tracer chaque fois que l'instruction à l'adresse 0x100020f0 est exécutée alors que l'unité d'exécution 3 est en cours d'exécution, entrez:
```
tracei at 0x100020f0 for $t3
```
Pour tracer chaque fois que l'instruction à l'adresse 0x100020f0 est exécutée par l'unité d'exécution en cours, entrez:
```
tracei at 0x100020f0 
```

Sous-commande ttracehwp

ttracehwp address size [for $tnuméro_unité d'exécution]

La sous-commandettracehwp définit une trace de point de contrôle matériel au niveau de l'unité d'exécution pour la région de mémoire spécifiée. Le programme de débogage dbx imprime les informations de trace lorsque le contenu de la région change lors de l'exécution de l'unité d'exécution spécifiée. L'unité d'exécution spécifiée doit exister en même temps que la création de l'événement. L'unité d'exécution en cours est utilisée si aucune unité d'exécution n'est spécifiée. Les événements de point de contrôle de niveau unité d'exécution ne peuvent être définis que pour les unités d'exécution de portée système. Lorsque l'unité d'exécution s'arrête, les événements qui lui sont associés sont supprimés.

Remarque :

La réussite de la sous-commande ttracehwp dépend du matériel. Cette fonction est disponible uniquement sur les systèmes POWER630 et POWER4 et suivants.
En raison de la limitation matérielle autorisant la définition d'un seul point de contrôle, un événement de point de contrôle d'unité d'exécution actif agit comme un conflit lors de la tentative de création d'un autre événement de point de contrôle matériel pour la même unité d'exécution à l'aide de tstophwp et ttracehwp. Pour éviter cela, l'événement précédent doit être supprimé avant d'en créer un nouveau. Etant donné que l'existence d'un point de contrôle logiciel actif (créé par certains appels des sous-commandes stop et trace ) peut annuler les gains de performances des points de contrôle matériel, ces types d'événement doivent également être supprimés avant la création d'un point de contrôle matériel pour éviter les conflits.
Lorsqu'un point de contrôle de niveau processus existe, une unité d'exécution n'ayant pas de point de contrôle de niveau unité d'exécution surveille l'emplacement du point de contrôle de processus. Si une unité d'exécution possède un point de contrôle au niveau de l'unité d'exécution, l'unité d'exécution surveille l'emplacement du point de contrôle de l'unité d'exécution.
Un point de contrôle matériel de niveau unité d'exécution et un point de contrôle matériel de niveau processus peuvent coexister et ne sont pas en conflit les uns avec les autres.
Si un point de contrôle de niveau processus et un point de contrôle de niveau unité d'exécution existent pour la même adresse, l'événement de point de contrôle de niveau processus est signalé.

Flags

Article	Descriptif
for $t `numéro_unité d'exécution`	Indique le numéro d'unité d'exécution.

Exemple

Pour tracer chaque fois que le contenu de la région de mémoire à 4 octets commençant à l'adresse 0x200004e8 change lors de l'exécution de l'unité d'exécution 2, entrez:

ttracehwp 0x200004e8 4 for $t2

Voir la sous-commande tstophwp . Voir également la rubrique relative au débogage de programmes impliquant plusieurs unités d'exécution dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande unalias

unalias Nom

La sous-commande unalias supprime l'alias spécifié par le paramètre Nom .

Exemple

Pour supprimer un alias nomméprintx, entrez:

unalias printx

Voir la sous-commande alias . Voir aussi Creating Subcommand Aliases dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande unset

unset Nom

La sous-commande unset supprime la variable de programme de débogage dbx associée au nom spécifié par le paramètre Nom .

Exemple

Pour supprimer la variable qui bloque l'affichage des registres à virgule flottante, entrez:

unset $noflregs

Voir la sous-commande set . Voir aussi Changing Print Output with Special Debugging Variables dans General Programming Concepts: Writing and Debugging Programs.

Sous-commande up

up [ Nombre ]

La sous-commande up déplace la fonction en cours vers le haut de la pile Nombre de niveaux. La fonction en cours est utilisée pour la résolution des noms. La valeur par défaut du paramètre Nombre est 1.

Exemples

Pour déplacer la fonction en cours vers le haut des niveaux de la pile 2, entrez:
```
up 2
```
Pour afficher la fonction en cours sur la pile, entrez:
```
up 0
```

Voir la sous-commande down . Voir aussi Modification du fichier ou de la procédure en cours, Affichage d'une trace de pile dans Concepts généraux de la programmation: Ecriture et débogage des programmes.

utiliser la sous-commande

use [ { + | Répertoire |'['Expression régulière = NewPath']'} ... ]

La sous-commande use définit la liste des répertoires à rechercher et les mappages de chemin à appliquer lorsque le programme de débogage dbx recherche des fichiers source. Si la sous-commande use est spécifiée sans arguments, la liste en cours des répertoires à rechercher et les mappages de chemin à appliquer sont affichés.

@ (at-sign) est un répertoire spécial qui demande au programme dbx de consulter les informations de nom de chemin d'accès complet dans le fichier objet, s'il existe. Si vous disposez d'un répertoire relatif appelé @ pour la recherche, vous devez utiliser./@dans le chemin de recherche.

La sous-commande use utilise le signe + (plus-sign) pour ajouter d'autres répertoires ou mappages à la liste des répertoires à rechercher. + représente la liste en cours des répertoires et des mappages lorsqu'elle est spécifiée en tant qu'entrée dans la sous-commande use . Pour ajouter un répertoire ou un mappage à la fin de la liste en cours, le paramètre + doit être spécifié avant le nouveau répertoire ou mappage. Pour ajouter un répertoire au début de la liste en cours, vous devez indiquer + après le nouveau répertoire ou mappage. Si vous disposez d'un répertoire nommé +, indiquez le nom de chemin d'accès complet du répertoire (par exemple, ./+ ou /tmp/+).

La sous-commande use interprète les chaînes entre [ et ] (crochets) qui contiennent un = (signe égal) comme mappages de chemin. Ces mappages de chemin sont utilisés avec le répertoire @ spécial. Ils permettent à l'utilisateur d'exprimer plus facilement les emplacements des fichiers source dans le cas où des structures de répertoire entières des fichiers source sont déplacées après la compilation.

Les règles suivantes s'appliquent lors de la tentative de localisation d'un fichier source lors du débogage:

Les répertoires de la liste sont évalués dans l'ordre indiqué.
Lors de l'évaluation d'un répertoire dans la liste, le fichier spécifié est recherché dans le répertoire. Si le fichier existe dans le répertoire et qu'il est lisible, ce fichier est utilisé.
Lors de l'évaluation du répertoire spécial @, lorsqu'un ou plusieurs mappages de chemin d'accès sont spécifiés, si la partie RegularExpression d'un mappage de chemin d'accès correspond aux n premiers caractères du nom de chemin d'accès complet dans le fichier d'objets et que la substitution de la partie NewPath du mappage de chemin d'accès génère un fichier lisible, ce fichier est utilisé.
Lors de l'évaluation du répertoire spécial @, lorsque aucun mappage de chemin n'est spécifié ou qu'aucun ne correspond, la recherche est effectuée dans le répertoire correspondant aux informations de nom de chemin complet. Si le fichier existe dans le répertoire et qu'il est lisible, ce fichier est utilisé.
Si plusieurs mappages de chemin d'accès génèrent un fichier lisible, le mappage de chemin dont RegularExpression correspond au plus grand nombre de caractères (1 ... n) des informations de nom de chemin d'accès complet (c'est-à-dire les plus spécifiques) sont appliquées et le fichier résultant est utilisé.
Si plusieurs mappages de chemins d'accès génèrent un fichier lisible et que chaque mappage de chemins d'accès a la même spécificité, le mappage de chemins d'accès le plus proche du début de la liste est appliqué et le fichier résultant est utilisé.

Remarque: Si le répertoire spécial @ n'est pas membre de la liste, tous les mappages de chemin pouvant être spécifiés sont ignorés.

Exemples

Pour modifier la liste des répertoires dans lesquels effectuer la recherche en fonction du répertoire en cours (.), du répertoire parent (..) et du répertoire /tmp , entrez:
```
use . .. /tmp
```
Pour modifier la liste des répertoires dans lesquels la recherche doit être effectuée en fonction du répertoire en cours (.), du répertoire dans lequel se trouvait le fichier source lors de la compilation (@) et du répertoire ../source , entrez:
```
use . @ ../source
```
Pour ajouter le répertoire /tmp2 à la liste des répertoires dans lesquels effectuer la recherche, entrez:
```
use + /tmp2
```
Pour ajouter le répertoire /tmp3 au début de la liste des répertoires à rechercher, entrez:
```
use /tmp3 +
```
Pour exprimer que les fichiers source dont les informations de chemin d'accès complet commencent par /home/developer se trouvent désormais sous /mnt, entrez:
```
use + [/home/developer=/mnt]
```
Pour demander au programme dbx de rechercher d'abord sous /latest , puis, si le fichier n'existe pas, de rechercher sous /stable les fichiers dont les informations de nom de chemin complet commencent par /home/developer, entrez:
```
use + [/home/developer=/latest] [/home/developer=/stable]
```

Voir aussi la sous-commande edit et la sous-commande list .

Sous-commande whatis

whatis Nom

La sous-commande whatis affiche la déclaration de Nom, où le paramètre Nom désigne un nom de variable, de procédure ou de fonction, éventuellement qualifié par un nom de bloc.

Remarque: utilisez la sous-commande whatis uniquement lors de l'exécution du programme de débogage dbx .

Exemples

Pour afficher la déclaration de laxvariable, entrez:
```
whatis x
```
Pour afficher la déclaration de lamainprocédure, entrez:
```
whatis main
```
Pour afficher la déclaration de laxau sein de la variablemainfonction, entrez:
```
whatis main.x
```
Pour imprimer la déclaration d'une énumération, d'une structure ou d'une étiquette d'union, utilisez$$TagName:
```
(dbx) whatis $$status
enum $$status { run, create, delete, suspend };
```

où sous-commande

where [ all | $tnombre d'unités d'exécution [ (startframe endframe) ] ... ] [ startframe endframe ] [ >Fichier ]

La sous-commande where affiche la liste des procédures et des fonctions actives associées aux numéros de châssis startframe à endframe. La numérotation du cadre de pile commence à partir du cadre de pile de fonction actuellement actif (toujours numéroté 0). S'il existe n cadres, le cadre de la fonction main est numéroté n-1. A l'aide de l'indicateur >Fichier , la sortie de cette sous-commande peut être redirigée vers le fichier spécifié.

Dans l'option d'environnement à unités d'exécution multiples, all affiche les détails de la pile pour toutes les unités d'exécution disponibles. Les détails de pile des unités d'exécution individuelles sont affichés en spécifiant le numéro d'unité d'exécution avec la sous-commande where. Si les cadres de début et de fin des unités d'exécution individuelles ne sont pas indiqués, les cadres de pile sont affichés par les numéros de cadres de début et de fin globaux. La commande sans option affiche les cadres de pile de l'unité d'exécution en cours.

Indicateur

Article	Descriptif
>`Fichier`	Redirige la sortie vers le fichier spécifié.

Voir la sous-commande frame , la sous-commande up et la sous-commande down . Voir aussi Affichage d'une trace de pile dans General Programming Concepts: Writing and Debugging Programs.

Exemple

Pour afficher les détails de la pile de toutes les unités d'exécution, entrez:
```
where all
```
Pour afficher les détails de pile des unités d'exécution $t1, $t2 et $t3, entrez:
```
where $t1 $t2 $t3
```
Pour afficher les détails de la pile des threads $t2 avec les cadres de pile 2 -3, $t1 et $t3 avec les cadres de pile 1 à 4, entrez :
```
where $t1 $t2(2 3) $t3 1 4
```

Voir la sous-commande frame , la sous-commande up et la sous-commande down . Voir aussi Affichage d'une trace de pile dans General Programming Concepts: Writing and Debugging Programs.

sous-commande whereis

whereis Identificateur

La sous-commande whereis affiche les qualifications complètes de tous les symboles dont les noms correspondent à l'identificateur spécifié. L'ordre dans lequel les symboles sont imprimés n'est pas significatif.

Exemples

Pour afficher les noms qualifiés de tous les symboles nommésx, entrez:

whereis x

Voir aussi la sous-commande which .

quelle sous-commande

which Identificateur

La sous-commande which affiche la qualification complète de l'identificateur. La qualification complète consiste en une liste des blocs externes auxquels l'identificateur est associé.

Exemples

Pour afficher la qualification complète de laxsymbole, entrez:

which x

Voir la sous-commande whereis . En outre. voir Scopie of Names dans dans General Programming Concepts: Writing and Debugging Programs.

Fichiers

Article	Descriptif
a.out	Fichier objet ; contient le code objet.
core	Contient un cliché du processus core.
.dbxinit	Contient les commandes initiales.

Débogage des applications qui utilisent la mémoire transactionnelle

Pour les applications qui utilisent la mémoire transactionnelle (TM), les aides au débogage les plus fiables sont les exceptions de transaction et le registre récapitulatif ($texasr), le registre d'adresse du gestionnaire d'échec de transaction ($tfhar) et les variables du registre d'adresse de l'instruction d'échec de transaction ($tfiar).

Les variables $texasr, $tfharet $tfiar peuvent être affichées à l'aide de la sous-commande print , qui est similaire à l'affichage de la variable $iar . Toutefois, vous ne pouvez pas manipuler les valeurs de ces registres à l'aide de la sous-commande assign .

Les variables $tfhar et $tfiar contiennent les adresses des instructions du segment de texte débogué dans un échec de transaction. Comme pour la variable $iar , les deux bits de poids fort des variables de registre $tfhar et $tfiar sont réservés et ne peuvent pas être pris en compte pour la lecture de l'adresse à partir de ces variables de registre.

Remarque: Lorsque vous utilisez les variables d'enregistrement $tfiar et $tfhar avec la sous-commande list , la commande dbx extrait l'adresse après avoir exclu les deux bits de poids fort du contenu de ces variables d'enregistrement.

(dbx) list at $tfiar

(dbx) list at $tfhar

La cause de l'échec d'une transaction peut être déterminée à l'aide de la variable $texasr . La sous-commande tm_status interprète la cause et la nature de l'échec d'une transaction.

La commande dbx surveille l'occurrence d'une transaction et affiche la cause de l'échec de la transaction via la série de messages suivante. Ces messages s'affichent après l'exécution de la sous-commande run , de la sous-commande rerun ou de la sous-commande continue .

Process {PID} may have failed a transaction - $texasr, $tfiar, $tfhar are valid and may be inspected
Process {PID} may have performed a transaction - $texasr, $tfiar, $tfhar, are valid and may be inspected
Ce message s'affiche uniquement lorsque la variable interne $trace_good_transaction est définie.
Process {PID} is in Transactional State – debugging efforts through dbx may result in repeated transaction failure or undefined behavior
Process {PID} is in Suspended State – debugging efforts through dbx may result in repeated transaction failure or undefined behavior

Où PID est l'ID du processus qui est débogué.