Vous êtes sur la page 1sur 9

Systèmes à Microprocesseurs

(6GEN645)

Professeur : Rachid Beguenane


Assistant : Eric Larouche

TP N° 1
PROGRMMATION AVEC DEBUG

I. INTRODUCTION

DEBUG, un programme inclus dans le système d’exploitation DOS de Microsoft et IBM PC,
permet de suivre l’exécution d’un programme écrit en langage assembleur, en bloc ou une
instruction à la fois. Ce qui est important pour trouver ce qui ne marche pas dans un programme.

Plus particulièrement, DEBUG permet d’examiner et de changer le contenu de la mémoire, entrer


un programme et l’exécuter.

L’objectif de ce TP est de bien comprendre la programmation avec l’utilitaire DEBUG, plus


particulièrement comment:

- entrer et sortir de DEBUG,


- entrer, exécuter et déboguer des programmes,
- examiner et changer le contenu des registres et de la mémoire,
- manipuler les commandes les plus importantes de DEBUG.

Plusieurs exemples de programmation en langage assembleur utilisant l’utilitaire DEBUG seront


vus. Pour commencer, voici un sommaire rapide des commandes DEBUG qui seront utilisées
tout au long de cette séance.

1
Fonction Commande et < options >
Assemble A < adresse du début >
Compare C < adresse du début > < adresse de la fin > <adresse de la comparaison>
C < adresse du début > < L nombre d’octets > <adresse de la comparaison>
Dump D < adresse du début > < adresse de la fin >
D < adresse du début > < L nombre d’octets >
Enter E < adresse du début > < liste des données >
E < adresse du début >
Fill F < adresse du début > < adresse de la fin > < données >
F < adresse du début > < L nombre d’octets > < données >
Go G < = adresse du début > < adresse(s) de la fin>
Hexarithmetic H < nombre 1 > < nombre 2 >
Move M < adresse du début > < adresse de la fin > < adresse de la destination >
M < adresse du début > <L nombre d’octets > < adresse de la destination >
Register R <nom de registre>
Search S < adresse du début > < adresse de la fin > < données >
S < adresse du début > < L nombre d’octets > < données >
Trace T< = adresse du début > < nombre d’instructions>
Proceed P< = adresse du début > < nombre d’instructions>
Unassemble U < adresse du début > < adresse de la fin >
U < adresse du début > < L nombre d’octets >

II. OBJECTIFS

• Se familiariser avec les commandes de DEBUG.


• Ecrire des exemples pour mieux appréhender l’utilité de DEBUG.
• Voir la différence entre coder avec DEBUG et avec un programme assembleur classique.

III. MATÉRIEL UTILISÉ

• Micro-ordinateur IBM et compatible muni d’un µP80x86.


• Programme DEBUG

IV. ACTIVITÉS

Activité 1
Entrée et Sortie de DEBUG

A partir de l’invite du DOS, pour entrer dans DEBUG taper ‘debug’ et ‘entrer’. L’invite des
commandes DEBUG est un petit trait. Pour sortir du DEBUG vers DOS, taper ‘q’.

2
A noter que DEBUG accepte aussi bien les lettres majuscules que minuscules, i.e. ‘q’ et ‘Q’ sont
la même commande.

Activité 2
Examiner et changer les contenus de registres.

A l’invite des commandes DEBUG, la commande ‘R’ permet d’afficher le contenu de tous les
registres du µP80x86.
La première ligne affiche le contenu des registres généraux : AX, BX, CX, DX, SP, BP, SI et DI.

La deuxième ligne affiche le contenu des registres : segments (CS, DS, SS, ES), pointeur
programme (IP) et l’état de 8 bits du registre flags (OF, DF, IF, SF, ZF, AF, PF, et CF).

La troisième ligne affiche l’adresse logique du segment de code (CS:IP), la mnémonique de


l’instruction du programme pointée par CS:IP et la case mémoire à laquelle l’instruction courante
réfère (s’il y a lieu, par exemple DS :0005=FA34)

A l’invite du DEBUG :
- taper ‘R’ et observer le résultat.
- Avec ‘R CX’, seul le contenu de CX est affiché et DEBUG donne la possibilité de le
changer. Faire changer le contenu de AX, successivement avec ces valeurs 9AC2, AC2,
C2, 2, 5ABC4 et taper à chaque fois ‘R’. Observer les résultats et commenter.
- Taper successivement ‘R’ BX, ‘R’ BH, ‘R’ BL. Observer et commenter les résultats.

Note Annexer la lettre H pour les nombres hexadécimaux n’est pas nécessaire avec DEBUG
contrairement aux utilitaires MASM/TASM ou les nombres par défaut sont décimaux.

Activité 3
Coder et Exécuter les programmes avec DEBUG

Pour coder et exécuter les programmes avec DEBUG, quatre commandes sont essentiellement
utilisées: A, U, G et T. Ces commandes et les options associées, décrites au tableau de la page 2,
sont définies comme suit :

• A, commande d’assemblage, est utilisée pour entrer dans la mémoire les instructions en
langage assembleur, l’adresse du début (offset IP) est indiquée en option.
• U, commande de désassemblage, permet d’afficher aussi bien le code machine que son
équivalent en mnémoniques d’une partie ou tout le programme se trouvant dans la
mémoire.
• G, commande d’exécution, instruit DEBUG d’exécuter une partie ou tout le programme
se trouvant dans la mémoire.
• T, commande trace, permet de suivre la trace de l’exécution du programme, une ou un
bloc d’instruction à la fois. C’est une commande puissante car elle permet de suivre la
trace des registres et des données à chaque instruction. Ce qui est très utile pour déboguer
un problème complexe.

3
- A l‘invite du DEBUG, taper ‘A 100’, et après chaque entrée du clavier, les instructions
suivantes, une ligne à la fois (Note : quand la commande ‘A’ est utilisée, ne pas prendre
des adresses offset <100):

MOV DH, FF3


MOV BX, 9ABCD4
MOV CS, 1200
MOV SI, CL
MOV AX, DL
MOV CH, DX
MOV DX, [AX]

Expliquer la raison des messages d’erreurs affichés.

- A l‘invite du DEBUG, taper ‘A’ 100, et après chaque entrée du clavier, les instructions
suivante (une ligne à la fois):

MOV AX, 1
MOV DI, 202
MOV BX, [200]
MOV CX, [DI]
ADD AX, BX
ADD AX, CX
INT 3 (point d’arrêt)

Observer les différents modes d’adressage utilisés et comment [CS:IP] s’incrémente.


Déduire les adresses physiques correspondes aux instructions précédentes?

Taper successivement ‘U 100 10D’, ‘R’ et ‘G’, ‘G =100’, ‘G =100 10A’. A chaque
étape, commenter vos observations.
Noter plus particulièrement l’importance de la commande ‘U’ ou les codes machine des
instructions assembleurs sont également affichés.
Est-ce qu’il y a une différence entre ‘G’, ‘G=CS:100’ et ‘G=100’ ?

Taper ‘R IP’ pour avoir la valeur actuelle de IP. Changer cette valeur à 100 pour pointer
au début du programme. Ensuite taper ‘G 10A’. Quel est le résultat?
Quitter DEBUG avec ‘Q’.

- A l’invite du DEBUG, taper à nouveau ‘A’ 100, et après chaque entrée du clavier, retaper
les instructions précédentes de la même façon. Utiliser la commande ‘T’ pour exécuter le
programme une instruction à la fois avec ‘T’ ou X instructions à la fois avec ‘T=100 X’,
ou X est le nombre désiré d’instructions pour suivre la trace de leur exécution à partir de
IP=100.

En tapant successivement sept fois ‘T’ et après chaque entrée du clavier, vérifier
l’évolution des différentes registres et l’exactitude des résultats d’addition.

4
Activité 4
Manipulation des données avec DEBUG

Pour manipuler des données avec DEBUG, trois commandes sont essentiellement utilisées :
F, D, et E. Ces commandes et les options associées, décrites au tableau de la page 2, sont
définies comme suit :

• F, commande de remplissage, est utilisée pour charger un bloc de mémoire avec une
donnée particulière.
• D, commande d’affichage des données, permet d’afficher le contenu de la mémoire à
l’écran.
• E, commande d’entrée, permet d’examiner et de changer le contenu de la mémoire.

- A l’invite du DEBUG, taper une à la fois les commandes ‘F 100 11F CD’ et ‘F 120 13F
FB’. Ensuite taper ‘D 100 13F’. Décrire ce qui est observé.
Avec les commandes ‘F’ précédentes, le chargement de la mémoire, par une donnée, se
fait dans le segment de données (DS) par défaut. Taper ‘F CS:100 10F CD’ pour altérer
un contenu de la mémoire dans le segment de code et observer le résultat avec ‘D CS:100
10F’.

- En reprenant le programme précédent (activité 3) , utiliser la commande ‘D CS:100 11F’


pour voir son code machine dans le segment de code de la mémoire.

- Comme application, à l’invite du DEBUG, taper votre nom et prénom en minuscules en


utilisant la commande « E 100 ‘votre nom prénom’ ». Avec ‘D 100 10F’, vérifier le
code ASCII de votre nom et prénom en minuscules.
Cela suppose que votre nom et prénom tiennent sur 16 caractères sinon changer la fin
d’adresse ‘10F’ en plus grand : par exemple ‘115’.

Noter qu’avec ‘D 100 10F’, l’affichage sur écran donne sur la même ligne aussi bien le
code ASCII que les lettres de votre nom et prénom.

- Avec ‘E 100’ le contenu des adresses à partir de d’offset 100 peut être changé un octet à
la fois en tapant sur la barre espace.
Par exemple, après les points qui suivent les octets à changer, remplacer les digits
(chiffres) 6 par les digits 4 de chaque octet. Observer le résultat avec ‘D 100 LF’ et
commenter.
Noter que le fait de taper ‘-‘ après le ‘.’, fait revenir en arrière vers l’octet précédent.

- A l‘invite du DEBUG, taper ‘A’ 100, et après chaque entrée du clavier, les instructions
suivante (une ligne à la fois) :
MOV BL, 0
ADD BL, [0400]
ADD BL, [0401]
ADD BL, [0402]
ADD BL, [0403]

5
ADD BL, [0404]
MOV[0405], BL
INT 3
Rentrer les données à additionner dans les cases mémoires [0400] Æ [0404] en utilisant
‘E DS : 400 2a 2b 2f 2d 2e’. Apres avoir exécuter le programme avec ‘G=100 11A’,
vérifier les contenus de [0400] Æ [0405] et par conséquent le résultat de l’addition, avec
‘D DS:400 L5’.
Activité 5
La convention « Little Endian » et comment le µP80x86 sauvegarde les mots

Effectuer les étapes suivantes pour comprendre la convention « Little Endian » :

• Déplacer un mot d’une location mémoire vers un registre :


- D 500 LF (Vérifier les contenus des 16 premiers octets à partir de CS:500)
- A 100 (Ecrire une instruction a partir de CS:100 …)
- MOV BX, [504] ( … pour déplacer le mot dans les adresses 504 et 505 vers BX)
- INT 3
- T (Vérifier l’exécution et comment le chargement de BX est fait)
• Déplacer un mot d’un registre avers une location mémoire:
- D 300 LF
- A 100 (Ecrire un code de 2 instructions à partir de CS:100 …)
- MOV BX, FA98 ( … pour déplacer le mot FA98h vers BX …)
- MOV [302], BX ( … et ensuite vers les locations mémoire 302 et 303 …)
- INT 3
- G=100 (Vérifier comment le chargement de BX vers la mémoire est fait)

Activité 6
Examiner et changer le registre FLAGS avec DEBUG
Avec la commande ‘R F’ ou même ‘R’ (à la fin de la 3eme ligne), l’état des 8 bits, les
plus importants, du registre flags sont affichés. Ceci permet de suivre leurs évolutions au
fur et à mesure que les instructions s’exécutent en utilisant ‘T’ par exemple.
Il convient de signaler que pour les 8 bits (OF, DF, IF, SF, ZF, AF, PF, et CF) du registre
FLAGS:
- Si tout ces bits sont à l’état RESET (mise à 0), le registre FLAG s’affichera comme :
NV, UP, DI, PL, NZ, NA, PO NC (pour les bits OF, DF, IF, SF, ZF, AF, PF, et CF)
- Si tout ces bits sont a haut (mise à 1), le registre FLAG s’affichera comme :
OV, DN, EI, NG, ZR, AC, PE CY.
A l‘invite du DEBUG, taper ‘A’ 100, et après chaque entrée du clavier, les instructions
suivante (une ligne à la fois) :

6
MOV BX, 0
MOV AX, 0
ADD BL, 4D
ADD BL, C3
ADD AX, 1222
ADD AX, 1333
ADD AX, 1191
MOV CX, AAAA
ADD CX, 5556
INT 3

Utiliser la commande ‘T’ pour suivre l’exécution des instructions, une à la fois, et
observer l’évolution des bits FLAGS tout en commentant.

Activité 7
Divers

- La commande ‘H <nbr 1>, <nbr 2>’ permet d’afficher la somme et la différence entre
deux nombres hexadécimaux. Vérifier avec ‘H BA 21’.

- La commande ‘P’ est utilisée pour exécuter un bloc d’instructions (une boucle, appel de
procédure, un programme d’interruption, ou répéter une chaîne de caractères), comme s’il
s’agit d’une seule (macro-)instruction. Avec le programme de l’activité 6, en tapant ‘P
100 5’, les 5 premières instructions s’exécutent en un seul bloc. Vérifier.

- La commande ‘M’ est utilisée pour copier une plage de données d’une location à une
autre. Exécuter ces commandes, après chaque entrée du clavier, et observer:

F 350 35f AB
D 350 LF
M 350 LF 370
D 350 LF
D 370 LF

- La commande ‘C’ permet de comparer deux espaces mémoires et afficher les octets qui
différent. Avec le programme précédent, appliquer la commande ‘C 350 35E 370’ et
ensuite ‘C 350 35E 36F’. Observer et commenter.

- La commande ‘S’ permet de chercher dans un espace mémoire une donnée particulière.
Avec le programme précédent, appliquer la commande ‘S 340 35E AB’. Observer et
commenter.

- Enfin, cette dernière activité montre comment coder un simple programme avec DEBUG,
l’exécuter et placer des données dans un espace. Elle permet aussi de voir la différence
avec le codage en utilisant un langage assembleur standard comme MASM.

7
A l‘invite du DEBUG, taper ‘A’ 100, et rentrer les instructions et commandes suivantes
(une à la fois):
MOV CX, 05
MOV BX, 200
MOV AL, 0
ADD AL, [BX]
INC BX
DEC CX
JNZ 0108
MOV [205], AL
INT 20 (fin de programme)
E 200 25 12 15 1F 2B
D 200 LF
G=100 111
D 200 LF
Ce programme contient une instruction de saut basée sur l’état de l’indicateur ZF du
registre FLAGS. Il montre quelques différences entre programmer avec DEBUG et avec
un programme assembleur classique comme MASM.
Noter par exemple qu’avec DEBUG l’instruction JNZ n’est pas suivie d’une étiquette
(telle BOUCLE) de l’instruction vers laquelle le saut s’effectue, contrairement à MASM.
L’opérande de l’instruction ‘JNZ 0108’ est directement l’offset de l’adresse vers laquelle
le saut est effectué.
L’autre différence importante avec le programme MASM : le segment de données DS,
dans lequel les données sont entrées, est séparé du segment du code qui contient les
instructions.

Avec DEBUG, ces données sont écrites avec la commande ‘E’ à partir de l’adresse
pointée par BX, alors qu’avec MASM, on aurait écrit ‘MOV BX, OFFSET DATA’ avec
‘DATA DB 25h, 12h 15h 1Fh 2Bh’.

Remarque : le même programme écrit avec MASM serait :


PAGE 60, 132
TITLE prog_add5.asm: Addition de 5 octets (25h, 12h 15h 1Fh 2Bh)
.MODEL SMALL
.STACK
.DATA
COUNT EQU 05
DATA DB 25h, 12h 15h 1Fh 2Bh
SUM DW ?
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
MOV CX, COUNT
MOV BX, OFFSET DATA
MOV AL, 00
BOUCLE: ADD AL, [BX]
INC BX
DEC CX
JNZ BOUCLE
MOV SUM, AX

8
INT 20h
MAIN ENDP
END MAIN