assembleur et binaire
TRANSCRIPT
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Sommaire
PROCÉDURE D'ASSEMBLAGE..............................................................................5
COMMENT ÉCRIRE UN PROGRAMME ASSEMBLEUR ?.............................................................................5Saisie....................................................................................................................................5Assemblage..........................................................................................................................6Références croisées.............................................................................................................7Création d'un fichier .EXE....................................................................................................7Création d'un fichier .COM...................................................................................................8
LE PORT SÉRIE..................................................................................................9
INTERRUPTIONS 14H.....................................................................................................................9But........................................................................................................................................9Zones RAM utilisées.............................................................................................................9Registres en entrée..............................................................................................................9Algorithme.........................................................................................................................11
SOURCE COMMENTÉ :..................................................................................................................12Subroutines fonctions........................................................................................................13Subroutine STATUS_MODEM.............................................................................................14Subroutine SEND_CHAR.....................................................................................................14Subroutine RECEIVE_CHAR................................................................................................15Subroutine SSPROG1.........................................................................................................16Subroutine SSPROG1_1.....................................................................................................16Subroutine STATUS............................................................................................................16
APPLICATIONS ASSEMBLEUR.........................................................................................................17Fonction 00 : Initialisation du port série...........................................................................17Fonction 01 : Transmission de caractère..........................................................................17Fonction 02 : Réception d'un caractère............................................................................18Fonction 03 : Prêt à émettre ?...........................................................................................18Fonction 03 : Caractère reçu ?..........................................................................................18Envoi des caractères saisis au clavier sur le port série....................................................19
LANGAGE C...............................................................................................................................19Fonction 01 : Envoi d'un caractère...................................................................................19Fonction 02 : Réception d'un caractère............................................................................20Fonction 03 : Prêt à recevoir ?...........................................................................................20Fonction 04 : Prêt à émettre ?...........................................................................................20
COMPARAISON LANGAGE D'ASSEMBLAGE / LANGAGE ÉVOLUÉ...........................22
TABLES UTILISÉES PAR LES ASSEMBLEURS.......................................................................................22Table des symboles (ou des identificateurs) :..................................................................22Table des codes opératoires :...........................................................................................22Table des constantes :.......................................................................................................23
ASSEMBLEUR À DEUX PASSES........................................................................................................23ERREURS LES PLUS COURANTES EN LANGAGE D'ASSEMBLAGE.............................................................25
ROUTINES D'INTÉRÊT GÉNÉRAL........................................................................26
MODIFIER UNE FONCTION D'UNE INTERRUPTION................................................................................26Modifier l'adresse d'une pile.............................................................................................26
INTERRUPTION 08H....................................................................................................................27Lecture de l'heure sur l'horloge........................................................................................27
INTERRUPTION 10H....................................................................................................................28Fonction 00h - Sélection de mode d'affichage.................................................................28Fonction 01h - Sélection du format du curseur................................................................28
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 1 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
INTERRUPTION 11H.....................................................................................................................28Détermination de la configuration....................................................................................28
INTERRUPTION 12H....................................................................................................................30INTERRUPTION 16H....................................................................................................................30
Fonction 01h - Y a-t-il un caractère dans le buffer ?.........................................................30INTERRUPTION 17H.....................................................................................................................30
Fonction 00h - Imprimer un caractère en testant si tout s'est bien passé......................30L'imprimante est-elle prête ?............................................................................................31
RÉFÉRENCES...................................................................................................32
BROCHAGES..............................................................................................................................328088...................................................................................................................................32Registres et instructions....................................................................................................33
LES DISQUES..................................................................................................38
LES DESSOUS DE LA DISQUETTE 360 KO........................................................................................38Secteur 0 - Zone d'initialisation ( Boot Sector)..............................................................39secteur 1-4 - Table d'allocation de fichiers (FAT = File Allocation Table)......................39Secteur 5-11 - Répertoire (Directory)................................................................................40
LE DISQUE DUR..........................................................................................................................40L'ORGANISATION D'UNE DISQUETTE................................................................................................40
Présentation.......................................................................................................................40Zone d'initialisation, Boot Sector......................................................................................41Table d'allocation de fichier, FAT = File Allocation Table................................................42Répertoire (Directory)........................................................................................................43Le préfixe de segment de programme (PSP)....................................................................44
L'IBM PC/XT JUSQU'À SES RACINES...................................................................46
PRÉSENTATION DES ÉLÉMENTS CONSTITUANT L'UNITÉ CENTRALE DE L'IBM PC/XT.................................46L'Unité d'Exécution (EU)....................................................................................................46L'Unité d'Interface de Bus.................................................................................................47
ARCHITECTURE GÉNÉRALE............................................................................................................47Le micro-processeur 8088.................................................................................................48
LES VECTEURS D'INTERRUPTION....................................................................................................48Les interruptions de type INTR (INTerrupt Request).........................................................49L'interruption NMI (Non Masquable Interrupt)..................................................................49L'interruption RESET (remise à zéro)................................................................................49
NOTATION.................................................................................................................................50
L'ARITHMÉTIQUE BINAIRE................................................................................51
PRÉSENTATION...........................................................................................................................51L'addition binaire...............................................................................................................53La soustraction binaire......................................................................................................53La multiplication et la division binaire..............................................................................53
LES FONCTIONS LOGIQUES DE BASE...............................................................................................54Présentation.......................................................................................................................54La logique combinatoire....................................................................................................54Le système des portes.......................................................................................................55Le décodeur.......................................................................................................................57Le multiplexeur..................................................................................................................57L'additioneur complet........................................................................................................57
INTERRUPTION 21H.....................................................................................................................57Fonction 09h - Affichage d'une chaîne de caractères......................................................57Fonction 0Ah - Lecture d'une ligne au clavier..................................................................58Fonction 12 - Vider le buffer du clavier.............................................................................58Fonction 25 - Installer une nouvelle interruption.............................................................58Fonction 3Dh - Création de répertoire..............................................................................58
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 2 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Fonction 3Dh - Changement de répertoire.......................................................................59Fonction 4Ch - Rendre la main à MS-DOS.........................................................................59
LA VIDÉO........................................................................................................61
ATTRIBUTS................................................................................................................................61Définition............................................................................................................................61Adaptateur monochrome..................................................................................................61Adaptateur graphique couleur..........................................................................................62
COURS D’ASSEMBLEUR....................................................................................63
GÉNÉRALITÉS.............................................................................................................................63Rappels sur le fonctionnement de l’ordinateur................................................................63La syntaxe..........................................................................................................................64
LES DONNÉES............................................................................................................................64Généralités.........................................................................................................................64Registres............................................................................................................................65Données et mémoire.........................................................................................................66
LES MODES D’ADRESSAGE............................................................................................................68LE JEU D’INSTRUCTIONS...............................................................................................................70
Les instructions de base....................................................................................................70Les instructions arithmétiques..........................................................................................71Les instructions logiques...................................................................................................73Les instructions de décalage et de rotation......................................................................74Les instructions de pile......................................................................................................75Les instructions de manipulation de chaînes de caractères............................................76Les instructions de saut conditionnel................................................................................78Les instructions de saut inconditionnel............................................................................78Les tests d’identificateur...................................................................................................78Les tests arithmétiques.....................................................................................................79Les tests de nombres non signés......................................................................................79Les tests de nombres signés.............................................................................................80Les instructions de boucle.................................................................................................81Les procédures (sous-programmes)..................................................................................81Les paramètres et les sous-programmes..........................................................................82Les instructions de gestion des adresses.........................................................................83
TECHNIQUES DE PROGRAMMATION.................................................................................................83Organisation d’un programme..........................................................................................84Utilisation de plusieurs segments : la directive Assume..................................................84La programmation modulaire............................................................................................85Les fichiers Exe..................................................................................................................85
POINTS PARTICULIERS.....................................................................................87
ADRESSAGE DE LA MÉMOIRE.........................................................................................................87INTERRUPTIONS LOGICIELLES.........................................................................................................87PRÉSENTATION DE L’IBM PC/XT..................................................................................................89PRÉSENTATION DES ÉLÉMENTS CONSTITUANT L’UNITÉ CENTRALE DU PC...............................................89
L'Unité d'Exécution (EU)....................................................................................................89L'Unité d'Interface de Bus.................................................................................................89
ARCHITECTURE GÉNÉRALE............................................................................................................91LE MICRO-PROCESSEUR 8088......................................................................................................91
Notion de segment............................................................................................................91LISTE DES REGISTRES..................................................................................................................91
Registres généraux............................................................................................................91Pointeurs............................................................................................................................92Segment.............................................................................................................................93Registre d'état et de commande.......................................................................................93
LES VECTEURS D’INTERRUPTION....................................................................................................95
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 3 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
BRÈVE PRÉSENTATION DU 6502...................................................................................................96LANGAGE MACHINE OU LANGAGE DE LA MACHINE...........................................................................101LES OPÉRATEURS ET LES ATTRIBUTS.............................................................................................102
AIDE SUR L’ASSEMBLEUR..............................................................................105
INFORMATIONS SUR LE 8088.....................................................................................................105REGISTRES..............................................................................................................................105
Pile....................................................................................................................................105Drapeaux.........................................................................................................................105
OPÉRATIONS ARITHMÉTIQUES......................................................................................................106Addition............................................................................................................................107Soustraction.....................................................................................................................107Multiplication...................................................................................................................107Division............................................................................................................................107Decalage..........................................................................................................................107Rotation............................................................................................................................108Logique............................................................................................................................108
Divers...................................................................................................................................108
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 4 / 107
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)
fin de la procédure ADDITION
ADDITION ENDP
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 5 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 6 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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]:)
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 7 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
- 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 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 8 / 107
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 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 9 / 107
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,
2 erreur de parité,
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 10 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
300 01 - 80
600 00 - C0
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 11 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
; Sauvegarder les registres modifiés
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 12 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Empile afin de ne pas perturber le programme courant.
PUSH BX
PUSH CX
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 à gauche.
SHL BL,1
; 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 * BX
MOV DX,[BX+0000]
; 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 non.
OR DX,DX
Si DX = 0 (pas de carte) alors aller à SORTIE.
JZ SORTIE
Aappel du sous-programme qui effectue l'exécution de la fonction sélectionnée.
CALL FONCTIONS
; 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 restaurer les conditions initiales d'appel.
POP DS
POP SI
POP DI
POP DX
POP CX
POP BX
Fin de routine de traitement d'interruption.
IRET
Subroutines fonctions
Pour la routine de sélection de fonction, se référer au paragraphe correspondant figurant en début de chapitre.
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).
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 13 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 l'octet dans AL.
IN AL,DX
; 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 et stocke l'octet dans AL.
IN AL,DX
; 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 dans le registre.
OUT DX,AL
; 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 STATUS.
CALL STATUS
Si pas égal alors saut au sous programme SSPROG1.
JNZ SSPROG1
; Pointe sur le registre d'état de la ligne
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.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 14 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
BH = 20 MOV BH,20
Aappel du sous-programme STATUS.
CALL STATUS
Si pas égal alors saut au sous-programme SSPROG1.
JNZ 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 initiale de AL)
MOV AL,CL
Sortie du caractère contenu dans AL sur le port de base.
OUT DX,AL
; 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 base + 4.
OUT DX,AL
; 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 STATUS.
CALL STATUS
Si pas égal alors saut au sous-programme SSPROG1_1.
JNZ 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 STATUS.
CALL STATUS
Si pas égal alors saut au sous-programme SSPROG1_1.
JNZ SSPROG1_1
; Pointe sur le registre de réception et de transmission de données.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 15 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 (00011110) => remise à zéro des bits 0, 5 à 7.
AND AH,1E ;
; Lecture de l'octet contenu dans le port
Lit le port de base et stocke l'octet en AL.
IN AL,DX
; 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 (10000000).
OR AH,80
; 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 [47C + numéro de la carte]
; MOV BL,[DI+007C]
; 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 stocke l'octet lu dans AL.
IN AL,DX
MOV AH,AL ; AH = AL
; 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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 16 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Si oui, alors saut à FIN_STATUS => fin de sous-programme.
JZ FIN_STATUS
; On recommence au point marqué BOUCLE
Saut à BOUCLE tant que CX différent de 0 décrémente CX.
LOOP BOUCLE
; 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 à REPRISE.
JNZ 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
code ASCII 48.
MOV AL,48
Fonction transmission de caractère ...
MOV AH,01
... par l'interruption 14 INT 14
RET
Fonction 02 : Réception d'un caractère.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 17 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
entrée :
Entrée d'un caractère ... MOV AH,0
... au clavier INT 16
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 18 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 15 fois tout de même.
LOOPZ encore
Si le compteur d'essais est à 0.
CMP CX,0
C'est qu'il y a une erreur ! JZ erreur
Sinon, on reprend au caractère suivant.
JMP entree
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;
Union REGS InRegs, OutRegs;
Sélection du port COM1 InRegs.x.dx = 0;
Réception de caractère InRegs.h.ah = 2;
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 19 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 20 / 107
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
- hexadécimal
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 21 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
Then Begin
Encore := False;
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 22 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
{ 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;
{ Preparer_Entree_Passe2; }
{ Trier_Table_Identificateurs; }
{ Epurer_Indentificateurs_Redondants; }
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 23 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 24 / 107
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 par exemple.
CMP AH,00
On exécute la nouvelle fonction.
JZ modif
PUSHF
Pour les autres fonctions, rien de nouveau.
CALL ancien_INT_17
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 nouvelle pile.
XCHG SP,CS:debut_pile_off
MOV AX,SS
Segment de l'adresse de la nouvelle pile.
XCHG AX,CS:debut_pile_seg
MOV SS,AX
STI
RET
; Et maintenant, retour à la normale.
CLI
Offset de l'adresse de l'ancienne pile.
XCHG SP,CS:debut_pile_off
MOV AX,SS
Segment de l'adresse de l'ancienne pile.
XCHG AX,CS:debut_pile_seg
MOV SS,AX
STI
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 25 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 communication du BIOS.
MOV DS,AX
TIMER_HIGH est situé en 0046E
MOV DX,[6E]
TIMER_LOW est situé en 0046C
MOV AX,[6C]
POP DS
; Calcul des heures.
65520 = heure - 60*60*18,2 MOV BX,65520
DX contient le reste, et AX le 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 !)
DIV BX
HEURES contient l'heure de l'horloge.
MOV heures,AL
; Calcul des minutes.
On s'occupe maintenant du reste.
MOV AX,DX
DX = 0 SUB DX,DX
BX = 1092 MOV BX,1092
Division du reste (DX,AX) par 1092 afin d'obtenir le nombre de minutes (AX).
DIV BX
AH est forcément nul, puis que le nombre de minutes est limité à 60.
MINUTES contient les minutes de l'horloge.
MOV minutes,AL
; Calcul des minutes.
Reste dans AX MOV AX,DX
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 26 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
BL = 18 (au lieu de 18,2 pour être plus précis)
MOV BL,18
Idem mais divisé cette fois par 18
DIV BL
AL contient le nombre de secondes de l'horloge
MOV secondes,AL
; et voilà, c'est fini ...
RET
Interruption 10H
Fonction 00h - Sélection de mode d'affichage
MODE = numéro du mode d'affichage
MOV AL,mode
Fonction 0 ... MOV AH,00
... de l'interruption 10H INT 10
RET
Fonction 01h - Sélection du format du curseur
LIGNE_DEBUT indique la ligne de début du curseur
MOV CH,ligne_debut
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 configuration
MOV BL,AL
On ne garde que le bit 0 AND BL,1
DISK prend la valeur 0 s'il n'y a pas d'unité de disquette, ou 1 s'il en a au moins une.
MOV disk,BL
Décalage d'un bit à droite puisque l'information précédente occupe 1 bit (de poids faible).
SHR AX,1
; Le bit 1 concerne la présence ou non du co-processeur 8087.
MOV BL,AL
AND BL,1
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 27 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Co-processeur arithmétique 8087 présent ou non ? 1 pour oui, 0 pour non
MOV coproc,BL
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 3
AND BL,3
MEM indique la quantité de mémoire sur la carte système
MOV mem,BL
MOV CL,2
Décalage de deux fois à droite
SHR AX,CL
; Les bits 4 et 5 indiquent la carte vidéo initiale
MOV BL,AL
On ne garde que les bits 4 et 5
AND BL,3
VIDEO indique le mode vidéo commuté lors de la mise en route de l'ordinateur
MOV video,BL
Encore décalage de deux bits à droite
SHR AX,CL
; 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 et 7.
AND BL,3
DISKS indique le nombre d'unités de disquettes présentes
MOV disks,BL
Cette fois, décalage de trois ...
MOV CL,3
... bits car le bit 8 est inutilisé les bits 9 à 11 indiquent le nombre de sorties RS-232 présentes.
SHR AX,CL
MOV BL,AL
On ne conserve que les bits 9 à 11.
AND BL,7
RS232 indique le nombre de sorties séries installées
MOV rs232,BL
Décalage de trois bits à droite le bit 12 indique la présence ou non d'une manette de jeu
SHR AX,CL
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 28 / 107
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 manette de jeu, 0 sinon
MOV joyst,BL
MOV CL,2
Décalage de deux bits à droite puisque le bit 13 est inutilisé
SHR AX,CL
; 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 d'imprimantes connectées
MOV printer,AL
RET
Interruption 12H
Déclenchement de l'interruption (détermination de la taille mémoire) sans passer aucun paramètre.
INT 12 ;
E sortie, AX contient le nombre de K contenus sur la carte système.
MOV mem,AX
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 : impression du caractère.
INT 17 ;
En cas d'erreur, ... JNZ erreur
... ça continue ... ... pas d'erreur ...
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 29 / 107
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 : lecture de l'octet d'état de l'imprimante.
INT 17
90H = 10010000 CMP AH,90
Va à PAS_PRETE si elle n'est pas prête ...
JZ pas_prête
Si elle est prête, ça continue...
... ;
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 30 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Références
Brochages
8088
Patte Description
1 masse
2 A14
3 A13
4 A12
5 A11
6 A10
7 A9
8 A8
9 A7/D7
10 A6/D6
11 A5/D5
12 A4/D4
13 A3/D3
14 A2/D2
15 A1/D1
16 A0/D0
17 NMI
18 INTR
19 CLK
20 masse
21 RESET
22 READY
23 /TEST
24 /INTA
25 ALE
26 /DEN
27 DT/R
28 IO//M
29 /WR
30 HLDA
31 HOLD
32 /RD
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 31 / 107
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 déplacement
MOV AX,constante [DI] avec adresse = 16 * DS + constante + DI
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 32 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Indirect de registre avec registre de base et registre d'index
MOV AX,[BX] [DI] avec adresse = 16 * DS + BX + DI
Indirect de registre avec registre de base, d'index plus constante
MOV AX, constante [BX] [SI] avec adresse = 16 * 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é.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 33 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 34 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 35 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Décalage
SAL Décalage arithmétique de n bits vers la gauche; des zéros sont introduits à droite
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 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 36 / 107
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
Piste 1 18 19 20 21 22 23 24 25 26
Piste 2 36 37 38 39 40 41 42 43 44
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 37 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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.
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.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 38 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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) :
Piste 0 :
secteur 1 Zone d'initialisation (Boot Sector).
1 secteur.
secteur 2-5 Table d'allocation de fichiers (FAT =
File Allocation Table).
2 secteurs.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 39 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
secteur 6-9 face 0 Répertoire (Directory).
secteur 1-2 face 1 7 secteurs.
secteur 12- Zone de stockage des données.
IBMBIO.COM : 10 secteurs.
IBMDOS.COM : 34 secteurs.
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.
Voici un tableau indicatif de la capacité des disquettes une fois formattée, selon le type de lecteur (DF = double face, SF = simple face), et que l'on est en présence d'une disquette système (avec /S) ou non système (sans /S) :
xF nb secteurs/piste capacité sans /S
capacité avec /S
SF 8 160.256 119.296
SF 9 179.712 138.752
DF 8 322.560 282.600
DF 9 362.496 321.536
Les lecteurs SF parcourent la disquette dans l'ordre : piste n, piste n+1, piste n+2, ... Les lecteurs DF dans l'ordre : piste n tête 0, piste n tête 1, piste n+1 tête 0, piste n+1 tête 1, ...
Dans la suite, nous ne considérerons que les lecteurs double face (DF) avec 9 secteurs par piste.
Notez que pour le traitement de revectorisation des entrées-sorties, MS-DOS utile un système de numérotation interne :
n° interne description
0000 unité standard d'entrée, redirigeable
0001 unité standard de sortie, redirigeable
0002 unité standard d'erreur, non redirigeable
0003 unité auxiliaire standard
0004 unité d'impression standard
0005 premier fichier ouvert après le boot
Zone d'initialisation, Boot Sector
Secteur 1
Ce secteur est le premier secteur chargé, avant même le SED lui-même. Son rôle principal est de charger IBMBIO.COM et IBMDOS.COM. C'est le Bootstrap (en ROM) qui le charge. Il contient :
le nom du fabricant
le numéro de la version du SED
informations sur le format de la disquette
quelques messages d'erreur (à la fin)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 40 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Octet Description
00-02 Instruction de saut.
Saut vers le programme de chargement du MS-DOS.
03-0A Original Equipment Manufactured (matériel).
Nom du constructeur et version du système.
0B-0C Taille d'un secteur.
Nombre d'octets par secteur.
0D Taille d'un cluster (unité d'allocation).
Nombre de secteurs par cluster.
0E-0F Nombre de secteurs réservés (pour le Boot).
Permet le calcul de la première FAT.
10 Nombre de FAT.
11-12 Taille du répertoire.
Nombre d'entrées du répertoire : un fichier, un répertoire ou un volume occupent chacun une entrée.
13-14 Capacité réelle du disque.
Nombre total de secteurs alloués aux données.
15 Identificateur du disque.
FC = disque simple face, 8 secteurs par piste,
FD = disque double face, 8 secteurs par piste,
FE = disque simple face, 9 secteurs par piste,
FF = disque double face, 9 secteurs par piste.
16-17 Taille d'une FAT en secteurs.
18-19 Nombre de secteurs par piste.
Générallement 8 ou 9.
1A-1B Nombre de têtes.
1C-1D Nombre de secteurs cachés.
Table d'allocation de fichier, FAT = File Allocation Table
Secteur 2-5
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. Elle existe en deux exemplaires, en début de chaque disquette, et placées de façon consécutive.
Plus une disquette a de clusters, plus la FAT doit être grande.
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.
Chaque cluster possède une entrée dans la FAT, et chaque entrée est constituée de 12 bits, soit un octet et demi. La représentation sur 12 bits permet la représentation de 4096 valeurs différentes au lieu des 256 habituelles.
Lors d'un accès à un fichier, la FAT est chargée en mémoire tampon. Elle indique alors l'état de chaque unité d'allocation (cluster) afin de gérer l'espace de sauvegarde et de regrouper l'ensemble des clusters.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 41 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Entrée Octets Description
1 0-1,5 Caractérisique de l'unité.
= FF pour une unité DF, 8 S/P, 40 P,
= FE pour une unité SF, 8 S/P, 40 P,
= FD pour une unité DF, 9 S/P, 40 P,
= FC pour une unité SF, 9 S/P, 40 P,
= FB pour une unité DF, 8 S/P, 80 P,
= F9 pour une unité DF, 9 S/P, 80 P,
= F8 pour une unité de disque dur.
2,3 1,5-4,5 Constantes.
= FFFF (deux octets)
3 4,5-6 Premier cluster accessible.
= 002 en standard,
(1 entrée à la fois) (1,5 octet à la fois)
Entrées suivantes de la FAT.
= 000 : cluster disponible,
= 001 : cluster invalide,
= 002-FEF : cluster utilisé, numéro du cluster suivant,
= FF0-FF6 : réservé pour DOS,
= FF7 : cluster défectueux (inutilisable),
= FF8-FFF : dernier cluster utilisé.
Remarques : DF signifie Double Face, SF, Simple Face, S/P, Secteurs/Piste, P, Pistes.
Répertoire (Directory)
Secteur 6-9, tête 0; secteur 1-2 tête 1
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. Sept secteurs fois 16 entrées par secteur font 112 entrées au total.
Les 32 octets réservés à chaque fichier sont représentés comme suit :
Octet Description
00-07 Nom du fichier (8 caractères au maximum !). Cadré à gauche, complété par des espaces (20H).
00 Etat de l'entrée.
= 00 : vierge, fin du répertoire,
= 2E : pointe un sous-répertoire; si l'octet suivant est aussi 2E, alors le champ cluster contient le nombre de clusters alloués pour ce sous-répertoire, etc...
= E5 : entrée effacée, maintenant libre,
= autre valeur : référence à un fichier.
08-0A Extension du fichier (3 caractères au maximum !).
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 42 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
0B Attribut.
= 00 : fichier normal (en lecture et écriture),
= 01 : fichier en lecture seule (Read Only),
= 02 : fichier caché (non affiché lors d'un DIR),
= 04 : fichier système (non affiché lors d'un DIR),
= 08 : répertoire principal, label de volume de 8 (nom) + 3 (extension) = 11 caractères,
= 10 : sous-répertoire (répertoire auxiliaire),
= 20 : fichier ayant été modifié et refermé (remis à zéro par la commande externe BACKUP).
0C-15 Réservé au DOS.
16-17 Heure de création.
Bits 0-4 de l'octet 16 : secondes,
Bits 5-8 de l'octet 16 : minutes,
Bits 0-2 de l'octet 17 : minutes
Bits 3-8 de l'octet 17 : heures.
18-19 Date de création.
Bits 0-4 de l'octet 18 : jour,
Bits 5-8 de l'octet 18 : mois,
Bits 0 de l'octet 19 : mois,
Bits 1-8 de l'octet 19 : année moins 1980.
1A-1B Premier cluster alloué pour le fichier.
1C-1F Taille du fichier en secteurs.
Le préfixe de segment de programme (PSP)
Octet Description
00-01 Contient l'instruction INT 20H (fin d'exécution de programme). Pour la compatibilité avec CP/M.
02-03 Limite supérieure de la mémoire.
04 Réservé.
05-09 Point d'entrée secondaire.
Pour la compatibilité avec CP/M.
0A-0D Adresse de la routine de fin d'exécution des programmes.
0E-11 Adresse de la routine des interruption Break.
12-15 Adresse de la routine des erreurs fatales.
16-2B Réservé pour la redirection des E/S et comme zone de travail.
2C-2D Numéro du segment qui contient la chaîne
d'environnement.
2E-2F Routine d'appel des fonctions DOS à travers un
CALL FAR.
30-4F Réservé.
50-52 Point d'entrée auxiliaire.
53-5B Réservé.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 43 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
5C-7F Contient un FCB (File Control Bloc).
54 Indicateur de l'unité (1 = A, 2 = B, ...).
= 0 : unité courante,
= 1 : unité A,
= 2 : unité B,
etc ...
55-5C Nom du fichier.
5C-5E Extension du nom du fichier.
5F-60 Emplacement du bloc (ensemble de 128 caractères) qui contient l'enregistrement courant.
61-62 Taille des enregistrements en octets (128 en standard).
Nombre d'octets à transférer lorsqu'un enregistrement est lu ou écrit.
63-66 Taille du fichier en octets.
67-69 Partie basse de la taille du fichier.
6A-70 Date de création ou de la dernière écriture du fichier.
Bits 0 à 4 de l'octet 14 : jours,
Bits 5 à 7 de l'octet 14 et bit 0 de l'octet 15 :
mois,
Bits 1 à 8 de l'octet 15 : année moins 1980.
71-72 Heure de création ou de la dernière écriture du
fichier.
Bits 0 à 4 de l'octet 16 : secondes,
Bits 5 à 7 de l'octet 16 et bits 0 à 2 de l'octet
17 : mois,
Bits 3 à 8 de l'octet 17 : heures.
73-7A Réservé.
7B Emplacement d'un des 128 enregistrements du bloc courant.
7C-7F Position de l'enregistrement actuellement sélectionné à partir du début du fichier.
F9-FF Extension du FCB.
F9 Contient FF pour indiquer la présence d'un FCB étendu.
FA-FE Réservé.
FF Attribut du fichier (voir le paragraphe correspondant).
80-FF Tampon du disque (DTA : Disk Transfer Area) et à la ligne de commande.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 44 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
L'IBM PC/XT jusqu'à ses racines
L'IBM PC/XT est équipé d'un micro-processeur 8 bits (binary digit) Intel 8088. C'est un pseudo 16 bits, c'est-à-dire d'architecture d'un 16 bits. 16 bits (numérotés de 0 à 15 de droite à gauche) forment un mot.
Il existe deux types de codes : ASCII et EBCDIC. L'IBM a opté pour les codes ASCII (de 1 à 127) et il dispose en outre de codes ASCII étendu non normalisés (128 à 255).
L'addition dans le système de numération binaire s'effectue comme suit :
0 + 0 = 0
1 + 0 = 1
0 + 1 = 1
1 + 1 = 0 et 1 de retenue (ou de report)
Un nombre négatif est repéré par la mise à 1 du bit de poids fort (le plus à gauche) et un nombre positif est repéré par la mise à 0 du bit de poids faible (le plus à droite).
La soustraction binaire est effectuée par addition d'un nombre positif et d'un nombre négatif. Soit à soustraire les deux nombres a et b :
a - b = a + (-b)
Pour cela, rappelez-vous comment reconnaître un nombre négatif d'un nombre positif (le paragraphe au-dessus).
Présentation des éléments constituant l'unité centrale de l'IBM PC/XT
L'Unité d'Exécution (EU)
Rôle : exécuter les instructions
Effets : exécution du contenu de la file d'attente
Interface : sortie d'une adresse logique au BIU
Comprend :
une Unité Arithmétique et Logique (ALU)
une Unité de Contrôle (CU)
dix registres généraux
L'Unité d'Interface de Bus
Rôle :
réalisation des échanges entre le mico-processeur et l'extérieur
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 45 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
contrôle de l'interface avec des co-processeurs (arithmétique 8087, ...)
Note : la seule différence entre le 8088 et le 8086 réside dans le BIU.
Effets : remplit la file d'attente.
Interface : transformation de l'adresse logique fournie par le EU en adresse réelle.
Comprend :
bus d'adresse de 20 bits : communication entre ROM, RAM, et interface d'E/S
bus de données de 16 bits : transmission de données entre l'EU et la mémoire demandée
bus de commande de 5 bits : définition de la fonction (écriture ou lecture), action début/fin de transfert
unité de contrôle : gestion des transferts de données via les bus entre l'EU, la mémoire et les périphériques
la file (des instructions) : autorisation de la pré-recherche des instructions
les registres de segments : génération des adresses de la mémoire en liaison avec le bus d'adresse
Note : Juste avant l'exécution d'une instruction, elle doit être décodée. Pendant ce temps, les bus sont inactifs. Mais pendant cet inactivité, le micro-processeur accède déjà !à l'instruction suivante, d'où l'introduction d'une notion de file d'attente. Cette dernière a une capacité de 4 octets. Ce système tient compte du fait qu'en général, le temps d'exécution d'une instruction est inférieur au temps de recherche d'une autre instruction.
Une autre partie très importante de l'IBM PC/XT est constituée par les slots. Chaque slot comprend 62 lignes de connexion en parallèle, que l'on appelle également des canaux d'E/S (Input/Output Channel).
8 lignes de données bidirectionnelles
20 lignes d'adressage
6 lignes de niveau d'interruption
3 lignes reliées au DMA
8 lignes de voltage (+/- 5V, +/- 12V)
autres : lecture - écriture de la mémoire ou des périphériques
Architecture générale
L'architecture générale de l'IBM PC/XT est la suivante :
micro-processeur INTEL 8088
mémoire ROM 8K (BIOS), 16K (BASIC optionnellement)
mémoire RAM (jusqu'à 640K)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 46 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
circuits intégrés indispensables au micro-processeur (8284, 8253, ...)
ports d'entrées-sorites (contrôleur DMA, monochrome, ...)
slots d'extensions
éventuellement un co-processeur arithmétique 8087
Parlons plus en détail du micro-processeur 8088.
Le micro-processeur 8088
Le 8088, d'ancienne référence IAPX 88, tout en ne disposant de bus que de 8 bits, met à la disposition du programmeur des registres 16 bits. D'où sa dénomination de faux 16 bits.
Ce circuit possède 20 broches sur 40 en tout pour gérer le bus d'adresse. Ce bus permet donc l'adressage de 1 Méga-octet de mémoire (220 = 1.048.5786 = 1 Mo).
Afin d'accéder à toute cette mémoire, on utilise la combinaison de deux registres de 8 bits : CS pour désigner le segment physique de 64K, et IP pour le déplacement (adresse relative) dans le segment. On obtiend donc la représentation de l'adresse logique sous la forme Segment:Offset (déplacement).
Notion de segment
Un segment est un espace mémoire de 64K.
La valeur de l'adresse réelle (sur 20 bits) est obtenue par l'opération :
adresse de base (segment) * 16 + déplacement (adresse relative)
16 bits 10H 16 bits
Les deux premiers termes font passer l'adresse de 4 à 5 chiffres. En langage machine, il suffit d'opérer un décalage quatre fois à gauche.
De plus, il est à noter que deux segments de numéros consécutifs peuvent se chevaucher en grande partie :
0000:0400 équivalent à 0040:0000.
Les vecteurs d'interruption
Toute interruption déclenchée est transmise au contrôleur d'interruption INT 8259A, lequel discerne huit niveaux :
priorité unité
0 horloge
1 clavier
2 inutilisé
3 port série 2
4 port série 1
5 disque dur
6 disquette
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 47 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
7 imprimante
Une mise en cascade de 8259 permet ainsi de gérer jusqu'à 64 niveaux de priorité.
Le contrôleur d'interruption envoit ensuite, codé sur 8 bits, à l'unité d'exploitation le numéro de l'interruption appelée. Là est exécutée la routine de gestion d'interruption dont l'adresse se trouve en (n° d'interruption * 4) dans la table des vecteurs d'interruption.
En effet, chaque vecteur d'interruption est codé sur 4 octets. Ainsi, pour connaitre l'emplacement dans la mémoire de ce vecteur, il suffit de multiplier par quatre le numéro de l'interruption.
Un point très important : lors de l'appel d'une interruption, le micro-processeur effectue les opérations suivantes :
SP = SP - 2 (décrémente deux fois SP)
empile l'indicateur d'état
SP = SP - 2
empile CS
SP = SP - 2
empile IP
L'instruction assembleur RET utilise ces valeurs pour la poursuite du programme.
On discerne trois types d'interruptions :
Les interruptions de type INTR (INTerrupt Request)
Elles sont masquables, et non prioritaires. Correspond à la broche n°8 du micro-processeur.
Les interruptions sont autorisées si l'indicateur IF est à 1 (interruption INTR autorisée); les interruptions sont interdites si IF est à 0 (interruption INTR interdite). L'instruction assembleur CLI (CLear Interrupt enable flag) met IF à 0 et STI (SeT Interrupt enable flag) à 1.
L'interruption NMI (Non Masquable Interrupt)
Correspond à la broche 17 du micro-processeur.
Les registres d'état et de contrôle sont empilés.
L'interruption RESET (remise à zéro)
Correspond à la broche 21 du micro-processeur.
Même (quasiment ...) effet que si vous éteignez votre ordinateur et le rallumez.
Notation
Code Base Exemple Commentaires
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 48 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
B Binaire 0101B Chiffres de 0 à 1
D Décimal 10D Chiffres de 0 à 9
E Scientifique 123E4
H Hexadécimal 0DH Chiffres de 0 à 9 plus A à F
O Octal 03O Chiffres de 0 à 7
C Caractère "Texte" ou 'Texte'
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 49 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
L'arithmétique binaire
Présentation
L'arithmétique binaire est un univers où l'on effectue des calcul uniquement avec les chiffres 0 et 1, d'où le mot binaire. On raisonne en fait en base 2 au lieu de la base 10 (décimale). C'est l'univers du micro-processeur.
L'univers de l'homme, c'est la base 10. Mais voilà, la base 2 et 10 ne s'entendent que très mal. D'où l'utilisation de la base 16. Les chiffres sont alors : 0, 1, ... 9, A, B, ..., F.
L'ordinateur doit alors disposer de circuits capables de :
transformer les nombres hexadécimaux en nombre binaires
le contraire
Il apparaît maintenant évident qu'il sera nécessaire de maîtriser la logique binaire afin de comprendre comment fonctionne les entrailles d'un ordinateur. La première tâche va être de bien comprendre les différentes notations.
Une première observation : les nombres binaires sont beaucoup plus longs que n'importe quels autres nombres.
On rencontre en informatique :
le binaire : utilisation de deux chiffres
l'octal : utilisation de huit chiffres
le décimal : utilisation de dix chiffres
l'hexadécimal : utilisation de seize chiffres
Il sera relativement aisé de convertir un nombre binaire en nombre hexadécimal, puis ce sont deux systèmes de numération à base de puissance de deux, les nombres binaires étant très difficiles à mémoriser.
Nous allons donc maintenant présenter un algorithme de conversion de base 10 vers la base 2, et vice-versa.
Mais avant, nous allons remarquer un fait. Soit un nombre décimal à quatre chiffre : abcd. Chaque lettre représente un chiffre quelconque.
le chiffre a est dans la colonne des unités, et représente donc la quantité d * 1 (poids 1)
le chiffre b est dans la colonne des dizaines, et représente donc la quantité c * 10 (poids 10)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 50 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
le chiffre c est dans la colonne des centaines, et représente donc la quantité b * 100 (poids 100)
le chiffre d est dans la colonne des milliers, et représente donc la quantité a * 1000 (poids 1000)
On retrouve donc bien le nombre de départ : a * 1 + b * 10 + c * 100 + d * 1000 = abcd
Passons maintenant à la conversion base 2 en 10. Soit un nombre binaire. Considérons le nombre binaire 10000010.
Le bit de plus faible poids (le plus à droite) a pour poids 20 = 1; le bit suivant 21 = 2, le troisième 22 = 4, et ainsi de suite.
Multiplions maintenant la valeur de chaque bit par son poids correspondant :
27 26 25 24 23 22 21 20
128 64 32 16 8 4 2 1
* * * * * * * *
1 0 0 0 0 0 1 0 Nombre en binaire
= = = = = = = =
128 + 0 + 0 + 0 + 0 + 0 + 2 + 0 Nombre en décimal (130)
Voici le tour de la conversion de base 10 en base 2. Le principe est simple : déterminer la puissances de deux juste inférieure au nombre décimal et l'affecter au bit de plus fort poids.
Considérons le nombre décimal 130. La puissance de deux directement inférieure est 128. On affecte donc cette valeur au bit de poids le plus fort :
128 64 32 16 8 4 2 1
128 est-il contenu dans 150 ?
- 1 pour oui, dans ce cas, on ajoute 128 au nombre suivant
- 0 pour non, dans ce cas, on Error: Reference source not found 128
128+64 est-il contenu dans 150 ?
- 1 pour oui, 0 pour non
- idem qu'au-dessus
etc...
128 64 32 16 8 4 2 1
1 0 0 0 0 0 1 0 Nombre binaire 10000010
Nous en venons maintenant aux nombres négatifs. Pour indiquer qu'un nombre est négatif, on place un moins devant ce nombre. Il est codé en binaire à l'aide du bit de signe. On parle d'un nombre binaire signé. Ce bit vaut 0 pour un nombre positif, et 1 pour un nombre négatif, et correspond au bit de plus fort poids du nombre. Conséquence de ce signe : ces octets (ensemble de huit bits) ne peuvent plus représenter que les valeurs -127 à 128. Avec deux octets, on peut représenter les valeurs de -32767 à 32768.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 51 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
L'addition binaire
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 1 plus 1 de retenue
Addition d'un mot (16 bits)
0 0 1 0 1 1 0 1 1 1 0 0 0 0 1 0
0 1 0 1 1 0 0 1 0 1 0 0 1 1 0 1
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1
Seconde addition Première addition
La soustraction binaire
On utilise la technique de complment à deux.
Exemple : soustraire 5 de 7.
7 - 5 = (+7) - (+5) = (+2)
7 = 111
5 = 101 donc le complément de 5 est 1010
Donc le complément à deux est 1010 + 1 = 1011
On ajoute maintenant 0111 + 1011 = 0010 en éliminant le 1 à gauche (7 + complément à deux de 5).
La multiplication et la division binaire
Lorsqu'on multiplie 10 par 4, on addition 4 fois le nombre 10. De même, lorsqu'on divise 40 par 4, on soustrait 10 fois le nombre 4 de 40, jusqu'à ce que le résultat soit nul.
En notation binaire, on effectue une procédure de décalage à droite ou à gauche, ce qui a pour effet de traduire une multiplication ou une division par deux.
Pour illustrer cela, voici un exemple :
En décimal :
(+12)
X (+11)
-------
12
12 décalage
-------
132 addition
Même chose, mais en binaire, en remarquant que 12 = 1100 et 11 = 1011 :
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 52 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
1100 addition
1100 décalage avec addition
------------
100100 résultat
1100 décalage sans addition
------------
100100 résultat
1100 décalage avec addition
------------
10000100 résultat = 132
Les fonctions logiques de base
Présentation
Du point de vue électroniques, les signaux électriques sont symbolisés par 1 (le courant passe, valeur logique vrai) ou par 0 (le courant ne passe pas, valeur logique faux). Il s'agit là du moins de l'électronique numérique?
Mais on rencontre aussi l'électronique analogique. Dans ce cas, les signaux ont la possibilité de prendre une infinité de valeur.
En logique combinatoire, une fonction est exécutée chaque fois et tant qu'un ensemble de conditions est réuni.
En logique séquentielle, il y a mémorisation de l'action antérieure. Le facteur temps intervient donc ici. De cette façon, une même condition peut entraîner des états différents.
La logique combinatoire
On discerne deux règles d'équivalence :
la logique positive.
La valeur binaire 1 est associée au niveau de tension le plus élevé (niveau haut), et la valeur binaire 0 au niveau le plus bas (niveau bas).
logique négative.
C'est exactement l'inverse.
Dans ces deux logiques (positives et négatives), les deux niveaux sont repérés par leur tension (+ 5 V ou 0 V, masse), ou encore H (High) pour le niveau haut, et L (Low) pour le niveau bas). Notez qu'en règle générale, c'est la logique positive qui est utilisée.
Le système des portes
Le terme porte prend sa signification si vous savez que les informations rentrent et sortent d'un circuit logique, exactement comme s'il s'agissait d'une porte.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 53 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Une porte logique obéit à une règle primordiale : si les conditions ne sont pas réunies, la porte est fermée. A l'inverse, elle est ouverte.
La porte ET
Les interrupteurs A et B sont les variables d'entrée.
Equation : X = A.B
X désigne la sortie. L'équation X = A.B est écrite en algèble booléen (de Boole).
On écrit alors la table de vérité :
A B X A B X
b b b 0 0 0
h b b 1 0 0
b h b 0 1 0
h h h 1 1 1
La porte OU (ou OU inclusif)
Les interrupteurs A et B sont les variables d'entrée.
Equation : X = A+B
X désigne la sortie.
On écrit alors la table de vérité :
A B X
0 0 0
0 1 1
1 0 1
1 1 1
Remarques :
il n'y a pas d'exclusivité au niveau des variables d'entrée puisque une seule sortie est à 0, et ce quelque soit le nombre de variables d'entrée à 1.
une porte OU en logique positive devient une porte ET en logique négative. L'inverse est vrai.
L'inverseur NON
A est la seule variable d'entrée. L'inverseur réalise donc la fonction logique NON, c'est-à-dire qu'il délivre en sortie le complément du signal d'entrée.
Equation : X = /A (se lit A barre)
X désigne la sortie.
On écrit alors la table de vérité :
A X
0 1
1 0
La porte logique ET-NON
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 54 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Les interrupteurs A et B sont les variables d'entrée.
Equation : X = Y avec Y = A.B
X désigne la sortie.
On écrit alors la table de vérité :
A B Y X
0 0 0 1
1 0 0 1
0 1 0 1
1 1 1 0
La porte logique OU-NON
Les interrupteurs A et B sont les variables d'entrée.
Equation : X = Y et Y = A + B
X désigne la sortie.
On écrit alors la table de vérité :
A B Y X
0 0 0 1
1 0 1 0
0 1 1 0
1 1 1 0
La porte OU exclusif
Les interrupteurs A et B sont les variables d'entrée.
Equation : X = A + B
X désigne la sortie.
On écrit alors la table de vérité :
A B X
0 0 0
0 1 1
1 0 1
1 1 0
Remarque : le OU exclusif ne diffère du OU inclusif que par le résultat de la quatrième combinaison. De plus, c'est l'opération logique qui est à la base de l'additioneur binaire.
Fonction coïncidence (ou comparateur)
Les interrupteurs A et B sont les variables d'entrée et X désigne la sortie.
En inversant la fonction de sortie X de la table de vérité de la porte OU exclusif, on obtient une nouvelle fonction qui n'est vrai que si les deux variables d'entrée sont identiques. Cette porte permet donc la comparaison de deux variables logiques A et B.
Equation : X = A + B
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 55 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
On écrit alors la table de vérité :
A B X
0 0 1
1 0 0
0 1 0
1 1 1
Le décodeur
Une de ses fonctions est la sélection d'une adresse de la mémoire parmi un ensemble important d'adresses.
Le principe est le suivant. Pour qu'une cellule de mémoire soit sélectionnée, il faut que la porte ET qui la précède délivre un 1 logique.
Le multiplexeur
Sa fonction est l'aiguillage sur une sortieunique d'un signal prélevé parmi plusieurs autres de nature différente. Il remplit, en gros, la fonction inverse d'un décodeur.
L'additioneur complet
Un additioneur complet est un circuit capable d'effectuer l'addition de deux variables binaires A et B, auxquelles se rajoute une éventuelle retenue provennat d'une opération précédente.
A et B sont les deux variables logiques à additioner, C la retenue provenant d'une colonne précédente, C0 la retenue de l'addition, et X la variable de sortie.
Interruption 21h
Fonction 09h - Affichage d'une chaîne de caractères
DX pointe sur l'adresse où est stocké le message à afficher à l'écran
MOV DX,message
Ssélection de la fonction d'affichage de chaîne de caractères
MOV AH,09
de l'interruption des fonctions MS-DOS
INT 21H
Fin RET
message :
DB 0D,0A,"Ca marche !$"
Fonction 0Ah - Lecture d'une ligne au clavier
Limite à 80 caractères (en décimal)
MOV buffer,80
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 56 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
DX pointe sur l'adresse de début du buffer
MOV DX,buffer
Sélection de la fonction lecture d'une ligne au clavier ...
MOV AH,0A
... de l'interruption des fonctions MS-DOS
INT 21
BX contient le nombre de caractères entrés
MOV BX,buffer[1]
Indicateur de fin de chaîne pour un affichage éventuel
MOV buffer[BX+2],00
Fin RET
Fonction 12 - Vider le buffer du clavier
Fonction 12H ... MOV AH,12
... de l'interruption 21h INT 21
RET
Fonction 25 - Installer une nouvelle interruption
Ssegment courant MOV AX,CS
MOV DS,AX
Nouveau offset MOV AX,100
Numéro du segment MOV DX,AX
Appel de la fonction 25H de ...
MOV AH,25
... l'interruption 21h INT 21
RET
Fonction 3Dh - Création de répertoire
DX contient l'offset de l'adresse où se trouve le nom du répertoire
MOV DX,ligne
Aappel de la fonction 3DH de ...
MOV AH,39
... l'interruption 21h INT 21
En cas d'erreur ... JC erreur
Sinon, tout va bien ... ... pas d'erreur ...
ligne :
DB 'WORD',00
Fonction 3Dh - Changement de répertoire
DX contient l'offset de l'adresse où se trouve le nom du répertoire
MOV DX,ligne
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 57 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Aappel de la fonction 3DH de ...
MOV AH,3D
... l'interruption 21h INT 21
Een cas d'erreur ... JC erreur
sinon, tout va bien ... ... pas d'erreur ...
ligne :
DB 'WORD',00
Fonction 4Ch - Rendre la main à MS-DOS
Pour quitter sans erreur ... MOV AL,00
Appel de la fonction 4CH de ...
MOV AH,4C
... l'interruption 21h INT 21
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 58 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 59 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
La vidéo
Attributs
Définition
Un attribut est la caractéristique apparaissant aux adresses impaires de la mémoire écran. C'est donc une indication au système du mode d'affichage du caractère correspondant, situé à l'adresse paire immédiatement précédente.
L'adresse en mémoire d'un point situé à l'intersection de la ligne l et la colonne c est :
B0000 + 2 * (l * largeur + c) pour l'adatateur monochrome,
B8000 + 2 * (l * largeur + c) pour l'adatateur couleur,
avec largeur valant 40 ou 80 pour respectivement les modes 40 ou 80 colonnes.
Adaptateur monochrome
Attribut Description
00 noir/noir -> pas d'affichage,
01 souligné,
07 blanc/noir -> mode normal,
09 soulignement intensifié,
0F surbrillant,
70 noir/blanc -> mode inverse,
78 vidéo inverse, intensifié,
80 clignote -> mode flash,
81 souligné, clignotant,
89 clignotant, souligné, intensifié,
F0 inverse, clignotant,
F8 inverse, clignotant, intensifié.
Plus généralement :
Bit Description
7 clignotant,
6-4 couleur de fond (arrière-plan),
3 intensifié,
2-0 couleur du caractère (avant-plan).
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 60 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Adaptateur graphique couleur
Les attributs sont définis comme l'indique le tableau suivant :
Bits Description
7 clignotement,
6 canal rouge pour la couleur de fond,
5 canal vert pour la couleur de fond,
4 canal bleu pour la couleur de fond,
3 intensifié,
2 canal rouge pour la couleur du caractère,
1 canal vert pour la couleur du caractère,
0 canal bleu pour la couleur du caractère.
Les trois canaux (rouge, vert, bleu) permettent ainsi de définissent ainsi 16 couleurs, selon la combinaison choisie :
intens. can roug can vert can bleu couleur
0 0 0 0 noir,
0 0 0 1 bleu,
0 0 1 0 vert,
0 0 1 1 cyan,
0 1 0 0 rouge,
0 1 0 1 magenta,
0 1 1 0 brun,
0 1 1 1 blanc,
1 0 0 0 gris foncé,
1 0 0 1 bleu clair,
1 0 1 0 vert clair,
1 0 1 1 cyan clair,
1 1 0 0 roug clair,
1 1 0 1 magenta clair,
1 1 1 0 jaune,
1 1 1 1 blanc souten
En mode 320 X 200 points (ou pixels), un octet définit quatre points, donc deux bits définissent un point.
En mode 640 X 200 pixels, un octet définit huit points, donc un bit définit un point.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 61 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Cours d’assembleur
Généralités
Rappels sur le fonctionnement de l’ordinateur
Voici les deux seules valeurs que l'ordinateur comprend :
0 1
faux vrai
éteint allumé
non oui
Afin d'étendre ces possibilités, on regroupe les 0 et les 1 en ensemble de 8 bits (octets), de 16 (mots) ou de 32 (doubles mots).
On va associer à chaque valeur (de 20 - 1 = 0 à 28 - 1 = 255) une instruction du micro-processeur.
On procède de même avec les caractères (voir les codes ASCII).
En ce qui concerne les données numériques, revoir la représentation décimale, hexadécimale et binaire et surtout les nombres négatifs.
Dans un octet (par exemple), le bit 0 est le "bit de poids faible", ou le "bit le moins significatif" et le bit 7 le "bit de poids fort" ou le "bit le plus significatif". Il en sera de même pour les mots et les doubles mots).
Chaque élément de 8 bits (un octet) de la mémoire du PC est repérée par une adresse. La mémoire est divisée en zones de 64 Koctets (65.536 octets) appelées segments. On définit alors par offset l'adresse relative (ou déplacement, ou offset) au début du segment de l'octet.
On définit alors la position d'un octet par le couple (segment, offset) que l'on notera : segment:offset.
... OCCUPE
une instruction un ou plusieurs octets
un caractère un octet
une chaîne de caractères la place égale à sa longueur
une valeur numérique 1, 2 ou 4 octets
Chaque registre a une fonction spécifique :
Registre Rôle Exemples
les registres de segment
indiquent le segment de
CS, DS, SS, ES
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 62 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
progremme et de données
les registres de travail
contiennent des résultats intermédiaires
AX, BX, CX, DX
les registres d'offset couplés aux registres de segment
indiquent l'adresse d'un octet en mémoire
SI, DI, IP, BP, SP
le registre drapeau (flag en anglais)
indique les états
Le micro-processeur permet de :
Déplacer des données en mémoire
Inverser des bits
Effectuer des opérations logiques
Additionner des bits
Déplacer et faire une rotation de bits
La syntaxe
Le jeu de caractères est constitué des caractères alphanumériques, de l'ensemble + - * / = ( ) [ ] ; ' . ! , _ : @ $ (espace) (tab) (return) (lf).
Les majuscules sont traitées comme les minuscules sauf dans les chaînes de caractères. Les différents éléments d'une instruction doivent être séparés d'au moins un espace, les opérandes par une virgule.
Les identificateurs doivent toujours commencer par une lettre, il est limité à 80 caractères et ne peut contenir d'espace.
Les données
Généralités
Les pseudo-instructions sont des instructions que l'assembleur doit faire.
On distingue trois types de données :
Immédiates (400h, ...)
Constantes : définir l'identificateur et le type de la variable
Zones de mémoire
Une donnée peut être :
Identificateur
Mnémonique de l'instruction
Opérande
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 63 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Commentaire
Registres
Registres de segment (16 bits) Rôle
CS (Code Segment) segment où se trouve le programme source
DS (Data Segment) segment où se trouvent les données
SS (Stack Segment) segment où se trouve la pile
ES (Extra Segment) segment où se trouve les données supplémentaires
Il y a une différence entre un programme COM et EXE. Un programme EXE peut travailler avec plusieurs segments, donc faire plus de 64 Ko, au contraire d'un programme COM (où les registres CS, DS, SS et ES contiennent la même valeur).
Registres de travail (16 bits) Rôle
AX (Accumulateur) utilisé lors des opérations arithmétiques
BX (Base indeX) utilisé de façon différente selon les modes d'adressage
CX (Compteur Index) utilisé dans les boucles (LOOP)
DX (Data indeX) utilisé lors d'opérations arithmétiques
Chacun de ces registres 16 bits peut être décomposé en deux registres 8 bits auxquels on pourra accéder individuellement :
Registre 16 bits Registres 8 bits
AX AH et AL
BX BH et BL
CX CH et CL
DX DH et DL
Registres d’offset (16 bits) Rôle
SI (Source Index) offset de chaînes de caractères (DS:SI)
DI (Destination Index) offset de opérations sur les chaînes de caractères (DS:DI ou ES:DI)
IP (Instruction Pointer) offset où se trouve la prochaine instruction à exécuter (CS:IP). Ne peut jamais être modifié directement !
BP (Base Pointer) offset de la pile lors de l'appel de sous-programmes (CALL)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 64 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
(SS:BP)
SP (Stack Pointer) offset du dernier élément de la pile (SS:SP)
Le registre d'état est manipulé bit à bit.
Registre Bit Nom Rôle
Registres d’état
0 = Retenue (Carry)
CF indique qu'il y a eu retenue
2 = Parité PF indique que le résultat contient un nombre pair de 1
4 = Retenue auxiliaire
AF
6 = Zéro ZF indique un résultat égal à zéro
7 = Signe SF indique un nombre négatif
11 = Débordement (Overflow)
OF indique que le signe a changé alors qu'il ne devrait pas
Registre de contrôle
8 = Trap TF
9 = Interruption IF
10 = Direction DF modifié par STD et CLD
1,5,12,13,14,15 Inutilisés.
Données et mémoire
Constante
Une constante est une valeur définie par une pseudo-instruction.
EQU est une pseudo-instruction qui affecte une valeur (qui peut être une expression évaluée lors de l'assemblage) à un identificateur (doit être défini avant).
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 65 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Vrai EQU 1
Faux EQU 0
Constante immédiate
Une constante immédiate est une valeur numérique (exprimée en différentes bases, 10 par défaut) ou un ensemble de caractères (représentés entre apostrophes).
Valeur Type
01100011b en binaire
0fffh en hexadécimal (doit commencer par un chiffre : ajouter au besoin un 0, afin de ne pas confondre avec un identificateur)
1024d en décimal
1024 aussi
'a' caractère
'ABC' chaîne de caractères
Variables
Une variables est une zone mémoire réservée lors de l'assemblage.
DB (Data Byte)
Définition et initialisation de valeurs numériques ou de caractères (les séparer par une virgule s'il y en a plusieurs) en spécifiant éventuellement le début par un identificateur.
DUP permet de dupliquer une valeur jusqu'à ce que la zone soit remplie. Dans le cas de caractères, ajouter $ en fin de chaîne pour un affichage.
Exemple Description
exemple DB 0 zone "exemple" d'un élément 0
abc DB 1, 2, 3 zone "abc" de trois éléments 1,2,3
inconnu DB ? zone "inconnu" d'un élément (0)
table1 DB 5 DUP (?) zone "table1" de 5 éléments (0,0,0,0,0)
table2 DB 5 DUP (1, 2, 3, 4, 5) zone "table2" de 5 éléments (1,2,3,4,5)
table3 DB 5 DUP (0, 1) zone "table3" de 5 éléments (0,1,0,1,0)
texte1 DB 'Bonjour !$' zone "texte1" de 10 caractères destiné à l'affichage
texte2 DB 07, 'Rebonjour !' zone "texte2" de 12 caractères dont le code ASCII 07 (beep sonore)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 66 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
DW (Data Word)
Même chose. Le byte de poids fort est stocké avant le byte de poids faible.
table DW 5 DUP (?) zone "table" de 5 éléments (0,0,0,0,0), chacun sur 16 bits (un mot)
DD (Data Double word)
Même chose.
Les modes d’adressage
Une adresse peut être spécifiée de multiples façons, et ce pour l'ensemble des instructions. Pour cela, nous allons prendre l'exemple du chargement d'une donnée (opérande) dans un registre (reg) : MOV reg, opérande.
Avant tout, précisons quelques points.
Une adresse peut être accédée soit à partir d'un identificateur préalablement défini, soit à partir d'une adresse sous la forme Segment:Offset.
DS est le registre de segment de données par défaut : au lieu de MOV AX, DS:[DX] on écrira MOV AX, [DX]. Cependant, on peut spécifier un autre registre de segment (MOV AX, CS:[DX]) et pour BP, son registre de segment est SS.
Adressage Principe Description
Adressage immédiat
Registre <-- valeur immédiate
La valeur immédiate (constante) est placée dans le registre : MOV AX, 12h
Adressage direct Registre <-- mémoire (adressage direct)
Le contenu de l'adresse spécifiée est placée dans le registre : MOV AX, Ident1
Attention : le type de la donnée et du registre doivent être les mêmes.
Adressage basé Registre <-- [Bx] adressage basé sur DS
Registre <-- [BP] adressage basé sur SS (non montré, identique)
Le contenu de l'adresse DS:[BX] est placé dans le registre : MOV BX, 3 et MOV AX, [BX].
Attention : le type de la donnée et
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 67 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
du registre doivent être les mêmes.
Adressaage indexé
Registre <-- [SI] ou [DI] adressage indexé
Le contenu de l'adresse DS:[SI] est placé dans le registre : MOV SI, 3 et MOV AX, [SI] (ou la même chose en remplaçant SI par DI). Cette instruction permet d'accéder à un élément d'un tableau. Très utilisé aussi pour le traitement des chaînes de caractères.
Adressage indexé et basé
Registre <-- [BX][SI] adressage indexé et basé sur DS
Registre <-- [BX][DI] adressage indexé et basé sur DS
BX désigne le segment et SI ou DI l'offset. On peut aussi utiliser la notation Registre <-- [BX+SI].On a aussi : Registre <-- [BP][SI] adressage indexé et basé sur SS.
Registre <-- [BP][DI] adressage indexé et basé sur SS
Adressage basé et déplacement (direct ou immédiat)
Registre <-- donnée [BX] adressage basé sur DS
Registre <-- donnée [BP] adressage basé sur SS
Ceci est une combinaison des modes d'adressage précédents.
On peut aussi noter : Registre <-- [BX + donnée]
Adressage indexé et déplacement (direct ou immédiat)
Registre <-- donnée [SI] adressage indexé + déplacement
Ceci est une combinaison des modes d'adressage précédents.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 68 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Registre <-- donnée [DI] adressage indexé + déplacement
On peut aussi noter : Registre <-- [SI + donnée]
Adressage basé, indexé et déplacement (direct ou immédiat)
Registre <-- donnée [BX][SI]
Registre <-- donnée [BX][DI]
Registre <-- donnée [BP][SI]
Registre <-- donnée [BP][DI]
Ceci est une combinaison des modes d'adressage précédents.
On peut aussi noter : Registre <-- [BX + SI + donnée]
Enfin, il est nécessaire de spécifier à l'ordinateur s'il doit effectuer des opérations sur 8 ou 16 bits :
si le registre est la seconde opérande, alors le nombre de bits de l'opération est déterminé par le sien
sinon, il faut ajouter le type BYTE (octet) : « MOV BYTE PTR [AX], 5h » ou pour le type mot « MOV WORD PTR [AX], 5h »
Le jeu d’instructions
Les instructions de base
Une instruction peut être précédée d'un identificateur (de forme générale Ident:) qui représente l'adresse de stockage de cette instruction. On appelle cet identificateur une étiquette (label en anglais).Debut: MOV AX, 00h
INC AX
JMP Debut
L'instruction de transfert de données se fait sur 8 ou sur 16 bits.
Notes :
reg = registre 8 ou 16 bits
mem = adresse (ou identificateur)
imm = constante (valeur immédiate)
MOV reg, imm
MOV mem, imm
MOV reg, mem
MOV mem, reg
MOV reg, reg
Déplace l'opérande de droite dans l'opérande de gauche.
MOV AH, 00h
N'affecte pas les indicateurs.
Si un opérande est de type indéfini, MOV [AX], 00h -> MOV BYTE PTR [AX], 00h ou -> MOV WORD PTR [AX], 00h
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 69 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Les instructions arithmétiques
DEC
DEC reg
DEC mem
Décrémente de un le registre spécifié.
Ne modifie pas CF.
DEC reg <=> SUB reg, 1
ADC reg
ADC mem
SBB reg
SBB mem
Addition et soustraction de deux nombres sur 16 bits
Voir aussi ADD et SUB.
Permet l'addition et la soustraction sur 32 bits (double précision).
ADC reg
ADC mem
Addition de deux nombres de 16 bits et ajout de la retenue.
Voir aussi ADC.
Permet l'addition sur 32 bits (double précision).
Exemple : MOV AX, WORD PTR Nombre1
ADD AX, WORD PTR Nombre2
MOV AX, WORD PTR Nombre1
ADC AX, WORD PTR Nombre2
SUB reg
SUB mem
Soustraction de deux nombres de 16 bits et tient compte de la retenue. Voir aussi SUB. Permet la soustraction sur 32 bits (double précision).
MUL reg
MUL mem
Multiplication AX := AL * opérande (8 bits) ou DX:AX := AX * opérande (16 bits)
Opère sur des nombres non signés.
Il ne peut pas y avoir de débordement.
Exemple : MOV AL, 05h AX := BH * AL := 05h * 02h := 0ah
MOV BH, 02h
MUL BH
IMUL reg
IMUL mem
Multiplication AX := AL * opérande (8 bits) ou DX:AX := AX * opérande (16 bits)
Opère sur des nombres signés.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 70 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
CF et OF sont modifiés.
Voir MUL.
DIV reg
DIV mem
Division AX := opérande * AL + AH (8 bits) ou DX:AX := opérande * AX + DX (16 bits)
Opère sur des nombres non signés.
OF modifié et arrêt brutal possible du programme.
Diviser un octet par un octet :
MOV AL, num
MOV BL, div
MOV AX, num
MOV BX, div
CBW DIV BL
CWD DIV BX
IDIV reg
IDIV mem
Division AX := opérande * AL + AH (8 bits) ou DX:AX := opérande * AX + DX (16 bits)
Opère sur des nombres signés.
Indicateurs modifiés et indéfinis.
NEG reg
NEG mem
Calcul du complément à deux de l'opérande spécifiée.
Fournit la représentation binaire négative d'un nombre.
Indicateurs arithmétiques (OF, SF, ZF, AF, PF, CF) modifiés.
Exemple :
MOV AX, 02h ‘ AX := + 02h
MUL [BX]
NEG AX ‘ AX := - 02h -> MUL BYTE PTR [BX] ou MUL WORD PTR [BX]
ADD reg,imm
ADD mem,imm
ADD reg,mem
ADD mem,reg
ADD reg,reg
Addition avec retenue. En cas de débordement, le bit perdu est placé dans CF.
ADD BX, 1
ADD AX, [BX + 2]
INC reg Incrémentation (ajout de 1)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 71 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
INC mem INC AX
INC BH
Les instructions logiques
Les instructions logiques opèrent des opérations logiques bit à bit sur des ensembles de 8 bits (un octet) ou de 16 bits (un mot) à la fois.
AND reg, imm
AND mem, imm
AND reg, mem
AND mem, reg
AND reg, reg
Effectue un ET logique sur les deux opérandes, le résultat est placé dans la première.
Utilisé pour isoler certains bits d'un ensemble, pour remettre à zéro certains bits, pour calculer le reste d'une division d'un nombre par un autre (puissance de 2, prendre alors pour second opérande - 1).
Le second opérande est appelé masque.
OR reg, imm
OR mem, imm
OR reg, mem
OR mem, reg
OR reg, reg
Effectue un OU logique sur les deux opérandes, le résultat est placé dans la première.
Utilisé pour mettre à un un ou plusieurs bits d'un ensemble.
Le second opérande est appelé masque.
XOR reg, imm
XOR mem, imm
XOR reg, mem
XOR mem, reg
XOR reg, reg
Effectue un OU EXCLUSIF logique sur les deux opérandes, le résultat est placé dans la première.
Utilisé pour remettre rapidement à zéro un registre, pour complémenter (inverser) un ou plusieurs bits d'un ensemble.
NOT reg
NOT mem
Effectue un NON logique sur l'opérande, le résultat est placé dans cette même opérande.
TEST reg, imm
TEST mem, imm
TEST reg, mem
TEST mem, reg
TEST reg, reg
Teste la valeur d'un ou de plusieurs bits d'un ensemble, le résultat étant fourni par les indicateurs.
CF et OF sont remise à zéro, AF est indéterminé, SF, ZF et PF sont modifiés. Exception faite pour NOT qui ne modifie aucun indicateur.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 72 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
AND [BX], 01h -> AND BYTE PTR [BX], 01h TEST AX, 01h ou AND WORD PTR [BX], 01h <=> AND & CMP
Les instructions de décalage et de rotation
Les instructions de décalage et de rotation décalent d'un certain nombre de positions les bits d'un ensemble (BYTE ou WORD) vers la gauche ou vers la droite.
Notez que décalager les bits vers la gauche équivaut à multiplier le nombre par deux, et vers la droite, par le diviser par deux.
SHL reg, 1
SHL mem, 1
SHL reg, CL
SHL mem, CL
Décale les bits d'un certain nombre de positions vers la gauche (décalage logique).
Seul le registre CL peut être utilisé ici.
Les bits passent d'abord par CF avant d'être perdus, et les positions libérées sont remplies de zéros.
SHR reg, 1
SHR mem, 1
SHR reg, CL
SHR reg, CL
Décale les bits d'un certain nombre de positions vers la droite (décalage logique).
Seul le registre CL peut être utilisé ici.
Les bits passent d'abord par CF avant d'être perdus, et les positions libérées sont remplies de zéros.
SAR reg, 1
SAR mem, 1
SAR reg, CL
SAR mem, CL
Décale les bits d'un certain nombre de positions vers la droite (décalage arithmétique).
Seul le registre CL peut être utilisé ici.
Les bits passent d'abord par CF avant d'être perdus, et les positions libérées sont remplies de zéros.
Revient au même que SHR.
SAL reg, 1
SAL mem, 1
SAL reg, CL
SAL mem, CL
Décale les bits d'un certain nombre de positions vers la gauche (décalage arithmétique).
Seul le registre CL peut être utilisé ici.
Les bits passent d'abord par CF
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 73 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
avant d'être perdus, et les positions libérées sont remplies de zéros.
Revient au même que SHL.
Les instructions de pile
Une pile est une zone mémoire servant à stocker temporairement des valeurs. On ne peut stocker qu'une information à la fois et l'élément dépilé à un moment donné est celui qui a été empilé en dernier : c'est la structure LIFO (Last In, First Out). Les opérations ne se font que sur 16 bits.
La pile commence au segment SS et elle fini dans le même segment mais à l'offset SP. A notez que cette pile est remplie à l'envers : le premier élément est situé à une adresse plus haute que le dernier élément.
PUSH reg
PUSH mem
Empile l'opérande.
SP est décrémenté de 2.
POP reg
POP mem
Dépile un élément et le copie dans l'opérande.
SP est incrémenté de 2.
MOV DS,ES est interdit => PUSH ES et POP DS
PUSHF reg
PUSHF mem
Même chose.
PUSHF n'affecte pas les indicateurs, POPF les affecte.
POPF reg
POPF mem
Modifier les indicateurs : MOV AX, drapeau et PUSH AX et POPF.
Les instructions de manipulation de chaînes de caractères
La chaîne source se trouve dans le segment DS et à l'offset SI.
La chaîne destination se trouve dans le segment ES et à l'offset DI.
De plus, les opérations doivent se faire caractère par caractère.
CLD CLear Direction flag.
DI et SI seront incrémentés après une instruction de manipulation de chaîne.
STD SeT Direction flag.
DI et SI seront décrémentés après une instruction de manipulation de chaîne.
MOVSB MOVe String Byte : transfère l'octet de DS:SI vers ES:DI.
Après exécution, SI et DI sont
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 74 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
incrémentés de 1.
MOVSW MOVe String Word : transfère le mot de DS:SI vers ES:DI.
Après exécution, SI et DI sont incrémentés de 2.
REP MOVSB
REP MOVSW
REP ...
Répéte l'instruction précédente CX fois.
Valable que pour les opérations sur les chaînes de caractères.
REP MOVSB <=> MOV AL, DS:[SI] Si on ne connait pas la longueur :
MOV ES:[DI], AL Texte1 DB 'abc'
INC SI Texte2 DB 'def'
INC DI long EQU $-Texte2
CMPSB
CMPSW
Comparaison de chaînes de caractères pointées par DS:SI et ES:DI. SI et DI incrémentés automatiquement.
si DS:[SI] = ES:[DI] alors ZF = 1
si DS:[SI] <> ES:[DI] alors ZF = 0
MOV AL, [SI]/MOV AH, ES:[DI]/CMP AL,AH <=> CMPSB
REPE, REPNE Répétition
Si la répétition est interrompue, SI eet DI pointent sur le caractère qui suit (CLD) ou celui qui précède (STD).
CLS / MOV CX, 5 / CMPSB
REPE <=> TANT QUE (DS:[SI] = ES:[DI]) ET (CX <> 0 FAIRE
REPNE <=> TANT QUE (DS:[SI] <> ES:[DI]) ET (CX <> 0) FAIRE
SCASB
SCASW
Comparaison
Compare le caractère en ES:DI avec AL
Compare les deux caractères en ES:DI avec AX
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 75 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
DI est automatiquement incrémenté (ou décrémenté) de 1 ou 2.
MOV BL, ES:[DI] / CMP AL,BL / INC DI <=> SCASB
LODSB
LODSW
Chargement d'une chaine de caractères dans l'accumulateur
Charge dans AL le caractère en DS:SI
Charge dans AX les deux caractères en DS:SI
SI est automatiquement incrémenté (ou décrémenté) de 1 ou 2.
STOSB, STOSW Rangement de l'accumulateur dans une chaine de caractères
DI est automatiquement incrémenté (ou décrémenté) de 1 ou 2.
... MOV CX, 10 / MOV AL, 0 / REP STOSB
STOSB Range le caractère en DS:SI dans AL
STOSW Range les deux caractères en DS:SI dans AX
Les instructions de saut conditionnel
Les saut conditionnels ne sont effectués que si une condition particulière est remplie; sinon, l'exécution continue normalement à l'instruction suivante.
Ces instructions testent l'état des indicateurs (drapeaux, FLAGs en anglais), qui sont modifiés par les opérations arithmétiques et de comparaison).
Les instructions de saut inconditionnel
JMP Branchement inconditionnel
JMP et SHORT Saut à une distance entre -127 et +128 octets. JMP suite
JMP et NEAR Saut à une distance entre -32767 et +32768. JMP suite
JMP et FAR Saut à une distance de plus de 32767. JMP FAR [DI]
JMP reg Saut indexé. JMP BX
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 76 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
JMP mem Saut indexé. JMP table [BX]
INT mem
INT imm
Appel d'une interruption (exécution d'une tâche particulière)
Appelle l'interruption dont le numéro figure dans l'opérande.
Les paramètres sont en général passés dans les registres (par valeur ou par adresse).
Les tests d’identificateur
etiq désigne un label qui doit être compris entre -127 et +128.
JZ etiq saut si ZF = 1 (« Jump if Zero »)
JE etiq saut si ZF = 0 (« Jump if Equal »)
JNZ etiq saut si ZF = 0 (« Jump if Not Zero »)
JNE etiq saut si ZF 0 (« Jump if Not Equal »)
JC etiq saut si CF = 1 (« Jump if Carry »)
JNC etiq saut si CF = 0 (« Jump if Not Carry »)
JS etiq saut si SF = 1 (« Jump if Sign »)
JNS saut si SF = 0 (« Jump if Not Sign »)
JO etiq saut si OF = 1 (« Jump if Overflow »)
JNO etiq saut si OF = 0 (« Jump if Not Overflow »)
Les tests arithmétiques
Les tests arithmétiques sont utilisés après l'exécution d'une instruction CMP (comparaison de deux nombres). Les indicateurs sont modifiés par CMP.
La distinction entre nombres signés et non signés est capitale.
La longueur des sauts étant limitée à 128 octets avant et 12! octets après l'instruction de saut, le mieux est de laisser le soin à l'assembleur de nous indiquer lorsqu'un déplacement excède 128 octets ou non. Dans le cas affirmatif, il suffira de combiner le saut condition avec un saut inconditionnel (JMP) qui autorise cette fois 32767 octets avant et autant en arrière de l'instruction.
Enfin, ces instructions ne font que tester, sans modifier, les indicateurs.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 77 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
CMP reg,imm
CMP mem,imm
CMP reg,mem
CMP mem,reg
CMP reg,reg
Comparaison de deux opérandes. Le résultat est placé dans les drapeaux (flags).
CMP A,B <=> (B-A)
Si le type des opérandes est indéfini : CMP BYTE PTR [BX], 1 ou CMP WORD PTR [BX], 1
Les tests de nombres non signés
CF = 1 indique un débordement.
JNBE etiq
JA etiq
saut si A > B (« Jump if Not BElow »)
ou si CF = 0 et ZF = 0 (« Jump if Above ou Equal »)
JNB etiq
JAE etiq
JNC etiq
Saut si A >= B (« Jump if Not Below »)
ou si CF = 1 et ZF = 1 (« Jump if Above or Equal »)
ou si CF <> ZF (« Jump if Not Carry »)
JBE etiq
JNA etiq
Saut A <= B (« Jump if Below or Equal »)
ou si CF = 1 et ZF = 1 (« Jump if Not Above »)
ou si CF <> ZF
JB etiq
JNAE etiq
JC etiq
Saut si A < B (« Jump if Below »)
ou si CF = 1 (« Jump if Not Above or Equal »)
(« Jump if Carry »)
JE etiq
JZ etiq
Saut si A = B (« Jump if Equal »)
ou si ZF = 1 (« Jump if Zero »)
JNE etiq
JNZ etiq
Saut si A <> B (« Jump if Not Equal »)
ou si ZF = 0 (« Jump if Not Zero »)
Les tests de nombres signés
SF indique le signe du résultat, OF indique que le signe du résultat est incorrect.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 78 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
JG etiq
JNLE etiq
saut si A > B (« Jump if Greater »)
ou si ZF = 0 et OF = SF (« Jump si Not Less or Equal »)
JGE etiq
JNL etiq
saut si A >= B (« Jump si Greater »)
ou si SF = OF (« Jump si Not Less »)
JNG etiq
JLE etiq
saut si A <= B (« Jump if Not Geater »)
ou si ZF = 0 et SF = OF (« Jump si if Less or Equal ») ou si ZF = 1 et SF = OF ou si ZF = 0 et SF <> OF
JNGE etiq
JL etiq
saut si A < B (« Jump if Not Greater or Equal »)
ou si SF <> OF (« Jump if Less »)
JE etiq
JZ etiq
saut si A = B (« Jump if Equal »)
ou si ZF = 1 (« Jump if Zero »)
JNE etiq
JNZ etiq
saut si A <> B (« Jump if Not Equal »)
ou si ZF = 0 (« Jump if Not Zero »)
Les instructions de boucle
Une instruction de boucle est toujours exécutée au moins une fois.
LOOP Décrémente CX et effectue un branchement à etiq
LOOP etiq si CX <> 0
Les indicateurs ne sont pas modifiés !
LOOPE Décrémente CX et effectue un branchement à etiq
LOOPE etiq si CX <> 0 ou si ZF = 1
Les indicateurs ne sont pas modifiés !
LOOPNE Décrémente CX et effectue un branchement à etiq
LOOPNE etiq si CX <> 0 ou si ZF = 0
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 79 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Les indicateurs ne sont pas modifiés !
Les procédures (sous-programmes)
PROC Indique le début d’un sous-programme
nom PROC NEAR ENDP indique la fin d'un sous-programme
nom PROC FAR LireCar PROC NEAR
nom ENDP MOV AH, 00h
INT 16h
LireCar ENDP
CALL nom
CALL adresse
Exécute le sous-programme indiqué. Une fois celui-ci terminé, l'exécution reprendra après le CALL.
LireCar PROC NEAR
... ... ...
LireCar ENDP
Debut: CALL LireCar
... ... ...
RET Fait reprendre l'exécution après l'instruction qui a provoqué l'exécution du sous-programme dont elle fait partie.
Tout sous-programme doit contenir un RET !
LireCar PROC NEAR
MOV AH, 00h
INT 16h
RET
LireCar ENDP
Les paramètres et les sous-programmes
Passage Commentaires
par regitres limité, beaucoup de paramètres
par pile le plus commode
par variables très bien, mais beaucoup de
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 80 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
variables
L'instruction qui sera exécutée juste après le sous-programme sera celle qui suit l'appel au sous-programme. Il faut donc empiler IP et dans certains cas (sous-programme se trouvant dans un segment différent) CS.
Un sous-programme ne peut lire les paramètres fournis dans la pile que grâce à BP. Pour cela, il devra :
PUSH BP ; sauvegarder la valeur actuelle de BP
MOV BP, SP ; initialiser BP à la même valeur que SP
On pourra alors accéder aux différents paramètres grâce à : MOV AX, [BX + 6]
Le sous-programme finit par RET n ou par RET (cas où n = 0).
L'ordinateur fait alors un retour normal et ajoute n à SP, ce qui a pour effet de dépiler les paramètres transmis.
Attention : tout élément empilé au début d'un sous-programme doit être dépilé à la fin de ce même sous-programme. Sinon, IP et CS éventuellement contiendront n'importe quelle valeur.
Conseil : Ecrire un en-tête descriptif en début de chaque sous-programme indiquant les registres utilisés, ...
Les instructions de gestion des adresses
LEA reg, mem Charge l'offset dans un registre.
Aucun indicateur n'est modifié.
LEA BX, Var1 -> ds:bx pointe sur le contenu de Var1
LEA BX, Var1 <=> MOV BX, OFFSET Var1
LEA BX, [DI] <=> MOV BX, DI
LEA BX, [DI + 5] <=> MOV BX, DI / ADD BX, 05h
LES reg, mem
LDS reg, mem
Charge le contenu d'une adresse dans un registre et charge le contenu du mot mémoire suivant dans ES (LES) ou DS (LDS).
Aucun indicateur n'est modifié.
Ces instructions permettent donc de charger le segment et l'offset d'un octet en une seule opération.
Techniques de programmation
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 81 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Algorithmie Assembleur
If AX = 1 Then AX := 255 Else AX := 0;
If: CMP AX, 1 JNZ ElseThen: MOV AX, 0ffh JMP EndIfElse: MOV AX, 00hEndIf:...
BX := 1;For k := 0 To 10 Do BX := BX + k;
MOV BX, 01h MOV CX, 00hFor: CMP CX, 10d JA EndFor ADD BX, CX INC CX JMP ForEndFor:
BX := 5;While BX > 0 Do BX := BX + 1;
MOV BX, 05hWhile: CMP BX, 00h JLE EndWhile DEC BX JMP WhileEndWhile:
BX := 10;Repeat BX := BX - 1;Until lBX <=0;
MOV BX, 10dRepeat: DEC BX CMP BX, 00h JG RepeatEndRepeat:ou encore : MOV BX, 00h MOV CX, 05hRepeat: ADD BX, CX LOOP RepeatFinRepeat:(nombre de répétitions connu et >= 1)
Case BX Of 1 : AX := 1; 2 : AX := 3; 3 : AX := 5; Else AX := 0;End;
Case1: CMP BX, 01h JNZ Case2 MOV AX, 01h JMP FinCaseCase2: CMP BX, 02h JNZ FinCase MOV AX, 03; JMP FinCaseAutre: MOV AX, 00hFinCase:
Organisation d’un programme
La méthode la plus simple est de découper le programme en une série de sous-programmes.
De plus, chaque programme possède son point d'entrée, qui est la première instruction à exécuter lors de l'exécution du programme, qui consistera en un saut inconditionnel au début du programme.
Chaque programme :
doit empiler au début et dépiler à la fin les registres modifiés
doit contenir un en-tête contenant :
- la fonction du programme
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 82 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
- les paramètres en entrée et en sortie
- les registres ou variables modifiés
- les sous-programmes appelés
Les paramètres peuvent être passés soit par registres (AX, ...) soit par la pile
Utilisation de plusieurs segments : la directive Assume
Toutes les données et instructions d'un fichier .COM sont situées dans le même segment, ce qui porte la limite d'un tel fichier à 64 Koctets.
Lors du chargement d'un tel fichier, Ms-Dos initialise CS, DS, SS, ES à la même valeur. SP vaut fffeh, IP 0100h (à cause de la présence d'un PSP).
L'instruction CS: (2Eh) signale que l'instruction suivante fait référence à une donnée, le segment sera CS au lieu de DS. Ceci n'est valable que pour l'instruction suivante.
Dans le cas de fichiers .COM, la première instruction à exécuter doit se trouver au tout début. Le segment de code doit donc précéder le segment de données.
On devra procéder comme suit :
définir une variable fictive VAR1 par exemple au tout début du segment de données
entrer :
MOV AX, OFFSET CS:VAR1
MOV DS, AX
ainsi on calcule l'adresse des variable à partir du début du segment de code
Toutefois, on est limité à 64 Koctets en tout, on peut accéder à plus de 64 Koctets à la fois.
La programmation modulaire
Le principe est de diviser un programme en plusieurs fichiers assemblés séparément.
Il suffira de procéder comme suit.
Placer le mot PUBLIC après le mot SEGMENT : Code SEGMENT PUBLIC au lieu de Code SEGMENT.
Notez que le ORG 100h et le point d'entrée ne sont définis que dans le programme principal.
Pour relier tous ces fichiers, il suffira d'entrer LINK suivi de la liste de tous les fichiers : LINK princip biba biba par exemple.
La directive PUBLIC suivie d'une liste de procédures indique que ces procédures peuvent être appelées depuis d'autres fichiers. Ces procédures doivent être définies avec PROC.
La directive EXTRN indique que l'on utilise les procédures citées définies dans un autre fichier.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 83 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
On procèdera de même pour le partage des variables, sauf que l'on devra spécifier le type des différentes variables (WORD, BYTE, ...).
Les fichiers Exe
Les fichiers EXE permettent la création de programmes de plus de 64 Koctets.
On ne termine par RET.
Le point d'entrée peut se trouver n'importe où, dans une procédure.
Spécifier un segment de pile SEGMENT STACK (pour le registre SS).
Ne pas s'occuper de la relocation (gestion de DS).
Au chargement, SS et SP sont initialisés correctement, DS et ES pointent sur le PSP.
L'attribut NEAR indique que les procédures se trouvent dans le même segment, FAR indiquant que la procédure peut être appelée d'un segment différent : (debut PROC FAR).
Il faut empiler DS, l'initialiser, exécuter la procédure proprement dite, puis dépiler DS. Le registre CS est automatiquement ajusté lors des CALL et des RET. SS n'est pas modifié car le segment de pile est unique.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 84 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Points particuliers
Adressage de la mémoire
Le 8088 peut manipuler des formes de bits qui constituent la mémoire de l'ordinateur. On peut effectuer un certain nombre d'opérations sur ceux-ci : copie, mise à zéro, mise à un, interprétation en tant que nombres, effectuer des opérations arithmétiques.
Une adresse est un pointeur dans la mémoire. Chaque adresse pointe sur le début d'une grande partie de la mémoire. Le 8088 a la possibilité de distinguer 1,048,576 octets différents de mémoire. Ces adresses peuvent être représentées sur 20 bits.
Mais il y a un petit problème : le 8088 ne peut manipuler que des mots de 16 bits. Il découpe alors les 20 bits en deux parties : des bits pour le segment et d'autres pour l'offset, ce qui doit faire en tout 20 bits !
0040 Segment
0010 Offset
-----
00410Adresse sous la forme segment:offset
Interruptions logicielles
Je vous présente l'insruction INT (interruption software).
Le 8088 réserve les 1024 premiers octets de la mémoire pour un ensemble de 256 vecteurs d'interruption. Chacun des vecteurs d'interruptions longs de deux mots est utilisé pour stocker l'adresse sous la forme segment:offset d'un emplacement en mémoire.
Lorsqu'on exécute une interruption, le 8088 empile l'adresse de l'instruction suivante de votre programme dans la pile, puis se branche à l'adresse mémoire pointée par le vecteur spécifié par l'interruption.
La raison pour laquelle cela est très important est qu'un certain nombre de petites routines en langage machine très utiles ont été implantées dans l'ordinateur, et les vecteurs d'interruption pointent vers elles.
Une partie de ces routines sont implantées dans le Ms-Dos (en RAM), une autre dans le Bios (en ROM). Elles permettent d'effectuer des opérations sur disque, sur l'écran, sur l'imprimante, ...
Une autre chose : ces vecteurs d'interruptions vous permettent de modifier ces routines. C'est comme cela que le disque virtuel (en RAM) et le spooler fonctionnenet.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 85 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Voici un exemple pratique. Le programme que nous allons écrire va afficher un message à l'écran, et retournera au DOS. Bien que très simple, ce programme illustrera un certain nombre de points. Notamment l'appel à une fonction DOS, le stockage en mémoire et une forme de bonne programmation.
Pour cela, il faut savoir que pour afficher une chaîne de caractères à l'écran, nous devons utiliser la fonction 9. Nous devons donc charger le registre D avec l'adresse de la chaîne, spécifier la fonction 9 en chargeant 9 dans le registre AH, puis demander à DOS l'affichage en exécutant l'interruption 21h.
Voici le code correspondant :
MOV AH, 9 ; spécifier la fonction 9
MOV DX, OFFSET (MESSAGE) ; lit l'adresse de la chaîne
INT 21h ; appelle le DOS
Notez qu'aucune des lignes ne commence à la marge gauche, afin de ne pas confondre avec une étiquette, et qu'un commentaire a été ajouté en fin de ligne.
Une fois le texte affiché, nous voulons retourner au DOS. Si nous ne faisons rien, le 8088 continuera à exécuter les instructions correspondant aux valeurs aléatoires suivant le programme. Il y aura alors un "crash" du système. C'est pourquoi, pour retourner au DOS, on utilisera :
MOV AH, 4ch
INT 21h ; retour au DOS
Maintenant, il faut encore spécifier la chaîne de caractères à afficher. On fait cela de la façon suivante :
MESSAGE DB 'Bonjour !$' ; message à afficher
L'adresse mémoire est donnée par le nom "MESSAGE" parce que la ligne a commencé avec "MESSAGE" comme étiquette (label en anglais). Maintenant, l'assembleur sait que le OFFSET précédent se rapporte à cette adresse.
Notez que la chaîne finit avec un caractère "$". En effet, la fonction 9 affiche le texte jusqu'à ce qu'il rencontre "$". Il s'arrête alors.
Voici finallement le programme terminé :;==============================;
; HELLO Version 1.00 ;
; ;
; Fichier source simple. ;
; Affiche un message à l'écran ;
;==============================;
MOV AH, 9 ; spécifie la fonction 9
MOV DX, OFFSET [MESSAGE] ; lit l'adresse de la chaîne
INT 21h ; appelle le DOS
MOV AH, 4ch ; spécifie la fonction 4ch
INT 21h ; retourne au DOS
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 86 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
MESSAGE DB 'Bonjour !$' ; message à afficher
Présentation de l’IBM PC/XT
L'IBM PC/XT est équipé d'un micro-processeur 8 bits (binary digit) Intel 8088. C'est un pseudo 16 bits, c'est-à-dire d'architecture d'un 16 bits. 16 bits (numérotés de 0 à 15 de droite à gauche) forment un mot.
Il existe deux types de codes : ASCII et EBCDIC. L'IBM a opté pour les codes ASCII (de 1 à 127) et il dispose en outre de codes ASCII étendu non normalisés (128 à 255).
L'addition dans le système de numération binaire s'effectue comme suit :
0 + 0 = 0
1 + 0 = 1
0 + 1 = 1
1 + 1 = 0 et 1 de retenue (ou de report)
Un nombre négatif est repéré par la mise à 1 du bit de poids fort (le plus à gauche) et un nombre positif est repéré par la mise à 0 du bit de poids faible (le plus à droite).
La soustraction binaire est effectuée par addition d'un nombre positif et d'un nombre négatif. Soit à soustraire les deux nombres a et b :
a - b = a + (-b)
Pour cela, rappelez-vous comment reconnaître un nombre négatif d'un nombre positif (le paragraphe au-dessus).
Présentation des éléments constituant l’unité centrale du PC
L'Unité d'Exécution (EU)
Rôle :
- exécuter les instructions
Effets :
- exécution du contenu de la file d'attente
Interface :
- sortie d'une adresse logique au BIU
Comprend :
- une Unité Arithmétique et Logique (ALU)
- une Unité de Contrôle (CU)
- dix registres généraux
L'Unité d'Interface de Bus
Rôle :
- réalisation des échanges entre le mico-processeur et l'extérieur
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 87 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
- contrôle de l'interface avec des co-processeurs (arithmétique 8087, ...)
Note :
- la seule différence entre le 8088 et le 8086 réside dans le BIU
Effets :
- remplit la file d'attente
Interface :
- transformation de l'adresse logique fournie par le EU en adresse réelle
Comprend :
bus d'adresse de 20 bits (communication entre ROM, RAM, et interface d'E/S)
bus de données de 16 bits (transmission de données entre l'EU et la mémoire demandée)
bus de commande de 5 bits (définition de la fonction (écriture ou lecture); action début/fin de transfert)
unité de contrôle (gestion des transferts de données via les bus entre l'EU, la mémoire et les périphériques)
la file (des instructions) (autorisation de la pré-recherche des instructions)
les registres de segments (génération des adresses de la mémoire en liaison avec le bus d'adresse)
Note :
Juste avant l'exécution d'une instruction, elle doit être décodée. Pendant ce temps, les bus sont inactifs. Mais le 8088 fonctionne en mode dit « pine line ». En effet, pendant cet inactivité, le micro-processeur accède déjà !à l'instruction suivante, d'où l'introduction d'une notion de file d'attente. Cette dernière a une capacité de 4 octets. Ce système tient compte du fait qu'en général, le temps d'exécution d'une instruction est inférieur au temps de recherche d'une autre instruction.
Une autre partie très importante de l'IBM PC/XT est constituée par les slots. Chaque slot comprend 62 lignes de connexion en parallèle, que l'on appelle également des canaux d'E/S (Input/Output Channel).
- 8 lignes de données bidirectionnelles
- 20 lignes d'adressage
- 6 lignes de niveau d'interruption
- 3 lignes reliées au DMA
- 8 lignes de voltage (+/- 5V, +/- 12V)
- autres : lecture - écriture de la mémoire ou des périphériques
Architecture générale
L'architecture générale de l'IBM PC/XT est la suivante :
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 88 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
micro-processeur INTEL 8088
mémoire ROM 8K (BIOS), 16K (BASIC optionnellement)
mémoire RAM (jusqu'à 640K)
circuits intégrés indispensables au micro-processeur (8284, 8253, ...)
ports d'entrées-sorites (contrôleur DMA, monochrome, ...)
slots d'extensions
éventuellement un co-processeur arithmétique 8087
Le micro-processeur 8088
Le 8088, d'ancienne référence IAPX 88, tout en ne disposant de bus que de 8 bits, met à la disposition du programmeur des registres 16 bits. D'où sa dénomination de faux 16 bits.
Ce circuit possède 20 broches sur 40 en tout pour gérer le bus d'adresse. Ce bus permet donc l'adressage de 1 Méga-octet de mémoire (220 = 1.048.5786 = 1 Mo).
Afin d'accéder à toute cette mémoire, on utilise la combinaison de deux registres de 8 bits : CS pour désigner le segment physique de 64K, et IP pour le déplacement (adresse relative) dans le segment. On obtiend donc la représentation de l'adresse logique sous la forme Segment:Offset (déplacement).
Notion de segment
Un segment est un espace mémoire de 64K.
La valeur de l'adresse réelle (sur 20 bits) est obtenue par l'opération :adresse de base (segment) * 16 + déplacement (adresse relative)
16 bits 10H 16 bits
Les deux premiers termes font passer l'adresse de 4 à 5 chiffres. En langage machine, il suffit d'opérer un décalage quatre fois à gauche.
De plus, il est à noter que deux segments de numéros consécutifs peuvent se chevaucher en grande partie :
0000:0400 équivalent à 0040:0000.
Liste des registres
Registres généraux
Ce sont les seuls à pouvoir être utilisés à 8 ou à 16 bits.
Instructions d'E/S, arithmétiques
AH Accumulateur, registre haut (High) 8 bits
AL Accumulateur, registre bas (Low)
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 89 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
- 8 bits
AX Accumulateur - 16 bits
Seul à pouvoir être utilisé comme registre d'index
BH Base, registre haut (High) - 8 bits
BL Base, registre bas (Low) - 8 bits
BX Base - 16 bits
Compteur de boucle
CH Compteur, registre haut (High) - 8 bits
CL Compteur, registre bas (Low) - 8 bits
CX Compteur - 16 bits
Valeurs de déplacement à gauche ou à droite dans les instructions de décalage, Adresses des ports pour les E/S, couplé à AX pour les multiplications et les divisions en précision étendue
DH Données, registre haut (High) - 8 bits
DL Données, registre bas (Low) - 8 bits
DX Données - 16 bits
Pointeurs
Index : utilisés lors de l'adressage étendu pour l'addition et la soustraction
SI Index Source
Utilisé surtout pour les opérations sur les chaînes associé alors à DS.
DI Index Destination
Idem mais associé alors à ES.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 90 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Pointeur: accès aux données de pile utilisés parfois lors des additions et des soustractions
SP Pointeur de Pile (Stack)
Adresse du sommet de la pile sous le format SS:SP. Opérations seulement sur un mot.
BP Pointeur de Base
Accès à la pile. PB doit remplacer SP pour l'adressage pour accéder à un élément de la pile.
IP Pointeur d'Instruction
Adresse relative de la prochaine instruction à exécuter adresse absolue sur 20 bits sous le format CS:IP.
Segment
CS Segment Code
Contient les instructions du programme. Prend le contrôle à l'exécution.
DS Segment Données
Variables, constantes, zones de travail.
SS Segment Pile
Adresse de retour dans le SE ou dans le programme principal le cas échéant.
ES Segment Extra
Opérations « primitives sur chaînes ».
Note : l'adresse de début de segment est toujours un multiple de 10H.
Registre d'état et de commandeBit : F E D C B A 9 8 7 6 5 4 3 2 1 0
Indic. : - - - - OF DF IF TF SF ZF - AF - PF - CF
Indicateurs d'état
OF indicateur de débordement (overflow flag)
SF signe (sign flag)
= 1 : bit de poids fort à 1
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 91 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
(nombre négatif)
= 0 : bit de poids ford à 0 (nombre positif)
ZF indicateur de zéro (zéro flag)
= 1 : résultat de l'opération vaut zéro
AF indicateur de retenue auxiliaire (auxiliary carry flag)
= 1 : retenue (soustraction) des quatre bits de poids faible dans l'octet de poids fort, ou emprunt (addition) des quatre bits de poids fort dans l'octet de poids faible
PF indicateur de parité (parity flag)
= 1 : résultat de l'opération contient un nombre pair de un
CF retenue (carry flag)
= 1 : retenue (soustraction), ou emprunt (addition)
Indicateurs de commande
TF indicateur piège (trap flag)
Indicateur d'interruption pas-à-pas
= 1 : génération d'interruption de vecteur 01H
DF indicateur de direction (direction flag)
déplacement de plus de plus d'un mot d'un ensemble d'octets
= 1 : opérations de décrémentation
= 0 : opérations d'incrémentation
IF autorisation d'interruption (interrupt enable flag)
= 0 : interruption interdite
= 1 : interruption autorisée
Les vecteurs d’interruption
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 92 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Toute interruption déclenchée est transmise au contrôleur d'interruption INT 8259A, lequel discerne huit niveaux :
priorité unité
0 horloge
1 clavier
2 inutilisé
3 port série 2
4 port série 1
5 disque dur
6 disquette
7 imprimante
Une mise en cascade de 8259 permet ainsi de gérer jusqu'à 64 niveaux de priorité.
Le contrôleur d'interruption envoit ensuite, codé sur 8 bits, à l'unité d'exploitation le numéro de l'interruption appelée. Là est exécutée la routine de gestion d'interruption dont l'adresse se trouve en (n° d'interruption * 4) dans la table des vecteurs d'interruption.
En effet, chaque vecteur d'interruption est codé sur 4 octets. Ainsi, pour connaitre l'emplacement dans la mémoire de ce vecteur, il suffit de multiplier par quatre le numéro de l'interruption.
Un point très important : lors de l'appel d'une interruption, le micro-processeur effectue les opérations suivantes :
SP = SP - 2 (décrémente deux fois SP)
empile l'indicateur d'état
SP = SP - 2
empile CS
SP = SP - 2
empile IP
L'instruction assembleur RET utilise ces valeurs pour la poursuite du programme.
On discerne trois types d'interruptions :
les interruptions de type INTR (INTerrupt Request); elles sont masquables, et non prioritaires. Correspond à la broche n°8 du micro-processeur. Les interruptions sont autorisées si l'indicateur IF est à 1 (interruption INTR autorisée); les interruptions sont interdites si IF est à 0 (interruption INTR interdite). L'instruction assembleur CLI (CLear Interrupt enable flag) met IF à 0 et STI (SeT Interrupt enable flag) à 1.
l'interruption NMI (Non Masquable Interrupt). Correspond à la broche 17 du micro-processeur. Les registres d'état et de contrôle sont empilés.
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 93 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
l'interruption RESET (remise à zéro). Correspond à la broche 21 du micro-processeur. Même (quasiment ...) effet que si vous éteignez votre ordinateur et le rallumez.
Brève présentation du 6502
Nous allons commencer l'initiation au traitement de l'information dans l'ordinateur par la présentation et l'explication de ce qu'est une carte de la mémoire.
Votre ordinateur peut adresser jusqu'à 256 pages de mémoire. Remarquez au passage que 256 = 16 * 16 = 28. Chacune de ces pages contient 256 octets. Pour simplifier, nous dirons pour l'instant qu'un octet est un caractère. Nous verrons plus tard ce que cela représente en réalité.
Logiquement, nous allons maintenant expliquer ce qu'est un bit. Un bit, c'est soit un 1, soit un 0, ou encore un état vrai ou un état faux, un oui ou un non, ... Votre ordinateur regroupe ainsi les bits par huit, ce qui forme un octet. Un octet est donc la représentation de 8 bits, par exemple : 10101010.
Mais cet octet peut être représenté de nombreuses façons :
par un caractère de code ASCII
par un entier positif
par un entier relatif
par un nombre hexadécimal
Nous allons nous donner pour tâche de vous présenter, le plus clairement possible, ce que sont toutes ces interprétations.
Sachant qu'un octet contient 8 bits, il peut donc représenter jusqu'à 256 combinaisons différentes. Nous pouvons classer toutes ces combinaisons comme ceci :..0 00000000
..1 00000001
..2 00000010
..3 00000011
... ........
125 01111101
... ........
254 11111110
255 11111111
Expliquons ce classement. Si nous cherchions à classer des mots comprenant uniquement les lettres A et B, AAAAAAAB viendrait bien avant AAAAAABA !
Dans la base 10 (nombres décimaux), il y a dix chiffres. Dans la base 2 (nombres binaires, bits), il n'y en que deux, 0 et 1. Pour interpréter un bit en nombre décimal, vous devrez procéder comme suit :
10000000 = 10000000 = 27 = 128
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 94 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
00100000 = 100000 = 25 = 32
00001000 = 1000 = 23 = 8
00000010 = 10 = 21 = 2
-------- -------- --
10101010 = 10101010 = 27+25+23+21
= 128 + 32 + 8 + 2 = 170
Ainsi, pour connaitre la valeur décimale positive d'un bit, vous n'aurez qu'à additionner les puissances indiquées par les positions des 1 dans la représentation. Un 1 le plus à gauche indique un 27, le suivant un 26, puis un 25, ... jusqu'à 20 = 1. Pour acquérir de la rapidité, vous devrez apprendre par coeur les puissances de 2 :
20 = 1
21 = 2
22 = 4
23 = 8
24 = 16
25 = 32
26 = 64
27 = 128
28 = 256
Mais l'ordinateur a besoin de représenter aussi bien des nombres positifs que négatifs. En assembleur, ce sont les entiers relatifs (valeur positive ou négative) qui sont le plus souvent utilisés. Pour cela, la moitié des 256 valeurs sont dites négatives, et les autres positives, comme ceci :
0 00000000
1 00000001
2 00000010
3 00000011
.... ........
127 01111111
-128 10000000
-127 10000001
.... ........
-1 11111111
Notez que tous les bits interprétés négativement commencent par un 1, et tous les positifs par un 0. Le bit le plus à gauche est donc appelé le bit de signe.
Il est bon de faire deux remarques :
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 95 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
le 0 est donc pris comme un chiffre positif, et le 1 comme un chiffre négatif
si un bit commence par un 0, alors il n'y a pas de différence si vous l'interprétez en entier positif ou en entier relatif
L'interprétation en entier relatif est appelée « complément de deux ».
Maintenant, voyons un peu ce qu'est un caractère. Chaque représentation de 8 bits peut être interprétée comme un caractère différent. La lecture des représentations des bits sous forme binaire (des 0 et des 1) est difficile à effectuer. Ainsi, une autre notation est utilisée. Il s'agit d'utiliser des nombres hexadécimaux (en base 16 = 24).
Maintenant, représentez-vous un octet de 8 bits sous la forme de deux groupes de 4 bits. Avec 4 bits, vous pouvez représenter jusqu'à 16 valeurs différentes. Lorsque ces combinaisons sont classées alphabétiquement, le 0 venant avant le 1, on obtient la table suivante :
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
A 1010
B 1011
C 1100
D 1101
E 1110
F 1111
En hexadécimal, ces représentations de 4 bits sont respectivement nommées de 0 à F. Il faudra que vous appreniez cette liste.
Un chiffre décimal (de 0 à 9) désigne une valeur prise parmi 10, tandis qu'un chiffre hexadécimal en désigne un dans une liste de 16 (de 0 à F). Avec deux chiffres décimaux, on peut représenter jusqu'à 10 X 10 = 100 valeurs différentes (de 00 à 99), tandis qu'avec deux chiffres hexadécimaux, ce sera 16 X 16 = 256 (de 00 à FF) ! La notation hexadécimale est un des fondements du langage d'assemblage.
Chaque octet de la mémoire de votre ordinateur possède un nom différent. Ce nom est appelé son adresse, et est unique. Pour indiquer l'adresse d'un
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 96 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
octet, vous devez indiquer dans quelle page se trouve cet octet, et quelle est sa place dans la page.
Il y a 256 pages, nommées de 00 (en hexadécimal) à FF (toujours en hexa), et il y a 256 octets par page, les pages étant aussi nommées par les lettres de 00 à FF. Ainsi, 0BFF désigne le dernier caractère (FF) de la page 10 en décimal (B en hexa).Ainsi, leur adresse occupe deux octets, et ce pour désigner un octet ! De plus, une adresse peut désigner 16 X 8 = 65536 emplacements différents. Avec les entiers positifs, de 0 à 65535. Avec les entiers relatifs, de -32768 à +32767.
Il y a un autre moyen d'interpréter une représentation de bits : l'instruction d'un programme en langage machine. Nous ne nous y arrêterons que très superficiellement, juste de quoi donner une idée au lecteur.
La mémoire d'un ordinateur se découpe en banques (chacune de 64 Koctets). Chaque banque contient 256 pages de 256 octets chacune. Toute cette mémoire est contrôlée par une petite boite noire (puce, CPU : Central Processing Unit ou Unité Centrale de Calcul) qui contient sept octets, appelés registres.
L'apprentissage du langage d'assemblage s'appuie sur cette puce (micro-processeur). Elle permet d'effectuer les opérations dites élémentaires disponibles dans le langage machine.
Les sept registres sont appelés :
PC (Program Counter) : registre du compteur du programme sur deux octets
X : registre d'index X
Y : registre d'index Y
A : accumulateur
P : registre d'état du processeur
S : pointeur du haut de pile
Il y a donc cinq registres de un octet et un de deux octets, ce qui fait bien sept au total.
Vous pouvez écrire une instruction par cinq moyens différents qui détermineront quel octet en mémoire sera la cible de l'instruction. Voici cinq exemples correspondant aux cinq possibilités :
LDA #$10
LDA $10
LDA $10,X
LDA ($10,X)
LDA ($10),Y
Nous allons étudier chacun de ces cas dans la suite de l'article. Mais remarquons avant de continuer que le signe
« $ » désigner un nombre hexadécimal. Ainsi, 10 n'est pas ici un nombre décimal, mais un nombre hexadécimal, soit 16 en base 10 (décimale).
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 97 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Voyons maintenant :
l'adressage immédiat : le signe # en est le signe particulier. L'instruction LDA #$10 copie le nombre hexa 10 (le nombre suivant immédiatement l'instruction LDA) dans l'accumulateur.
l'adressage absolu (ou adressage direct) : aucun signe particulier. L'instruction LDA $10 copie le nombre contenu à l'adresse 0010 (en hexa) dans l'accumulateur. On aurait pu utiliser une instruction du type LDA $149A qui aurait copié le contenu de l'adresse $149A (octet numéro 94 en hexa, de la page 14, en hexa) dans l'accumulateur.
l'adressage indexé : signe particulier : « ,X » ou « ,Y ». Admettons que le registre contienne la valeur 02. Dans c cas, l'instruction LDA $10,X copie le contenu de l'adresse 12 en hexa (10 + 2 = 12) dans l'accumulateur. On pourra également utiliser des instructions du type LDA $249F,Y. Remarquez que l'interprétation par les entiers positifs est utilisée avec ce mode d'adressage (et non pas celui avec les entiers relatifs). Vous ne pouvez utiliser que les registres X et Y (appelés registres d'index, et pour cause !) dans ce mode.
l'adressage indirect : signe particulier : parenthèses. Supposons que les adresses 0010 et suivantes contiennent respectivement les valeurs 00-15-69-FF, et que le registre contienne la valeur 02. L'instruction LDA ($10,X) copiera le contenu de l'adresse FF69 (contenue aux adresses 10 + 2 et 10 + 3 soit 12 et 13, en hexa). Vous remarquerez que l'adresse est « inversée » : le numéro de la page suit la position dans la page.
Supposons maintenant que le registre contienne la valeur 03. L'instruction LDA ($10),Y copiera le contenu de l'adresse, donnée par le contenu de l'adresse contenu en 0010 et 0011 (soit 1500; e, hexa) ajoutée de 3 (contenu du registre Y), soit au total 1503, dans l'accumulateur.
L'intérêt de l'emploi de l'adressage immédiat réside dans l'utilisation de constantes, de l'adressage absolu (ou direct), celle des variables, de l'adressage indexé, celle des tableaux, et enfin de l'adressage indirect, pour, par exemple, recopier un programme d'un endroit de la mémoire à un autre.
Pour écrire un programme avec un assembleur, vous entrez les instructions (comme LDA $110) et l'assembleur les traduit en nombres (sous forme de bits) et le stocke en mémoire.
Nous allons finir par l'étude des instructions de comparaison. En langage machine, nous devons passer par deux étapes pour cela :
faire la comparaison et « se rappeler » du résultat en adaptant le registre d'état
se brancher à l'adresse correspondante, selon que le registre d'état est à 1 ou à 0
Voyons un exemple, afin de bien comprendre.
LDA #$10
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 98 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
CMP #$11
Ces instructions chargent la valeur hexa 10 dans l'accumulateur, puis comparent le contenu de l'accumulateur (10) à la valeur hexa 11. Le seul effet de CMP est d'adapter trois bits du registre d'état : le bit zéro, le bit négatif, et le bit de retenue.
La comparaison se fait en soustrayant 11 de 10. On obtient dans ce cas précis -1, soit FF en hexa.
Maintenant, iul faut utiliser une instruction de branchement, qui dépendra des trois bits dont on a parlé plus haut : « BMI $2000 » qui continuera l'exécution du programme à l'adresse 2000, si le bit négatif est à 1.
Précisons quelques points pour bien comprendre cela :
FF n'est pas 00. Donc le bit zéro est mis à 0.
FF est négatif. Donc le bit négatif est mis à 1.
Si vous effectuez l'opération ??10 - 0011, où ?? désigne deux chiffres hexa inconnus, et si vous voulez « retenir quelque chose » aux chiffres ??, alors le bit de retenue sera mis à 0 (il aurait été mis à 1 s'il y avait eu besoin de retenir).
Nous allons arrêter là l'initiation, car elle risquerait de trop se compliquer, et ainsi de sortir du cadre de cet article. Réfléchissez donc bien à tout ceci. Cela peut paraitre affreusement abstrait au premier abord, mais tout devrait s'éclaircir avec le temps.
Langage machine ou langage de la machine
L'ordinateur ne comprend qu'un langage : le langage machine, qui n'est rien d'autre qu'une suite de 0 et de 1. Les instructions de ce langage sont donc très élémentaires. D'où un langage de programmation lourd, fastidieux. La difficulté de ce langage est donc une source d'erreurs.
On a donc dû faire appel à un langage afin de pouvoir programmer sans entrer à chaque fois dans un cauchemar ! Ce langage symbolique a été appelé langage d'assemblage ou assembleur. Ses fonctions sont de vérifier la syntaxe et de signaler les éventuelles erreurs, puis de traduire ce programme source (d'origine) en un autre programme (programme objet) en langage machine.
Nous pouvons donc maintenant essayer de dresser une liste des principaux avantages et inconvénients de l'emploi du langage machine. Vous verrez ainsi pourquoi ce langage est réputé si complexe.
Parmi les avantages, nous pouvons citer :
le plus rapide
bonne protection (très peu lisible, et donc très difficilement modifiable par une personne non autorisée)
compatible (attention aux adresses-mémoire) à tous les autres micro-ordinateurs de même micro processeur.
Maintenant, on en vient aux inconvénients :
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 99 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
accès souvent mal aisé
très compliqué (dû à l'emploi d'instructions élémentaires)
très grande difficulté de modification sans le source (programme pas encore assemblé, c'est-à-dire encore sous forme de mnémoniques)
incompatibilité avec les machines centrées sur un micro-processeur différent.
Les opérateurs et les attributs
AND Opération ET logique entre deux expressions
ARITHMETIQUE Faites grâce à +, -, /, *
MOD Modulo d'une expression
NOT Opération NON logique entre deux expressions
OR Opération OU logique entre deux expressions
RELATIONNEL Comparaison par soustraction entre deux expressions
EQ égal
NE non égal
LT plus petit
LE plus petit ou égal
GT plus grand
GE plus grand ou égal. Exemple : MOV AX, 0DH WIDTH ENR_1 LT 5
SHL Décalage d'un bit à gauche. Un 0 est inséré dans la position supplémentaire. Correspond à une multiplication en puissance de 2.
SHR Décalage d'un bit à droite. Correspond à une division en puissance de 2.
XOR Opération logique OU EXCLUSIF entre deux expressions.
= Affectation d'une valeur ou d'un label à une référence.
PTR Modification du type de l'objet codé en regard de cet attribut pour manipuler un objet avec un type différent de celui qui lui a été attribué lors de sa définition.
Les attributs peuvent être :
BYTE type octet (1 octet)
WORD type mot (2 octets)
DWORD type double mot (4 octets)
QWORD type quatre mots (8 octets)
TBYTE type dix octets (10 octets)
NEAR type intrasegment
FAR type extrasegment
SEGMENT Modification de registre de segment.
SHORT Modification de l'adresse de branchement. Exemple : JMP SHORT SUITE
HIGH Donner la position de l'octet de poids fort d'un objet déclaré avec un
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 100 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
type WORDL. L'assembleur générera automatique un déplacement de +1.
LOW Donner la position de l'octet de poids faible d'un objet déclaré avec un type WORD.
THIS Identification d'un objet à la position courante du compteur d'assemblage.
Les valeurs de type :
BYTE type octet (1 octet)
WORD type mot (2 octets)
DWORD type double mot (4 octets)
QWORD type quatre mots (8 octets)
TBYTE type dix octets (10 octets)
NEAR type intrasegment
FAR type extrasegment. Exemple : TAMPON EQ THIS WORD
LENGTH Obtenir le nombre de duplications faires dans une définition de données. Exemple : MOV CL, LENGTH TAMPON
MASK Obtenir le masque binaire nécessaire pour isoler unchamp d'une chaîne de bits au moyen d'une opération AND. Exemple : MOV AX, MASK ENREG
OFFSET Obtenir le déplacement relatif d'un objet dans un segment. L'objet doit être défini dans un segment déclaré et défini par les directives SEGMENT et ENDS.
SEG Obtenir le numéro de paragraphe d'un objet.
SHIFT Le nom d'un champ d'une chaîne de bits est pris comme attribut de décalage. La valeur rendue est celle qu'il faut appliquer à la chaîne de bits après isolement avec cette valeur par l'attribut MASK, pour cadrer le champ à droite de la chaîne. Ce décalage doit être fait grâce à l'instruction SHR.
SIZE Obtenir l'encombrement en octets d'une allocation globale de variable, structure, ou chaîne de bits.
TYPE Obtenir l'encombrement en octets d'une unité de type de la définition.
WIDTH Obtenir la longueur en bits d'un champ d'une chaîne de bits.
La notation est la suivante :
Caractère Type Exemple
B Binaire 0101B (chiffres de 0 à 1)
D Décimal 10D (chiffres de 0 à 9)
E Scientifique 123E4
H Hexadécimal 0DH (chiffres de 0 à 9 plus A à F)
O Octal 03O (chiffres de 0 à 7)
C Caractère "Texte" ou 'Texte'
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 101 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Aide sur l’assembleur
Informations sur le 8088
masse - 1 40 - +5V
A14 - 2 39 - A15
A13 - 3 38 - A16/S3
A12 - 4 37 - A17/S4
A11 - 5 36 - A18/S5
A10 - 6 35 - A19/S6
A9 - 7 34 - /SS0
A8 - 8 33 - MN//MX
A7/D7 - 9 32 - /RD
A6/D6 - 10 31 - HOLD
A5/D5 - 11 30 - HLDA
A4/D4 - 12 29 - /WR
A3/D3 - 13 28 - IO//M
A2/D2 - 14 27 - DT/R
A1/D1 - 15 26 - /DEN
A0/D0 - 16 25 - ALE
NMI - 17 24 - /INTA
INTR - 18 23 - /TEST
CLK - 19 22 - READY
masse - 20 21 - RESET
Registres
Pile
Instruction Description
POP Dépile un registre général
POPF Dépile vers le registre d'indicateur
PUSH Empile un registre
Drapeaux
Registres généraux :
Registre Description
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 102 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 :
Registre Description
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 :
Registre Description
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 :
Mode d’adressage Syntaxe
Immédiat MOV BL,FFh
De registre MOV AX,BX
Direct MOV AX,constante
adresse = DS:constante
Indirect de registres MOV BX,[SI]
adresse = 16 * DS + SI
Indirect de registre avec déplacement MOV AX,constante [DI]
adresse = 16 * DS + constante + DI
Indirect de registre avec registre de base et registre d'index
MOV AX,[BX] [DI]
adresse = 16 * DS + BX + DI
Indirect de registre avec registre de base, d'index plus constante
MOV AX, constante [BX] [SI]
adresse = 16 * DS + constante + BX + SI
Opérations arithmétiques
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 103 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
Addition
Instruction Description
AAA Ajustement ASCII pour addition
ADC Addition avec retenue
ADD Addition sans retenue
DAA Correction décimale pour addition
INC Incrément de un
Soustraction
Instruction Description
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
Multiplication
Instruction Description
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
Division
Instruction Description
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
Decalage
Instruction Description
SAL Décalage arithmétique de n bits vers la gauche; des zéros sont introduits … droite
SAR Décalage arithmétique de n bits vers la droite; le bit de poids fort
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 104 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
Rotation
Instruction Description
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
Logique
Instruction Description
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
Instruction Description
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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 105 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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 Verrouillage 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 supé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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 106 / 107
Bruno Delb http://www.brunodelb.com Date : 20/11/2000
Le langage Assembleur
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
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
Edité le 12/04/2023 technique/langages/java_jdbc.pdf (52 Ko) Page 107 / 107