TD/TP2 (semestre1, période 2) : Fonctionnement de l

ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
IUT Orléans, Département Informatique
2007-2008
ASR : Architectures des Ordinateurs UF2 : Fonctionnement de l’ordinateur
TD/TP2 (semestre1, période 2) : Fonctionnement de l’ordinateur, langage
assembleur
Chapitre 5 (partie1) : Un simulateur simple pour le langage «assembleur (NASM)»
Durant ce TD/TP, on réalise sur une initiation à la programmation en assembleur (voir
modèles NASM ou AS). Mais, pour mieux comprendre le fonctionnement de l’ordinateur, on
utilise ici un simulateur (voir le site http://www.softwareforeducation.com/sms32v50/ ,
SMS32V50). La machine prise en compte par le simulateur n’est pas la machine réelle sur
laquelle on travaille. C’est une machine « 8 bits » du type Intel8086. L’assembleur proposé
« ASSEMBLE » à une syntaxe simplifiée, mais très proche d’un sous-ensemble de
l’assembleur NASM (ou AS) permettant de programmer sur la machine réelle. Seules, un petit
nombre d’instructions ont une syntaxe légèrement différente : MUL, DIV, décalages, etc.
NASM et la machine réelle seront utilisés dans les TD/ TP ASR de la partie système (sous
Linux).
L’assembleur « simplifié » ne propose pas l’utilisation de noms symboliques pour les
variables : on indique directement des adresses dans la mémoire RAM. Par contre, on dispose
d’étiquettes symboliques pour les ruptures de séquence.
Pour des raisons (évidentes) de simplification, le langage machine binaire généré lors de
l’assemblage du texte en « NASM simplifié » ne correspond PAS au langage machine de la
série IntelX86. La plupart des instructions sont ici codées, de manière très simple, sur 3 octets.
L’environnement est l’environnement Win(XP). On dispose d’une représentation simplifiée du
clavier » et de « l’écran » à travers un « environnement système élémentaire ».v
1. Prise en main du simulateur, assemblage du texte d’un programme écrit en
« NASM simplifié », implantation d’un programme en mémoire [Exercices série 1]
Architecture de l’ordinateur, la carte machine
a) Rappeler le schéma (« carte machine ») de la machine utilisée par le simulateur. On situera
notamment les registres utilisateurs ( AL, BL, CL et DL), les registres cachés et la mémoire
RAM de 256 octets. Rappeler le rôle des registres de travail et de la mémoire RAM. Comment
peut-on visualiser l’information en binaire ?
Le fonctionnement du simulateur
b) Quels sont les rôles respectifs des commandes « assemble », « run » et « step » du
simulateur ? Que peut-on suivre avec les options « write run log » et « run log » ?
Un modèle de texte de programme pour l’ implantation en mémoire du code binaire par
« ASSEMBLE »
c) Proposer un premier texte de programme (- modele01.asm -) contrôlant l’emplacement
occupé, dans la zone RAM attribuée à un utilisateur, par :
- les données initialisées ( des étiquettes dataStart à dataEnd ) et la directive DB;
- le code du programme ( de textStart à textEnd ) et les mnémoniques JMP, HALT,
MOV, etc. ;
24/10/07
ASR03-04TD_06V1
19
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
-
éventuellement, la zone pour des données NON initialisées ( de bssStart à bssEnd ).
Cette zone peut se partager le reste de la mémoire RAM attribuée à l’utilisateur avec la
PILE d’exécution.
Commenter l’utilisation de la directive ORG (- qui n’est pas une instruction mais une directive
à « ASSEMBLE » -)… Commenter le fait que cet assembleur « simplifié » ASSEMBLE ne
propose pas l’utilisation de noms symboliques pour les variables : on indiquera directement
des adresses dans la mémoire RAM. Par contre, on dispose d’étiquettes symboliques pour
les ruptures de séquence. Leur transformation est prise en charge par ASSEMBLE.
Rappel : L’ensemble de la mémoire comporte ici 256 octets de 00 à FF. La mémoire utilisateur
s’étend de 00 à BF. Le système utilise la zone C0 à FF pour simuler la « zone vidéo ». Il utilise
également la zone 0 à xx pour la table des vecteurs d’interruptions. La PILE d’exécution n’est
pas utilisée dans ce TD/TP, elle débute en BF (- voir TD/TP partie Système de ASR -)…
Relever le schéma d’occupation de la RAM. Expliquer précisément le rôle et le fonctionnement
de « jmp ».
Le fonctionnement du simulateur, de l’assembleur ASSEMBLE et du processeur SMS
Classer et expliciter :
Les directives pour le simulateur « assemble », « run » et « step », « clo »etc. ;
Les directives pour l’assembleur ASSEMBLE (- DB, ORG -) ;
Les directives (- instructions en binaire après ASSEMBLE -) pour le processeur.
2. Registres, transferts d’information entre registres et mémoire [Exercices série 2]
Permutation de cases mémoires
a) Écrire un premier programme en langage machine ( mov01.asm ) qui réalise l’échange du
contenu de cases de la mémoire RAM. Ces cases contiennent :
- Deux valeurs entières (représentées en complément à 2 sur 8 bits) : ces valeurs sont
données en hexadécimal et non en décimal ou en binaire. Elles sont définies ici comme
des données initialisées (zone data ) et non saisies au « clavier ».
- Deux caractères ASCII : ils sont également fournis comme des données initialisées.
Rappel : il est nécessaire ici de passer par des registres. Vérifier, en consultant la visualisation
de la RAM, le résultat de la permutation. Les choix retenus (- hexadécimal ou ASCII -) sont en
rapport avec la directive « DB » disponible.
Utilisation de la zone vidéo pour la visualisation (de valeurs codées en ASCII…)
b) Compléter le programme ( mov02.asm ) en transférant, avant et après la permutation, les
deux caractères ASCII dans la « zone vidéo ». On les place en position D0 et E0 avant la
permutation ; en position D2 et E2 après. En C1, on placera le message « : ».
Rappeler ( et tester ) comment sont codés, en binaire et en hexadécimal, les caractères
ASCII :
{0, …, 9], {A, …, Z}et {+, -, /, *, % }.
Remarque : Que faudrait-il faire pour visualiser, en zone vidéo, les deux « valeurs
entières » codant les caractères au lieu des deux caractères ASCII ? Ne pas écrire ce
programme pour l’instant, voir plus loin dans les applications.
24/10/07
ASR03-04TD_06V1
20
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
Saisie au clavier par « in » (- lecture de valeurs codées en ASCII sur un octet -)
c) Introduire ( mov03.asm ) la lecture au clavier d’une nouvelle valeur pour les 2 caractères
ASCII. Réaliser la séquence : lecture, visualisation, permutation et visualisation.
Comment pourrait-on utiliser la zone « bss » des données non initialisées?
Remarque : Le simulateur n’offre pas d’instruction mov Reg1, Reg2. On verra plus loin
comment permuter le contenu de ces deux registres sans utiliser une case mémoire (voir plus
loin les instruction XOR et OR).
Ensemble des cinq possibilités de l’instruction de déplacement (- lecture/écriture en RAM -)
d) Proposer maintenant un programme ( mov04.asm) montrant l’ensemble des possibilités des
instructions « mov ». Ne pas oublier les déplacements indirects, ils seront nécessaires par la
suite.
Ensemble des (autres) périphériques disponibles dans le simulateur
e) Tester et commenter le programme de démonstration demo01.asm.
3. Instructions arithmétiques [Exercices série 3]
Addition de deux entiers [arit03.asm ]
a) Écrire un programme ( arit01.asm et arit02.asm ) réalisant l’addition de deux entiers
courts (8bits). Les entiers sont :
- Définis en valeurs immédiates ;
- Définis par des données initialisées et placés dans des cases mémoires ;
Rappel : les entiers sont codés en complément à 2 et ces valeurs sont données en hexadécimal.
Possibilités des opérations arithmétiques
b) Proposer un programme ( arit03.asm ) montrant et regroupant les différentes possibilités
des opérations arithmétiques.
Multiplications et divisions, introduction des décalages
c) Comment sont représentés les nombres entiers négatifs.
[Montrer dans quel cas une multiplication ou un division par 16 correspondent à des décalages
de 4 positions binaires (arit04.asm).]
4. Opérations logiques et opérations de décalage [Exercices série 4]
Opérations logiques [logi01 à logi04]
a) Donner un programme (logi01.asm ) montrant les différentes possibilités de AND, OR,
XOR et NOT.
b) Utiliser XOR et OR pour transférer le contenu d’un registre dans un autre ( logi02.asm )…
c) Utiliser aussi l’instruction AND pour transcoder un caractère hexadécimal, lu en ASCII,
vers sa valeur binaire ( logi03.asm). On distingue :
- Valeurs souhaitées de 0 à 9 codées en binaire sur 4 positions et codes ASCII
introduits par les touches du clavier de « 0 » à « 9 »8 ;
8
Exemple ASCII[ [1]CLAVIER ] = 0011 0001, [0011 0001]2 = [3 1]16 et 2[ [1]CLAVIER ] ? 0001
24/10/07
ASR03-04TD_06V1
21
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
-
Valeur souhaitées de 10 à 15 codées en binaire sur 4 positions et codes ASCII
introduits par les touches du clavier de « A » à « F ».
Remarque : On n’effectue pas, pour l’instant, de contrôle sur les valeurs lues. Ces contrôles
seront introduit plus tard sur une version logi03C.asm (Voir également plus loin, l’exercice
complet e_sHexa.asm). Il est important ici d’analyser ce transcodage et sa nécessité.
On pourra éventuellement placer les 4 positions binaires obtenues après transcodage en partie
basse ou en partie haute d’un même octet (- voir : décalages -). On pourra également, en sens
inverse, réécrire à l’écran les codes hexadécimaux correspondant à une valeur binaire sur 8
positions..
Opérations de décalage
d) Charger une valeur immédiate dans BL et visualiser ( sur l’écran de la « zone vidéo » ) le bit
de poids fort ( logi04.asm ).
Remarque : L’exercice sera repris plus loin pour visualiser successivement toutes les positions
binaires (- logi04C.asm -). Voir également plus loin e_sBin.asm.
Eventuellement, lire un caractère 0/1 en ASCII, le transcoder en valeur binaire sur 8 bits (exercice précédent… -) et visualiser à l’écran le bit de poids faible.
5. Introduction des instructions de ruptures de séquences [exercices série 5]
Sélection et répétition en assembleur (utilisation des étiquettes, instructions cmp, jmp et
jcond) [Commentaires et modèles simples]
a) A l’aide des instructions de base jmp, cmp et jcond présentées en cours, définir
« l’équivalent » des l’instructions:
« if (cond) { } else { } » ; « do { }while(cond) ; » ;« while(cond) { } » et « switch »
Exemple simple avec une sélection [Exercice siSinon01.asm]
b) Écrire des programmes ( siSinon01.asm ) qui, disposant de deux entiers (données
initialisées en constantes), affiche
- l’un des trois messages : 1 > 2 , 2 >1 ou 1=2 ( le 1 est supérieur au 2, etc.).
Exemple simple avec un aiguillage [Modification exercice précédent ]
c) Reprendre éventuellement le programme précédent avec une structure d’aiguillage.
Itération et écriture d’une chaîne ASCII [Exercice e_sAscii.asm]
d) Proposer un programme ( e_sAscii.asm ) qui écrit une chaîne ASCII sur l’écran vidéo. La
chaîne est d’abord définie comme un message (donnée initialisée), puis elle est lue au clavier et
réécrite.
Exemple avec un aiguillage et une visualisation simple d’une position décimale [Exercice
arith05.asm ]
e) Proposer un programme ( arit05.asm ) qui, disposant déjà de deux nombre entiers (
données initialisées en constantes et inférieures à 10), lit un opérateur (opérateur choisi
parmi : + - * / % ). L’opérateur est introduit au clavier. Le programme affiche le résultat de
l’opération demandée en réalisant un aiguillage à partir de l’opérateur. Le résultat à tester sera
ici inférieur à 10 - donc à visualiser sur une seule position décimale -, mais on tiendra compte
d’un résultat éventuellement négatif…
24/10/07
ASR03-04TD_06V1
22
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
Exemple avec des structures itératives [e_sBin.asm]
f) Un programme lit successivement, puis réécrire les 8 positions binaires [réalisant une
itération de 8 pas]. La lecture a lieu sur le clavier (donc, en ASCII caractère par caractère).
L’écriture des 8 positions binaires est faite sur l’écran vidéo.
Exemple- facultatif - avec des structures itératives [Exercices Logi03C.asm, logi04D.asm]
g) A partir de l’exercice logi03.asm de 4c) proposer une version plus complète logi03C.asm :
on ajoute une structure de contrôle de type aiguillage permettant de vérifier que l’on a bien
introduit – pour fournir une valeur binaire - un caractère hexadécimal [ On utilise également
une sélection si…]. Réécrire cette valeur en hexadécimal en passant par la zone vidéo [On
utilise un aiguillage ou une sélection si_sinon…].
Reprendre le programme logi04.asm de 4d) – sous le nom, logi04D.asm - : on donne une
valeur binaire en hexadécimal (- saisie et contrôle de 2 caractères hexadécimaux à partir de
l’exercice précédent logi03C.asm -) dont on visualise successivement les 8 positions binaires
dans la zone vidéo. [ Aiguillage, puis itération pour la visualisation des 8 bits.]
[Voir directement plus loin l’application e_sHex.asm où l’on saisit et on réécrit deux
caractères hexadécimaux pour disposer d’un valeur sur 8 bits ?]
6. Applications des notions précédentes
Application1, lecture et ré-écriture d’un nombre décimal [Exercice e_sNombre.asm ]
Proposer un programme ( e_sNombre.asm ) qui lit un nombre décimal compris entre -127 et
+127 (- donc, sur le terminal, caractère ASCII par caractère, signe compris -). Ce programme
construit la valeur décimale correspondante (- donc, codée en binaire complément à 2 -) et la
range en mémoire. Puis, il réécrit cette valeur à l’écran (- donc, caractères ASCII par caractère
ASCII -).
Application2, réaliser une opération entre 2 entiers [Exercice : e_sNombres.asm d’après
siSinon01.asm et e_sNombre.asm]
Proposer un programme ( e_sNombres.asm ) qui, disposant de deux nombres entiers (données
initialisées) et d’un opérateur saisi au clavier (opérateur choisi parmi : + - * / % ), réalise
l’opération demandée et affiche le résultat. Seul l’un des deux nombres est saisi au clavier
(problème de taille du programme)…
Application3, lecture/écriture et traitement de chaînes héxadécimales [Exercice e_sHex.asm
d’après logi3C.asm]
Proposer un programme ( e_sHex.asm ) qui obtient la valeur d’un entier naturel (- compris
entre 0 et 255 -) codée en binaire. Il lit cette donnée sous la forme de deux caractères
hexadécimaux introduits au clavier (donc, sous forme de caractères ASCII…). Le programme
reconstruit donc la valeur binaire, sur 8 bits, à partir de ces deux caractères hexadécimaux
(récupérés successivement au clavier – donc en en ASCII…). Ensuite, le programme ré-écrire
la valeur binaire en hexadécimal sur « l’écran vidéo » (donc, de nouveau, sous la forme de
deux caractères en ASCII codant les deux caractères hexadécimaux).
24/10/07
ASR03-04TD_06V1
23
ASR Architecture des ordinateurs
24/10/07
ASR03-04TD_06V1
TD2 & TD/TP2 (semestre 1, période 2)
24
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
IUT D’Orléans, Département Informatique
ASR : Architectures des Ordinateurs
UF2 : Fonctionnement de l’ordinateur
Eléments de réponse : corrections
fonctionnement de l’ordinateur
24/10/07
ASR03-04TD_06V1
2007-2008
autour
du
25
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
Annexes autour de l’utilisation du simulateur :
Le simulateur
24/10/07
ASR03-04TD_06V1
26
ASR Architecture des ordinateurs
TD2 & TD/TP2 (semestre 1, période 2)
Exemples (partiels) de programmes
Modele01.asm
;______________ Exercice: modele01_2005.asm
________________________
monProg:
; nom (externe) du programme: momProg, point de lancement imposé en 00
jmp
textStart
; renvoi vers le début effectif du programme
; lancement systématiquement dans la case 0
; par le "système"
; d'ou, un ensemble de renvois
; Zone pour la TABLE des INTERRUPTIONS, NON PRISE EN COMPTE ICI...
;________________________________________ TABLE _______________________
;
;_______________________________________________________________________
; directement vers début effectif du CODE textStart en évitant les données
;________________________________________ DATA _______________________
dataStart:
; zone DONNEES INITIALISEES
; exemple:
db
db
30
31
; octet1 en 02 (hex.), valeur 30 (hex.)
; octet2 en 03 (hex.), valeur 31 (hex.)
; ...
db
"ABC...abc" ; chaîne en ASCII (début en 04)
db
0
; marque fin de chaîne si nécessaire
dataEnd:
; fin DONNEES
;________________________________________ CODE _______________________
ORG
10
; à tester, début du code en 10
textStart:
;début du CODE
mov
dl, 02
;si nécessaire: début données...
; ...
push dl
; pour voir la PILE
halt
textEnd:
; fin du CODE
;________________________________________ BSS ________________________
bssStart:
; zone DONNEES NON INITIALISEES
; exemple:
ORG
20
;
db
"ICI"
; ...
bssEnd:
;fin DONNEES NON INITIALISEES
;_______________________________________________________________________
end
;______________ Exercice: mov01.asm
________________________________
monProg:
jmp
textStart
; nom du programme
;________________________________________ DATA ______________________
dataStart:
; zone DONNEES INITIALISEES(début en 02)
; exemple:
db
00
; octet1 en 02 (hex.), valeur 00 (hex.)
db
01
; octet2 en 03 (hex.), valeur 01 (hex.)
db
"0"
; octet3 en 04 (hex.), valeur ASCII
db
"1"
; ...
dataEnd:
; fin DONNEES
ORG
10
;________________________________________ CODE ______________________
textStart:
;début du CODE
; séquence permutation:
mov
AL, [02]
mov
BL, [03]
mov
[02], BL
mov
[03], AL
24/10/07
ASR03-04TD_06V1
27
ASR Architecture des ordinateurs
mov
mov
mov
mov
TD2 & TD/TP2 (semestre 1, période 2)
AL, [04]
BL, [05]
[04], BL
[05], AL
halt
textEnd:
; fin du CODE
;________________________________________ BSS ___________________
bssStart:
; zone DONNEES NON INITIALISEES
; ...
bssEnd:
;fin DONNEES NON INITIALISEES
;__________________________________________________________________
end
mov02.asm
;______________ Exercice: mov02.asm
________________________________
monProg:
jmp
textStart
; nom du programme
;________________________________________ DATA ______________________
dataStart:
; zone DONNEES INITIALISEES
; exemple:
db
"0"
; octet1 en 02 (hex.), car. ASCII
db
"1"
; octet2 en 03 (hex.), car. ASCII
; ...
db
":"
; chaîne en ASCII (début en 04)
db
0
; marque fin de chaîne si nécessaire
dataEnd:
; fin DONNEES
ORG
10
;________________________________________ CODE ______________________
textStart:
;début du CODE
; séquence 1 de visualisation (ASCII):
mov
AL, [02]
; caractère ASCII dans [02]
mov
[D0], AL
; placé en zone vidéo, position D0
mov
AL, [03]
; caractère ASCII dans [03]
mov
[E0], AL
; placé en zone vidéo, position E0
; séquence permutation:
mov
mov
mov
mov
AL, [02]
BL, [03]
[02], BL
[03], AL
mov
mov
mov
mov
mov
mov
AL, [04]
[C1], AL
AL, [02]
[D2], AL
AL, [03]
[E2], AL
;
;
;
;
;
;
;
séquence 2 de visualisation (ASCII):
message (ASCII) dans [04], soit :
placé en zone vidéo, position C0
caractère ASCII dans [02]
placé en zone vidéo, position D0
caractère ASCII dans [03]
placé en zone vidéo, position E0
halt
textEnd:
; fin du CODE
;________________________________________ BSS _______________________
bssStart:
; zone DONNEES NON INITIALISEES
; ...
bssEnd:
;fin DONNEES NON INITIALISEES
;______________________________________________________________________
end
24/10/07
ASR03-04TD_06V1
28