Android Lab Test : Le capteur gyroscope (français)
Assembleur et binaire
1. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Sommaire
PROCÉDURE D'ASSEMBLAGE...................................................................................5
COMMENT ÉCRIRE UN PROGRAMME ASSEMBLEUR ?.................................................................5
Saisie.................................................................................................................5
Assemblage.........................................................................................................6
Références croisées..............................................................................................7
Création d'un fichier .EXE.....................................................................................7
Création d'un fichier .COM.....................................................................................8
LE PORT SÉRIE........................................................................................................9
INTERRUPTIONS 14H....................................................................................................9
But.....................................................................................................................9
Zones RAM utilisées.............................................................................................9
Registres en entrée..............................................................................................9
Algorithme........................................................................................................11
SOURCE COMMENTÉ :.................................................................................................12
Subroutines fonctions.........................................................................................13
Subroutine STATUS_MODEM...............................................................................14
Subroutine SEND_CHAR......................................................................................14
Subroutine RECEIVE_CHAR.................................................................................15
Subroutine SSPROG1..........................................................................................16
Subroutine SSPROG1_1......................................................................................16
Subroutine STATUS............................................................................................16
APPLICATIONS ASSEMBLEUR..........................................................................................17
Fonction 00 : Initialisation du port série...............................................................17
Fonction 01 : Transmission de caractère...............................................................17
Fonction 02 : Réception d'un caractère.................................................................18
Fonction 03 : Prêt à émettre ?.............................................................................18
Fonction 03 : Caractère reçu ?.............................................................................18
Envoi des caractères saisis au clavier sur le port série............................................18
LANGAGE C.............................................................................................................19
Fonction 01 : Envoi d'un caractère.......................................................................19
Fonction 02 : Réception d'un caractère.................................................................19
Fonction 03 : Prêt à recevoir ?.............................................................................20
Fonction 04 : Prêt à émettre ?.............................................................................20
COMPARAISON LANGAGE D'ASSEMBLAGE / LANGAGE ÉVOLUÉ............................21
TABLES UTILISÉES PAR LES ASSEMBLEURS.........................................................................21
Table des symboles (ou des identificateurs) :........................................................21
Table des codes opératoires :..............................................................................21
Table des constantes :........................................................................................22
ASSEMBLEUR À DEUX PASSES........................................................................................22
ERREURS LES PLUS COURANTES EN LANGAGE D'ASSEMBLAGE...................................................24
ROUTINES D'INTÉRÊT GÉNÉRAL...........................................................................25
MODIFIER UNE FONCTION D'UNE INTERRUPTION...................................................................25
Modifier l'adresse d'une pile.................................................................................25
INTERRUPTION 08H...................................................................................................26
Lecture de l'heure sur l'horloge............................................................................26
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 1 / 109
2. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
INTERRUPTION 10H...................................................................................................27
Fonction 00h - Sélection de mode d'affichage........................................................27
Fonction 01h - Sélection du format du curseur......................................................27
INTERRUPTION 11H....................................................................................................27
Détermination de la configuration........................................................................27
INTERRUPTION 12H...................................................................................................29
INTERRUPTION 16H...................................................................................................29
Fonction 01h - Y a-t-il un caractère dans le buffer ?...............................................29
INTERRUPTION 17H....................................................................................................29
Fonction 00h - Imprimer un caractère en testant si tout s'est bien passé.................29
L'imprimante est-elle prête ?...............................................................................30
RÉFÉRENCES..........................................................................................................31
BROCHAGES.............................................................................................................31
8088.................................................................................................................31
Registres et instructions.....................................................................................32
LES DISQUES.........................................................................................................37
LES DESSOUS DE LA DISQUETTE 360 KO..........................................................................37
Secteur 0 - Zone d'initialisation ( Boot Sector)......................................................38
secteur 1-4 - Table d'allocation de fichiers (FAT = File Allocation Table)..................38
Secteur 5-11 - Répertoire (Directory)...................................................................39
LE DISQUE DUR.........................................................................................................39
L'ORGANISATION D'UNE DISQUETTE.................................................................................39
Présentation......................................................................................................39
Zone d'initialisation, Boot Sector..........................................................................40
Table d'allocation de fichier, FAT = File Allocation Table.........................................41
Répertoire (Directory).........................................................................................42
Le préfixe de segment de programme (PSP)..........................................................43
L'IBM PC/XT JUSQU'À SES RACINES.....................................................................45
PRÉSENTATION DES ÉLÉMENTS CONSTITUANT L'UNITÉ CENTRALE DE L'IBM PC/XT..........................45
L'Unité d'Exécution (EU).....................................................................................45
L'Unité d'Interface de Bus...................................................................................46
ARCHITECTURE GÉNÉRALE.............................................................................................47
Le micro-processeur 8088...................................................................................47
LES VECTEURS D'INTERRUPTION......................................................................................48
Les interruptions de type INTR (INTerrupt Request)...............................................48
L'interruption NMI (Non Masquable Interrupt).......................................................49
L'interruption RESET (remise à zéro)....................................................................49
NOTATION...............................................................................................................49
L'ARITHMÉTIQUE BINAIRE...................................................................................50
PRÉSENTATION..........................................................................................................50
L'addition binaire................................................................................................52
La soustraction binaire........................................................................................52
La multiplication et la division binaire...................................................................52
LES FONCTIONS LOGIQUES DE BASE.................................................................................53
Présentation......................................................................................................53
La logique combinatoire......................................................................................53
Le système des portes........................................................................................54
Le décodeur.......................................................................................................56
Le multiplexeur..................................................................................................56
L'additioneur complet.........................................................................................56
INTERRUPTION 21H....................................................................................................56
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 2 / 109
3. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Fonction 09h - Affichage d'une chaîne de caractères..............................................56
Fonction 0Ah - Lecture d'une ligne au clavier........................................................57
Fonction 12 - Vider le buffer du clavier.................................................................57
Fonction 25 - Installer une nouvelle interruption...................................................57
Fonction 3Dh - Création de répertoire...................................................................57
Fonction 3Dh - Changement de répertoire.............................................................58
Fonction 4Ch - Rendre la main à MS-DOS.............................................................58
LA VIDÉO...............................................................................................................60
ATTRIBUTS..............................................................................................................60
Définition..........................................................................................................60
Adaptateur monochrome.....................................................................................60
Adaptateur graphique couleur..............................................................................61
COURS D’ASSEMBLEUR..........................................................................................62
GÉNÉRALITÉS...........................................................................................................62
Rappels sur le fonctionnement de l’ordinateur.......................................................62
La syntaxe.........................................................................................................63
LES DONNÉES...........................................................................................................63
Généralités........................................................................................................63
Registres...........................................................................................................64
Données et mémoire..........................................................................................66
LES MODES D’ADRESSAGE............................................................................................67
LE JEU D’INSTRUCTIONS...............................................................................................69
Les instructions de base......................................................................................69
Les instructions arithmétiques.............................................................................70
Les instructions logiques.....................................................................................72
Les instructions de décalage et de rotation............................................................73
Les instructions de pile.......................................................................................74
Les instructions de manipulation de chaînes de caractères......................................75
Les instructions de saut conditionnel....................................................................77
Les instructions de saut inconditionnel.................................................................77
Les tests d’identificateur.....................................................................................77
Les tests arithmétiques.......................................................................................78
Les tests de nombres non signés.........................................................................78
Les tests de nombres signés................................................................................79
Les instructions de boucle...................................................................................80
Les procédures (sous-programmes)......................................................................80
Les paramètres et les sous-programmes...............................................................81
Les instructions de gestion des adresses...............................................................82
TECHNIQUES DE PROGRAMMATION...................................................................................82
Organisation d’un programme..............................................................................83
Utilisation de plusieurs segments : la directive Assume..........................................84
La programmation modulaire...............................................................................84
Les fichiers Exe..................................................................................................85
POINTS PARTICULIERS.........................................................................................86
ADRESSAGE DE LA MÉMOIRE.........................................................................................86
INTERRUPTIONS LOGICIELLES.........................................................................................86
PRÉSENTATION DE L’IBM PC/XT....................................................................................88
PRÉSENTATION DES ÉLÉMENTS CONSTITUANT L’UNITÉ CENTRALE DU PC.......................................88
L'Unité d'Exécution (EU).....................................................................................88
L'Unité d'Interface de Bus...................................................................................89
ARCHITECTURE GÉNÉRALE.............................................................................................90
LE MICRO-PROCESSEUR 8088.......................................................................................90
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 3 / 109
4. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Notion de segment.............................................................................................90
LISTE DES REGISTRES.................................................................................................91
Registres généraux.............................................................................................91
Pointeurs...........................................................................................................92
Segment...........................................................................................................92
Registre d'état et de commande...........................................................................93
LES VECTEURS D’INTERRUPTION......................................................................................94
BRÈVE PRÉSENTATION DU 6502.....................................................................................95
LANGAGE MACHINE OU LANGAGE DE LA MACHINE...............................................................101
LES OPÉRATEURS ET LES ATTRIBUTS...............................................................................101
AIDE SUR L’ASSEMBLEUR....................................................................................104
INFORMATIONS SUR LE 8088......................................................................................104
REGISTRES............................................................................................................104
Pile.................................................................................................................104
Drapeaux.........................................................................................................104
OPÉRATIONS ARITHMÉTIQUES.......................................................................................106
Addition..........................................................................................................106
Soustraction....................................................................................................106
Multiplication...................................................................................................106
Division...........................................................................................................106
Decalage.........................................................................................................106
Rotation..........................................................................................................107
Logique...........................................................................................................107
DIVERS................................................................................................................107
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 4 / 109
5. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Procédure d'assemblage
Comment écrire un programme assembleur ?
Pour élaborer un programme assembleur, utilisez :
• un éditeur de lignes
• ou un éditeur de texte
• ou un traitement de texte
L'extension du nom du fichier devra obligatoirement être ASM.
Saisie
Nous allons écrire un programme qui additionne 1 et 2. Difficile ? Non,
facile ! Nous allons voir... Suivez les étapes suivantes :
• début de segment de code
• PROG SEGMENT
• début de procédure (PROcedure)
• ADDITION PROC FAR
• on stocke 1 dans le registre DL
• MOV DL,1
• on ajoute 2 au contenu du registre
• ADD DL,3
• on convertit au format ASCII (en fait, il suffit d'ajouter 48 au
code ASCII !)
• ADD DL,48
• déclenchement de l'interruption 21H (sélection de l'affichage du
caractère ASCII correspondant au code ASCII contenu dans le
registre DL par stockage de 2 dans le registre AH)
• MOV AH,2 (préparation)
• INT 21H (déclenchement proprement dit)
• déclenchement de l'interruption 21H (retour au DOS par stockage
de 4CH dans le registre AH)
• MOV AH,4CH (préparation)
• INT 21H (déclenchement proprement dit)
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 5 / 109
6. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
• fin de la procédure ADDITION
• ADDITION ENDP
• fin du segment PROG
• PROG ENDS
• fin du programme avec indication du point d'entrée (ADDITION)
• END ADDITION
Assemblage
Admettons que le fichier (dit fichier source) s'appelle ADD.ASM. Vous
lancez l'assembleur (MASM suivi de ENTREE pour le Macro-Assembleur).
L'ordinateur vous pose alors toute une série de questions du type :
• Source filename [.ASM]: (nom du fichier source [.ASM]:)
• Entrez le nom du fichier-programme à assembler, sans
l'extension ASM (il l'ajoute automatiquement au nom du fichier).
• Object filename [xxx.OBJ]: (nom du fichier objet [xxx.OBJ]:)
• xxx représente le nom du fichier (ADD dans notre cas).
L'ordinateur vous propose donc un nom de fichier. A vous de
valider (ENTREE) ou d'invalider (entrez un autre nom).
• Source listing [NUL.LST]: (listage du source [NUL.LST]:)
• NUL.LST indique que ce fichier ne sera pas créé. Tout autre nom
en créera un. Il s'agit du listage du source mais avec
l'assemblage.
• Cross reference [NUL.CRF]: (références croisées [NUL.CRF]:)
• NUL.CRF pour réponde non, un nom de fichier quelconque pour
oui. Il s'agit de la liste des références croisées.
Puis l'assemblage commence.
L'ordinateur affiche alors le nombre d'erreurs d'avertissement (warning
errors) : il a rencontré des erreurs de compréhension (ambiguïtés dans le
programme). Cependant, l'assemblage s'est tout de même effectué.
Puis c'est au tour des erreurs fatales (severe erreors). L'assemblage a dû
être interrompu à cause de ces erreurs.
Maintenant, vous êtes retourné à DOS.
Listez le contenu du fichier ADD.LST (listage du source avec assemblage) :
TYPE ADD.LST.
On y trouve :
• le programme source à droite
• l'assemblage (valeurs numériques) à gauche : ce sont les
instructions correspondantes en langage machine
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 6 / 109
7. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Les lignes sont numérotées afin de permettre un rapide repérage dans le
programme. Sur chaque ligne :
• le numéro de ligne
• le champ adresse (quatre chiffres), en commençant à 0000
• le champ opération (2 ou 4 chiffres) : ce sont les instructions en
langage machine (code)
• le champ opérande : il contient les données ou adresses (parfois)
Enfin figure indiquant l'état du programme (erreurs éventuelles, avec leur
type, ...).
Références croisées
Regardez maintenant le contenu du fichier de références croisées (.CRF).
Pour cela, utilisez le programme CREF. Il vous demande :
• le nom du fichier Cref (avec l'extension CRF) :
• Cref filename [.CRF]:
• le nom du fichier de listage des références croisées (il recevra
l'extension .REF) :
• List filename [xxx.REF] :
• xxx étant le nom du fichier sans son extension
• Le tableau obtenu (stocké dans le fichier xxx.REF) fournira les
renseignements suivants :
• le nom du symbole rencontré (PROG, ADDITION ici)
• à droite une liste de nombres : ils indiquent les numéros des
lignes où ont été rencontrées les références à ces symboles.
• Lorsqu'il s'agit d'une première référence (c'est-à-dire de leur
définition), le numéro de immédiatement suivi de #.
Très utile pour la détection d'erreur et pour la correction d'un programme,
n'est-il pas ?
Création d'un fichier .EXE
On va maintenant créer un fichier exécutable, c'est-à-dire de suffixe EXE.
Pour cela, lancez le programme LINK. L'ordinateur vous demande :
• les modules objets (le fichier de suffixe OBJ)
• (Object Modules [.OBJ]:)
• le nom du fichier de suffixe EXE à créer
• (Run File [xxx.EXE]:)
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 7 / 109
8. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
• le nom du fichier de listage (de suffixe MAP) : NUL pour pas de
fichier, un autre nom de fichier pour en créer un (List File
[NUL.MAP]:)
• le nom du fichier de bibliothèque : ne nous concerne pas encore !
• (Libraries [.LIB]:)
• Le fichier xxx.MAP (ici ADD.MAP) contient :
- l'adresse de départ des segments (un seul dans notre cas
présent)
- l'adresse d'arrêt de ces mêmes segments
- leur longueur
- leur nom
Il s'agit toujours d'adresses relatives (à 0000). Ce sera DOS, au moment
du chargement, qui sélectionnera l'adresse de logement.
Pour exécuter ce fichier, tapez xxx suivi de ENTREE (xxx étant le nom du
fichier sans son suffixe) : ADD suivi de ENTREE pour nous.
Création d'un fichier .COM
Nous allons maintenant nous donner pour tâche la conversion d'un fichier
de suffixe EXE en fichier de suffixe COM.
Pour cela, il faut lancer la commande externe DOS EXE2BIN. Mais pour
cela, il faut avoir intégré l'ordre : "ORG 100H" juste avant les premières
instructions (c'est-à-dire juste après la définition de procédure ADDITION).
D'un fichier d'origine 0 (fichier EXE), on « passe » à un fichier d'origine
100H (fichier COM).
La syntaxe de cette commande est : "EXE2BIN nom1 nom2", nom1 étant
le nom du fichier EXE (le suffixe est optionnel) et nom2 étant le nom du
fichier COM (spécifier le suffixe COM, sinon, l'ordinateur sélectionne le
suffixe BIN !)
Vous obtenez donc le fichier xxx.COM (ou ADD.COM).
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 8 / 109
9. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Le port série
Interruptions 14h
But
Gestion port série.
Zones RAM utilisées
Utilise la zone de communication asynchrone de 00400 à 00407
(RS232_BASE) et 0047C à 0047F (TIME_OUT_COM1, 2, 3, 4).
Registres en entrée
AH contient le numéro de la fonction à appeler.
Voir les fonctions individuellement.
Octets spéciaux :
Octet d'état :
Bit Description
7 état CD,
6 indicateur RING (sonnerie),
5 état de DSR,
4 état de CTS,
3 changement d'état de CD,
2 détection d'impulsion ERP,
1 changement d'état de DSR,
0 changement d'état de CTS.
Initialisation des ports (AH = 00h)
En entrée :
AL est l'octet de configuration.
Bit Description
0,1 Taille du mot :
10 = 7 bits
11 = 8 bits
2 Bits d'arrêt :
0 = 1 bit d'arrêt
1 = 2 bits d'arrêt
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 9 / 109
10. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
3,4 Bits de parité :
00 = pas de parité
01 = parité impaire
10 = pas de parité
11 = parité paire
5-7 Vitesse de transmission :
000 = 110 bauds
001 = 150 bauds
010 = 300 bauds
011 = 600 bauds
100 = 1200 bauds
101 = 2400 bauds
110 = 4800 bauds
111 = 9600 bauds,
En sortie :
AH est l'octet d'état.
Transmission du caractère contenu dans AL (AH = 01h)
En cas de non-transmission le bit 7 de AH est mis à un.
En entrée :
AL = caractère à émettre.
En sortie :
AH = octet d'état.
Réception d'un caractère dans AL (AH = 02h)
En cas d'erreur, les bits 1 à 4 et 7 de AH sont mis à un.
En entrée :
Pas de paramètre.
En sortie :
AL = caractère lu,
AH = octet d'état.
Lecture de l'état du port de communication (AH = 03h)
En entrée :
Pas de paramètres.
En sortie :
AH = mot d'état de la ligne,
AL = mot d'état du modem.
AH :
Bit Description
0 donnée prête,
1 erreur de tassement des données,
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 10 / 109
11. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
2 erreur de parité,
3 erreur d'encadrement,
4 détection d'un Break,
5 registre d'attente vide,
6 registre de décalage vide,
7 dépassement du temps alloué.
AL :
Bit Description
0 delta prêt à émettre,
1 delta donée prête,
2 fin de détection de la sonnerie,
3 état delta du signal de réception,
4 prêt à émettre,
5 donnée prête,
6 indicateur de la sonnerie,
7 signal de réception de la ligne.
Algorithme
Initialisation
• Autoriser les interruptions
• Empiler les registres modifiés
• Pointer sur l'adresse du port de la carte sélectionnée
Test
• Carte présente ?
• si oui, on continue, si non, on sort (-> SORTIE).
Fonctions
Si la fonction demandée est :
• 0 alors initialisation du port série (-> INIT_RS232),
• 1 alors émission d'un caractère (-> SEND_CHAR),
• 2 alors réception d'un caractère (-> RECEIVE_CHAR),
• 3 alors état du modem (-> STATUS_MODEM).
Fonction initialisation du port (INIT_RS232).
• indiquer que l'on veut accéder au diviseur pour changer la vitesse
de transmission
• mettre de côté les trois bits indiquant la vitesse
Si la vitesse est de (en bauds) Codes
110 04 - 17
150 03 - 00
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 11 / 109
12. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
300 01 - 80
600 00 - C0
1200 00 - 60
2400 00 - 30
4800 00 - 18
9600 00 - 0C
• Mettre le code dans les registres en 2F8 - 2F9.
• Indiquer à la carte la parité et la longueur de mot choisies
(Registre de contrôle de la ligne).
• Remettre à 0 le registre d'autorisation d'activation des
interruptions.
Fonction émission d'un caractère (SEND_CHAR).
• Signaler que l'ordinateur est prêt.
• Envoyer le signal de demande d'émissionn de caractère.
• Contrôle du time out (temps maximal alloué) :
- si le modem n'est pas prêt ou si aucune sonnerie n'est détectée
alors on va à sortie.
- s'il n'y a eu pas d'écrasement de données.
• Envoi effectif du code par écriture dans le registre de
transmission.
Fonction réception d'un caractère (RECEIVE_CHAR).
• Indiquer que l'ordinateur est prêt (DTR).
• Si le modem n'est pas prêt ou si aucun caractère n'est disponible
alors sortie.
• Indique pour la suite que :
- Aucune donnée n'est prête.
- Registre d'attente non vide.
- Registre de décalage non vide.
- Pas de dépassement de temps alloué (time out).
• Lecture effective du code par simple lecture du registre de
réception.
Fonction état du modem (STATUS_MODEM).
• Lecture du registre d'état de la ligne.
• Lecture du registre d'état du modem.
Source commenté :
; Entrée dans l'interruption
STI
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 12 / 109
13. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
; Sauvegarder les registres modifiés
Empile afin de ne pas PUSH BX
perturber le programme
PUSH CX
courant.
PUSH DX
PUSH DI
PUSH DS
; Accès à la zone de communication du BIOS
Se place en segment 40. CALL SEGMENT_40
; L'adresse de chaque carte est repérée à l'aide de la formule suivante :
Adresse = (400 + 2 * Numéro de la carte)
BX = DX = n° carte MOV BX,DX
Décalage d'une fois à SHL BL,1
gauche.
; On effectue en fait une multiplication par 2 (BH est nul !). On lit l'adresse
du port de la carte correspondante.
DX vaut l'adresse 400 + 2 * MOV DX,[BX+0000]
BX
; Soit l'adresse du port de la carte concernée. Si l'octet lu vaut 0 alors c'est
qu'il n'y a pas de carte ! Sinon, on appelle la fonction sélectionnée.
Sert à tester si DX vaut 0 ou OR DX,DX
non.
Si DX = 0 (pas de carte) JZ SORTIE
alors aller à SORTIE.
Aappel du sous-programme CALL FONCTIONS
qui effectue l'exécution de la
fonction sélectionnée.
; Au retour de l'exécution de la fonction, on restaure les registres modifiés
et inutiles au programme appelant.
SORTIE :
Dépile les registres afin de POP DS
restaurer les conditions
POP SI
initiales d'appel.
POP DI
POP DX
POP CX
POP BX
Fin de routine de traitement IRET
d'interruption.
Subroutines fonctions
Pour la routine de sélection de fonction, se référer au paragraphe
correspondant figurant en début de chapitre.
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 13 / 109
14. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Cette routine oriente le programme vers la routine INIT_RS_232 (fonction
0), SEND_CHAR (fonction 1), RECEIVE_CHAR (fonction 2), ou
STATUS_MODEM (fonction 3).
On prend comme exemple le cas oû la carte sélectionnée est COM1, dont le
port est situé à partir de 2F8.
Subroutine STATUS_MODEM
; Pointe sur le registre d'état de la ligne (2FD)
DX = DX + 5 ADD DX,+05
; Lecture du registre
Lecture du registre et stocke IN AL,DX
l'octet dans AL.
; On le met de côté
AH = AL MOV AH,AL
; Maintenant, pointe le registre d'état de la ligne
DX = DX + 1 INC DX
; Lecture du registre
Lecture du port de base + 6 IN AL,DX
et stocke l'octet dans AL.
; Fin ...
Fin de sous-programme. RET
Subroutine SEND_CHAR
; Met de côté l'octet à envoyer
CL = AL MOV CL,AL
; Pointe sur le registre de contrôle des signaux modem
DX = DX + 4 ADD DX,+04
; Met à 1 les bits RTS (demande pour émettre) et DTR (ordinateur prêt)
AL = 03 MOV AL,03
Ecrit 3 = 00000011 = AL OUT DX,AL
dans le registre.
; Pointe sur le registre d'état des signaux modem
DX = DX + 2 ADD DX,+02
; Si les 1 et 2 du registre pointé (modem prêt et détection de sonnerie) ne
sont pas à 1 alors on sort en se branchant à SSPROG1.
BH = 30 MOV BH,30
Appel du sous-programme CALL STATUS
STATUS.
Si pas égal alors saut au sous JNZ SSPROG1
programme SSPROG1.
; Pointe sur le registre d'état de la ligne
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 14 / 109
15. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
DX = DX - 1 DEC DX
; Si le bit 1 du registre pointé (écrasement de donnée) pas à 1 alors on
sort en se branchant à SSPROG1.
BH = 20 MOV BH,20
Aappel du sous-programme CALL STATUS
STATUS.
Si pas égal alors saut au JNZ SSPROG1
sous-programme SSPROG1.
; Pointe sur le registre de réception et de transmission de données.
DX = DX - 5 SUB DX,+05
; Envoi l'octet à envoyer qui a été mis de côté au début du sous-
programme.
AL = CL (retour à la valeur MOV AL,CL
initiale de AL)
Sortie du caractère contenu OUT DX,AL
dans AL sur le port de base.
; Et voilà, c'est fini ...
Fin de sous-programme. RET
Subroutine RECEIVE_CHAR
; Pointe sur le registre de contrôle des signaux modem
DX = DX + 4 ADD DX,+04
; Met à 1 le bit DTR (ordinateur prêt)
AL = 1 MOV AL,01
Ecriture de 1 sur le port de OUT DX,AL
base + 4.
; Pointe sur le registre d'état des signaux modem
DX = DX + 2 ADD DX,+02
; Teste si le bit Modem Prêt est à 1 ou non
BH = 20 MOV BH,20
Appel du sous-programme CALL STATUS
STATUS.
Si pas égal alors saut au JNZ SSPROG1_1
sous-programme
SSPROG1_1.
; Pointe sur le registre d'état de la ligne
DX = DX - 1 DEC DX
; Teste si un caractère est disponible ou non
BH = 1 MOV BH,01
Appel du sous-programme CALL STATUS
STATUS.
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 15 / 109
16. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Si pas égal alors saut au JNZ SSPROG1_1
sous-programme
SSPROG1_1.
; Pointe sur le registre de réception et de transmission de données.
DX = DX - 5 SUB DX,+05
; Adapter l'octet d'état à la situation : forcer à 0 les bits 0 et 5 à 7 de
l'octet d'état
Et entre AH et 1E AND AH,1E ;
(00011110) => remise à zéro
des bits 0, 5 à 7.
; Lecture de l'octet contenu dans le port
Lit le port de base et stocke IN AL,DX
l'octet en AL.
; Fin ...
Fin de sous-programme. RET
Subroutine SSPROG1
AH = CL MOV AL,CL
JMP SSPROG1_1
Subroutine SSPROG1_1
; Mise à 1 du port 80
Ou entre AH et 80 OR AH,80
(10000000).
; Fin de la routine
Fin du sous-programme. RET
Subroutine STATUS
; Lecture de l'octet de Time_Out correspondant à la carte
BL = contenu de l'adresse ; MOV BL,[DI+007C]
[47C + numéro de la carte]
; On sauvegarde les registres modifiés par cette routine
Empile DX. PUSH CX
; On initialise le compteur de boucle
REPRISE :
CX = 0 SUB CX,CX
BOUCLE :
; Lecture du registre d'état sélectionné
Lecture du port de base et IN AL,DX
stocke l'octet lu dans AL.
MOV AH,AL ; AH = AL
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 16 / 109
17. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
; Si les bits (indiqués dans BH) du registre d'état lu sont à 1 alors c'est la
fin du sous-programme.
Et entre AL et BH. AND AL,BH
Est-ce que AL = BH ? CMP AL,BH
Si oui, alors saut à JZ FIN_STATUS
FIN_STATUS => fin de sous-
programme.
; On recommence au point marqué BOUCLE
Saut à BOUCLE tant que CX LOOP BOUCLE
différent de 0 décrémente
CX.
; On décrémente le compteur de temps alloué (time out) 256 fois en tout.
BL = BL - 1 DEC BL
; Arrivé ici, on a CX = 0
Si BL est différent de 0, on va JNZ REPRISE
à REPRISE.
; On restaure la valeur de BX
BX = BX + 1 INC BX
; Arrivé ici, on CX = BL = 0
; Fin du sous-programme ...
FIN_STATUS :
Dépile. POP CX
Fin de sous-programme. RET
Applications Assembleur
Fonction 00 : Initialisation du port série.
init :
Sélection du port COM1. MOV DX,0
Octet de configuration. MOV AL,11010111B
Initialisation du port. MOV AH,0
Série COM1. INT 14
RET
Fonction 01 : Transmission de caractère.
send :
Sélection du port COM1. MOV DX,0
Pour envoyer le caractère de MOV AL,48
code ASCII 48.
Fonction transmission de MOV AH,01
caractère ...
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 17 / 109
18. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
... par l'interruption 14 INT 14
RET
Fonction 02 : Réception d'un caractère.
receive :
Sélection du port COM1. MOV DX,0
Lecture de l'octet reçu. MOV AH,02
Sur le port COM1. INT 14
Fin de la routine. RET
Fonction 03 : Prêt à émettre ?
send_? :
Pour COM1. MOV DX,0
Fonction de lecture de l'état. MOV AH,3
Appel de l'interruption. INT 14
Masque AND AH,01000000B
Vrai MOV AX,1
Saut à la fin JNZ fin
Faux DEC AL
...
fin :
Fin de la routine RET
Fonction 03 : Caractère reçu ?
receive_? :
Sélection du port COM1 MOV DX,0
Fonction lecture de l'état MOV AH,03
Appel de l'interruption INT 14
Masque pour caractère reçu AND AH,01
Vrai MOV AX,1
Saut JNZ fin
Faux DEC AL
fin :
Fin de la routine RET
Envoi des caractères saisis au clavier sur le port série.
Sélection du port COM1. MOV DX,0
Initialisation du port série. MOV AH,0
En 1200 bauds, sans parité, MOV AL,10000011B
1 bit d'arrêt, sur 8 bits INT 14
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 18 / 109
19. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
entrée :
Entrée d'un caractère ... MOV AH,0
... au clavier INT 16
Si on a entré '$' alors on ... CMP AL,'$'
... arrête là JNZ envoi
Fin ... RET
envoi :
Nombre maximum d'essais. MOV CX,15
encore :
Transmission du caractère. MOV AH,1
Frappé au clavier. INT 14
En cas de problème, ... TEST AH,80
... On remet ça ! Pas plus de LOOPZ encore
15 fois tout de même.
Si le compteur d'essais est à CMP CX,0
0.
C'est qu'il y a une erreur ! JZ erreur
Sinon, on reprend au JMP entree
caractère suivant.
erreur :
Fin de la routine. RET
Langage C
Fonction 01 : Envoi d'un caractère.
Unsigned Char Input (c)
{ Unsigned Char C;
Int Var;
Union REGS InRegs, OutRegs;
Sélection du port COM1 InRegs.x.dx = 0;
Réception de caractère InRegs.h.ah = 1;
InRegs.h.ah = c;
Var = Int86 (20,&InRegs,&OutRegs);
}
Fonction 02 : Réception d'un caractère.
Unsigned Char Input ()
{ Unsigned Char C;
Int Var;
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 19 / 109
20. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Union REGS InRegs, OutRegs;
Sélection du port COM1 InRegs.x.dx = 0;
Réception de caractère InRegs.h.ah = 2;
Var = Int86 (20,&InRegs,&OutRegs);
OutRegs.h.ah = 0;
Return (c=OutRegs.h.al);
}
Fonction 03 : Prêt à recevoir ?
Int Input_Ready ();
{ Int Var, Bool;
Union REGS InRegs, OutRegs;
Sélection du port COM1 InRegs.x.dx = 0;
Eétat du port InRegs.h.ah = 3;
Var = Int86(20,&InRegs,&OutRegs);
If (OutRegs.h.ah & 01) Bool = 1;
Else Bool = 0;
Return (Bool);
}
Fonction 04 : Prêt à émettre ?
Int Output_Ready ();
{ Int Var, Bool;
Union REGS InRegs, OutRegs;
Ssélection du port COM1 InRegs.x.dx = 0;
Etat du port InRegs.h.ah = 3;
Var = Int86(20,&InRegs,&OutRegs);
If (OutRegs.h.ah == 1) Bool = 0;
Else Bool = 1;
Return (Bool);
}
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 20 / 109
21. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Comparaison langage d'assemblage / langage évolué
MULTICS a été développé pour 95% en PL/1 par 50 personnes, et a coûté
10 millions de dollars.
TSS/67 a été développé entièrement en assembleur par 300 personnes, et
a coûté 50 millions de dollars.
Puisque qu'une instruction d'un langage évolué est équivalente à plusieurs
instructions en langage d'assemblage, la productivité d'un programmeur
en langage évolué est d'autant supérieure à celle d'un programmeur en
langage d'assemblage.
La maintenance des programmes en assembleur est très difficile.
Un faible pourcentage du code total est responsable de la plus grande
partie du temps d'exécution. On pourra donc effectuer des mesures afin de
détecter les parties qui prennent le plus de temps.
Les langages en langage évolué permettent d'avoir une vue plus globale
des problèmes et peut ainsi obtenir des améliorations de performance
spectaculaires, tandis qu'en langage d'assemblage, on essaie de jongler
sur des micro-secondes.
Pourquoi conserver le langage d'assemblage ?
• pour pouvoir ré-écrire une partie critique d'un programme
• parfois, le langage d'assemblage est le seul langage disponible
• un compilateur peut parfois produire de l'assembleur
Tables utilisées par les assembleurs
Table des symboles (ou des identificateurs) :
• Identificateur
• Valeur
• Autre information :
- Longueur du champ de données associé au symbole
- Bits de relogement (Le symbole change-t-il de valeur si le
programme est chargé à une adresse différente de celle prévue
par l'assembleur ?)
- Le symbole est-il ou non accesible en dehors de la procédure.
Table des codes opératoires :
• Code opération :
- symbolique
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 21 / 109
22. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
- hexadécimal
• Longueur des instructions en octets
• Classe d'instructions (groupement des instructions par nombre et
par type des opérandes)
Table des constantes :
• valeur
• adresse (Trier les constantes, et éliminer les doublons)
Assembleur à deux passes
Procedure Premiere_Passe;
Var
Compteur_Emplacementn Classe, Longueur, Valeur : Integer;
Encore : Boolean;
Identificateur, Symbole, OpCode : Array [1..20] Of Integer;
Ligne : String [80];
Begin
Compteur_Emplacement := 0;
Encore := True;
Initialisation_Des_Tables;
While Encore Do
Begin
{ Prendre_Instruction (Ligne); }
Lire_Instruction (Ligne);
Garder_Pour_Passe_2 (Ligne);
If Pas_Commentaire (Ligne)
Then Begin
Tester_Symbole (Ligne, Symbole);
If Symbole [1] <> ' '
Then Entrer_Symbole (Symbole, Emplacement);
Chercher_Indentificateur (Ligne, Indentificateur);
If Identificateur [1] <> ' '
Then Entrer_Indentificateur (Identificateur);
Extraire_Operateur (Ligne, OpCode);
Chercher_Operateur (OpCode, Classe, Valeur);
If Classe < 0
Then Essayer_Pseudo_Instruction (OpCode, Classe, Valeur);
Longueur := 0;
If Classe < 0
Then Erreur_Operateur;
Case Classe Of
0 : Longueur := Type0 (Ligne);
1 : Longueur := Type1 (Ligne);
End;
{ Assembler_Morceaux (Code, Classe, Valeur, Operande); }
{ Sortir_Code (Code); }
Compteur_Emplacement := Compteur_Emplacement + Longueur;
If Classe = 99
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 22 / 109
23. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Then Begin
Encore := False;
{ Finir; }
Preparer_Entree_Passe2;
Trier_Table_Identificateurs;
Epurer_Indentificateurs_Redondants;
End;
End;
End;
End;
Procedure Deuxieme_Passe;
Var
Compteur_Emplacementn Classe, Longueur, Valeur : Integer;
Encore : Boolean;
Identificateur, Symbole, OpCode : Array [1..20] Of Integer;
Ligne : String [80];
Begin
Compteur_Emplacement := 0;
Encore := True;
{ Initialisation_Des_Tables; }
While Encore Do
Begin
Prendre_Instruction (Ligne);
{ Lire_Instruction (Ligne); }
{ Garder_Pour_Passe_2 (Ligne); }
If Pas_Commentaire (Ligne)
Then Begin
{ Tester_Symbole (Ligne, Symbole); }
{ If Symbole [1] <> ' ' }
{ Then Entrer_Symbole (Symbole, Emplacement); }
{ Chercher_Indentificateur (Ligne, Indentificateur); }
{ If Identificateur [1] <> ' ' }
{ Then Entrer_Indentificateur (Identificateur); }
Extraire_Operateur (Ligne, OpCode);
Chercher_Operateur (OpCode, Classe, Valeur);
If Classe < 0
Then Essayer_Pseudo_Instruction (OpCode, Classe, Valeur);
Longueur := 0;
If Classe < 0
Then Erreur_Operateur;
Case Classe Of
0 : Longueur := Type0 (Ligne);
1 : Longueur := Type1 (Ligne);
End;
Assembler_Morceaux (Code, Classe, Valeur, Operande);
Sortir_Code (Code);
Compteur_Emplacement := Compteur_Emplacement + Longueur;
If Classe = 99
Then Begin
Encore := False;
Finir;
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 23 / 109
24. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
{ Preparer_Entree_Passe2; }
{ Trier_Table_Identificateurs; }
{ Epurer_Indentificateurs_Redondants; }
End;
End;
End;
End;
Erreurs les plus courantes en langage d'assemblage
• symbole non défini
• plusieurs définitions de symbole
• nom de code opératoire invalide
• pas assez (ou trop) d'opérandes compte tenu du code opération
• nombre octet contenant un 8 ou un 9
• utilisation d'un registre interdite (exemple : saut vers un registre)
• pas d'instruction END
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 24 / 109
25. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Routines d'intérêt général
Modifier une fonction d'une interruption.
Pour modifier la fonction 0 CMP AH,00
par exemple.
On exécute la nouvelle JZ modif
fonction.
PUSHF
Pour les autres fonctions, CALL ancien_INT_17
rien de nouveau.
IRET
modif :
... nouvelle fonction ...
IRET
Modifier l'adresse d'une pile
debut_pile_off DW ?
debut_pile_seg DW ?
Offset de l'adresse de la XCHG SP,CS:debut_pile_off
nouvelle pile.
MOV AX,SS
Segment de l'adresse de la XCHG AX,CS:debut_pile_seg
nouvelle pile.
MOV SS,AX
STI
RET
; Et maintenant, retour à la normale.
CLI
Offset de l'adresse de XCHG SP,CS:debut_pile_off
l'ancienne pile.
MOV AX,SS
Segment de l'adresse de XCHG AX,CS:debut_pile_seg
l'ancienne pile.
MOV SS,AX
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 25 / 109
26. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
STI
RET
Interruption 08H
Lecture de l'heure sur l'horloge
Note : heures, minutes, secondes doivent être remplacées par trois
adresses différentes
; Initialisation : lecture de TIMER_HIGH et TIMER_LOW
Srtout conserver DS PUSH DS
Sélection du segment 40 pour MOV AX,40
...
... accès à la zone de MOV DS,AX
communication du BIOS.
TIMER_HIGH est situé en MOV DX,[6E]
0046E
TIMER_LOW est situé en MOV AX,[6C]
0046C
POP DS
; Calcul des heures.
65520 = heure - 60*60*18,2 MOV BX,65520
DX contient le reste, et AX le DIV BX
quotient de la division de
DX,AX par BX (65520) AH
est forcément nul, compte
tenu du fait que le nombre
d'heures est limité à 24 !)
HEURES contient l'heure de MOV heures,AL
l'horloge.
; Calcul des minutes.
On s'occupe maintenant du MOV AX,DX
reste.
DX = 0 SUB DX,DX
BX = 1092 MOV BX,1092
Division du reste (DX,AX) DIV BX
par 1092 afin d'obtenir le
nombre de minutes (AX).
AH est forcément nul, puis MOV minutes,AL
que le nombre de minutes est
limité à 60.
MINUTES contient les
minutes de l'horloge.
; Calcul des minutes.
Reste dans AX MOV AX,DX
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 26 / 109
27. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
BL = 18 (au lieu de 18,2 MOV BL,18
pour être plus précis)
Idem mais divisé cette fois DIV BL
par 18
AL contient le nombre de MOV secondes,AL
secondes de l'horloge
; et voilà, c'est fini ...
RET
Interruption 10H
Fonction 00h - Sélection de mode d'affichage
MODE = numéro du mode MOV AL,mode
d'affichage
Fonction 0 ... MOV AH,00
... de l'interruption 10H INT 10
RET
Fonction 01h - Sélection du format du curseur
LIGNE_DEBUT indique la MOV CH,ligne_debut
ligne de début du curseur
MOV CL,ligne_fin
Interruption 11h
Détermination de la configuration
; Stocker le mot de configuration dans AX
Appel de l'interruption INT 11H
; On s'occupe de l'octet de poids faible (AL). Le bit 0 concerne la présence
ou l'absence d'unité de disquette.
AX est le mot de MOV BL,AL
configuration
On ne garde que le bit 0 AND BL,1
DISK prend la valeur 0 s'il MOV disk,BL
n'y a pas d'unité de disquette,
ou 1 s'il en a au moins une.
Décalage d'un bit à droite SHR AX,1
puisque l'information
précédente occupe 1 bit (de
poids faible).
; Le bit 1 concerne la présence ou non du co-processeur 8087.
MOV BL,AL
AND BL,1
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 27 / 109
28. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Co-processeur arithmétique MOV coproc,BL
8087 présent ou non ? 1 pour
oui, 0 pour non
Décalage d'un bit à droite SHR AX,1
; Les bits 2 à 3 indiquent la quantité de mémoire présente sur la carte
système.
MOV BL,AL
On ne garde que les bits 2 et AND BL,3
3
MEM indique la quantité de MOV mem,BL
mémoire sur la carte système
MOV CL,2
Décalage de deux fois à SHR AX,CL
droite
; Les bits 4 et 5 indiquent la carte vidéo initiale
MOV BL,AL
On ne garde que les bits 4 et AND BL,3
5
VIDEO indique le mode MOV video,BL
vidéo commuté lors de la
mise en route de l'ordinateur
Encore décalage de deux bits SHR AX,CL
à droite
; Les bits 6 et 7 indiquent le nombre d'unités de disquettes présentes.
MOV BL,AL
On ne conserve que les bits 6 AND BL,3
et 7.
DISKS indique le nombre MOV disks,BL
d'unités de disquettes
présentes
Cette fois, décalage de MOV CL,3
trois ...
... bits car le bit 8 est SHR AX,CL
inutilisé les bits 9 à 11
indiquent le nombre de
sorties RS-232 présentes.
MOV BL,AL
On ne conserve que les bits 9 AND BL,7
à 11.
RS232 indique le nombre de MOV rs232,BL
sorties séries installées
Décalage de trois bits à SHR AX,CL
droite le bit 12 indique la
présence ou non d'une
manette de jeu
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 28 / 109
29. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
MOV BL,AL
On ne conserve que le bit 12 AND BL,1
JOYST vaut 1 s'il y a une MOV joyst,BL
manette de jeu, 0 sinon
MOV CL,2
Décalage de deux bits à SHR AX,CL
droite puisque le bit 13 est
inutilisé
; Les bits 14 et 15 indiquent le nombre d'imprimantes connectées. Il n'y a
plus d'informations après, tous les bits à gauche sont donc à 0.
PRINTER indique le nombre MOV printer,AL
d'imprimantes connectées
RET
Interruption 12H
Déclenchement de INT 12 ;
l'interruption (détermination
de la taille mémoire) sans
passer aucun paramètre.
E sortie, AX contient le MOV mem,AX
nombre de K contenus sur la
carte système.
RET
Interruption 16H
Fonction 01h - Y a-t-il un caractère dans le buffer ?
MOV AH,1
INT 16
JE vide
JMP réaction
Interruption 17h
Fonction 00h - Imprimer un caractère en testant si tout s'est
bien passé
Numéro de l'imprimante MOV DX,00
Appel de la fonction 0 ... SUB AH,AH
... de l'interruption 17H : INT 17 ;
impression du caractère.
En cas d'erreur, ... JNZ erreur
... ça continue ... ... pas d'erreur ...
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 29 / 109
30. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
L'imprimante est-elle prête ?
DX = n° de l'imprimante MOV DX,00
Sélection de la fonction 02 ... MOV AH,02
... de l'interruption 17H : INT 17
lecture de l'octet d'état de
l'imprimante.
90H = 10010000 CMP AH,90
Va à PAS_PRETE si elle JZ pas_prête
n'est pas prête ...
Si elle est prête, ça ... ;
continue...
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 30 / 109
32. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
33 MN//MX
34 /SS0
35 A19/S6
36 A18/S5
37 A17/S4
38 A16/S3
39 A15
40 +5V
Registres et instructions
Registre/Instruction Description
Registres généraux
AX (AH+AL) Accumulateur
BX (BH+BL) Base
CX (CH+CL) Compteur
DX (DH+DL) Donnée
SP Pointeur de pile
BP Pointeur de base
SI Index source
DI Index destination
Registres de segmentation
CS Segment du code
DS Segment des données
SS Segment de la pile
ES Segment extra
IP Pointeur d'instruction
Registres d'état et de contrôle
CF Retenue
PF Parité
AF Retenue auxiliaire
ZF Zéro
TF Piège
IF Autorisation d'interruption
DF Indicateur de direction
OF Débordement
SF Signe
Modes d'adressage
Immédiat MOV BL,FFh
De registre MOV AX,BX
Direct MOV AX,constante avec adresse = DS:constante
Indirect de registres MOV BX,[SI] avec adresse = 16 * DS + SI
Indirect de registre avec MOV AX,constante [DI] avec adresse = 16 * DS +
déplacement constante + DI
Indirect de registre avec registre MOV AX,[BX] [DI] avec adresse = 16 * DS + BX
de base et registre d'index + DI
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 32 / 109
33. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Indirect de registre avec registre MOV AX, constante [BX] [SI] avec adresse = 16 *
de base, d'index plus constante DS + constante + BX + SI
Addition
AAA Ajustement ASCII pour addition
ADC Addition avec retenue
ADD Addition sans retenue
DAA Correction décimale pour addition
INC Incrément de un
Division
AAD Ajustement ASCII pour division
DIV Division non signée. Si octet, division de AX,
AH=quotient, AL=reste. Si mot, division de
DX,AX,AX=quotient, DX=reste
IDIV Division signée. Si octet, division de AX,
AL=quotient, AH=reste. Si mot, division de
DX,AX,AX=quotient, DX=reste
Multiplication
AAM Ajustement ASCII pour multiplication
IMUL Multiplication signée. Si octet, AX=AL*source. Si
mot, DX,AX=AX*source
MUL Multiplication non signée. Si octet,
AX=AL*source. Si mot, DX,AX=AX*source
Soustraction
AAS Ajustement ASCII pour soustraction
DAS Correction décimale pour soustraction
DEC Décrémente le registre ou la mémoire
SBB Soustraction avec retenue. Si CF=1, dest=dest-
source-1. Si CF=0, dest=dest-source
SCAS Soustrait la chaîne pointée par DI de
l'accumulateur. DI est décrémenté
SUB Soustraction
Logique
AND Et logique
NEG Complément à deux
NOT Complément à un; inverse tous les bits
OR Ou inclusif
XOR Ou exclusif; CF=0, OF=0
Divers
CBW Conversion d'octet en mot
CWD Conversion de mot en mot double
LDS Charge un pointeur 32 bits dans un registre
LEA Charge le déplacement dans une chaîne vers un
registre
LES Charge un pointeur 32 bits vers un registre et ES
LODS Charge la chaîne pointée par SI dans AL ou AX. Si
DF=0, SI incrémenté; si DF=1, SI décrémenté.
MOV Transfert d'une opérande à une autre
MOVS Transfert de la chaîne pointée par SI vers la chaîne
pointée par DI. DI et SI sont incrémentés
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 33 / 109
34. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
STOS Charge l'accumulateur vers la chaîne pointée par
DI. DI incrémenté
XCHG Echange le contenu des deux opérandes
XLAT Echange l'accumulateur par la table de 256 octets
pointée par BX+AL; BX pointe en début de table
CLC Mise à zéro de CF
CLD Mise à zéro de DF
CLI Mise à zéro de IF
CMC Complément à un de CF
LAHF Charge les indicateurs dans AH : SFZF--AF--PF--
CF
SAHF Charge AH dans le registre des indicateurs
STC Mise à un de CF
STD Mise à un de DF
STI Mise à un de IF
CMP Comparaison
CMPS Comparaison de la chaîne pointée par DI avec
celle pointée par SI. Incrémente DI et SI
ESC Envoit d'instruction au co-processeur
HLT Mise à l'arrêt du 8088
IN Lecture d'un port dans l'accu
INT Déclenche une interruption
INTO Déclenche une interruption si OF=1
IRET Retour d'interruption
LOCK Vérrouillage du bus
NOP Aucune opération
OUT Ecriture sur un port d'E/S
CALL Appel de sous-programme. S'il est éloigné, CALL
[FAR], sinon [NEAR]
JA Saut si supérieur / CF=0, ZF=0
JAE Saut si supérieur ou égal / CF=0
JB Saut si inférieur / CF=1
JBE Saut si inférieur ou égal / CF=1, ZF=1
JC Saut si retenue / CF=1
JCXZ Saut si CX=0
JE Saut si égal / ZF=1
JG Saut si plus grand / SF=OF, ZF=0
JGE Saut si supérieur ou égal / SF=OF
JL Saut si inférieur / SF<>OF
JLE Saut si inférieur ou égal / SF<>OF ou ZF=1
JMP Saut inconditionnel. CS et IP mis à jour
JNA Saut si non dupérieur / CF=1, ZF=1
JNAE Saut si non supérieur ou égal / CF=1
JNB Saut si non inférieur / CF=0
JNBE Saut si non inférieur ou égal / CF=0, ZF=0
JNC Saut si CF=0
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 34 / 109
35. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
JNE Saut si non égal / ZF=0
JNG Saut si non supérieur / SF<>OF ou ZF=1
JNGE Saut si non inférieur ou égal / SF<>OF
JNL Saut si non inférieur / SF=OF
JNLE Saut si non inférieur ou égal / SF=OF, ZF=0
JNO Saut si pas de déébordement / OF=0
JNP Saut si pas de parité / PF=0
JNS Saut si SF=0
JNZ Saut si non zéro / ZF=0
JO Saut si OF=1
JP Saut si parité paire / PF=1
JPE Saut si parité égale / PF=1
JPO Saut si parité impaire / PF=0
JS Saut si SF=1
JZ Saut si zéro / ZF=0
RET Retour de sous-programme
TEST Et logique / CF=0, OF=0; indicateurs mis à jour
Boucle
LOOP Boucle tant que CX<> 0. Décrémente CX
LOOPE Boucle tant que égal et CX<>0 / ZF=1.
Décrémente CX
LOOPNE Boucle tant que non égal et CX<>0 / ZF=0.
Décrémente CX
LOOPNZ Boucle tant que non zéro et CX<>0 / ZF=0.
Décrémente CX
LOOPZ Boucle tant que zéro et CX<>0 / ZF=1.
Décrémente CX
REP Répéter tant que CX<>0
REPE Répéter tant qu'égal / ZF=1
REPNE Répéter tant que non égal / ZF=0
REPNZ Répéter tant que non zéro / ZF=0
REPZ Répéter tant que zéro / ZF=1
Pile
POP Dépile un registre général
POPF Dépile vers le registre d'indicateur
PUSH Empile un registre
Rotation
RCL Rotation de n bits vers la gauche à travers
l'indicateur de retenue
RCR Rotation de n bits vers la droite à travers
l'indicateur de retenue
ROL Rotation de n bits vers la gauche
ROR Rotation de n bits vers la droite
Décalage
SAL Décalage arithmétique de n bits vers la gauche;
des zéros sont introduits à droite
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 35 / 109
36. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
SAR Décalage arithmétique de n bits vers la droite; le
bit de poids fort d'origine remplit les trous
SHL Décalage logique de n bits vers la gauche; des
zéros sont introduits à droite
SHR Décalage logique de n bits vers la droite; des zéros
sont introduits à gauche
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 36 / 109
37. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Les disques
Les dessous de la disquette 360 Ko
Lors du formatage, la disquette est découpée :
• en pistes (tracks)
• Les pistes sont représentées par des cercles concentriques à
partir du centre de la disquette.
• en secteurs (sectors)
• Les secteurs sont représentées par des subdivisions des pistes en
segments.
Si vous regardez ce qu'il y a d'écrit sur une disquette, vous pouvez lire, le
plus souvent :
• double face
• Le stockage est fait sur les deux faces.
• double densité
La densité d'écriture est de 40 pistes par face (ou 48 Tracks Per Inch = 48
TPI).
Si une disquette est organisée par soft, la division en secteurs est faite
pendant le formatage.
Une fois formatée, une disquette de 360 Ko contient les informations
suivantes :
• 40 pistes
• 1 piste = 9 secteurs
• 1 face = 360 secteurs
• 1 secteur = 512 octets
• 1 disquette = 2 faces * 9 secteurs * 40 pistes * 512 octets
• soit 1 disquette = 368.640 octets
De plus, la disquette est numérotée de façon continue et de la façon
suivante :
Face 0 de la disquette
0 1 2 3 4 5 6 7 8
Piste 0 0 1 2 3 4 5 6 7 8
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 37 / 109
38. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Piste 1 18 19 20 21 22 23 24 25 26
Piste 2 36 37 38 39 40 41 42 43 44
Piste 39 702 703 704 705 706 707 708 709 710
Face 1 de la disquette
0 1 2 3 4 5 6 7 8
Piste 0 9 10 11 12 13 14 15 16 17
Piste 1 27 28 29 30 31 32 33 34 35
Piste 2 45 46 47 48 49 50 51 52 53
Piste 39 711 712 713 714 715 716 717 718 719
Note importante : un cluster est la plus petite zone de stockage que prend
un fichier pour être stocké. Un cluster représente un groupe de deux
secteurs, soit 1024 octets. Ainsi, un fichier de 1 octet occupera 1024 octets
= 1 cluster !
Une disquette contient 354 clusters.
Après formatage d'une disquette, la disquette se découpe comme suit :
Secteur Contenu
secteur 0 Zone d'initialisation (Boot Sector)
secteur 1-4 Table d'allocation de fichiers (FAT = File Allocation
Table)
secteur 5-11 Répertoire (Directory)
secteur 12 Zone de stockage des données
Les autres secteurs reçoivent la valeur hexa F6, soit 246 en décimal. Ainsi,
le DOS peut savoir si le secteur a été utilisé ou non.
Secteur 0 - Zone d'initialisation ( Boot Sector)
Ce secteur est le premier secteur chargé, avant même le SED lui-même.
C'est le Bootstrap (en ROM) qui le charge. Il contient :
• le nom du fabricant
• le numéro de la version du SED
• quelques messages d'erreur (à la fin)
Le 15ème octets (hexa) contient l'information qui caractérise le type de
lecteur (FD en hexa pour un lecteur de disquettes 5 pouces 1/4, double
faces, 40 pistes, 9 secteurs; F9 pour les lecteurs AT, F8 pour les disques
durs.
secteur 1-4 - Table d'allocation de fichiers (FAT = File Allocation
Table)
La FAT s'occupe de stocker les informations concernant la place occupée
par un fichier, ainsi que les clusters occupés par ce fichier.
Plus une disquette a de clusters, plus la FAT doit être grande.
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 38 / 109
39. Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
En théorie, les fichiers devraient être stockés sur des clusters qui se
suivent. En pratique, à cause des fichiers effacés ou des fichiers qui
grossissent, ils peuvent parfaitement être dispersés sur toute la disquette.
Le cluster de départ est indiqué dans le répertoire. Une zone de stockage
libre est repérée par la valeur 0.
Secteur 5-11 - Répertoire (Directory)
Tous les fichiers (sauf les sous-répertoires) sont mentionnés, avec
différents paramètres. Chaque fichier occupe 32 octets, et une disquette
360 Ko autorise au maximum 112 entrées, ce qui représente sept
secteurs.
Les 32 octets réservés à chaque fichier sont représentés comme suit :
Octets Description
0à7 Nom du fichier : huit caractères au maximum
8 à 10 Etension du fichier (ou suffixe, ou nom de famille) : trois
caractères au maximum
11 Attribut. Il définit si le fichier est : caché, archive, protégé,
nom du disque (volume), protégé en écriture, sous-répertoire
(fichier de longueur 0)
12 à 21 Réservé au DOS
22 et 23 Heure de création
24 et 25 Date de création
26 et 27 Pemier cluster du fichier
28 à 31 Taille du fichier
Note : les fichiers effacés sont repérés par le fait que le premier caractère
de leur nom vaut E5 (hexa) ou 229 (décimal). Mais parallèlement, la FAT
est mise à jour.
Le disque dur
Un disque dur, lors du formatage, est divisé en :
• secteurs
• pistes
• cylindres
Un disque dur peut être assimilé à un ensemble de plusieurs disquettes. Un
cylindre représente alors une division dans le sens vertical.
Les capacités de stockage dépendent du disque dur employé.
L'organisation d'une disquette
Présentation
Après formatage d'une disquette, la disquette se découpe comme suit (les
pistes sont numérotées de 0 à 39, et les secteurs de 1 à 9) :
Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 39 / 109