DEBUG

Syntaxe

Paramètres

Description

Cette commande permet de charger le débogueur simplifié pour les programmes exécutables du système d'exploitation.

Objectif

La commande DEBUG est un utilitaire MS-DOS fournissant un environnement de test contrôlé pour isoler et éliminer les erreurs ou les dysfonctionnements des fichiers objets binaires et exécutables. C'est un outil de développement logiciel fournissant un environnement contrôlé pour charger, examiner et modifier un programme.

Remarque

• Cette page suppose que l'utilisateur est familiarisé avec la programmation en langage assembleur et avec le fonctionnement des registres et des instructions 8086 et 8088. L'utilisateur doit également connaître la définition des termes du micro-ordinateur tels que : bit, octet, drapeau et registre.

Concepts préliminaires

Tout comme un éditeur de texte (comme EDLIN) est utilisé pour modifier les fichiers texte, DEBUG modifie les fichiers binaires. DEBUG élimine souvent le besoin de réassembler un programme pour voir si un problème a été corrigé par une modification mineure. Il vous permet de modifier le contenu d'un fichier ou le contenu d'un registre CPU, puis de réexécuter immédiatement un programme pour vérifier la validité des modifications.

Toutes les fonctions DEBUG peuvent être interrompues à tout moment en maintenant la touche CTRL enfoncée et en appuyant sur la touche BREAK (CTRL+BREAK). CTRL+NUMLOCK de DEBUG suspend les affichages afin que vous puissiez en lire des parties avant qu'ils ne disparaissent. Toute entrée autre que CTRL+BREAK, CTRL+C, CTRL+S ou CTRL+NUMLOCK redémarre l'affichage. Toutes ces entrées sont cohérentes avec les fonctions de caractère de contrôle disponibles au niveau de la commande MS-DOS.

Lorsque DEBUG est appelé, il définit un entête de programme à le déplacement 0 dans sa zone de travail de programme. Dans les versions précédentes, il était acceptable d'écraser cet entête en toute impunité : c'est le cas de la configuration d'entête par défaut si aucune spécification de fichier n'est donnée à DEBUG. Cependant, si vous déboguez un fichier .COM ou .EXE, vous devez veiller à ne pas altérer l'entête du programme sous l'adresse 5CH. Faire cela entraînera probablement un plantage. Il est également important qu'aucune tentative ne soit faite pour "redémarrer" un programme une fois que le message «Program terminate normally» est donné. Le programme doit être rechargé avec les fonctions N (Name) et L (Load) pour qu'il s'exécute correctement.

Appeler DEBUG

Pour appeler DEBUG, vous devez saisir une commande au prompt du système sous la forme suivante :

où

Par exemple, si seule une spécification de fichier est spécifiée, comme indiqué :

DEBUG charge le filespec FILE.EXT en mémoire dans le segment disponible le plus bas. Les registres BX:CX sont chargés avec le nombre d'octets placés en mémoire. Le prompt DEBUG est un trait d'union (-).

Un arglist peut être spécifié si filespec est présent. Ce sont des paramètres de nom de fichier et des commutateurs devant être placés dans le programme filespec. Ainsi, lorsque filespec est chargé en mémoire, il est chargé comme s'il avait été appelé avec la commande :

Ici, filespec est le fichier à déboguer et arglist est le reste de la ligne de commande, composée de fonctions et de paramètres, étant utilisée lorsque filespec est appelé et chargé en mémoire.

Si vous ne souhaitez pas spécifier de filespec, entrez votre commande DEBUG comme suit :

et appuyez sur RETURN.

DEBUG revient avec le prompt «-» (trait d'union), signalant qu'il est prêt à accepter vos fonctions. Puisqu'aucun nom de fichier n'a été spécifié, la mémoire actuelle, les secteurs de disque ou les fichiers de disque peuvent être travaillés en invoquant des fonctions ultérieures.

Fonctions

Chaque fonction DEBUG se compose d'une seule lettre suivie d'un ou plusieurs paramètres. De plus, le caractère de contrôle et la fonction d'édition spéciale décrits dans Fonctionnalités de commande, s'appliquent tous au fonctionnement du programme DEBUG.

Si une erreur de syntaxe se produit dans une fonction DEBUG, DEBUG réaffiche la ligne de commande de la fonction et indique l'erreur par un ^ (carat) et le mot Error.

Par exemple :

Toutes les fonctions et tous les paramètres peuvent être saisis en majuscules ou en minuscules. Toute combinaison de majuscules et minuscules peut être utilisée dans la ligne de commande.

Les fonctions DEBUG sont résumées dans le tableau suivants, ils sont décrits en détail, avec des exemples, après la description des paramètres de fonction :

Paramètres de fonction

Le tableau précédent montre que toutes les fonctions DEBUG, à l'exception de la fonction Quit, acceptent les paramètres. Les paramètres peuvent être séparés par des délimiteurs (espaces ou virgules), mais un délimiteur n'est requis qu'entre deux valeurs hexadécimales consécutives. Ainsi, les fonctions suivantes :

et

sont équivalents. (N'oubliez pas que les entrées peuvent être faites dans n'importe quelle combinaison de majuscules ou de minuscules.)

Descriptions de fonction DEBUG

Les pages suivantes décrivent la syntaxe des fonctions DEBUG, leurs paramètres, leur objectif et les conditions particulières s'appliquant à certaines fonctions.

Assemble

Syntaxe

Description

Pour assembler les mnémoniques 8086/8087/8088 directement en mémoire.

Commentaires

Toutes les valeurs numériques sont hexadécimales et peuvent être saisies sous la forme de 1 à 4 caractères. Si une erreur de syntaxe est rencontrée, DEBUG répond par :

et réaffiche l'adresse d'assemblage actuelle.

Les mnémoniques de préfixe doivent être entrés devant l'opcode (code d'opération) auquel ils se réfèrent. Ils peuvent être inscrits sur la même ligne ou sur une ligne précédente distincte. Les mnémoniques du préfixe se composent de :

Les mnémoniques de préfixe de remplacement de segment sont CS:, DS:, ES: et SS:. Ces mnémoniques doivent être saisis sur une ligne distincte précédant immédiatement le remplacement du segment.

Pour les mnémoniques de manipulation de chaîne, vous devez indiquer explicitement la taille de la chaîne. Par exemple, le MOVSW doit être utilisé pour déplacer des chaînes de mots et MOVSB doit être utilisé pour déplacer des chaînes d'octets.

La mnémonique pour le retour long est RTF.

L'assembleur assemblera automatiquement les sauts et appels courts, proches ou lointains, en fonction du déplacement d'octets (quantité représentant le changement de position) vers l'adresse de destination. Ceux-ci peuvent être remplacés par le préfixe NEAR ou FAR. Les préfixes NEAR et FAR sont utilisés pour désigner l'emplacement d'un appel ou d'un saut. Par exemple :

Le préfixe NEAR peut être abrégé en NE mais le préfixe FAR ne peut pas être abrégé.

DEBUG ne peut pas dire si certains opérandes font référence à un emplacement de mémoire de mots ou à un emplacement de mémoire d'octets. Par conséquent, le type de données doit être explicitement indiqué avec le préfixe "WORD PTR" ou "BYTE PTR". DEBUG acceptera également les abréviations "WO" et "BY". Par exemple :

De plus, DEBUG ne peut pas dire si un opérande fait référence à un emplacement mémoire ou à un opérande immédiat. DEBUG utilise la convention courante selon laquelle les opérandes entre crochets font référence à la mémoire. Par exemple :

Deux pseudo-opérations populaires ont également été incluses. L'opcode DB assemblera les valeurs d'octet directement dans la mémoire. L'opcode DW assemblera les valeurs des mots directement dans la mémoire. Par exemple :

Toutes les formes de commandes indirectes de registre sont prises en charge. Par exemple :

Tous les synonymes d'opcode sont pris en charge. Par exemple :

Pour les opcodes 8087, le préfixe WAIT ou FWAIT doit être explicitement spécifié. Par exemple :

Compare

Syntaxe

Description

Faites correspondre la portion de mémoire spécifiée par plage à une portion de même taille commençant à address.

Commentaires

Si les deux zones de mémoire sont identiques, il n'y a pas d'affichage et DEBUG revient avec le prompt système MS-DOS. S'il y a des différences, elles sont affichées comme suit :

Les fonctions suivantes ont le même effet :

ou

Chaque fonction compare le bloc de mémoire de 100 à 1FFH avec le bloc de mémoire de 300 à 3FFH.

Dump

Syntaxe

Description

À partir de l'address spécifiée, affiche le contenu de la mémoire d'une seule adresse, d'une intervalle d'adresses ou du nombre de lignes spécifiées par valeur.

Commentaires

Si une seule adresse est spécifiée, le contenu de 128 octets est affiché. Si une plage d'adresses est spécifiée, le contenu de l'intervalle est affiché. Si la fonction D est entrée sans paramètres, le résultat est le même que si vous avez spécifié une seule adresse, sauf que l'affichage commence à l'emplacement actuel dans le DS (segment de données).

Le vidage est affiché en trois parties : l'adresse (l'adresse du registre de segment et le décalage), un vidage hexadécimal (chaque octet est affiché en valeur hexadécimale) et un vidage ASCII (les octets sont affichés en caractères ASCII). Les caractères non imprimables sont signalés par un point (.) dans la partie ASCII de l'affichage. Chaque ligne d'affichage affiche seize octets avec un trait d'union entre les huitième et neuvième octets.

Chaque ligne affichée commence sur une limite de 16 octets. Si l'adresse initiale n'est pas sur une limite de 16 octets, la première et la dernière ligne peuvent contenir moins d'octets que le reste des lignes affichées (mais ensemble, la première et la dernière ligne incomplète équivalent à une ligne d'affichage complète - 128 octets).

Suppose que la fonction suivante est entrée :

DEBUG affiches :

Si seule la fonction D est entrée, l'affichage est formaté comme décrit ci-dessus. Chaque ligne de l'affichage commence par une adresse ; sur une limite paire de 16 octets. Chaque D suivant (saisi sans paramètre) affiche les octets suivant immédiatement ceux affichés en dernier.

Si vous saisissez la fonction :

l'affichage est formaté comme décrit ci-dessus, mais 20H octets sont affichés.

Si vous saisissez la fonction :

l'affichage est formaté comme décrit ci-dessus, mais tous les octets dans la plage d'adresses de 100H à 115H dans le segment CS sont affichés.

Enter

Syntaxe

Description

Saisissez une adresse, affichez son contenu et attendez la saisie.

Commentaires

Si la list facultative de valeurs hexadécimales est saisie, le remplacement des valeurs d'octets se produit automatiquement. (Si une erreur se produit, aucune valeur d'octet n'est modifiée.)

Si l'adresse est entrée sans la liste facultative, DEBUG affiche l'adresse et son contenu, puis répète l'adresse sur la ligne suivante et attend votre entrée.

Pendant que DEBUG attend votre entrée, vous pouvez effectuer l'une des actions suivantes :

1. Remplacez une valeur d'octet par une valeur que vous saisissez. Saisissez simplement la valeur après la valeur actuelle.

Si la valeur que vous entrez n'est pas une valeur hexadécimale valide ou si plus de deux chiffres sont saisis, le caractère non valide ou supplémentaire n'est pas renvoyé en écho.

2. Appuyez sur la BARRE D'ESPACEMENT pour passer à l'octet suivant.

Pour modifier la valeur, entrez simplement la nouvelle valeur (comme décrit à l'étape 1). Si vous entrez des espaces pour avancer au-delà d'une limite de huit octets, DEBUG démarre une nouvelle ligne d'affichage avec l'adresse affichée au début.

3. Tapez un trait d'union (-) pour revenir à l'octet précédent.

Si vous décidez de modifier un octet qui précède la position actuelle, la saisie du trait d'union ramène la position actuelle à l'octet précédent. Lorsque le trait d'union est tapé, une nouvelle ligne commence avec l'adresse et sa valeur d'octet affichées.

4. Appuyez sur la touche RETURN pour terminer la fonction Enter. La touche RETURN peut être enfoncée à n'importe quelle position d'octet.

Supposons que la fonction suivante est entrée :

DEBUG affiche :

Pour modifier cette valeur d'octet à 41, entrez "41" comme indiqué :

Pour parcourir les octets suivants, appuyez sur la BARRE D'ESPACEMENT pour voir :

Pour changer BC en 42, entrez "42" comme indiqué :

Maintenant, réalisant que 10 devrait être 6F, entrez le trait d'union autant de fois que nécessaire pour revenir à l'octet 0101 (valeur 10). Remplacez ensuite 10 par 6F.

Appuyer sur la touche RETURN met fin à la fonction Entrée et renvoie le prompt DEBUG (-) avec trait d'union.

Fill

Syntaxe

Description

Remplissez les adresses de la plage avec les valeurs de la list.

Commentaires

Si l'intervalle contient plus d'octets que le nombre de valeurs dans la list, la list sera utilisée à plusieurs reprises jusqu'à ce que tous les octets de la range soient remplis. Si la list contient plus de valeurs que le nombre d'octets dans la range, les valeurs supplémentaires dans la list seront ignorées. Si l'une des mémoires de la plage n'est pas valide (mauvaise ou inexistante), l'erreur sera propagée à tous les emplacements suivants.

La fonction F n'abandonne pas comme le fait la fonction E. Oui, la fonction F est une version multiple de la fonction E en ce sens qu'elle vous permet de modifier plus d'une adresse à la fois.

Supposons que la fonction suivante est entrée :

DEBUG remplit les emplacements mémoire 04BA:100 à 04BA:1FF avec l'octet spécifié. Les cinq valeurs sont répétées jusqu'à ce que tous les 100H octets soient remplis.

Go

Syntaxe

Description

Si la fonction GO est entrée seule, le programme s'exécute comme s'il avait été exécuté en dehors de DEBUG.

Commentaires

Si la fonction Go est entrée seulement, le programme s'exécute comme si le programme avait été exécuté en dehors de DEBUG.

Si =address1 est défini, l'exécution commence à l'adresse spécifiée. Si la désignation de segment est omise de =address1, seul le pointeur d'instruction est défini. Si la désignation de segment est omise from=address1, seul le pointeur d'instruction est défini. Si la désignation de segment est incluse dans =address1, le segment CS et le pointeur d'instruction sont définis. Le signe égal (=) est requis, afin que DEBUG puisse distinguer le début =address1 des adresses de point d'arrêt (address2...).

Si vous avez défini d'autres adresses facultatives, l'exécution s'arrêtera à la première address rencontrée (quelle que soit la position de l'adresse dans la liste des adresses pour arrêter l'exécution) quelle que soit la branche prise par le programme. Lorsque l'exécution du programme atteint un point d'arrêt, les registres, les drapeaux et l'instruction décodée sont affichés pour la prochaine instruction à exécuter. (Le résultat est le même que si vous aviez saisi la fonction Register pour l'adresse du point d'arrêt.)

Jusqu'à 10 points d'arrêt peuvent être définis. Les points d'arrêt ne peuvent être définis qu'aux adresses contenant le premier octet d'un opcode 8088. Si plus de 10 points d'arrêt sont définis, DEBUG renvoie le message d'erreur BP.

Votre pointeur de pile doit être valide et avoir six octets disponibles pour cette fonction. La fonction G utilise une instruction IRET (Retour d'interruption) pour provoquer un saut vers le programme en cours de test. Votre pointeur de pile est défini et vos drapeaux, registre de segment de code et pointeur d'instruction sont poussés sur votre pile. (Ainsi, si votre pile n'est pas valide ou est trop petite, le système d'exploitation peut planter.)

Un code d'interruption (0CCH) est placé à l'adresse ou aux adresses de point d'arrêt spécifiées. Lorsqu'une instruction avec le code de point d'arrêt est rencontrée, toutes les adresses de point d'arrêt sont restaurées à leurs instructions d'origine. Si l'exécution n'est pas arrêtée à l'un des points d'arrêt, les codes d'interruption sont remplacés par les instructions d'origine.

Par exemple, supposons que la fonction suivante est saisie :

Le programme actuellement en mémoire s'exécute jusqu'à l'adresse 7550 dans le segment CS. Ensuite, DEBUG affiche les registres et les drapeaux, après quoi la fonction Go est terminée.

Après avoir rencontré un point d'arrêt, si vous entrez à nouveau dans la fonction Go, le programme s'exécute comme si vous aviez entré le nom du fichier au niveau de la commande MS-DOS. La seule différence est que l'exécution du programme commence à l'instruction à l'adresse du point d'arrêt plutôt qu'à l'adresse de début habituelle.

Hex

Syntaxe

Description

Effectuez une arithmétique hexadécimale sur les deux paramètres.

Commentaires

Tout d'abord, DEBUG ajoute les deux paramètres, puis soustrait le deuxième paramètre du premier. Les résultats de l'arithmétique sont affichés sur une ligne ; d'abord la somme, puis la différence.

Par exemple, supposons que la fonction suivante est saisie :

DEBUG effectue les calculs puis renvoie les résultats :

Input

Syntaxe

Description

Entrez et affichez un octet du port spécifié par valeur.

Commentaires

Une adresse de port d'entrée/sortie 80x86 en 16 bits est autorisée.

Supposons que la fonction suivante soit entrée :

Supposons également que l'octet au port est 42H. DEBUG saisit l'octet et affiche la valeur :

Load

Syntaxe

Description

Charger un fichier en mémoire.

Commentaires

Définit BX:CX sur le nombre d'octets lus. Le fichier doit avoir été nommé soit avec la commande d'invocation DEBUG, soit avec la fonction N. L'invocation et les fonctions N formatent correctement un nom de fichier dans le format normal d'un bloc de contrôle de fichier sur DS:5C.

Si la fonction L est donnée sans aucun paramètre, DEBUG charge le fichier en mémoire (sauf s'il s'agit d'un fichier .EXE) en commençant à l'adresse CS:100 et définit BX:CX sur le nombre d'octets chargés.

Si la fonction L est donnée avec un paramètre d'adresse, le chargement commence à l'adresse (address) mémoire spécifiée.

Si L est entré avec tous les paramètres, des secteurs de disque absolus (plutôt qu'un fichier) sont chargés. Les enregistrements sont extraits du record spécifié, (où les noms de l'unité de disque sont représentés par des nombres - 0=A:, 1=B:, 2=C:, 3=D:, 4=E:, 5=F:, 6=G:, et 7=H:). DEBUG commence le chargement avec le premier record spécifié ; et continue jusqu'à ce que le nombre de secteurs spécifié dans le second record ait été chargé.

Supposons que les entrées suivantes sont effectuées (la première au prompt du système et la seconde au prompt DEBUG) :

Maintenant, pour charger FILE.COM, entrez :

DEBUG charge le fichier et renvoie le prompt DEBUG. Si vous souhaitez charger uniquement des parties d'un fichier ou certains enregistrements d'un disque, saisissez :

DEBUG charge ensuite 109 enregistrements (hexadécimaux 6D) de l'unité de disque C (2), en commençant par l'enregistrement logique numéro 15, dans la mémoire en commençant à l'adresse 04BA:0100. Lorsque les enregistrements ont été chargés, DEBUG renvoie simplement le prompt (-).

Si le fichier a une extension .EXE, il est déplacé vers le chargement address spécifié dans l'entête du fichier .EXE ; le paramètre d'adresse est toujours ignoré pour les fichiers .EXE. Notez que l'entête lui-même est supprimé du fichier .EXE avant qu'il ne soit chargé en mémoire. Ainsi, la taille d'un fichier .EXE sur disque sera différente de sa taille en mémoire.

Move

Syntaxe

Description

Déplacez le bloc de mémoire spécifié par range vers l'emplacement commençant à l'adresse spécifiée address.

Commentaires

Les déplacements se chevauchant (déplacements où une partie du bloc chevauche certaines des adresses actuelles) sont toujours effectués sans perte de données.

Les adresses susceptibles d'être écrasées sont déplacées en premier. La séquence pour les déplacements des adresses supérieures aux adresses inférieures consiste à déplacer les données en commençant à l'adresse la plus basse du bloc et à progresser vers la plus élevée. La séquence pour les déplacements des adresses inférieures aux adresses supérieures consiste à déplacer les données en commençant par le bloc le plus élevé. La séquence pour les déplacements des adresses inférieures aux adresses supérieures consiste à déplacer les données en commençant à l'adresse la plus élevée du bloc et à progresser vers la plus basse.

Remarque : si les adresses du bloc en cours de déplacement ne contiennent pas de nouvelles données écrites, les données s'y trouvant avant le déplacement resteront. La fonction M copie réellement les données d'une zone dans une autre, dans l'ordre décrit, et écrase les nouvelles adresses. C'est pourquoi la séquence du déménagement est importante.

Par exemple, si vous saisissez :

DEBUG déplace d'abord l'adresse CS:110 vers l'adresse CS:510, puis CS:10F vers CF:50F, et ainsi de suite jusqu'à ce que CS:100 soit déplacé vers CS:500. Vous devez entrer la fonction D, en utilisant l'address entrée pour la fonction M, pour revoir les résultats du déplacement.

Name

Syntaxe

Description

Définissez les noms de fichiers.

Commentaires

La fonction de nom effectue deux actions distinctes, toutes deux liées aux noms de fichiers. Tout d'abord, Name est utilisé pour attribuer un nom de fichier, avec un nom de l'unité de disque et/ou un nom de chemin facultatif, pour une fonction Load ou Write ultérieure. Ainsi, si vous appelez DEBUG sans nommer aucun fichier à déboguer, la fonction «Nfilespec» doit être entrée avant qu'un fichier puisse être chargé. Deuxièmement, Name est utilisé pour attribuer des paramètres de nom de fichier au fichier en cours de débogage. Dans ce cas, Name accepte une liste de paramètres associés au fichier en cours de débogage. Dans ce cas, Name accepte une liste de paramètres utilisés par le fichier en cours de débogage.

Ces fonctions se chevauchent. Considérez l'ensemble suivant de fonctions DEBUG :

En raison de l'effet à deux volets de la fonction Name, ce qui suit se produit :

1. (N)ame affecte le nom FILE1.EXE au fichier à utiliser ultérieurement dans les fonctions Load et Write.
2. (N)ame attribue également le nom de fichier FILE.EXE au premier paramètre de nom de fichier à utiliser par tout programme débogué ultérieurement.
3. (L)oad charge FILE.EXE en mémoire.
4. (G)o provoque l'exécution de FILE.EXE avec FILE.EXE comme si le fichier FILE.EXE avait été tapé au niveau de la commande.)

Une chaîne de fonctions plus utile pourrait ressembler à ceci :

Dans cet exemple, Name définit FILE1.EXE comme nom de fichier pour la fonction Load suivante. La fonction Load charge FILE1.EXE en mémoire, puis la fonction Name est à nouveau utilisée - cette fois pour vérifier les paramètres à utiliser par FILE1.EXE. Enfin, lorsque la fonction Go est exécutée, FILE1.EXE est exécuté comme si FILE1 FILE2.DAT FILE3.DAT avait été tapé au niveau de la commande MS-DOS.

Remarque : Si une fonction d'écriture était exécutée à ce stade, FILE1.EXE - le fichier en cours de débogage - serait enregistré sous le nom FILE2.DAT! Pour éviter de tels résultats indésirables, vous devez toujours exécuter une fonction Name avant une fonction Load avant une fonction Load ou une fonction Write.

Il existe quatre régions de mémoire distinctes pouvant être affectées par la fonction Name :

Un bloc de contrôle de fichier (FCB) pour le premier paramètre de nom de fichier donné à la fonction Name est configuré sur CS:5C. Si un deuxième paramètre de nom de fichier est donné, un FCB est configuré pour celui-ci en commençant à CS:6C. Le nombre de caractères saisis dans la fonction Name (à l'exclusion du premier caractère, "N") est donné à l'emplacement CS:80. Le flux de données réel de caractères donné par la fonction Name (encore une fois, à l'exclusion de la lettre "N") commence à CS:81. Notez que ce flux de caractères peut contenir des commutateurs et des délimiteurs étant valides dans n'importe quelle commande tapée au prompt système MS-DOS.

Une utilisation typique de la fonction Name serait :

Dans ce cas, la fonction Go exécute le fichier en mémoire comme si la ligne de commande suivante avait été saisie au prompt système MS-DOS :

Les tests et le débogage reflètent donc un environnement d'exécution normal pour PROG.COM.

Output

Syntaxe

Description

Envoie l'octet spécifié au port de sortie spécifié par valeur.

Commentaires

Une adresse de port d'entrée/sortie 80x86 en 16 bits est autorisée.

Si vous saisissez :

et appuyez sur RETURN, DEBUG envoie la valeur d'octet 4F au port de sortie 2F8.

Quit

Syntaxe

Description

Arrêtez le débogueur.

Commentaires

La fonction Q ne prend aucun paramètre et quitte DEBUG sans enregistrer le fichier en cours d'utilisation. Vous revenez au niveau de commande MS-DOS.

Pour terminer la session de débogage, entrez :

et appuyez sur RETURN. DEBUG est terminé et le contrôle revient au niveau de commande MS-DOS.

Register

Syntaxe

Description

Afficher le contenu d'un ou plusieurs registres du microprocesseur.

Commentaires

Si aucun register n'est entré, la fonction R vide la zone de sauvegarde du registre et affiche le contenu de tous les registres et drapeaux.

Si un nom de registre est saisi, la valeur 16 bits de ce registre s'affiche en hexadécimal, puis deux-points s'affichent en guise de prompt. Ensuite, entrez une value pour modifier le registre ou appuyez simplement sur la touche RETURN si aucune modification n'est souhaitée.

Les seuls registers valides sont :

• AX
• BX
• CX
• DX
• SP
• BP
• SI
• DI
• DS
• ES
• SS
• CS
• IP (IP et PC font référence au pointeur d'instruction)
• PC
• F

Toute autre entrée pour register entraînera le message d'erreur BR.

Voici les codes de registre des drapeaux :

Si F est entré comme register, DEBUG affiche une liste de codes alphabétiques à deux caractères. Pour modifier un drapeau, entrez le code alternatif à deux lettres. Les drapeaux sont soit fixé (valeur 1), soit effacé (valeur 0).

Les drapeaux, avec leurs codes de fixé et d'effacé, sont répertoriés dans le tableau précédent.

Chaque fois que vous entrez dans la fonction RF, les drapeaux sont affichés dans l'ordre indiqué ci-dessus dans une ligne au début d'une ligne. À la fin de la liste des drapeaux, DEBUG affiche un trait d'union statique (-). Vous pouvez entrer de nouvelles valeurs de drapeau sous forme de paires alphabétiques. Les nouvelles valeurs de drapeau peuvent être saisies dans n'importe quel ordre. Vous n'êtes pas obligé de laisser des espaces entre les entrées de drapeau. Pour quitter la fonction R, appuyez sur la touche RETURN. Le prompt DEBUG (-) s'affiche. Les drapeaux pour lesquels de nouvelles valeurs n'ont pas été saisies restent inchangés.

Si plusieurs valeurs sont saisies pour un drapeau, DEBUG renvoie un message d'erreur DF. Si vous entrez un code de drapeau autre que ceux indiqués ci-dessus, DEBUG renvoie un message d'erreur BF. Dans les deux cas, les drapeaux jusqu'à l'erreur dans la liste sont modifiés ; les drapeaux à et après l'erreur ne le sont pas.

Au démarrage, les registres de segment sont définis au bas de la mémoire libre, le pointeur d'instruction est défini sur 0100H, le pointeur de pile est défini sur 005AH, tous les drapeaux sont effacés et les registres restants sont définis sur zéro.

Quand vous entrez :

et appuyez sur RETURN, DEBUG affiche tous les registres, drapeaux et l'instruction décodée pour l'emplacement actuel. Si l'emplacement est CS:11A, alors DEBUG peut afficher :

Si vous entrez :

et appuyez sur la touche RETURN, DEBUG affiche les drapeaux :

Maintenant, entrez n'importe quelle désignation de drapeau valide, dans n'importe quel ordre, avec ou sans espaces. Par exemple, entrez :

et appuyez sur la touche RETURN. DEBUG ne répond qu'avec le prompt DEBUG. Pour voir les modifications, vous pouvez entrer la fonction R ou RF. Par exemple, entrez :

et appuyez sur la touche RETURN. L'écran affiche :

Maintenant, vous pouvez appuyer sur RETURN pour laisser les drapeaux de cette façon ou entrer différentes valeurs de drapeaux.

Search

Syntaxe

Description

Recherche le range spécifiée pour la list d'octets spécifiés et affiche l'adresse de début de la chaîne de caractères.

Commentaires

La list peut contenir un ou plusieurs octets, chacun séparé par un espace ou une virgule. Si la liste contient plusieurs octets, seule la première adresse de chaque chaîne d'octets trouvée est renvoyée.

Si la list ne contient qu'un seul octet, toutes les adresses de l'octet de l'intervalle sont affichées.

Quand vous entrez :

DEBUG peut renvoyer la réponse :

Trace

Syntaxe

Description

Exécutez une instruction et affichez le contenu de tous les registres, drapeaux et l'instruction décodée.

Commentaires

Si =address facultative est entrée, le traçage se produit à =address spécifiée.

Si =address inclut la désignation du segment, alors CS et le pointeur d'instruction sont spécifiés.

Si =address omet la désignation du segment, seul le pointeur d'instruction est spécifié.

La value facultative entraîne l'exécution de DEBUG et le suivi du nombre d'étapes spécifié par value. La fonction T utilise le mode trace matériel du microprocesseur 8086 ou 8088. Par conséquent, l'utilisateur peut également suivre les instructions entreposées dans la ROM.

Si vous saisissez :

et appuyez sur la touche RETURN, DEBUG renvoie un affichage des registres, des drapeaux et de l'instruction décodée pour cette instruction. Supposons que la position actuelle est 04BA:011A; alors DEBUG peut renvoyer l'affichage :

Maintenant entrée :

et appuyez sur RETURN. DEBUG exécute seize instructions à partir de 011A dans le segment en cours, puis affiche tous les registres et drapeaux pour chaque instruction au fur et à mesure de son exécution. L'affichage défile jusqu'à ce que la dernière instruction soit exécutée. Ensuite, l'affichage s'arrête et vous pouvez voir les valeurs de registre et de drapeau pour les dernières instructions exécutées.

N'oubliez pas que CTRL+NUMLOCK suspend l'affichage à tout moment, afin que vous puissiez étudier les registres et les drapeaux pour n'importe quelle instruction.

Unassemble

Syntaxe

Description

Désassemblez les octets et affichez les instructions source qui leur correspondent, un long avec les adresses et les valeurs d'octets.

Commentaires

L'affichage du code désassemblé ressemble à une liste pour un fichier assemblé.

Si vous entrez la fonction U sans paramètres, 20 octets hexadécimaux sont désassemblés pour afficher les instructions correspondantes.

Si vous entrez la fonction U avec le paramètre range, alors DEBUG désassemble tous les octets de l'intervalle.

S'il y a moins d'octets du range que le nombre affiché lorsque U est saisi sans paramètres, seuls les octets de l'intervalle sont affichés.

Si vous entrez la fonction U avec le paramètre address, alors DEBUG désassemble le nombre d'octets par défaut, en commençant à address spécifiée.

Si vous entrez la fonction U avec les paramètres address L value, alors DEBUG désassemble tous les octets en commençant à l'adresse spécifiée pour le nombre d'octets spécifié par value. La saisie de la fonction U avec les paramètres address L value annule la limite par défaut (20H octets).

Quand vous entrez :

et appuyez sur RETURN, DEBUG désassemble 16 octets à partir de l'adresse 04BA:0100 :

Si vous entrez :

et appuyez sur RETURN, DEBUG désassemble uniquement les octets entre l'adresse 04BA:0100 et l'adresse 04BA:0108. L'affichage indique :

Si vous entrez :

et appuyez sur RETURN, DEBUG désassemble et affiche tous les octets entre l'adresse 100 et l'adresse 120.

Si, toutefois, vous saisissez la fonction :

et appuyez sur la touche RETURN, tous les octets commençant à l'adresse CS:100, pour les vingts octets spécifiés, sont désassemblés et affichés. Notez que vous pouvez spécifier le registre de segment alphabétique à la place de l'adresse de segment à quatre chiffres sans affecter les résultats.

Si les octets de certaines adresses sont modifiés, le désassembleur modifie les instructions d'instruction. La fonction U peut être saisie pour les emplacements modifiés, les nouvelles instructions affichées et le code désassemblé utilisé pour modifier le fichier source.

Write

Syntaxe

Description

Écrivez le fichier en cours de débogage dans un fichier disque.

Commentaires

Si seul le W apparaît, BX:CX doit déjà être réglé sur le nombre d'octets à écrire ; le fichier est écrit à partir de CS:100.

Si la fonction W est donnée avec juste une adresse, alors le fichier est écrit en commençant à cette adresse.

Si une fonction G ou T a été utilisée, BX:CX doit être réinitialisé avant d'utiliser la fonction Write sans paramètres.

Remarque : Si un fichier est chargé et modifié, le nom, la longueur et l'adresse de départ sont correctement définis pour enregistrer le fichier modifié tant que la longueur n'a pas changé.

Le fichier doit avoir été nommé soit avec la commande d'appel DEBUG soit avec la fonction N (voir la description de la fonction Name). L'invocation et la fonction N formatent correctement un nom de fichier dans le format normal d'un bloc de contrôle de fichier sur CS:5C.

Si la fonction W est donnée sans paramètre, BX:CX doit être défini sur le nombre d'octets à écrire. Ensuite, DEBUG écrit le nombre d'octets BX:CX dans le fichier disque. Le fichier débogué est écrit sur le disque à partir duquel il a été chargé. Cela signifie que le fichier débogué est écrit sur le fichier d'origine ayant été chargé en mémoire.

Si la fonction W est donnée avec des paramètres, l'écriture commence à partir de l'adresse mémoire spécifiée ; et le fichier est écrit sur le drive spécifié, (où les noms de l'unité de disque sont représentés par des nombres - 0=A:, 1=B:, 2=C:, 3=D:, 4=E:, 5=F:, 6=G:, et 7=H:). DEBUG écrit le fichier en commençant par le numéro d'enregistrement logique spécifié par le premier record ; et l'écriture continue jusqu'à ce que le nombre de secteurs spécifié dans le second record ait été écrit.

Attention : L'écriture dans des secteurs absolus est extrêmement dangereuse car le processus contourne le gestionnaire de fichiers.

Quand vous entrez :

et appuyez sur la touche RETURN, DEBUG écrit le fichier sur le disque, puis affiche l'invite DEBUG :

dans l'exemple :

DEBUG écrit le contenu de la mémoire, en commençant par l'adresse CS:100 sur le disque de l'unité de disque B:. Les données écrites commencent dans l'enregistrement logique de disque numéro 37H et se composent d'enregistrements 2BH. Lorsque l'écriture est terminée, DEBUG affiche le prompt :

Messages d'erreur

Au cours de la session DEBUG, vous pouvez recevoir l'un des messages d'erreur suivants. Chaque erreur termine la fonction DEBUG à laquelle elle est associée mais ne termine pas la commande DEBUG elle-même ou ne rend pas le contrôle à MS-DOS.

Code source

Voici des exemples de code source de DEBUG :