Mr.

OMOR

PDF par M.A

 Sommaire
Introduction.................................................................................................................................... 9
Partie 1 : Systèmes de numération et Codage................................................................. 10
Introduction.................................................................................................................................. 10
Définitions et théorèmes de base ................................................................................................. 10
Définition: ..................................................................................................................................... 10
Remarque:.................................................................................................................................... 10
Méthode:Théorème..................................................................................................................... 10
Méthode:Le système binaire b = 2 .......................................................................................... 10
Méthode:Le système octale {0, 1, 2,.......7} b = 8................................................................ 11
Méthode:Le système Hexadécimale b = 16 ............................................................................ 11
Exercices : Conversion en Base 10 ............................................................................................... 11
Remarque:.................................................................................................................................... 11
Remarque:.................................................................................................................................... 11
Conversion Inter- base ................................................................................................................... 12
Fondamental:Conversion décimal vers Binaire ....................................................................... 12
Complément: ............................................................................................................................... 12
Fondamental:Conversion décimal vers Octal .......................................................................... 12
Fondamental:Conversion Décimale vers Hexadécimale ........................................................ 12
Fondamental:Conversion binaire vers Octale ......................................................................... 12
Complément:Conversion binaire vers Hexadécimale ............................................................. 12
Exercices : Conversion inter- base ............................................................................................... 12
Exercice 1 ..................................................................................................................................... 12
Exercice 2 ..................................................................................................................................... 12
Exercice 3 ..................................................................................................................................... 12
Représentation des nombres sur n chiffres ................................................................................ 13
Définition: ..................................................................................................................................... 13
Rappel:.......................................................................................................................................... 13
Attention: ..................................................................................................................................... 13
Remarque:.................................................................................................................................... 13
Représentation d'un nombre négatif............................................................................................ 14
Représentation du signe + nombre ......................................................................................... 14
Exemple:Représentation du nombre 4 ........................................................................................ 14
 Remarque:.................................................................................................................................... 14
Attention:Limitation de cette solution ......................................................................................... 14
Représentation en complément restreint: ............................................................................... 14
Exemple:....................................................................................................................................... 15
Attention: ..................................................................................................................................... 15
Exemple:....................................................................................................................................... 15
Représentation des nombres signés dans le code du complément vrai ............................. 15
Exemple:....................................................................................................................................... 15
Remarque:.................................................................................................................................... 15
Exemple:....................................................................................................................................... 16
Les opérations arithmétiques sur une base B............................................................................. 16
Rappel:Les opérations arithmétiques ....................................................................................... 16
les opérations en binaire s'effectuent comme en base 10.................................................... 16
Addition binaire ........................................................................................................................... 16
Soustraction binaire .................................................................................................................... 17
Exemple:....................................................................................................................................... 17
Définition:Débordement ( Over Flow ) .................................................................................... 17
Cas d'une addition sans débordement ..................................................................................... 18
Méthode:Détection du débordement ....................................................................................... 18
Multiplication binaire ................................................................................................................... 18
Division binaire ............................................................................................................................ 18
Exemple:Division normal et soustraction successives ........................................................... 18
Représentation des nombres fractionnaires en virgule fixe ..................................................... 20
Rappel:Nombre réel .................................................................................................................... 20
Règle de représentation ............................................................................................................. 20
Exemple:....................................................................................................................................... 20
Conversion Décimal / Binaire .................................................................................................... 21
Remarque:.................................................................................................................................... 21
Méthode:Déterminer le rang de développement des puissances de 2 ............................... 21
Chapitre 2 - Les systèmes de codage .................................................................................. 22
Le codage DCB ................................................................................................................................ 24
Définition:Binaire codé en décimal ........................................................................................... 24
Attention:Probléme ..................................................................................................................... 24
Remarque:.................................................................................................................................... 24
 Opération arithmétique avec un résultat supérieur à 9 ........................................................ 24
Solution ......................................................................................................................................... 24
Complément:Travail à faire ....................................................................................................... 24
Codage de Gray ............................................................................................................................... 25
Systèmes de codage tenant compte des erreurs ....................................................................... 25
Définition:Il existe deux grandes familles de codage ............................................................ 25
Contrôle de parité ....................................................................................................................... 25
Exemple:....................................................................................................................................... 25
Contrôle double parité ................................................................................................................ 25
Codage de HAMMING ................................................................................................................. 26
Remarque:.................................................................................................................................... 26
Exemple:....................................................................................................................................... 26
Suite de l'exemple ....................................................................................................................... 27
À la réception ............................................................................................................................... 27
Remarque:.................................................................................................................................... 27
Partie 2 : Architecture interne de l'ordinateur ................................................................ 28
Introduction.................................................................................................................................. 28
Chapitre 1 : L'approche von Neumann ............................................................................... 29
 Principe du modèle von Neumann................................................................................ 29
Architecture et modèle de calcul .................................................................................................. 30
Le modèle de calcul de von Neumann ..................................................................................... 30
L'architecture von Neumann...................................................................................................... 30
Remarque:.................................................................................................................................... 31
Chapitre 2 : Les composants de l'architecture................................................................. 31
Unité centrale .................................................................................................................................. 32
Définition: ..................................................................................................................................... 32
Définition: ..................................................................................................................................... 32
Exemple:....................................................................................................................................... 34
Définition: ..................................................................................................................................... 34
Le cycle d'exécution .................................................................................................................... 34
Inconvénient ................................................................................................................................ 35
Unité de commande.................................................................................................................... 36
Récapitulons ................................................................................................................................. 38
Mémoires .......................................................................................................................................... 41
 Rappel:.......................................................................................................................................... 41
Qu'est ce qu'une mémoire ? ...................................................................................................... 41
Hiérarchie des mémoires ........................................................................................................... 42
Fondamental:Organisation des informations .......................................................................... 43
Caractéristiques des mémoires ................................................................................................. 43
Fondamental:Différents types d'accès aux mémoires ........................................................... 43
Mémoire centrale......................................................................................................................... 43
Fondamental: ............................................................................................................................... 45
Le système de communication ...................................................................................................... 46
Rappel:Caractéristiques.............................................................................................................. 46
Bus de communication ............................................................................................................... 46
Fondamental:Le buffer ............................................................................................................... 46
Remarque:.................................................................................................................................... 47
Echange synchrone VS asynchrone .......................................................................................... 47
L'arbitrage d'accès ...................................................................................................................... 48
Conseil: ......................................................................................................................................... 51
Remarque:.................................................................................................................................... 51
Les unités d'échange d'entrée/sortie ........................................................................................... 51
Partie 3 : Programmation assembleur 80X86 ............................................................................. 52
Introduction.................................................................................................................................. 52
Chapitre 1 : Premiers pas.. ...................................................................................................... 53
 ......................................................................................................................................................... 53
 Pourquoi l'assembleur ? ................................................................................................... 53
Écriture et exécution d'un programme ............................................................................... 54
Architecture du Intel X86 ............................................................................................................... 55
Remarque:.................................................................................................................................... 55
Méthode: ...................................................................................................................................... 57
Chapitre 2 : Les Bases du langage........................................................................................ 58
 ......................................................................................................................................................... 58
 Structure d'un programme assembleur...................................................................... 58
Déclaration des variables simples ................................................................................................. 60
Remarque: ..................................................................................................................................... 60
Exemple:........................................................................................................................................ 61
Méthode:....................................................................................................................................... 62
Les tableaux ..................................................................................................................................... 62
Remarque: ..................................................................................................................................... 62
Exemple:........................................................................................................................................ 63
Méthode:....................................................................................................................................... 63
Plus loin avec les REGISTRES ....................................................................................................... 64
Rappel:.......................................................................................................................................... 64
Les registres généraux ________________________________ ........................................ 65
Exemple:Utilisation ..................................................................................................................... 65
Les registres de segment
_______________________________________________________________________
__________ ................................................................................................................................. 66
Attention: ..................................................................................................................................... 67
Les modes d'adressage .................................................................................................................. 68
Définition: ..................................................................................................................................... 68
Adressage immédiat ................................................................................................................... 68
Exemple:Adressage direct ou immédiat .................................................................................. 69
Remarque:.................................................................................................................................... 69
Attention: ..................................................................................................................................... 69
Fondamental: ............................................................................................................................... 69
Adressage indexé et adressage basée ..................................................................................... 70
Conseil: ......................................................................................................................................... 70
Récapitulons ................................................................................................................................. 70
Remarque:.................................................................................................................................... 71
Chapitre 3 : Les instructions de base .................................................................................. 71
Format standard d'une instruction ............................................................................................... 72
Format d'une instruction ............................................................................................................ 72
Déplacement des données............................................................................................................. 73
Remarque: ..................................................................................................................................... 73
Les opérations arithmétiques ........................................................................................................ 74
Quelques opérations arithmétiques de base ........................................................................... 74
Attention: ..................................................................................................................................... 74
Les opérations logiques.................................................................................................................. 75
Attention: ..................................................................................................................................... 75
Branchement inconditionnel .......................................................................................................... 76
Les sauts inconditionnels ........................................................................................................... 76
Branchement conditionnel ............................................................................................................. 77
Les sauts conditionnels .............................................................................................................. 77
Remarque:.................................................................................................................................... 79
Exemple:....................................................................................................................................... 79
Les structures itératives ................................................................................................................. 80
L'instruction LOOP....................................................................................................................... 80
Exemple:Parcours d'un tableau.. ............................................................................................... 81
Équivalent des instruction en C .................................................................................................... 81
Attention:Exercice ....................................................................................................................... 83
Chapitre 4 : Notions avancées ............................................................................................... 83
Interruptions utiles.......................................................................................................................... 83
Les entrées / sorties ................................................................................................................... 84
Les procédures ................................................................................................................................ 84
Remarque:.................................................................................................................................... 86
La pile ............................................................................................................................................... 86
Définition ...................................................................................................................................... 86
Instructions PUSH et POP .......................................................................................................... 86
Exemple:Transfert de AX vers BX en passant par la pile ....................................................... 86
Les registres SS et SP ................................................................................................................. 87
Déclaration d'une pile ................................................................................................................. 87
Remarque: ..................................................................................................................................... 88
Partie 4 : Travaux pratiques ................................................................................................... 89
TP 1 .................................................................................................................................................. 89
 Introduction.......................................................................................................................... 89
 ......................................................................................................................................................... 90
 ......................................................................................................................................................... 90
 ......................................................................................................................................................... 90
 Activité 1 : Entrée et Sortie de DEBUG ....................................................................... 90
Activité 2 : Examiner et changer les contenus de registres ..................................................... 91
Conseil: .......................................................................................................................................... 91
Activité 3 : Coder et Exécuter les programmes avec DEBUG ................................................... 92
Attention: ...................................................................................................................................... 92
Attention: ...................................................................................................................................... 93
Attention: ...................................................................................................................................... 93
Activité 4 : Manipulation des données avec DEBUG .................................................................. 93
Remarque: ..................................................................................................................................... 94
Activité 5 : La convention « Little Endian » et comment le μP80x86 sauvegarde
les mots .......................................................................................................................................... 95
Activité 6 : Examiner et changer le registre FLAGS avec DEBUG ........................... 96
Méthode:....................................................................................................................................... 96
Activité 7 : Compléments .................................................................................. 97
Méthode:....................................................................................................................................... 97
Remarque: .................................................................................................................................... 98
Complément: ................................................................................................................................ 98
 Introduction
Un cours d'architecture des ordinateurs est souvent un moment difficile à passer pour
l'étudiant. Cela n'est pas étonnant car la première source de difficultés réside déjà dans
la diversité des sujets traités. Les différentes parties qui y sont abordées sont
pratiquement chacune une matière à part entière. On peut ainsi passer de la théorie de
l'information, aux technologies digitales, au traitement du signal et aux réseaux locaux,
aux développements logiciels et aux systèmes d'exploitation. Les technologies, les
abstractions abordées à chaque étape sont quasiment nouvelles et pour comprendre
l'architecture générale, il faut avoir un minimum de maîtrise des différentes techniques
ou technologies approchées.
Comme pour d'autres domaines, il y a deux grandes manières d'aborder un cours de ce
type. L'approche descendante consiste à partir de la machine complète, c'est-à-dire
considérer l'ordinateur sous forme de machine abstraite capable de résoudre des
problèmes de traitement de l'information tels qu'un utilisateur final les perçoit. La
machine est décrite comme un tout dont on analyse ensuite les composants
fonctionnels. La modélisation de la machine peut être totalement mathématique et, à la
limite, peu importe comment elle fonctionne réellement.
L'objectif est donc de faire comprendre le fonctionnement d'un ordinateur par une
présentation des fondements sur lesquels s'appuie son architecture interne. Dans ce
sens, la mise en oeuvre de l'approche ascendante permet de mettre en exergue les «
fondamentaux » qui reviennent systématiquement d'un chapitre à l'autre. Il s'agit du
codage de l'information, des mécanismes de communication, des opérations
arithmétiques, de l'organisation interne de la mémoire. L'étudiant pourra aussi retrouver
ces fondamentaux dans les deux autres domaines proches de l'architecture des
ordinateurs que sont les réseaux et les systèmes d'exploitation.
Une information est un élement de connaissance capable d'être représenté à l'aide de
convention pour être conservé, traité ou communiqué.
La mémoire est un organe électronique capable de contenir et de conserver sans
alternation ni modification des quantités d'information.
L'instruction est une commande d'une opération à effectuer au niveau le plus bas, et
donc un programme est une suite d'instructions.
En règle général :
1 Kilo Octet = 1024 Octet
1 Méga Octet = 1024 Kilo Octet
1 Giga Octet = 1024 Méga Octet
 Un système d'exploitation est un ensemble de programme qui se charge de
l'exploitation d'une machine (Ordinateur).
 Partie 1 : Systèmes de numération et Codage
 Chapitre 1 - Les systèmes de numération
 Chapitre 2 - Les systèmes de codage

Introduction
Problématique : Comment représenter les chiffres ?
Représentation du système romain :
I , II , III , IIII, IV ,.......IX....
Représentation du système Arabe :
1, 2, 3, 4, 5, 6.........10.....

Représentation du système
persane : persanne

Définitions et théorèmes de base

Définition:
Un système de numération est un ensemble de chiffres (Symboles), et un ensemble de
régles qui permettent de représenter de façon cohérante et unique les entiers naturels.
 Le nombre de chiffres utilisés dans un système de numération s'appel la base du
système.
Remarque:
Le système usuel a pour base = 10, on l'appel le système décimal, et on noteb=10.
Méthode:Théorème
Soit B un entier ≥ 2
Pour tout p Є N , il ya n ≥ 0 et Ai tel que
i Є [0,1,........., n-1]
Tel que :

Méthode:Le système binaire b = 2

Le système binaire comprend deux symboles appelés « bits »
Tous les nombres N s'écrivent en binaire sous la forme suivante :
Méthode:Le système octale {0, 1, 2,.......7} b = 8
Un nombre N s'écrit en octale sous la forme

Méthode:Le système Hexadécimale b = 16

Le système Héxadécimal présente un grand interêt dans l'étude des microprocesseurs.
Le système Héxadécimal dispose des symboles :
Les 10 chiffres décimaux allant de 0.....9 complétés par les six lettres Majiscules allant
de „A' à „F'. Ai Є { 0, ........,9, A, B, C, D, E, F }

Exercices : Conversion en Base 10

Remarque:
L'équivalent décimal d'un nombre écrit en base quelconque s'obtient par application
directe de la forme polynomiale.
Convertissez les nombres suivants en Base 10 :

Remarque:
Plus la base est grande, moins il faut de symboles pour représenter le même nombre.
Le système Hexadécimal offre une écriture plus condensée ( compact ) des nombres
élevés.
 Conversion Inter- base
Fondamental:Conversion décimal vers Binaire
Il s'agit d'une répétition de divisions par2 jusqu'à obtention d'un quotient NUL.
Les coefficients ( à déterminer ) correspondent aux restes des différentes divisions.
Complément:
Il s'agit de composer le nombre décimal en question sous forme d'une somme de
puissance entières de 2.
Si le terme 2 à la puissance k est présent, on inscrit un 1 vis à vis de sa position.
sinon, si le terme est absent On inscrit un 0.
Fondamental:Conversion décimal vers Octal
C'est le même principe qu'avant sauf au lieu de diviser par 2, on divise par 8.
Fondamental:Conversion Décimale vers Hexadécimale
Même principe sauf qu'au lieu de diviser par 2, on divise par 16.
Fondamental:Conversion binaire vers Octale
Il suffit de grouper les bits par blocs de 3 bits en allant vers la gauche, et de faire
correspondre à chaque bloc son équivalent décimale.
Exemple :

Complément:Conversion binaire vers Hexadécimale

Il suffit de grouper les bits par blocs de 4 en allant vers la gauche et de faire
correspondre à chaque bloc son équivalent hexadécimale.
Exemple :

Exercices : Conversion inter- base

Exercice 1
convertir en Binaire:
12, 31, 9, 114, 288, 312.

Exercice 2
Convertir en Octale :
63, 100, 56, 24, 85, 111.

Exercice 3
Convertir en Hexadécimale:
103, 254, 97, 75, 23, 300, 163
 Représentation des nombres sur n
chiffres
Définition:
Sur 4 chiffres dans la base b = 10. le plus grand nombre est Nbr = 9999

La valeur max qu'on peut représenter avec n chiffre est :

Maximiser P revient à maximiser les Ai

Sachant que Ai < b
Alors maximiser les Ai donne :

Sur n chiffres on peut représenter (coder) b à la puissance n valeurs.

Rappel:
Dans un ordinateur, l'information est codée en binaire sur un nombre de bits déterminé
à l'avance: 8 , 16, 32..
Attention:
Calculez la valeur max et le nombre max de représentation pour chaque cas !
Remarque:
l'information qui circule entre différents composants d'un ordinateur est souvent
décomposée en partie ou en bloc ayant le même nombre de bits. On parle alors
de MOT (16 bits).
 Représentation d'un nombre négatif
Représentation du signe + nombre
C'est la façcon la plus simple pour représenter les nombres négatifs. Elle consiste à
représenter le sign sur le bit au poid le plus fort et sur les bits qui restent, on code le
module ou le nombre.

Exemple:Représentation du nombre 4
4 : 00000100
-4 : 10000100
Remarque:
Sur n bits, les nombres qu'on peut représenter appartiennent à l'intervalle :

car on utilise n-1 bits pour les représentations.

Attention:Limitation de cette solution
Le problème majeur posé par la solution actuelle est qu'elle fournit deux
représentations de ZERO
0 : 00000000
0 : 10000000
Les opérations arithmétiques deviennent trés difficiles:

Représentation en complément restreint:

Ce codage, fort simple, consiste à inverser la valeur de chaque bit composant une
valeur binaire.
Exemple:
Pour obtenir -5
0101 Valeur décimale de 5
1010 complément à un de 5 qui donne -5
Attention:
Le souci avec un tel système est qu'il y a toujours deux représentation de la valeur
ZERO pour un nombre de bit donné.
Le complément restreint est aussi appelé :
Complément à UN
Exemple:
Soit l'information 453 : son format est de 3 caractères et la base utilisé est 10. La valeur
maximale que l'on peut exprimer dans ce format est : 999

La différence qui existe entre cette valeur maximale et 453 s'appelle lecomplément
restreint.

Représentation des nombres signés dans le code du complément vrai

Afin de pallier ce défaut, on a introduit la représentation par complément à deux. Celle
ci consiste à réaliser un complément à un de la valeur, puis d'ajouter 1 au résultat.

Exemple:
Par exemple : pour obtenir -5
0101: codage de 5 en binaire
1010: codage en complément restreint de 5
→ On ajoute un 1
1011: codage en cmplément vrai -
Remarque:
Ce codage a l'avantage de ne pas nécessiter de différenciation spéciale des nombres
positifs et négatifs, et évite en particulier le problème d'ordinateurs anciens (Control
DATA 6600) qui avaient un +0 et -0 dont il fallait faire comprendre aux circuits de tests
que c'etait le même nombre !
Exemple:

Voici une addition de -5 et +7

réalisée en complément à deux sur
4 bits :

Les opérations arithmétiques sur une base B

Rappel:Les opérations arithmétiques
Pour toutes les bases, il existent les différentes opérations habituelles :
 Addition
 Soustraction
 Multiplication
 Division

les opérations en binaire s'effectuent comme en base 10

– Addition et soustraction
 chiffre par chiffre
 des poids faibes aux poids forts
 en propageant la retenue
– Multiplication et division
 par série d'additions ou de soustractions

Addition binaire
Calculons : 1010 + 0011
 -

Soustraction binaire
Pour bien réussir une soustracton binaire, il y a une méthode, c'est d'essayer
d'additionner le résultat avec le nombe soustrait, pour vérifier que ca donne le nombre
principal.

Exemple:

faisons l'addition et la soustraction de 27 et

22

Définition:Débordement ( Over Flow )

On dit qu'il y a débordement si le résultat de l'opération n'est pas représentable dans le
système utilisé.

addition en binaire naturel :

-
 Le débordement correspond à une retenue sortante à 1

Cas d'une addition sans débordement

L'addition suivante est sans débordement :

Méthode:Détection du débordement
Comparer le signe des opérandes et le signe du résultat :
 S'ils sont différents, il y a débordement
 S'il y a retenue sur le bit de poid fort alors il ya débordement.

Multiplication binaire
La multiplication consiste à faire une suite d'additions avec le multiplicande décalé vers
la gauche. Cette opération est répétée autant de fois qu'il y a d'éléments binaires dans
le multiplicateur.

Le résultat est codé sur 2n bits pour 2 opérandes sur n bits.

Division binaire
La division binaire s'effectue à l'aide de soustractions et de décalages, comme la
division décimale, sauf que les digits du quotient ne peuvent être que 1 ou 0. Le bit du
quotient est 1 si on peut soustraire le diviseur, sinon il est 0.
Exemple:Division normal et soustraction successives
Calculons 15 / 3
 Représentation des nombres fractionnaires en
virgule fixe
Rappel:Nombre réel
un nombre réel se compose de deux parties distinctes: une partie entière, située à
gauche de la virgule, et, éventuellement, une partie décimale, située après celle-ci.

Règle de représentation
Pour ce qui est de la partie entière, nous savons désormais parfaitement la coder. Mais
qu'en est - il de de la partie décimale ?
Et bien il nous suffit de reprendre le principe de la numération positionnelle, en
considérant chaque bit situé après la virgule comme associé cette fois à des puissances
négative de deux, tout comme nous le faisons pour la base 10.
Ainsi nous savons que:
5.022,78 = 5 x 1.000 + 0 x 100 + 2 x 10+ 2 x 1 + 7 x 0,1 + 8 x 0,01 ...ce qui
revient à écrire:

De la même manière, on pourra également écrire:

v_fixe1

Exemple:
Soit un nombre binaire : 1 1 0 1,0 1 1 0 1
 -

Conversion Décimal / Binaire

Effectuer des multiplications successives par 2 de la partie fractionnaire en conservant à
chaque fois
la partie entière du résultat.
Exemple : soit le nombre 3,14 à convertir en Binaire :

Remarque:
On voit immédiatement que, contrairement à la partie entière, la partie fractionnaire
peut s'exprimer par une suite non finie, ce qui impose de définir un critère d'arrêt. Ce
critère est la précision qui doit être équivalente dans les deux bases.
Méthode:Déterminer le rang de développement des puissances de 2
La précision décimale de 3,14 est 5.e-3

Vérification :
Partie fractionnaire
00100011 = 0,125 + 0,0078125 + 0,00390625
00100011 = 0,13671875
La précision attendue est bien obtenue (n=8 chiffres)
 Chapitre 2 - Les systèmes de
codage
 Introduction
 Le codage DCB
 Codage de Gray
 Systèmes de codage tenant compte des erreurs
 Exercices

Un système de codage consiste à établir une loie ou régle entre l'information à

représenter et l'information binaire.
Exemple : Le code ASCII
Dans ce chapitre vous allez voir :
1. le codage DCB
2. le codage de GRAY
3. le codage tenant compte des erreurs
 Le codage DCB
Définition:Binaire codé en décimal
Le (DCB) ou le (BCD) représente l'un des codes les plus répandus.
Chaque chiffre est codé individuellement en binaire sur 4 bits.
Les valeurs représentables sur 4 bits : 16 valeurs.
Sur 4 bits on peut représenter 16 valeurs différentes. Or en DCB 6
configurations sont inutiles !

Attention:Probléme
Quand le résultat est supérieur à 9 et représentable sur 4 bits. La représentation
binaire de ce résultat ne correspond à aucun code en DCB.
Remarque:
Dans l'exemple précèdent 8 + 2 = 10 ne correspond à aucune représentation en DCB.
La représentation de 10 en DCB est : 0001 0000

Opération arithmétique avec un résultat supérieur à 9

Solution
On procéde comme suit:

Il faut ajouter 6 à chaque fois que le

résultat dépasse 9.

Complément:Travail à faire
Comment ferons-nous pour les autres opérations arithmétiques ?
 Codage de Gray

Systèmes de codage tenant compte des erreurs

Définition:Il existe deux grandes familles de codage
Codage auto-vérificateur : Permet de vérifier l'information reçue. Retenir l'information s'
elle est correcte ou demander sa retransmission s' elle est erronée.
Codage auto-correcteur : Permet de vérifier l'information reçue, retenir l'information s'
elle est correcte et la corriger s' elle est erronée.

Contrôle de parité
C'est le code le plus simple de type autovérificateur.
Principe: consiste à ajouter un bit de parité à la fin de l'info et qui prend une valeur ( 0
ou 1 ) de façon à ce que le nombre de 1 dans l'info soit PAIR.
Ce code est utilisé quand le taux d'erreur est trop faible.
Exemple:

Problème: ce code est autovérificateur quand le nombre d'erreurs est impairs. Par
contre l'erreuren'est pas detéctée s'elle est commise sur un nombrePAIR de bits.

Contrôle double parité

Utilisée principalement dans le cas où l'info est sous forme matricielle.
Principe: il consiste à ajouter des bits de parité pour chaque ligne et chaque colonne
de la matrice.
 C'est un code auto-correcteur pour une erreur et auto-vérificateur pour plus d'une
erreur.

Codage de HAMMING
Utilisé dans une information sous forme vectorielle. Il est fondé sur plusieurs tests de
parité à des positions bien déterminés dans l'information pour m bits de l'information,
on rajoute k bits de parité. L'information à transmettre est composée de n bits avec n =
m + k.
Le nombre k est choisi de façon à ce que:

La table ci dessus indique les 1éres valeurs de k suivant la longeur m du message à

coder.
Les bits de contrôle sont placés dans le message final aux positions correspondantes à
des puissances de 2 (1, 2, 4, 8....).
Remarque:
Chaque bit de parité contrôle l'ensemble des bits ayant un 1 dans la représentation
bianire de leurs positions aux mêmes endroits que les bits de parités.

À la réception du message, on calcul toutes les parités. Pour chaque bit on compare la
valeur calculée et la valeur reçue, s'elles sont identiques, on lui assigne la valeur 0,
sinon on lui assigne la valeur 1.
Le nombre binaire ainsi généré indique la position de l'erreur.
Exemple:
Information initiale : 1 1 0 0 1 0 0 1 (8 bits)

À partir de la formule :
On trouve k = 4
Le message est donc constitué de 12 bits.
 Suite de l'exemple
Pour k2 (22) = (0 1 0 0)

Le 1 en 3éme position !

À la réception
L'information reçue est :

Aprés vérification des bits de parité, on trouve:

(1001)=9
Dans le message reçue, il y a une erreur dans la 9 éme position !!
Remarque:
Le codage de hamming est un codage autovérificateur pour une seule erreur.
S'il y a plus d'une seul erreur, ou plus précisément si le nombre d'erreurs est pairs alors
ce codage est incapable de les détécter.
 Partie 2 : Architecture interne de
l'ordinateur
 Introduction
 Chapitre 1 : L'approche von Neumann
 Chapitre 2 : Les composants de l'architecture

Introduction
Lorsqu'un utilisateur est devant son poste de travail micro-informatique, il est loin de se
douter qu'il est devant une machine dont le fonctionnement est régi par des principes
décrits par le mathématiciens John von Neumann dans les années quarante.
Avant de détailler les sous ensembles d'entrée-sortie (E/S) d'un micro-ordinateur, il est
donc nécessaire de plonger dans l'histoire et de revenir sur un concept qui gouverne
encore le fonctionnement des ordinateurs malgré tous les progrès réalisés depuis. Ainsi
dans un premier chapitre vous allez découvrir l'architecture dite de von Neumann.
Dans cette deuxième partie du cours, le terme UC pour "Unité Centrale" ou CPU pour
"Central Processing Unit" est pris au sens originel, c'est à dire l'unité qui réalise les
calculs et non le micro-ordinateur lui-même. aujourd'hui il qualifie le plus souvent le
microprocesseur.
 Chapitre 1 : L'approche von
Neumann
 Principe du modèle von Neumann
 Architecture et modèle de calcul

 Principe du modèle von Neumann

 Il faut d'abord préciser deux concepts fondamentaux que sont le modèle
de calcul et l'architecture.
 Un modèle de calcul est une abstraction de haut niveau qui explicite
comment effectuer un calcul mathématique. il précise les entités de base et
le modèle d'exécution.
 Pour s'exécuter, le modèle de calcul repose sur une architecture d'ordinateur,
mais aussi sur les langages pour le programmer. Une architecture définit la
structure conceptuelle et le comportement fonctionnel de l'ordinateur en se
reposant sur un modèle de calcul et sur son ou ses langages de
programmation. Elle ne détaille ni la conception (c'est-à-dire les opérateurs
logiques combinatoires et séquentiels) , ni l'implémentation physique (c'est-
à-dire les composants électroniques).


 Architecture et modèle de calcul
 Architecture et modèle de calcul
Le modèle de calcul de von Neumann
L'entité de base du modèle de calcul est la donnée implémentée sous la forme d'une
variable dans les langages informatiques. Le modèle de description d'un problème est
de type procédural, une séquence d'instructions s'exécutant sur un flux entrant de
données et donnant un flux sortant de données résultat. Le modèle d'exécution repose
sur une sémantique de transition d'états. Il est piloté par une séquence d'instructions
ordonnées et exécutées séquentiellement.

L'architecture von Neumann

Issue du projet EDVAC (Electronic Discrete Variable Automatic Computer), cette
architecture est au cœur de tous les processeurs actuels, même si de nouveaux
mécanismes d'accélération du temps de calcul ou d'accès aux données comme le
pipeline, la mémoire cache ou la pré-recherche d'instructions ou de données se greffent
à cette dernière.
D'un point de vue organisationnel, il faut distinguer trois sous-ensembles qui sont l'unité
centrale, c'est-à-dire le microprocesseur pour un micro-ordinateur, la mémoire, les
unités d'échanges d'entrées et de sorties et le système de communication qui permet la
communication entre les trois premiers modules.
Aux unités d'échanges sont connectés les périphériques qui permettent à l'unité centrale
d'entrer et de sortir des données. Aujourd'hui les unités d'échanges sont
bidirectionnelle.
Les trois caractéristiques principales de cette architecture sont un élément de calcul
unique, l'UC, une mémoire unique composée d'une organisation linéaire de cellules
mémoire de taille fixe dans laquelle se trouvent le code des instructions et les données,
et un modèle d'exécution séquentielle des instruction par cette UC.
La donnée qui est l'entité de base du modèle de calcul est rangée dans une case
mémoire ou un registre et elle est adressée par référence.

Schéma d'un ordinateur von Neumann

Ce système de communication est composé de trois bus. Un bus est un ensemble de

voie de communication où circule l'information au sens large. Ce sont les bus de
données, d'adresse et de contrôle.
Comme leur nom peut le suggérer, le premier véhiculera des données, mais aussi des
instructions, le deuxième, des adresses et le dernier permet de contrôler les échanges
entre les sous-ensembles.
 Les trois bus de communication

Lorsque l'UC veut communiquer avec la mémoire ou les unités d'échanges d'E/S, elle le
fait via une enveloppe libellée avec une adresse et contenant une information
(instruction ou donnée).
Remarque:
Cette structure est de type maître-esclave. L'UC est toujours le maître des échanges. La
mémoire et les unités d'échanges d'entrée-sortie sont des entités passives, donc
esclaves.
Dans d'autres configurations, comme un système multiprocesseur ou un système dont
les échanges se font par accès direct à la mémoire, il se peut que le contrôle des
échanges soit partagé entre plusieurs maîtres.

Chapitre 2 : Les composants de

l'architecture
 Unité centrale
 Mémoires
 Le système de communication
 Les unités d'échange d'entrée/sortie
 Unité centrale
Définition:
Un microprocesseur est un circuit intégré complexe. Il résulte de l'intégration sur une
puce de fonctions logiques combinatoires (logiques ou arithmétique) et séquentielles
(registres, compteur, etc..).
Il est capable d'interpréter et d'exécuter les instructions d'un programme.

Processeur

De manière général le processeur, (ou CPU, Central Processing Unit, « Unité centrale de
traitement ») est le composant essentiel d'un ordinateur qui interprète les instructions
et traite les données d'un programme.
pour fonctionner, le processeur est cadencé au rythme d'une horloge interne, grâce à
un cristal de quartz qui, soumis à un courant électrique, envoie des impulsions,
appelées « top ». La fréquence d'horloge (appelée également cycle, correspondant au
nombre d'impulsions par seconde, s'exprime en Hertz (Hz)).
A chaque top d'horloge le processeur exécute une action, correspondant à
une instruction ou une partie d'instruction.
Définition:
Une instruction est l'opération élémentaire que le processeur peut accomplir. Les
instructions sont stockées dans la mémoire principale, en vue d'être traitée par le
processeur. Une instruction est composée de deux champs :
Le code opération : représentant l'action que le processeur doit accomplir.
Le code opérande : définissant les paramètres de l'action. Le code opérande dépend
de l'opération. Il peut s'agir d'une donnée ou bien d'une adresse mémoire.
L'UC se compose d'une unité de traitement (UT), d'une unité de contrôle ou de
commande (UCo) et de registres.
 Unité centrale

L'unité de traitement, sous le contrôle de l'unité de commande, est chargée d'exécuter

les instructions. Les registres servent à mémoriser des données et à d'autres fonctions
nécessaires au fonctionnement de l'UC.

Unité de traitement

Ces trois sous ensembles (registres, unité de traitement, unité de commande)

communiquent entre eux et vers l'extérieur grâce à un système de communication
interne. Ces bus sont connectés à une interface qui permet de dialoguer avec
l'extérieur. Cette dernière adapte les signaux et gère l'échange.
 Structure de l'unité centrale

Exemple:
Les bus 1 et 2 ,représentés successivement en bleu et rouge dans la figure "Unité de
traitement", font partie du système de communication interne de l'UC.
Intéressons-nous maintenant à ce petit composant nommé "UAL", de quoi s'agit-il ?
Définition:
L'unité arithmétique et logique (notée UAL ou en anglais ALU pour Arithmetical and
Logical Unit). L'UAL assure les fonctions basiques de calcul arithmétique et les
opérations logiques (ET, OU, Ou exclusif, etc.).
Donc l'UAL est un composant chargé des :
 Opérations arithmétiques : ADD(+), SUB(-), MUL(*), DIV( : ), INC(+1), DEC(-
1)
 Opérations logiques : ( AND, OR, XOR, NOT, CMP ) et pour les décalages
(LSL, LSR, ASR, ASL)

Unité Arithmétique et logique

Le cycle d'exécution
L'UC va chercher en mémoire le code de l'instruction, avec éventuellement, un
opérande. Après décodage, elle va chercher en mémoire, le cas échéant, d'autres
opérandes nécessaires au calcul. Elle exécute ensuite l'instruction sur cette ou ces
données. Le résultat est ensuite stocké dans un registre interne ou en mémoire
centrale.
Le chemin de donnée est l'ensemble des éléments participant au transfert et au
traitement des données. Il comprend donc l'UT, les registres concernés dont
l'accumulateur, et le bus de donnée.
 Flots des instructions et des données

Un cycle d'exécution se compose d'une étape de recherche du code d'instruction, d'une

étape de décodage pour savoir ce qu'il faut faire, éventuellement d'une étape de
recherche d'opérandes et enfin, d'une étape d'exécution de l'instruction sur le ou les
opérandes.
Les indicateurs ou drapeaux d'état, comme la retenue (CF "Carry Flag") , le signe (SF
"Sign Flag") ou le dépassement de capacité (OF "Overflow Flag") renseignent
l'utilisateur sur la validité du résultat. Ils sont positionnés éventuellement en fin
d'exécution.

Cycle d'exécution

Inconvénient
Un inconvénient majeur de cette architecture est la centralisation des échanges de
données. L'unité centrale est un goulot d'étranglement, source de ralentissement des
communication. Un échange entre la mémoire et l'unité d'échange d'E/S se fait
obligatoirement par intermédiaire du microprocesseur qui exécute le transfert.
Des solutions à ce problème ont été proposées comme d'autres architectures, celle de
Harvard par exemple, avec la séparation des données et des instructions, ou des
améliorations comme l'ADM.

Unité de commande
L'unité de commande est l'ensemble des dispositifs coordonnant le fonctionnement de
l'ordinateur afin de lui faire exécuter la suite d'opérations spécifiées dans les instructions
du programme.
Les principaux dispositifs de l'unité de commande qui entrent en jeu lors de la
recherche en mémoire et du décodage d'une instruction (cycle de recherche) sont :
 Le compteur ordinal (CO), qui est un registre contenant l'adresse en mémoire
où est stockée l'instruction à chercher.
 Le registre d'instruction (RI), qui reçoit l'instruction qui doit être exécutée.
 Le décodeur de code opération, qui détermine quelle opération doit être
effectuée, parmi toutes les opérations possibles.
 Le séquenceur qui, génère les signaux de commande.
 L'horloge, qui émet des impulsions électroniques régulières, synchronisant ainsi
toutes les actions de l'unité centrale.
La circulation des informations pendant un cycle de recherche (fetch cycle) est illustrée
dans la figure suivante :

Cycle de recherche d'une instruction

Les différentes étapes du cycle de recherche peuvent être ainsi résumées :

1. Transfert de l'adresse de la nouvelle instruction du CO vers le RA, registre adresse
de la mémoire (memory adress register).
2. Une impulsion de lecture, générée par l'unité de commande, provoque le transfert
de l'instruction cherchée vers le RM (Registre Mot), qui fonctionne comme un
registre tampon pour toutes les informations lues ou écrites en mémoire.
 3. Transfert de l'instruction dans le RI (instruction = code opération + adresse
opérande).
4. Pendant que l'adresse de l'opérande est envoyée vers le RA, le code opération est
transmit au décodeur qui détermine le type d'opération demandée et le transmet
au séquenceur en envoyant un signal sur la ligne de sortie correspondante.
5. Le CO est incrémenté en vue du cycle de recherche suivant.
Le cycle de recherche est suivi par le cycle d'exécution durant lequel l'opération
spécifiée dans l'instruction est effectuée par l'UAL. La séquence exacte des actions
coordonées par le séquenceur dépendra naturellement de l'opération. En général,
pendant un cycle d'exécution, l'information circulera selon le schéma suivant :

Cycle d'exécution

Un cycle d'exécution comprend les étapes suivantes :

1. Le séquenceur commence à envoyer les signaux de commande vers la mémoire
pour lire l'opérande à l'adresse déjà stockée dans le RA et le faire parvenir dans le
RM.
2. Transfert du contenu du RM vers l'UAL, et plus précisément vers l'accumulateur ou
tout autre registre affecté à l'opération spécifiée. Dans certains cas, par exemple,
mémorisation d'un résultat, ce sera le contenu de l'accumulateur qui sera transféré
vers le RM.
3. L'opération est effectuée sous contrôle du séquenceur.
Une fois le cycle d'exécution terminé, l'unité de commande passe immédiatement au
cycle de recherche suivant et prend en compte la nouvelle instruction indiquée par
l'adresse contenue dans le CO.
Récapitulons

Schéma fonctionnel global de l'unité centrale

Le microprocesseur ne comprend qu'un certain nombre d'instructions qui sont codées

en binaire. Le traitement d'une instruction peut être décomposé en trois phases.
Phase 1: Recherche de l'instruction à traiter
1. Le PC contient l'adresse de l'instruction suivante du programme. Cette valeur est
placée sur le bus d'adresses par l'unité de commande qui émet un ordre de lecture.
2. Au bout d'un certain temps (temps d'accès à la mémoire), le contenu de la case
mémoire sélectionnée est disponible sur le bus des données.
3. L'instruction est stockée dans le registre instruction du processeur.

Recherche de l'instruction
Phase 2 : Décodage de l'instruction et recherche de l'opérande
Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut
être codée sur plusieurs mots. Ce mot contient le code opération qui définit la nature de
l'opération à effectuer (addition,soustraction,...) et le nombre d'opérandes.
1. L'unité de commande transforme l'instruction en une suite de commandes
élémentaires nécessaires au traitement de l'instruction.
2. Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de
commande récupère sa valeur sur le bus de données.
3. L''opérande est stockée dans un registre.

Décodage et recherche des opérandes

Phase 3 : Exécution de l'instruction

1. Le micro-programme réalisant l'instruction est exécuté.
2. Les drapeaux sont positionnés (registre d'état).
3. L'unité de commande positionne le PC pour l'instruction suivante.
Exécution de l'instruction
 Mémoires
Rappel:
Un ordinateur a deux caractéristiques essentielles qui sont la vitesse à laquelle il peut
traiter un grand nombre d'informations et la capacité de mémoriser ces informations.
C'est cette deuxième caractéristique que nous allons découvrir.

Qu'est ce qu'une mémoire ?

Une mémoire est un circuit à semi-conducteur permettant d'enregistrer,
de conserver et de restituer des informations (instructions et variables). C'est cette
capacité de mémorisation qui explique la polyvalence des systèmes numériques et leur
adaptabilité à de nombreuses situations. Les informations peuvent êtreécrites ou lues.
Il y a écriture lorsqu'on enregistre des informations en mémoire, lecture lorsqu'on
récupère des informations précédemment enregistrées.

Une mémoire

Les éléments de mémoire d'un ordinateur se repartissent en plusieurs niveaux

caractérisés par leur capacité (nombre d'informations qu'elles peuvent contenir) et
leur temps d'accès.
Si l'on compare la faculté de mémorisation d'un ordinateur avec celle de l'homme, on
s'aperçoit que l'homme a de plus grandes capacités, principalement dans les
mécanismes d'activation et de recherche en mémoire. Bien qu'il soit possible d'ajouter
indéfiniment des mémoires auxiliaires à un ordinateur jusqu'à rejoindre et même
dépasser la capacité d'un cerveau, on ne peut pas encore égaler les performances d'un
cerveau dans le traitement de certaines classes de données (par exemple, des sons ou
des images). Le cerveau travaille sur un grand nombre de données simultanément,
alors que l'ordinateur selon von Neumanntravaille essentiellement en séquence. Ceci
explique la différence de performance, mais il faut remarquer que l'organisation d'un
ordinateur est moins évoluée que celle d'un cerveau. En effet, la mémoire d'un
ordinateur est un élément passif au service de l'UC, alors que dans le cerveau, les
fonctions de mémoire et de traitement sont réalisées par des éléments actifs
intimement liés.
Hiérarchie des mémoires
Les différents éléments de la mémoire d'un ordinateur sont ordonnés en fonction des
critères suivants : temps d'accès, capacité et coût par bit.

Hiérarchie des mémoires

Une mémoire idéale serait une mémoire de grande capacité, capable de stocker un
maximum d'informations avec un temps d'accès très faible.
Quand on s'éloigne de l'UC vers les mémoires auxilliaires, on constate que le temps
d'accès et la capacité des mémoires augmentent, mais le coût par bit diminue. En
général les mémoires de grande capacité sont souvent très lente et les mémoire rapides
sont très chères. Et pourtant, la vitesse d'accès à la mémoire conditionne dans une
large mesure les performances d'un système. En effet, c'est là que se trouve le goulot
d'étranglement entre un microprocesseur capable de traiter des informations très
rapidement et une mémoire beaucoup plus lente.
Les éléments de mémoire situés dans l'unité centrale de traitement sont :
 Les registres qui sont caractérisées par une grande vitesse et servent
principalement au stockage des opérandes et des résultats intermédiaires.
 La mémoire cache ou l'antémémoire est une mémoire rapide de faible capacité
utilisée comme mémoire tampon entre l'UC et la mémoire centrale. Cette mémoire
permet au CPU de faire moins d'accès à la mémoire centrale et ainsi de gagner du
temps.
 La mémoire centrale ou principale est l'organe principal de rangement des
informations utilisées par l'UC. Pour exécuter un programme, il faut le charger
(instructions + données) en mémoire centrale. Cette mémoire est une mémoire à
semi-conducteurs, mais son temps d'accès est beaucoup plus grand que celui des
registres et du cache.
 La mémoire d'appui sert de mémoire intermédiaire entre la mémoire centrale et
les mémoires auxiliaires. Elle est présente dans les ordinateurs les plus évolués et
permet d'augmenter la vitesse d'échange des informations entre ces deux niveaux.
 La mémoire de masse est une mémoire périphérique de grande capacité et de
coût relativement faible utilisée pour le stockage permanent des informations. Elle
est utilisée pour le stockage, la sauvegarde ou l'archivage à long terme des
informations.
Fondamental:Organisation des informations
Les informations que l'on désire traiter dans un ordinateur doivent s'adapter à un
certain format, dont les caractéristiques générales sont les suivantes :
 Le bit (BInary Digit) constitue l'unité de base de l'information. Dans une mémoire,
le plus petit élément de stockage est souvent appelé point mémoire, il mémorise
un bit d'information.
 L'octet, plus connu sous le terme anglais byte, correspond à un groupement de 8
bits.
 Le caractère est un groupement de 6,7,8... bits permettant le codage d'un
caractère alphanumérique ou d'un caractère spécial.
 Le mot (word) est un groupement de bits constituant une unité d'information
adressable en unité centrale.

Caractéristiques des mémoires

 Adresse : c'est la valeur numérique désignant un élément physique de mémoire.
 Capacité ou taille d'une mémoire : elle correspond au nombre d'informations
qu'elle peut contenir. On peut exprimer cette valeur en fonction du nombre de bits,
de bytes ou de mots.
 Temps d'accès : c'est le temps qui s'écoule entre le lancement d'une opération
d'accès (lecture ou écriture) et son accomplissement.
 Cycle mémoire : c'est le temps minimal s'écoulant entre deux accès successifs à
la mémoire. Il est plus long que le temps d'accès, car le bon fonctionnement de la
mémoire nécessite quelques opérations de maintien, de stabilisation des signaux
dans les circuits, de synchronisation, etc.
 Débit : c'est le nombre d'informations lues ou écrites par seconde.
 Volatilité : elle caractérise la permanence des informations dans une mémoire.
Une mémoire volatile perd son contenu lorsque l'on coupe le courant, celle-ci a
donc besoin d'un apport constant d'énergie électrique pour conserver ses
informations.
Fondamental:Différents types d'accès aux mémoires
Accès séquentiel : c'est l'accès le plus lent ; pour accéder à une information
particulière, on est obligé de parcourir toutes celles qui la précèdent (par exemple, les
bandes magnétiques)
Accès direct : les informations ont une adresse propre, ce qui permet d'y avoir accès
directement (par exemple, les registres)
Accès semi-séquentiel : c'est une combinaison des accès direct et séquentiel (par
exemple, pour un disque magnétique, l'accès au cylindre est direct et l'accès au secteur
est séquentiel).

Mémoire centrale
La mémoire centrale ou principale contient les instructions et les données des
programmes que l'on désire exécuter, ainsi qu'une partie du système d'exploitation
nécessaire au bon fonctionnement de l'ordinateur. Tout programme que l'on veut
exécuter doit d'abord être chargé en mémoire centrale. Ensuite en y cherche les
instructions les unes après les autres pour les exécuter séquentiellement dans l'UC. La
capacité et la vitesse d'accès à la mémoire centrale sont des éléments déterminants
dans la puissance d'un ordinateur.
La mémoire centrale peut être représentée comme une armoire de rangement
constituée de différents tiroirs. Chaque tiroir représente alors une case mémoire qui
peut contenir un seul élément : des données. Le nombre de cases mémoires pouvant
être très élevé, il est alors nécessaire de pouvoir les identifier par un numéro. Ce
numéro est appelé adresse. Chaque donnée devient alors accessible grâce à son
adresse.

Organisation de la mémoire

Avec une adresse de n bits il est possible de référencer au plus 2n cases mémoire.
Chaque case est remplie par un mot de données (sa longueur m est toujours une
puissance de 2). Le nombre de fils d'adresses d'un boîtier mémoire définit donc le
nombre de cases mémoire que comprend le boîtier. Le nombre de fils de données
définit la taille des données que l'on peut sauvegarder dans chaque case mémoire.
En plus du bus d'adresses et du bus de données, un boîtier mémoire comprend une
entrée de commande qui permet de définir le type d'action que l'on effectue avec la
mémoire (lecture/écriture) et une entrée de sélection qui permet de mettre les
entrées/sorties du boîtier en haute impédance.
On peut donc schématiser un circuit mémoire par la figure suivante où l'on peut
distinguer :

Circuit mémoire

 les entrées d'adresses

 les entrées de données
 les sorties de données
  les entrées de commandes :
o une entrée de sélection de lecture ou d'écriture. ( R/W)
o une entrée de sélection du circuit. ( CS )
Fondamental:
Une opération de lecture ou d'écriture de la mémoire suit toujours le même cycle :
1. Sélection de l'adresse
2. Choix de l'opération à effectuer ( R/W )
3. Sélection de la mémoire ( CS = 0 )
4. Lecture ou écriture la donnée
Chronogramme d'un cycle de lecture :

Chronogramme d'un cycle de lecture

 Le système de communication
Rappel:Caractéristiques
Un bus transporte une information au sens large qui peut être une donnée, une
adresse, un contrôle ou un état. Il peut être spécialisé, c'est-à-dire dédié au type de
l'information qu'il véhicule ou générique. Un bus se caractérise principalement par sa
largeur L, et la définition de ses signaux et de son débit.
Un bus parallèle est un bus à L voies (L > 1) de communication. Ce bus est matérialisé
par des conducteurs électriques où circulent des signaux qui représentent l'information
binaire.

Bus de communication
Un bus peut être unidirectionnel (communication simplex) d'un émetteur vers un ou
plusieurs récepteurs, ou de plusieurs émetteurs vers un récepteur (bus convergent).
Plusieurs maîtres posent un problème de contention lors d'une demande multiple
d'accès au système de communication. Le bus peut aussi être bidirectionnel avec
communication simultanée (duplex intégral ou full duplex) ou alternée (semi-duplex ou
half duplex). Lors d'un échange entre deux entités de plusieurs types d'information, par
exemple une adresse et une donnée, le transfert peut utiliser des médias séparés ou
empreinter la même voie. La première approche est plus intéressante en terme de débit
mais il faut des bus séparés, un par type d'information.
La solution du bus multiplexé permet à plusieurs types d'information de circuler sur un
même bus mais à des instants différents. La communication peut être synchrone ou
asynchrone selon qu'un signal d'horloge est transmit explicitement ou non. Lorsqu'un
maître accède à un esclave, il précise le type d'accès : lecture ou écriture d'un mot,
écriture ou lecture d'un bloc...
Comme plusieurs entités communiquent sur un même bus, il est nécessaire de disposer
d'une logique spécialisée de gestion des accès et des échanges entre l'entité et le bus.
Fondamental:Le buffer
La connexion et la déconnexion de l'entité sur les bus se font à l'aide
d'un buffer ou tampon électronique qui appartient aussi à ce sous ensemble qui
permet de partager un bus.

Buffer de communication
Remarque:
Pour échanger les informations, il est nécessaire de définir un protocole de
communication qui va gérer l'échange.
Un protocole est un ensemble de conditions et d'opérations dont l'ordre strict doit
être respecté. Les conditions à respecter sont la définition des signaux matériels et des
contraintes temporelles. Les opérations sont l'activation ou non de signaux d'état, de
contrôle et de donnée.

Echange synchrone VS asynchrone

La figure suivante détaille un échange synchrone d'un processeur qui effectue une
lecture dans une mémoire. il envoi l'adresse sur le bus d'adresse où elle est décodée
par tous les décodeurs d'adresse des entités esclaves. L'entité concernée est accédée
grâce à l'activation de son signal de sélection (signal CS), et renvoie la donnée désirée.
L'ensemble est rythmé par une horloge.

Echange synchrone

Dès que la donnée est délivrée à la mémoire, il peut exister un temps appelé Latence.
Le transfert synchrone facilite la conception et garantit les temps d'échange. La
tendance actuelle va vers le transfert asynchrone pour sa consommation électrique
moindre, critère important pour les systèmes nomade et sa plus grande flexibilité.

Cycle de lecture processeur

Lors d'un échange asynchrone, le début de déroulement du protocole est le même
que précédemment, sauf que la lecture de la donnée est liée à un signal d'acquittement
de l'esclave. Ce signal peut ne jamais arriver, bloquant ainsi l'échange. Des mécanismes
comme le chien de garde permettent de débloquer la situation, une erreur bus étant
alors générée.

Lecture asynchrone

L'arbitrage d'accès
Lorsque plusieurs maîtres demandent le bus, il est nécessaire de réaliser un arbitrage
d'accès. L'arbitrage consiste à sélectionner un maître parmi n pour l'autoriser à prendre
le bus (accord ou grant). Une fois l'échange terminé, l'entité peut relâcher le bus.
Plusieurs techniques existent de type centralisé ou réparti. La demande et la résolution
peuvent être série ou parallèle. Plusieurs politiques d'arbitrage existent, comme la
priorité fixe, tournante, la première demandée - la première servie.
Dans une approche centralisée, les demandes d'accès aux bus se font de manière
asynchrone. Il faut distinguer alors, dans le contrôleur du bus, l'arbitre de bus qui reçoit
les demandes et, en fonction de la politique d'accès, détermine quelle entité peut
accéder au bus.
Dans la figure suivante, chaque nœud génère sa demande de bus BReq (Bus Request)
et reçoit son autorisation BPRI (Bus Priority In). Un encodeur de priorité détermine alors
le numéro de ligne qui sera servie selon une politique donnée.

Arbitrage avec demande et résolution parallèles

Dans le cas d'un arbitrage centralisé, le gérant de bus a besoin de savoir s'il y a une
demande en cours et si le bus est occupé ou relâché.
Les unités intéressées positionnent leurs ligne "demande de bus" (demande de type
parallèle). L'arbitre positionne la ligne "accord" si la ligne "bus occupé" ne l'est pas.
Une unité demandeuse qui recoit un accord occupe le bus le temps qu'elle désire. Ceci
est un inconvénient.

L'arbitrage centralisé

Lors de demandes simultanées, le gérant de bus peut demander la relâche impérative

du bus pour une unité moins prioritaire l'utilisant. Un signal de relâche est donc
nécessaire.
Le chronogramme suivant donne un exemple d'arbitrage avec cette approche. Le noeud
n° 0 est ici le plus prioritaire. Le bus est libre. Le noeud n°1 demande le bus et est
autorisé à le prendre. Il le libère. Le noeud n°0 fait de même. Pendant que ce dernier
est le maître du bus, le noeud n°1 fait une demande qui est refusée tant qu'un noeud
de priorité supérieure possède le bus. Après libération du bus, il peut le prendre.

Exemple d'un protocole d'arbitrage centralisé

La" daisy-chain " est une technique d'arbitrage répartie série. Répartie car chaque
noeud possède son arbitre.
Dans la figure suivante, la demande et la résolution se font en série. L'autorisation
rentre dans chaque noeud par BPRI (Bus Priority In) et ressort si l'unité est d'accord par
BPRO (Bus Priority Out).

L'arbitrage série

Dans l'approche répartie par auto-sélection, chaque entité est élément de la

négociation. Les accès aux bus se font de manière synchrone (par cycle). Les phases
d'arbitrage sont les suivantes :
Au début d'un cycle, les unités intéressées émettent leur adresse sur le bus. L'adresse
formée est le "OU logique" des adresses. L'élément absorbant est donc "1".
Durant le cycle, les unités écoutent le bus et modifient leurs émission en 0 à partir de la
première différence (ordre MSB ==> LSB).
Au cycle suivant, il y a abandon d'une unité si ce qu'elle a émis n'est pas ce qu'elle
écoute.
Il y a achèvement si une unité reconnaît son adresse.
Exemple :
 Exemple d'un arbitrage réparti par auto sélection

Conseil:
La solution centralisée a le mérite d'être simple mais les politiques réparties sont plus
tolérantes aux fautes matérielles sauf, bien évidement, pour l'approche daisy-chain.
Remarque:
La demande d'accès aux bus pour un échange E/S peut se faire comme expliqué
précédemment ou par interruption avec intervention de l'UC.
dans une architecture actuelle à plusieurs maîtres, la ressource critique n'est plus
uniquement le bus de communication, c'est aussi la mémoire. Il est nécessaire de
réaliser un arbitrage au niveau même de l'entité esclave pour des problèmes de
cohérence de données.

Les unités d'échange d'entrée/sortie

 Partie 3 : Programmation
assembleur 80X86
 Introduction
 Chapitre 1 : Premiers pas..
 Chapitre 2 : Les Bases du langage
 Chapitre 3 : Les instructions de base
 Chapitre 4 : Notions avancées

Introduction
Tous les langages de programmation modernes sont
des héritiers plus ou moins directs de ce langage
élémentaire qu'est l'assembleur. Mais à l'heure où la
programmation objet fait fureur dans le milieu des
développeurs de logiciels, on peut se demander à
juste titre à quoi peuvent servir des connaissances et
des compétences dans un langage de programmation
aussi ancestral et aussi primitif.
La seule qualité que l'on peut trouver au langage
assembleur c'est d'être celui qui est le plus proche du
langage machine. En effet, quelque soit le langage
d'origine c'est un programme en langage machine qui
sera exécuté en définitive par le microprocesseur.
Connaître la programmation en assembleur peut donc
donner des atouts considérables pour la
compréhension et la maîtrise de tous les autres
langages de programmation.
 Chapitre 1 : Premiers pas..
 Pourquoi l'assembleur ?
 Écriture et exécution d'un programme
 Architecture du Intel X86


 Pourquoi l'assembleur ?
 Lorsque l'on doit lire ou écrire un programme en
langage machine, il est difficile d'utiliser la
notation hexadécimale .
 On écrit les programmes à l'aide de symboles
comme MOV, ADD, etc.
 Les concepteurs de processeur, comme Intel,
fournissent toujours une documentation avec les
codes des instructions de leur processeur, et les
symboles correspondant.
 Écriture et exécution d'un
programme
L'assembleur est un utilitaire qui n'est pas interactif,
contrairement à l'utilitaire debugqui fera l'objet du
premier TP. Le programme que l'on désire traduire
en langage machine (on dit assembler) doit être
placé dans un fichier texte (avec
l'extension.ASM sous DOS).
La saisie du programme source au clavier nécessite
un programme appelé éditeur de texte.
L'opération d'assemblage traduit chaque instruction
du programme source en une instruction machine. Le
résultat de l'assemblage est enregistré dans un fichier
avec l'extension .OBJ (fichier objet ).
Le fichier .OBJ n'est pas directement exécutable. En
effet, il arrive fréquemment que l'on construise un
programme exécutable à partir de plusieurs fichiers
sources. Il faut "relier'' les fichiers objets à l'aide
d'un utilitaire nommé éditeur de lien.
L'éditeur de liens fabrique un fichier exécutable , avec
l'extension .EXE. Ce dernier est directement
exécutable grâce Un utilitaire spécial du système
d'exploitation.
 Étape de compilation d'un programme assembleur

Architecture du Intel X86

Le processeur 8086 date de 1978, et il est toujours
en vigueur aujourd'hui dans les processeurs Intel et
AMD.
Parmi les caractéristiques fonctionnelles de ce
processeur on trouve :
 Données sur 16 bits
 Adresses mémoire sur 20 bits : 1 Mo addressabe
 8 registres généraux de 16 bits
Remarque:
Cette architecture a l'inconvénient de disposer de peu
de registre de taille trop petites. Cependant elle a
l'avantage d'évoluer avec les nouvelles gammes de
processeurs intel tout en gardant la compatibilité
avec l'architecture originale x86.
La première évolution a eu lieu en1985. cette
évolution était marqué par le passage au 32 bit de
tel sorte que le programmeur dispoe de 8 registres
généraux de 32 bit ains que des adresses mémoires
sur la même taille.

Les registres du intel 8086

Chaque registre peut avoir une fonction particulière

implicite selon l'instruction utilisée :
 AX : accumulateur
 BX : base (adresse mémoire)
  CX : compteur
 DX : donnée, entrées/sorties
 SI : index source
 DI : index destination
 BP : base de la pile
 SP : pointeur sur le sommet de la pile
Méthode:
Les registres en « X » peuvent être utilisés sous la
forme de 2 registres 8 bits tel que xX = xH + xL
H : partie haute, L : partie basse
xX = 256 * xH + xL
AX = 256 * AH + AL
BX = 256 * BH + BL
CX = 256 * CH + CL
DX = 256 * DH + DL
Autres registres :
 IP : pointeur d'instruction
 FLAGS : flags (drapeaux 1 bit)
 Registres de segments mémoires
 CS : code
 DS : données (data)
 SS : pile (stack)
 ES : extra
 Chapitre 2 : Les Bases du langage
 Structure d'un programme assembleur
 Déclaration des variables simples
 Les tableaux
 Plus loin avec les REGISTRES
 Les modes d'adressage


 Structure d'un programme

assembleur
 La structure générale d'un programme assembleur
est représentée dans la figure suivante :


 Structure d'un programme ASM
 Comme tout programme, un programme écrit en
assembleur comprend des définitions
de données et des instructions, qui s'écrivent
chacune sur une ligne de texte.
 Les données sont déclarées par des directives,
mots clef spéciaux que comprend l'assembleur.
Les directives qui déclarent des données sont
regroupées dans le segment de données, qui
est délimité par les
directives SEGMENT et ENDS.
 Les instructions sont placées dans un autre
segment, le segment de code.
 La directive ASSUME est toujours présente et
sera expliquée plus loin (section ).
 La première instruction du programme (dans le
segment d'instruction) doit toujours être repérée
par une étiquette. Le fichier doit se terminer
par la directive END avec le nom de
l'étiquette de la première instruction (ceci
permet d'indiquer à l'éditeur de liens quelle est la
première instruction à exécuter lorsque l'on lance
le programme).
 Les points-virgules indiquent des commentaires.
 Déclaration des variables simples
On déclare les variables à l'aide dedirectives.
L'assembleur attribue a chaque variable
une adresse. Dans le programme, on repère les
variables grâce à leur nom.
Les noms des variables (comme les étiquettes ) sont
composés d'une suite de 31 caractères au maximum,
commençant obligatoirement par une lettre. Le nom
peut comporter des majuscules, des minuscules, des
chiffres, plus les caractères @, ? et _.
Les variables se déclarent de la manière suivante:
variable1 db ? ; variable1 est un byte non initialisé
une_autreVARIABLE2 db 0FFh ;
une_autreVARIABLE2 est un byte initialisé à FF (255
en hexadécimal)
My_Var dw ? ; My_Var est un word (16 bits) non
initialisé
Remarque:
De manière générale:
DB : 1 byte (8 bits) (Declare Byte)
DW : 1 word (16 bits) (Declare Word)
DD : 2 words (32 bits) (Declare Double)
DF,DP : 6 bytes
DQ : 8 bytes (64 bits)
DT : 10 bytes
Les constantes peuvent être écrites en:
- décimal: 1, 2, 3, 123, 45
- hexadécimal : 1h,2h,3h,12h,0Fh,0AD4h (noter la
présence du 0 quand le le premier chiffre du nombre
en hexadécimal commence par une lettre)
- binaire : 1b,0b,1010b,111101b
Exemple:
Les directives DB (Define Byte) et DW (Define Word)
permettent de déclarer des variables de
respectivement 1 ou 2 octets.
data SEGMENT
entree DW 15 ; 2 octets initialises a 15
sortie DW ? ; 2 octets non initialises
cle DB ? ; 1 octet non initialise
nega DB -1 ; 1 octet initialise a -1
data ENDS
Les valeurs initiales peuvent être données en
hexadécimal (constante terminée par H) ou en
binaire (terminée par b) :
data SEGMENT
truc DW 0F0AH ; en hexa
masque DB 01110000b ; en binaire
data ENDS
Méthode:
Les variables s'utilisent dans le programme en les
désignant par leur nom. Après la déclaration
précédente, on peut écrire par exemple :
MOV AX, truc
AND AL, masque
MOV truc, AX
L'assembleur se charge de remplacer les noms de
variable par les adresses correspondantes.

Les tableaux
Il est possible de déclarer des tableaux , c'est à dire
des suite d'octets ou de mots consécutifs.
Pour cela, utiliser plusieurs valeurs initiales :
data SEGMENT
machin db 10, 0FH ; 2 fois 1 octet
chose db -2, 'ALORS'
data ENDS
Remarque:
la déclaration de la variable chose : un octet à -2
(=FEH), suivi d'une suite de caractères.
L'assembleur n'impose aucune convention pour la
représentation des chaînes de caractères : c'est à
l'utilisateur d'ajouter si nécessaire un octet nul pour
marquer la fin de la chaîne.
Après chargement de ce programme, la mémoire
aura le contenu suivant :

Exemple:
Si on veut écrire un caractère Z à la place du O de
ALORS, on pourra écrire :
MOV AL, 'Z'
MOV chose+1, AL
Notons que chose+1 est une constante (valeur
connue au moment de l'assemblage) : l'instruction
générée par l'assembleur pour
MOV chose+1, AL est :
MOV [adr] , AL ----------> ( [adr] est une adresse
mémoire, le point suivant traite des différents modes
d'adressage)
Méthode:
Une autre méthode pour déclarer un tableau consiste
à utiliser la directiveDUP qui nous permet de déclarer
un tableau de n cases, toutes initialisées à la même
valeur.
tab DB 100 dup (15) ; 100 octets valant 15
zzz DW 10 dup (?) ; 10 mots de 16 bits non
initialises

Plus loin avec les REGISTRES

Rappel:
Le microprocesseur est le cœur de l'ordinateur.
C'est lui qui est chargé de reconnaître les instructions
et de les exécuter (ou de les faire exécuter). Chaque
instruction se présente sous la forme d'une suite de
bits qu'on représente en notation hexadécimale
(exemple : B44C, ou 1011010001001100 en binaire).
Une instruction se compose d'un code opérateur (le
plus souvent appelé « opcode ») qui désigne l'action
à effectuer (B4 dans notre exemple) et d'un « champ
d'opérandes » sur lesquelles porte l'opération (ici
l'opérande est 4C).
Les registres des processeurs INTEL se classent en
quatre catégories :
 les registres généraux (16 bits)
 les registres de segment (16 bits)
 les registres d'offset (16 bits)
 le registre des indicateurs (16 bits)
 Les registres généraux
________________________________
Ils ne sont pas réservés à un usage très précis, On
les utilises pour manipuler des données diverses. Ce
sont en quelque sorte des registres à tout faire.
Chacun de ces quatre registres peut servir pour la
plupart des opérations, mais ils ont tous une fonction
principale qui les caractérise.
AX Accumulateur
BX Base
CX Compteur
DX Données
 Le registre AX sert à effectuer des calculs
arithmétiques ou à envoyer un paramètre à une
interruption
 Le registre BX sert à effectuer des calculs
arithmétiques ou bien des calculs sur les adresses
 Le registre CX sert généralement comme
compteur dans des boucles
 Le registre DX sert à stocker des données
destinées à des fonctions
Exemple:Utilisation
L'instruction “MOV AX, 1982” place l'entier 1982
dans AX.
“ADD AX, 1983” ajoute à AX le nombre 1983 et
place le résultat dans AX.
 Utilisation de CX dans les boucles

Le code ci dessus place 18 dans le registre

compteur CX. Ainsi à chaque passage de
l'instruction loop, la valeur du registre CX se
décrémente automatiquement.
Les registres de segment
________________________________
________________________________
_________________
Ces registres ne peuvent servir pour les opérations
courantes : ils ont un rôle très précis. On ne peut
d'ailleurs pas les utiliser aussi facilement que AX ou
BX, et une petite modification de l'un d'eux peut
suffire à « planter » le système.
CS Segment de code
DS Segment de données
ES Extra segment
SS Segment de pile
 Dans le registre CS est stockée l'adresse de
segment de la première instruction à exécuter. La
raison pour laquelle il ne faut surtout pas changer
 sa valeur directement est évidente. Le seul moyen
viable de le faire est d'utiliser des instructions
telles que des sauts (JMP) ou des appels (CALL)
vers un autre segment. CS sera alors
automatiquement actualisé par le processeur en
fonction de l'adresse d'arrivée. ( Les
instructions JMP et autres..seront détaillés plus
loin dans ce chapitre ).
 Le registre DS est quant à lui destiné à contenir
l'adresse du segment des données du
programme en cours. On peut le faire varier à
condition de savoir exactement pourquoi on le fait.
Par exemple, on peut avoir deux segments de
données dans son programme et vouloir accéder
au deuxième. Il faudra alors faire pointer DS vers
ce segment.
 L'extra segment ES est un registre qui sert à
adresser le segment de son choix. On peut le
changer aux mêmes conditions que DS. Par
exemple, si on veut copier des données d'un
segment vers un autre, on pourra faire pointer DS
vers le premier et ES vers le second.
 Le stack Segment SS est un registre contenant
l'adresse du segment de pile. Il est rare qu'on
doive y toucher car le programme n'a qu'une seule
pile.
Attention:
Avant l'exécution chaque registre contient l'adresse
d'un segment diffèrent qui a une taille de 64 ko. Par
 contre dans un programme ".com" tous les registres
contiennent l'adresse de début du même segment.

fichier .com à gauche et fichier .exe à droite

Les modes d'adressage

Définition:
Un mode d'adressage est un moyen qui permet au microprocesseur d'avoir accès à une
donnée.
Cette donnée peut être un nombre quelconque dont on aura besoin dans le
programme, un nombre qui se trouve déjà dans un registre, ou encore un nombre qui
se trouve écrit quelque part en mémoire.
La connaissance des principaux modes d'adressage est nécessaire car elle permet
d'écrire les programmes de la façon la plus courte, la plus simple et la plus lisible
possible.

Adressage immédiat
On appelle « adressage immédiat » l'adressage qui ne fait intervenir que des
constantes.
Exemple :
mov AX, 568
Exemple:Adressage direct ou immédiat
Considérons cette partie de programme qui stocke le nombre 14 dans une variable
appelée TOTO, lui ajoute 20puis charge le résultat dans AX.

Adressage immédiat

Remarque:
L'instruction mov byte ptr ds:[TOTO], 14 charge le nombre 14 dans l'octet de la RAM
adressé par DS et l'offset de “TOTO”.
La ligne suivante ajoute 20 au contenu de cet octet.
L'expression “byte ptr” devant l'adresse, obligatoire ici, indique la taille de la
variable dans laquelle doit être stocké le nombre 14
Si on avait mis “word ptr”, ce nombre aurait été codé sur 16 bits au lieu de 8 bits :
on aurait donc écrasé le prochain octet qui suit la variable.
Attention:
Que se passe-t-il si le programmeur n'écrit pas le registre de segment dans l'adresse ?
Fondamental:
C'est là qu'intervient la directive “assume”. Le compilateur va trouver lui-même quel
registre l'utilisateur a voulu sous-entendre.
Si on a utilisé le nom de la variable, alors le segment sera celui dans lequel est déclaré
cette variable.
Mais le compilateur veut un REGISTRE de segment. Il va donc prendre celui qui est
censé pointer vers le bon segment et pour le savoir, il examine la directive assume.
Voilà pourquoi cette dernière peut nous épargner d'écrire pour chaque variable
l'expression “ds:”.
 Adressage indexé et adressage basée
il est possible d'utiliser des registres de base ou d'index pour adresser un octet.
On appelle « base » les registres BX et BPet « index » les registres SI et DI.
Conseil:
BX, BP, DI et SI peuvent tous être utilisés comme des registres généraux.

Récapitulons

.
 .

Remarque:
Si la constante n'est pas un label, il est parfois impératif de spécifier le registre de
segment ! Tout dépend du contexte...

Chapitre 3 : Les instructions de

base
 Format standard d'une instruction
 Déplacement des données
 Les opérations arithmétiques
 Les opérations logiques
 Branchement inconditionnel
 Branchement conditionnel
 Les structures itératives
 Équivalent des instruction en C
 Format standard d'une instruction
Format d'une instruction
Label: Mnémonique Opérandes ;commentaire
Label: est un identificateur permettant de désigner un endroit dans le code source, soit
une instruction, soit une donnée. Si le label est placé avant une instruction, on fait
référence à l'adresse de cette instruction. Si c'est avant une donnée, on fait référence à
l'adresse de cette instruction.
Le label de code doit se terminer par deux points (:). Il sert général comme
destinations des instructions ou des retour de début des boucles de répétition.
Le label de donnée ne contient pas les deux points(:) à la fin. Il sert dans ce cas là
comme identificateur.
Mnémonique (des instructions): il sert à identifier une instruction donnée..
Quelques instructions de base sont résumées dans la prochaine section.
Opérandes: une instruction assembleur peut avoir de 0 à 3 opérandes. Chaque
opérande peut être le nom d'un registre, un opérande mémoire, une expression
constante ou le nom d'un périphérique entrée/sortie.
Commentaire: précédé du point-virgule (;). Il sert à à ajouter des informations
explicatives au sujet du fonctionnement du programme ou de l'instruction
correspondante.
 Déplacement des données
L'affectation des données à des emplacement mémoire ou à des registres s'effectue
principalement à l'aide de l'instruction MOV

Remarque:
L'instruction Offset retourne l'adresse mémoire de la variable qui la suit.
c'est très utile lorsqu'on veut parcourir une plage mémoire. (Nous verrons
unexemple plus loin dans ce chapitre)
 Les opérations arithmétiques
Quelques opérations arithmétiques de base

Attention:
Comment Faire pour la multiplicationet la division ?
 Les opérations logiques

Attention:
Comment faire pour initialiser un registre à 0 ? (juste en utilisant des opérations
logiques)
 Branchement inconditionnel
Les sauts inconditionnels
Contrôler le flux du programme est une chose très importante, c'est là que votre
programme peut prendre des décisions en fonction de certaines conditions.
L'instruction de base qui transfère le contrôle d'un point vers un autre point du
programme est JMP.
La syntaxe de base de l'instruction JMP:

JMP label
Pour déclarer une étiquette dans votre programme, il suffit de taper son nom et
ajouter ":" à la fin, l'étiquette peut être n'importe quelle combinaison de caractères,
mais il ne peut pas commencer par un nombre, par exemple voici 3 définitions des
étiquettes :

label1:
label2:
a:
Voici un exemple de l'instruction JMP:

.
 Branchement conditionnel
Les sauts conditionnels
Contrairement à l'instruction JMP qui fait un saut inconditionnel, il ya des instructions
qui font un saut conditionnel (sauter seulement lorsque certaines conditions sont
réalisées). Ces instructions sont divisés en trois groupes, le premier groupe teste
seulement le drapeau, le second compare les nombres comme étant signés, et la
troisième compare les nombres comme non signés.
Toutes les instructions de branchement testent les valeurs du registre d'état. Ce dernier
contient un ensemble de flags qui changent de valeurs surant l'exécution du
programme.
La figure suivante détaille le contenu du registre d'état :

Premier groupe (test sur un seul drapeau):

 Instructions de saut qui testent un seul drapeau

Deuxième groupe (test pour les nombres signés):

Instructions de saut conditionnelle pour les nombres signés

Troisième groupe (test pour les nombres non signés):

 Instructions de saut conditionnelle pour les nombres non signés

Remarque:
Quand il s'agit de comparer des valeurs numériques, l'instruction CMP est utilisée (elle
fait la même chose que l'instruction SUB (soustraction), mais ne garde pas le résultat,
elle affecte seulement les drapeaux)
Exemple:
Voici un exemple montrant l'utilisation de l''instruction CMP avec les sauts conditionnels
 .

L'instruction putc joue le meme role que printf en C. Cette instruction est définie dans
un fichier qui vient avec l'èmulateur emu8086.
donc pour pouvoir l'utiliser on met toujours en entête du programmeinclude
"emu8086.inc"

Les structures itératives

L'instruction LOOP

l'instruction Loop

Dans cet exemple, à chaque passage par l'instruction loop, le registre CX est
décrémenté et l'exécution reprend à partir de mon_etiquette.
 une fois le registre CX atteint la valeur 0, l'exécution continu de manière séquentielle.
Exemple:Parcours d'un tableau..

dites ce que fait ce programme ! ! !

Équivalent des instruction en C

.
.

.
 Un dernier exemple :

Attention:Exercice
Coder en assembleur les instructions suivantes :

Chapitre 4 : Notions avancées

 Interruptions utiles
 Les procédures
 La pile

Interruptions utiles
Les entrées / sorties

Les procédures
La procédure est une partie du code qui peut être appelé à partir de votre programme
afin de faire quelques tâches spécifiques. Les procédures rendent les programmes plus
structurels et plus facile à comprendre. Généralement à la fin de son exécution, la
procédure revient au même point d'où elle a été appelée.
La syntaxe de déclaration de la procédure:
 .

name - est le nom de la procédure, le même nom doit être dans le haut et le bas, ceci
est utilisé pour vérifier la fermeture correcte des procédures.
Probablement, vous savez déjà que l'instruction RET est utilisée pour revenir au
système d'exploitation. La même instruction est utilisée pour retourner de la procédure.
PROC et ENDP sont des directives de compilation, elles ne sont pas assemblés dans un
code machine. Le compilateur se souvient juste de l'adresse de la procédure pour
l'appeler,
et c'est l' instruction CALL est utilisé pour appeler une procédure.
Voici un exemple:

Il ya plusieurs façons de passer des paramètres à la procédure, la meilleure façon de

passer des paramètres est d'utiliser des registres.
Voici un autre exemple d'une procédure qui reçoit deux paramètres dans AL et BL,
multiplie ces paramètres et retourne le résultat dans AX :
 .

Remarque:
Dans l'exemple ci-dessus le registre AL est mis à jour chaque fois que la procédure est
appelée, BL reste inchangé. Cet algorithme calcule 2 à la puissance de 4,
et le résultat final se trouve dans AX.

La pile
Définition
Les piles offrent un nouveau moyen d'accéder à des données en mémoire principale,
qui est très utilisé pour stocker temporairement des valeurs.
Une pile est une zone de mémoire et unpointeur qui conserve l'adresse du sommet
de la pile.

Instructions PUSH et POP

Deux nouvelles instructions, PUSH et POP, permettent de manipuler la pile.

PUSHregistre --
empile le contenu du registre sur la pile.
>
retire la valeur en haut de la pile et la place dans le
POPregistre
regsitres spécifié.
Exemple:Transfert de AX vers BX en passant par la pile
PUSH AX ..................; Pile <- AX
POP BX .....................; BX <- Pile
La pile est souvent utilisée pour sauvegarder temporairement le contenu des registres :
 .

On voit que la pile peut conserver plusieurs valeurs. La valeur dépilée par POP est la
dernière valeur empilée; c'est pourquoi on parle ici de pile LIFO (Last In First Out,
Premier Entré Dernier Sorti).

Les registres SS et SP
La pile est stockée dans un segment séparé de la mémoire principale. Le processeur
possède deux registres dédiés à la gestion de la pile, SS et SP.
Le registre SS (Stack Segment) est un registre segment qui contient l'adresse du
segment de pile courant (16 bits de poids fort de l'adresse). Il est normalement initialisé
au début du programme et reste fixé par la suite.
Le registre SP (Stack Pointer) contient le déplacement du sommet de la pile (16 bits
de poids faible de son adresse).

Les adresses croissent vers le bas. SP pointe sur le sommet (dernier emplacement occupé).

Déclaration d'une pile

Pour utiliser une pile en assembleur, il faut déclarer un segment de pile, et y réserver
un espace suffisant. Ensuite, il est nécessaire d'initialiser les registres SS et SP pour
pointer sous le sommet de la pile.
Voici la déclaration d'une pile de 200 octets :
 .

Remarque:
Noter le mot clef ``stack '' après la directive SEGMENT, qui indique à l'assembleur qu'il
s'agit d'un segment de pile. Afin d'initialiser SP, il faut repérer l'adresse du bas de la
pile; c'est le rôle de la ligne
base_pile EQU this word

Une pile vide. L'étiquette base-pile repère la base de la pile, valeur initiale de SP

Après les déclarations ci-dessus, on utilisera la séquence d'initialisation :

Noter que le registre SS s'initialise de façon similaire au registre DS; par contre, on peut
accéder directement au registre SP.
 Partie 4 : Travaux pratiques
 TP 1

TP 1
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.
MATÉRIEL UTILISÉ
• Micro-ordinateur IBM et compatible muni d'un μP80x86.
• Programme DEBUG

 Introduction
 Activité 1 : Entrée et Sortie de DEBUG
 Activité 2 : Examiner et changer les contenus de registres
 Activité 3 : Coder et Exécuter les programmes avec DEBUG
 Activité 4 : Manipulation des données avec DEBUG
 Activité 5 : La convention « Little Endian » et comment le μP80x86
sauvegarde les mots
 Activité 6 : Examiner et changer le registre FLAGS avec DEBUG
 Activité 7 : Compléments

 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.

 .

 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'.
 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.
Conseil:
Note Annexer la lettre H pour les nombres hexadécimaux n'est pas nécessaire avec
DEBUG.
 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.
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]
Attention:
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)
Attention:
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.
Attention:
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.

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 vu
enintroduction, 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.
Remarque:
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]
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éplacer un mot d'un registre avers une location mémoire:

.
 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) :
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
Méthode:
Utiliser la commande „T' pour suivre l'exécution des instructions, une à la fois,
et observer l'évolution des bitsFLAGS tout en commentant.
 Activité 7 : Compléments
- 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 commeMASM.
Méthode:
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)
Ensuite :
 E 200 25 12 15 1F 2B
D 200 LF
G=100 111
D 200 LF
Remarque:
Ce programme contient une instruction de saut basée sur l'état de l'indicateurZF 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'.
Complément:
le même programme écrit avec MASM serait :
G:\cours d'achitecture\web\co\Architecture_Ordis_60.html

Ce qui vient par la suite sera uniquement du TASM. Donc tous les programmes écrits
vont respecté la structure vu précédemment dans le COURS !
 TP 2
Objectifs

 Coder un programme en langage assembleur.

 Créer un fichier exécutable en assemblant avec TASM et liant avec TLINK le code.
 Utiliser DEBUG avec le fichier exécutable généré.
MATÉRIEL UTILISÉ
Micro-ordinateur IBM et compatible muni d'un μP80x86.
Assembleur TASM et éditeur de liens TLINK
Programme DEBUG

 Introduction
 Activité 1 : Écrire et exécuter un programme assembleur
 Activité 2 : Additionner des mots au lieu des octets
 Activité 3 : Déplacer un bloc de données octet / mot
 Activité 4 : Les emplacements mémoire des données
 Introduction
Les programmes de Borland Turbo
Assembler et Turbo Link sont des utilitaires qui
permettent d'assembler (avec la
commande TASMnom_fichier.asm) et lier (avec la
commande TLINK nom_fichier.obj) un fichier écrit en
langage assembleur (nom_fichier.asm) pour le
convertir en un fichier exécutable (nom_fichier.exe)
écrit dans le langage machine binaire.
Il est possible d'utiliser l'utilitaire DEBUG pour
déboguer le programme assembleur se trouvant dans
le format exécutable (nom_fichier.exe). Pour utiliser
DEBUG, sous DOS, on écrit: DEBUG nom_fichier.exe
Ensuite, toutes les commandes vues durant la séance
du TP1 peuvent être utilisées de la même manière. Il
est à noter qu'un équivalent de DEBUG existe. Il s'agit
de EMU8086. Celui-ci sera utilisé durant la prochaine
séance de TP.
 Activité 1 : Écrire et exécuter un
programme assembleur
Partie 1 :
En utilisant un éditeur de texte de votre choix, écrivez un programme qui permet
d'additionner dix nombres quelconques (entiers non-signés d'un octet); faites toutefois
attention au dépassement! Pour cela, utiliser une boucle et le mode d'adressage
registre indirect. Dans le programme, vous devrez inclure un segment de code et un
segment de données.
 Assembler et lier votre programme en utilisant les
commandes TASM et TLINK simplement sans aucune option. Vérifier que les
fichiers .OBJ et .EXE sont générés.
 Sous DOS, taper TASM /? et TLINK /? pour avoir une idée générale de toutes les
options disponibles.
 Assembler à nouveau en incluant l'option ( /l ou /la ) pour TASM qui permet
d'obtenir un listing d'assemblage. Visualiser le fichier portant l'extension .LST et
observer son contenu.
 Lier à nouveau en incluant l'option ( /m ou /s ) pour TLINK qui permet d'obtenir
une carte détaillée de l'occupation mémoire. Visualiser le fichier .MAP et observer
son contenu.
 Fournir ces fichiers avec votre rapport.
Note: Dorénavant, inclure toujours les options ( /la et /zi ) pour TASM et ( /s et /v )
pour TLINK.

Partie 2 :
Avec le programme DEBUG, charger le fichier exécutable généré durant la partie
précédente. Désassembler le programme pour voir les valeurs assignées par le DOS au
registre CS et l'offset d'origine de votre code. Où se trouve en mémoire votre segment
de données? Vérifier le placement des données à sommer et en indiquer la plage
d'adresse.

Partie 3 :
Tracer le programme et analyser les changements des registres généraux, index, base,
pointeurs et flag, instruction par instruction jusqu'à la fin du programme. Vérifier
l'exactitude de votre somme et son emplacement mémoire.
Activité 2 : Additionner des mots au lieu
des octets
Reprendre l'activité 1, mais cette fois-ci en additionnant 4 mots de 16-bits:
1222H, 1333H, 1191H, et 32F1H. Sauvegarder le programme pour l'utiliser
ultérieurement.

.
 Activité 3 : Déplacer un bloc de
données octet / mot
Énoncé :
Ecrire deux programmes qui permettent de déplacer un bloc de données un octet à la
fois, ensuite, un mot à la fois.
Utiliser le segment de données suivant (pour les MOTS 16 bit ) :

Utiliser le segment de données

suivant (pour les octets 8 bit ) :

Attention:Objectif
Votre objectif consiste à déplacer le contenu de var1 dans var2 !
Testez vos deux programmes avec Debug, biensur aprés les avoir conpiler et linker
avec (TASM et TLINK).
 Activité 4 : Les emplacements mémoire des
données
Partie 1:
Décrire ce que fait ce programme :

Utiliser Turbo Assembleur et Turbo Link pour générer le fichier exécutable de ce

programme. En utilisant DEBUG, vérifier la valeur de DS assignée par le DOS de votre
PC. Donner les emplacements mémoire des données du programme.

Méthode:Partie 2 :
Placer ce segment de données dans le programme :
 .

Assembler et LINKer le programme et observer avec DEBUG comment ces données sont
placées dans la mémoire.

Partie 3 :
Que fait le programme suivant :