ARCHITECTURE DES ORDINATEURS

ARCHITECTUREDESORDINATEURS

Filière : InfoTronique

Chap. 1 : Introduction à l’architecture des

1 I t d ti

à l’

hit

ordinateurs et à la programmation en assembleur

Dr. Abdelhakim Khouas

Dr Abdelhakim Khouas

Email : [email protected]

Département de Physique

Faculté des Sciences

lté d

S i

Objectif de ce chapitre

Survoler les éléments de base d’un ordinateur et la

programmation en assembleur

(cid:138) Les éléments importants d’un ordinateur et leur utilité

(cid:153) Le microprocesseur

(cid:153) La mémoire

(cid:153) Bus de communication

(cid:153) Périphériques d’entrée/sortie

(cid:138) Programmation en assembleur 8086

(cid:153) Les instructions et leur codage

(cid:153) Jeux d’instructions

Utilisation de DEBUG

(cid:138) Utilisation de DEBUG

(cid:153) Assemblage et désassemblage et exécution d’un programme en

assembleur, scrutation et modification du contenu de la mémoire,

affichage et modification du contenu des registres

Architecture –Chap. 1

Plan

Introduction

1. Architecture des ordinateurs

1. Microprocesseur

2. Mémoire

3. Périphériques d’entrée/sortie

4. Bus de communication

2. Programmation en assembleur

1. Programme assembleur

Programme assembleur

2. Les instructions

4. Codage en mémoire des instructions

Jeux d’instructions

3. Utilisation de DEBUG

1. Lancement de DEBUG

2. Les paramètres des commandes de DEBUG

3. Les commandes de DEBUG

Conclusion

Architecture –Chap. 1

Introduction

Pour mieux comprendre le fonctionnement d un

Pour mieux comprendre le fonctionnement d’un

ordinateur, il est très recommandé de pouvoir

manipuler les différents éléments le composant

(cid:138) Comprendre le fonctionnement et l’exécution des

instructions de bas niveau de la machine

(cid:138) Écrire et exécuter par le microprocesseur des programmes

en langage machine (langage assembleur)

(cid:138) Manipuler la mémoire de l’ordinateur

(cid:138) Manipuler les registres internes

(cid:138) Accéder aux périphériques de l’ordinateur

Architecture –Chap. 1

Introduction

Connecteurs d’entrée/sortie

Slots pour la mémoire

Microprocesseur

Ports IDE

Port AGP

Port PCI

HorlogeHorloge

Contrôleur de la carte ou Chipset

Port ISA

PortISA

Exemple de carte mère pour

ancien processeur d Intel

ancien processeur d’Intel

Architecture –Chap. 1

Introduction

Exemple de carte mère

Architecture –Chap. 1

Introduction

Ventilateur pour

V til t

CPU

Blocs de

refroidissement

pour CPU

Blocs de

refroidissement

pour Chipset

pourChipset

Barrette de

mémoire

Exemple de carte

mère pour PC

Architecture –Chap. 1

Introduction

Architecture –Chap. 1

Exemple de carte

mère pour PC

Introduction

Exemple de carte mère pour PC

l d

Architecture –Chap. 1

Plan

Introduction

)

1. Architecture d’un ordinateur (calculateur)

(

1. Microprocesseur

2. Mémoire

3. Périphériques d’entrée/sortie

4. Bus de communication

2. Programmation en assembleur

1. Programme assembleur

Programme assembleur

2. Les instructions

4. Codage en mémoire des instructions

Jeux d’instructions

3. Utilisation de DEBUG

1. Lancement de DEBUG

2. Les paramètres des commandes de DEBUG

3. Les commandes de DEBUG

Conclusion

Architecture –Chap. 1

1. Architecture d’un ordinateur

Architecture –Chap. 1

Architecture Von Newmann

ArchitectureVonNewmann

: schéma 1

Réf. : Architecture des ordinateurs

Emmanuel Viennet

1. Architecture d’un ordinateur

Architecture –Chap. 1

Architecture Von

Newmann : schéma 2

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

1. Architecture d’un ordinateur

Architecture –Chap. 1

Architecture Von

Newmann : schéma 3

Réf. : Architecture des ordinateurs

Eric Garcia

1. Architecture d’un ordinateur

Architecture –Chap. 1

Architecture Von

Newmann : schéma 4

Réf. : Principe des microprocesseurs

Jaques BAUMANN

1. Architecture d’un ordinateur

Les 4 éléments importants d’un ordinateur sont :

(cid:138) Le microprocesseur (mP) qui est l’unité de calcul et de

traitement d’un ordinateur, il est composé :

(cid:138) La mémoire centrale pour sauvegarder les programmes et

les données

(cid:138) Les d’entrée/sortie pour communiquer avec les

périphériques

f i

(cid:138) Les Bus pour faire circuler les données

Architecture –Chap. 1

1.1 Microprocesseur

Le microprocesseur (μP) qui

est l’unité de calcul et de

traitement d’un ordinateur

t d’

est composé de :

(cid:138) Unité arithmétique et

logique UAL (ALU) qui

effectue les opérations

(cid:138) Registres pour stocker les

données

(cid:138) Unité de contrôle qui

coordonne les opérations

Architecture –Chap. 1

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

1.1 Microprocesseur : UAL

L’unité arithmétique et logique est l’unité de traitement

d’un ordinateur, elle peut effectuer :

d’

(cid:138) Des opérations arithmétiques

(cid:138) Des opérations logiques

(cid:138) Des opérations de décalage et de rotation

(cid:138) Des opérations de comparaison

(cid:138) Des opérations de sauts et de branchement

Architecture –Chap. 1

1.1 Microprocesseur : UAL

À chaque opération particulière de l UAL correspond

À chaque opération particulière de l’UAL correspond

une instruction bien définie dans le langage

machine (langage assembleur de la machine)

Exemple : 8086

(cid:138) L’instruction : ADD AX,BX permet de faire l’addition des

contenus des registres AX et BX et sauvegarde le résultat

dans le registre AX.

(cid:138) L instruction : AND CX,DX permet de faire un ET logique

(cid:138) L’instruction : AND CX DX permet de faire un ET logique

des contenu des registres CX et DX et sauvegarde le

résultat dans le registre CX

Architecture –Chap. 1

1.1 Microprocesseur : UAL

L ensemble de toutes les instructions d une machine

L’ensemble de toutes les instructions d’une machine

constitue le jeu d’instructions de l’ordinateur (voir

annexe B : aide mémoire jeu d instructions du 8086)

annexe B : aide mémoire jeu d’instructions du 8086)

Pour exécuter un programme sur une machine donnée, il

faut l’écrire avec seulement le jeu d’instructions de la

machine en question

Sous le programme DEBUG du 8086, la commande a

permet d’entrer un programme composé d’un ensemble

d’instructions du 8086

Architecture –Chap. 1

1.1 Microprocesseur : UAL

Exemple : Sous DEBUG du 8086

a 100 --rentre un programme à l’adresse 100 de la mémoire

(cid:138) MOV AX,0001

(cid:138) MOV

AX 0001

(cid:138) MOV BX,0010

(cid:138) MOV CX,0001

(cid:138) MOV

CX 0001

(cid:138) ADD AX,BX

(cid:138) AND BX,CX

(cid:138) AND

BX CX

(cid:138) INT

Ce programme permet de faire l’addition et un ET logique des

deux valeurs 0001 et 0010

Architecture –Chap. 1

1.1 Microprocesseur : Registres

Les registres sont des éléments mémoire de n bits ( n=

taille du registre) qui permettent de stocker des données

et qui sont utilisés par le microprocesseur pour effectuer

les opérations

Sous le programme DEBUG du 8086, la commande r permet

d afficher le contenu de tous les registres du 8080

d’afficher le contenu de tous les registres du 8080

La commande r <reg> permet d’afficher et de modifier le

contenu du registre <reg>

Architecture –Chap. 1

1.1 Microprocesseur : Registres

)

La taille des registres du 8086 est de 16 bits (2 octets)

(

Les registres généraux du 8086 sont : AX, BX, CX, DX

Chaque registre général est composé de deux registres

é é

de 8 bits (1 octet)

(cid:138) AX = AH-AL

(cid:138) BX = BH-BL

(cid:138) CX = CH-CL

(cid:138) DX = DL-DL

AH, BH, CH, et DH sont les registres de poids fort, et AL, BL, CL, et DL

sont les registres de poids faible

Architecture –Chap. 1

1.1 Microprocesseur : Registres

Exemple : Sous DEBUG du 8086

(cid:138) La commande r donne le résultat suivant :

AX=0011 BX=0000 CX=0001 DX=0000

SP=FFF0 BP=0000 SI=0000 DI=0000

DS=180D ES=180D SS=0000 CS=180D IP=010F

NV UP EI NG NZ NA PE NC

(cid:138) La commande r ax donne le résultat suivant :

AX 0011

: -- on peut entrer ici la nouvelle valeur pour AX

Architecture –Chap. 1

1.2 MÉMOIRE

La mémoire centrale est l élément ou sont sauvegardés les

La mémoire centrale est l’élément ou sont sauvegardés les

programmes à exécuter par l’ordinateur et les données

nécessaires à l’exécution des programme

écessa es à e écut o des p og a

La mémoire est organisée en plusieurs cellules de n bits

chacune et chaque cellule à une adresse fixe permettant

d accéder en écriture ou en lecture à la cellule en question

d’accéder en écriture ou en lecture à la cellule en question

Pour le 8086, la mémoire est organisée en 220 cellules de 8

d 8

l 8086 l

220

i é

bits (1 octet) ce qui donne une capacité de 1Go=256 Gbits

Architecture –Chap. 1

1.2 MÉMOIRE

données

255

254

253

FFh

FEh

FDh

Adresses en décimal

Adressesendécimal

Adresses en hexadéciml

Adressesenhexadéciml

04h

03h

02h

01h

00h

Organisation d’une mémoire de 256*8 bits (2048 bits ou 2kbits)

Architecture –Chap. 1

1.2 MÉMOIRE

p g

Sous le programme DEBUG du 8086, la commande d

<adr> permet d’afficher le contenu des 128 octets

(

(128*8 bits) de la mémoire à partir de l’adresse

spécifiée <adr>

)

La commande e <adr> permet de modifier le contenu

des cellules mémoires une à une à partir de l’adresse

spécifiée <adr>

ti d l’ d

Remarque: Sous DEBUG, toutes les adresses sont en hexadécimal.

Architecture –Chap. 1

1.2 MÉMOIRE

UG du 8086

Exemple : Sous DEBUG du 8086

e p e Sous

(cid:138) Après avoir entrer le programme précédant, la commande d 100 a donné

le résultat ci-dessous

180D:0100 B8 01 00 BB 10 00 B9 01-00 01 D8 21 CB CD 20 00 ...........!.. .

180D:0110 00 00 00 00 00 00 00 00-00 00 00 00 34 00 FC 17 ............4...

180D 0110 00 00 00 00 00 00 00 00 00 00 00 00 34 00 FC 17

180D:0120 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................

180D:0130 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

180D:0130 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00

180D:0140 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................

180D:0150 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................

180D:0160 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................

180D:0170 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................

Architecture –Chap. 1

2.2 MÉMOIRE

Exemple : Mémoire du 8086

(cid:138)13B0:0100 10 FF 00 05 01 00 BB FF-FF 83 C3 01 29 C0 21 D8 ............).!.

Adresse 100h

Segment 13B0de la mémoire

(La notion de segment sera vue

dans le chapitre sur les mémoires)

FFFFh

FFFEh

FDh

104h

0103h

0102h

0101h

0100h

0001h

0000h

Architecture –Chap. 1

1.3 Périphériques d’entrée/sortie

Le bloc E/S permet de faire communiquer le microprocesseur

avec les périphériques pour :

(cid:138) Entrer les données (clavier, souris, modem, …etc)

(cid:138) Sortir des résultats (écran, imprimante, modem, …etc)

Architecture Von Newmann

Architecture –Chap. 1

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

1.4 Bus de communication

Le bus permet de faire circuler les données entre les

différents blocs d’un ordinateur

Architecture Von Newmann

Architecture –Chap. 1

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

1.4 Bus de communication

Un bus permet de transférer N bits simultanément

(cid:138) N est la taille du bus

Il existe des bus :

(cid:138) 8 bits

(cid:138) 8 bits,

(cid:138) 16 bits,

(cid:138) 20 bits,

(cid:138) 20 bits

(cid:138) 24 bits,

32 bits,

(cid:138) 32 bits,

(cid:138) 64 bits.

Architecture –Chap. 1

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

1.4 Bus de communication

Il existe 3 types de bus :

1. Bus d’adresses : bus unidirectionnel pour le transfert des adresse

2. Bus de données : bus pour les transferts des données

3. Bus de commandes : Bus pour le transfert des signaux de commandes (e.g.

signaux d’écriture et de lecture)

Architecture –Chap. 1

Réf. : Microprocesseur, support de cours

Dr. J. Y. Haggège

Plan

Introduction

1. Architecture des ordinateurs

1. Microprocesseur

2. Mémoire

3. Périphériques d’entrée/sortie

4. Bus de communication

2. Programmation en assembleur

1. Programme assembleur

Programme assembleur

2. Les instructions

4. Codage en mémoire des instructions

Jeux d’instructions

3. Utilisation de DEBUG

1. Lancement de DEBUG

2. Les paramètres des commandes de DEBUG

3. Les commandes de DEBUG

Conclusion

Architecture –Chap. 1

2. Programmation en assembleur

Le fonctionnement d’un microprocesseur (μP) consiste

à exécuter séquentiellement les instructions du

programme assembleur

un programme assembleur est un ensemble

d instructions à exécuter séquentiellement par le μP

d’instructions à exécuter séquentiellement par le μP

Architecture –Chap. 1

2. Programmation en assembleur

Le fonctionnement d’un microprocesseur (μP) consiste

à exécuter séquentiellement les instructions du

programme assembleur

un programme assembleur est un ensemble

d instructions à exécuter séquentiellement par le μP

d’instructions à exécuter séquentiellement par le μP

Architecture –Chap. 1

2.1 Programme assembleur

Exemple d un programme en assembleur du 8086

Exemple d’un programme en assembleur du 8086

MOV AX,0001

AX 0001

MOV

MOV BX,0010

MOV CX,0001

MOV

CX 0001

ADD AX,BX

AND BX,CX

BX CX

AND

INT

Ce programme permet de faire l’addition et un ET logique des

deux valeurs 0001 et 0010

Architecture –Chap. 1

2.2 Les instructions

L’instruction est une opération de base qui peut être

décodée et exécutée par le μP

Chaque instruction représente une opérations de base

qui peut être exécutée par le μP

Exemple d instructions du 8086

Exemple d’instructions du 8086

(cid:138) ADD AX, BX -- instruction d’addition

(cid:138) SUB CX DX

(cid:138) SUB CX, DX

(cid:138) AND AX, CX

(cid:138) OR BX, DX

(cid:138) OR BX DX

-- instruction de soustraction

instruction de soustraction

-- instruction de ET logique

instruction de OU logique

-- instruction de OU logique

Architecture –Chap. 1

2.3 Jeu d’instructions

Le jeux d instructions d un ordinateur est l ensemble des

Le jeux d’instructions d’un ordinateur est l’ensemble des

instructions qui peuvent être exécutées par le μP

Il existe plusieurs types d’instructions (voir Annexe B)

(cid:138) Les instructions de transfert de données

(cid:138) Les instructions logiques et arithmétiques

(cid:138) Les instruction de décalage et rotation

(cid:138) Les instructions de saut et de branchement

(cid:138) Les instructions de comparaison

(cid:138) Les instructions d’incrémentation et de décrémentation

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instructions de transfert de données

MOV dest, orig

(cid:153) dest == registre (R) ou adresse mémoire (M)

(cid:153) orig == R ou M ou immédiat (I) sauf dest/orig=M/M

Exemples :

(cid:138) MOV

MOV AX,BX

AX,BX

(cid:138) MOV AX,FF00

(cid:138) MOV AX,[FF00]

(cid:138) MOV [00FF],BX

(cid:138) MOV BYTE PTR [00FF],1A

(cid:138) MOV WORD PTR [00FF],1A

(cid:138) MOV

WORD PTR [00FF] 1A

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instructions logique et arithmétiques

OR dest, op

AND dest, op

XOR dest, op

XOR dest

NOT dest

ADD dest, op

ADC dest, op

SUB dest, op

SBB dest, op

SBB dest

NEG dest

INC dest

DEC dest

OU logique

ET logique

XOR logique

inverse logique

addition

addition avec retenue

soustraction

soustraction avec retenue

inverse arithmétique

incrémentation

décrémentation

dé é

(cid:153) dest == registre ou adresse mémoire

(cid:153) op == registre ou adresse mémoire ou immédiat sauf dest/op=M/M

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instructions de décalage et de rotation

SHL dest, op

SHR dest, op

SHR dest op

SAR dest, op

ROL dest, op

ROL dest op

ROR dest, op

RCL dest, op

RCL d t

RCR dest, op

décalage logique gauche dest.0

décalage logique droite 0.dest

décalage logique droite 0 dest

décalage arithmétique droite S.dest

rotation gauche dest

rotation droite dest

rotation gauche avec carry dest.C

rotation gauche avec carry dest C

rotation droite avec carry C.dest

(cid:153) dest == registre ou adresse mémoire

ou C

(cid:153) op == 1 ou CL

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instruction de comparaison

CMP op1, op2

comparaison op1-op2

(cid:138) L’instructions de comparaison permet seulement de mettre

à jour les drapeaux (Flags) du microprocesseur

(cid:138) L’instruction de comparaison est souvent utilisée avec les

instructions de sauts

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instructions de sauts inconditionnels :

JMP addr

CALL addr

RET

saut inconditionnel

appel sous-programme

retour sous-programme

Instructions de sauts conditionnels / carry:

JC addr

JNC addr

saut si carry=1

saut si carry=0

Instructions de sauts conditionnels / entiers :

Inst ctions de sa ts conditionnels / entie s

saut si =

saut si /

saut si =/

saut si = 0

saut si =/ 0

JE addr

JNE addr

JZ addr

JNZ addr

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Instructions de sauts conditionnels / entiers non signés:

l /

diti

JB addr

JA addr

JBE addr

JAE addr

JAE dd

saut si <

saut si >

saut si <=

saut si >=

saut si >

Instructions de sauts conditionnels / entiers signés :

JL addr

JG addr

JLE addr

JGE addr

saut si <

saut si >

saut si <=

saut si >=

Architecture –Chap. 1

2.3 Jeu d’instructions du 8086

Autres instructions de sauts conditionnels :

JCXZ addr

JO addr

JNO addr

JP addr

JNP addr

JS addr

JNS addr

Les boucles :

saut si CX vaut 0

saut si débordement (O =1)

saut si pas de débordement (O =0)

saut si parité (P =1)

saut si pas de parité (P =0)

ité (P 0)

saut si signe (S =1)

saut si pas de signe (S 0)

saut si pas de signe (S =0)

LOOP addr

LOOPE addr

LOOPNE addr

saut court si le compteur CX est différent de 0

saut court si compteur CX différent de 0 et Z =1

saut court si compteur CX différent de 0 et Z =0

Architecture –Chap. 1

2.4 Codage en mémoire d’une instruction

Comme le microprocesseur ne comprend que le

langage binaire (0 et 1), chaque instruction est

placée en mémoire sous forme d’un code binaire pour

qu’elle puisse être décodée et exécutée par le

microprocesseur

Le codage de l’instruction est effectué suivant une

méthode donnée qui sera présentée dans les

chapitres suivants

éth d d

té d

Architecture –Chap. 1

2.4 Codage en mémoire d’une instruction

Sous DEBUG la commande u <adr> permet d’afficher les

instructions et leurs codes du programme assembleur qui

se trouve à l’adresse <adr>

Une instruction du 8086 peut être codée sur 1 ou plusieurs

octets

t t

La taille d un programme correspond à la somme des tailles

La taille d’un programme correspond à la somme des tailles

de toutes les instructions du programme

Remarque: Sous DEBUG, les codes binaires des instructions sont donnés en

hexadécimal.

Architecture –Chap. 1

2.4 Codage en mémoire d’une instruction

Exemple :

(cid:138) Après avoir entrer le programme précédant, la commande u 100

a donné le résultat ci-dessous

Adresses

Codes

Instructions

180D:0100

180D:0103

180D:0106

180D:0109

180D:010B

180D:010D

B80100 MOV AX,0001

BB1000 MOV BX,0010

B90100 MOV CX,0001

01D8 ADD AX,BX

21CB AND BX,CX

CD20 INT 20

Architecture –Chap. 1

Plan

Introduction

1. Architecture des ordinateurs

1. Microprocesseur

2. Mémoire

3. Périphériques d’entrée/sortie

4. Bus de communication

2. Programmation en assembleur

1. Programme assembleur

Programme assembleur

2. Les instructions

4. Codage en mémoire des instructions

Jeux d’instructions

3. Utilisation de DEBUG

1. Lancement de DEBUG

2. Les paramètres des commandes de DEBUG

3. Les commandes de DEBUG

Conclusion

Architecture –Chap. 1

3. Utilisation de DEBUG

DEBUG est un programme utilitaire de MS_DOS

permettant un contrôle total du microprocesseur

DEBUG permet :

(cid:138) D’entrer, d’afficher et d’exécuter des instructions ou un

(cid:138) D’afficher et de modifier le contenu des registres du

difi

i t

programme assembleur

t d

D’ ffi h

microprocesseur

(cid:138) D’afficher et de modifier le contenu de la mémoire

(cid:138) D afficher et de modifier le contenu de la mémoire

(cid:138) De débugger et d’exécuter pas à pas les programmes

Architecture –Chap. 1

3.1 Lancement de DEBUG

Sous MS-DOS, on peut lancer DEBUG de plusieurs façons:

Sous MS DOS on peut lancer DEBUG de plusieurs façons:

(cid:138) En tapant debug : pour lancer DEBUG sans charger de programme.

En tapant debug <programme avec extension> : pour lancer

(cid:138) En tapant debug <programme avec extension> : pour lancer

DEBUG en chargeant un programme.

(cid:138) En tapant debug <programme avec extension> <paramètres> :

pour lancer DEBUG en chargeant un programme et en donnant des

paramètres au programme.

(cid:138) En tapant debug < <fichier.txt> : pour lancer DEBUG avec

redirection de l entrée à partir d un fichier au lieu du clavier.

redirection de l’entrée à partir d’un fichier au lieu du clavier

(cid:138) En tapant debug > <fichier.txt> : pour lancer DEBUG avec

(cid:138) En tapant des combinaisons des commandes précédentes pour lancer

redirection de la sortie vers un fichier au lieu de l’écran.

E t

é éd t

DEBUG avec redirections des entrées et/ou des sorties et avec ou sans

chargement d’un programme.

t d

Architecture –Chap. 1

3.1 Lancement de DEBUG

Sous WINDOWS, il est préférable d ouvrir une fenêtre DOS

Sous WINDOWS, il est préférable d’ouvrir une fenêtre DOS

et ensuite lancer DEBUG. Il est aussi possible de lancer le

programme DEBUG an allant dans Démarrer (cid:198)

Exécuter, et ensuite taper debug.

Une fois lancé, DEBUG nous donne un tiret d’invite nous

permettant d’entrer les commandes de DEBUG.

Remarques :

(cid:138) Les commandes de DEBUG sont toutes composées d’une lettre avec en

option une suite de paramètres.

(cid:138) Il n'y a pas de différences entre les majuscules et les minuscules.

Toutes les valeurs numériques sont en hexadecimal.

Architecture –Chap. 1

3.2 Les paramètres des commandes de DEBUG

Les paramètres des commandes de DEBUG peuvent être :

(cid:138) <adresse> : L'adresse peut s'écrire sous un seul nombre <offset> ou

sous un couple de nombres <segment>:<offset>. Il est possible de

donner comme segment le mot DS ou CS. Si on ne précise pas de

donner comme segment le mot DS ou CS Si on ne précise pas de

segment, c'est DS qui est pris par défaut, sauf pour certaines

commandes.

(cid:138) <bloc> : C'est un ensembles d'adresses dans un même segment. Il y a

deux formes: <adresse début> <adresse fin> ou <adresse début> L

<longueur en octet>. Seulement l’adresse de début peut avoir un

segment.

(cid:138) <port> : C'est une adresse d'un port d'entrée/sortie. Par exemple 378

l 378

t é /

t d'

pour les données de l'imprimante.

(cid:138) <octet> : C'est une donnée sur 1 ou 2 chiffres hexadécimal.

(cid:138) <liste d’octets> : C'est une suite d'octets séparés par des espaces (ou

it d'

t t

(

li t d’

t t

des virgules).

(cid:138) <mot> : Nombre de 1 à 4 chiffres hexadécimal.

Architecture –Chap. 1

3.2 Les paramètres des commandes de DEBUG

Les paramètres des commandes de DEBUG peuvent être :

(cid:138) <nom de fichier> : Donne au moins le nom et l'extension d'un fichier.

On peut y mettre le chemin.

h î

déli

h î

(cid:138) <chaîne> : Une chaîne est délimitée par des apostrophes ou des

i é

guillemets (e.g. ‘bonjour’ ou "bonjour"). Pour mettre une apostrophe

dans une chaîne, il faut utiliser les guillemets comme délimiteurs (e.g.

"ceci est un exemple pour l’apostrophe").

h ")

(cid:138) <registre> : Nom d'un registre.

(cid:138) <disque> : 0 représente le lecteur A:, 1 le lecteur B:, 2 le disque C: et

l’

ainsi de suite.

(cid:138) <secteur> : le numéro de secteur.

(cid:138) <nombre de secteurs> : Nombre de secteur entre 1 et 80 (on ne

peut pas lire ou écrire en une fois plus de 80 secteurs. Les secteurs

sont de 512 octets.

Architecture –Chap. 1

3.3 Les commandes de DEBUG

Ci-dessous la syntaxe et la signification de certaines commandes

Ci dessous la syntaxe et la signification de certaines commandes

de DEBUG :

(cid:138) ? : La commande ? permet d afficher la liste des commandes de

(cid:138) ? : La commande ? permet d’afficher la liste des commandes de

DEBUG.

(cid:138) A <adr> : La commande A (assemble) permet d’entrer ligne par ligne

des instructions d’un programme à partir de l’adresse <adr> On

des instructions d un programme à partir de l adresse <adr>. On

termine les lignes par un retour chariot supplémentaire.

(cid:138) C <bloc> <adr> : La commande C (compare) permet de comparer le

bloc <bloc> au bloc qui débute à l adresse <adr> (e.g. C F100 F200

bloc <bloc> au bloc qui débute à l’adresse <adr> (e g C F100 F200

F400 ou C F100 L100 F200 compare les blocs F100-F200 et F400-F500).

Si les blocs sont identiques, la commande ne renvoie aucun message.

D < d >

(cid:138) D <adr> ou D <bloc> : La commande D (dump) permet d’afficher la

suite d’octets du bloc de 128 octets qui commence à l’adresse <adr>

ou du bloc <bloc>. D sans paramètre affiche les 128 octets suivants.

D <bl > L

t d’ ffi h

d D (d

)

Architecture –Chap. 1

3.3 Les commandes de DEBUG

(cid:138) E <adr> <liste d’octets> : La commande E (enter) permet de

mettre en mémoire une liste d’octet à partir de l’adresse <adr>. E sans

mettre en mémoire une liste d octet à partir de l adresse <adr>. E sans

la liste d’octets permet d’afficher un à un les anciens octets et d’entrer

les nouveaux octets en tapant l’octet suivi d’un espace. Un espace tout

seul permet de garder l’ancien octet et de passer à l’octet suivant. On

termine la commande par un retour chariot. La touche ‘-‘ permet de

termine la commande par un retour chariot La touche ‘ ‘ permet de

revenir en arrière.

(cid:138) F <bloc > <liste d’octets> : La commande F (fill) remplit le bloc

<bloc> avec la liste d’octets La liste d’octet est répétée jusqu’à ce que

<bloc> avec la liste d octets. La liste d octet est répétée jusqu à ce que

tout le bloc soit rempli.

(cid:138) G <=adr1> <adr2>…. : La commande G (go) permet d’exécuter un

programme à partir de l’adresse <adr1>. Les adresses suivantes

programme à partir de l adresse adr1 . Les adresses suivantes

représentent des points d’arrêt. Si aucune adresse n’est spécifiée, la

commande exécute le programme à partir de l’adresse définie par

CS:IP. CS est le registre de segment de donnée et IP est le registre du

pointeur d instruction.

pointeur d’instruction

(cid:138) H < mot1> <mot2> : La commande H (hexa) permet d’afficher la

somme et la soustraction des deux nombres (i.e. <mot1> + <mot2> et

<mot1> <mot2>.

Architecture –Chap. 1

3.3 Les commandes de DEBUG

(cid:138) M <bloc> <adr> : La comande M (move) déplace le bloc dans la

mémoire à partir de l’adresse <adr>.

ti d l’ d

(cid:138) P <=adr> <mot> : La commande P (proceed) exécute <mot>

instructions à partir de l’adresse <adr>. Si aucun mot n’est spécifié, la

commande exécute une instruction. Si aucune adresse n’est spécifiée,

la commande exécute le programme à partir de l’adresse définie par

CS:IP La commande P considère les boucles comme si c’était une seule

CS:IP. La commande P considère les boucles comme si c était une seule

instruction.

(cid:138) Q : La commande Q (quit) permet de terminer la session de DEBUG.

(cid:138) R <reg> : La commande R (register) permet de modifier le contenu

du registre <reg >. Si aucun registre n’est spécifié, R affiche le contenu

de tous les registres. R F permet de modifier individuellement le

registre des flags. OV, DN, EI, NG, ZR, AC, PE, CY permet de mettre à 1

les flags, et NV, UP, DI, PL, NZ, NA, PO, NC permet de mettre 0 les

flags.

Architecture –Chap. 1

3.3 Les commandes de DEBUG

(cid:138) T <adr> <mot> : La commande T (trace) exécute <mot>

instructions à partir de l’adresse <adr>. Si aucun mot n’est spécifié, la

instructions à partir de l’adresse <adr> Si aucun mot n’est spécifié la

commande exécute une instruction. Si aucune adresse n’est spécifiée,

la commande exécute le programme à partir de l’adresse définie par

CS:IP. T ressemble à la commande P, sauf qu’elle entre dans les

...

Architecture des Ordinateurs

Architecture des Ordinateurs