138
Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Sommaire PROCÉDURE D'ASSEMBLAGE.......................................................5 COMMENT ÉCRIRE UN PROGRAMME ASSEMBLEUR ?.........................................5 Saisie................................................................................................................................................................ 5 Assemblage..................................................................................................................................................... 6 Références croisées........................................................................................................................................ 7 Création d'un fichier .EXE.............................................................................................................................. 7 Création d'un fichier .COM............................................................................................................................ 8 LE PORT SÉRIE................................................................9 INTERRUPTIONS 14H............................................................ 9 But................................................................................................................................................................... 9 Zones RAM utilisées........................................................................................................................................ 9 Registres en entrée......................................................................................................................................... 9 Algorithme.................................................................................................................................................... 11 SOURCE COMMENTÉ :........................................................... 12 Subroutines fonctions.................................................................................................................................. 13 Subroutine STATUS_MODEM....................................................................................................................... 14 Subroutine SEND_CHAR............................................................................................................................... 14 Subroutine RECEIVE_CHAR.......................................................................................................................... 15 Subroutine SSPROG1.................................................................................................................................... 16 Subroutine SSPROG1_1................................................................................................................................ 16 Subroutine STATUS....................................................................................................................................... 16 APPLICATIONS ASSEMBLEUR.......................................................17 Fonction 00 : Initialisation du port série................................................................................................... 17 Fonction 01 : Transmission de caractère................................................................................................... 17 Fonction 02 : Réception d'un caractère...................................................................................................... 18 Fonction 03 : Prêt à émettre ?..................................................................................................................... 18 Fonction 03 : Caractère reçu ?.................................................................................................................... 18 Envoi des caractères saisis au clavier sur le port série............................................................................ 19 LANGAGE C..................................................................19 Fonction 01 : Envoi d'un caractère............................................................................................................. 19 Fonction 02 : Réception d'un caractère...................................................................................................... 20 Fonction 03 : Prêt à recevoir ?.................................................................................................................... 20 Fonction 04 : Prêt à émettre ?..................................................................................................................... 20 COMPARAISON LANGAGE D'ASSEMBLAGE / LANGAGE ÉVOLUÉ...........................22 TABLES UTILISÉES PAR LES ASSEMBLEURS............................................22 Table des symboles (ou des identificateurs) :............................................................................................ 22 Table des codes opératoires :..................................................................................................................... 22 Table des constantes :.................................................................................................................................. 23 Edité le 11/06/2022 technique/langages/java_jdbc.pdf (52 Ko) Page 1 / 138

Assembleur et binaire

Embed Size (px)

Citation preview

Page 1: Assembleur et binaire

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

Page 2: Assembleur et binaire

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

Page 3: Assembleur et binaire

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

Page 4: Assembleur et binaire

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

Page 5: Assembleur et binaire

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

Page 6: Assembleur et binaire

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

Page 7: Assembleur et binaire

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

Page 8: Assembleur et binaire

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

Page 9: Assembleur et binaire

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

Page 10: Assembleur et binaire

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

Page 11: Assembleur et binaire

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

Page 12: Assembleur et binaire

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

Page 13: Assembleur et binaire

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

Page 14: Assembleur et binaire

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

Page 15: Assembleur et binaire

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

Page 16: Assembleur et binaire

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

Page 17: Assembleur et binaire

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

Page 18: Assembleur et binaire

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

Page 19: Assembleur et binaire

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

Page 20: Assembleur et binaire

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

Page 21: Assembleur et binaire

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

Page 22: Assembleur et binaire

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

Page 23: Assembleur et binaire

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

Page 24: Assembleur et binaire

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

Page 25: Assembleur et binaire

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

Page 26: Assembleur et binaire

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

Page 27: Assembleur et binaire

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

Page 28: Assembleur et binaire

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

Page 29: Assembleur et binaire

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

Page 30: Assembleur et binaire

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

Page 31: Assembleur et binaire

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

Page 32: Assembleur et binaire

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

Page 33: Assembleur et binaire

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

Page 34: Assembleur et binaire

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

Page 35: Assembleur et binaire

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

Page 36: Assembleur et binaire

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

Page 37: Assembleur et binaire

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

Page 38: Assembleur et binaire

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

Page 39: Assembleur et binaire

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

Page 40: Assembleur et binaire

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

Page 41: Assembleur et binaire

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

Page 42: Assembleur et binaire

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

Page 43: Assembleur et binaire

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

Page 44: Assembleur et binaire

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

Page 45: Assembleur et binaire

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

Page 46: Assembleur et binaire

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

Page 47: Assembleur et binaire

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

Page 48: Assembleur et binaire

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

Page 49: Assembleur et binaire

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

Page 50: Assembleur et binaire

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

Page 51: Assembleur et binaire

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

Page 52: Assembleur et binaire

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

Page 53: Assembleur et binaire

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

Page 54: Assembleur et binaire

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

Page 55: Assembleur et binaire

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

Page 56: Assembleur et binaire

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

Page 57: Assembleur et binaire

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

Page 58: Assembleur et binaire

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

Page 59: Assembleur et binaire

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

Page 60: Assembleur et binaire

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

Page 61: Assembleur et binaire

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

Page 62: Assembleur et binaire

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

Page 63: Assembleur et binaire

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

Page 64: Assembleur et binaire

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

Page 65: Assembleur et binaire

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

Page 66: Assembleur et binaire

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

Page 67: Assembleur et binaire

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

Page 68: Assembleur et binaire

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

Page 69: Assembleur et binaire

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

Page 70: Assembleur et binaire

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

Page 71: Assembleur et binaire

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

Page 72: Assembleur et binaire

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

Page 73: Assembleur et binaire

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

Page 74: Assembleur et binaire

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

Page 75: Assembleur et binaire

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

Page 76: Assembleur et binaire

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

Page 77: Assembleur et binaire

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

Page 78: Assembleur et binaire

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

Page 79: Assembleur et binaire

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

Page 80: Assembleur et binaire

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

Page 81: Assembleur et binaire

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

Page 82: Assembleur et binaire

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

Page 83: Assembleur et binaire

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

Page 84: Assembleur et binaire

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

Page 85: Assembleur et binaire

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

Page 86: Assembleur et binaire

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

Page 87: Assembleur et binaire

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

Page 88: Assembleur et binaire

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

Page 89: Assembleur et binaire

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

Page 90: Assembleur et binaire

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

Page 91: Assembleur et binaire

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

Page 92: Assembleur et binaire

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

Page 93: Assembleur et binaire

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

Page 94: Assembleur et binaire

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

Page 95: Assembleur et binaire

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

Page 96: Assembleur et binaire

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

Page 97: Assembleur et binaire

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

Page 98: Assembleur et binaire

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

Page 99: Assembleur et binaire

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

Page 100: Assembleur et binaire

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

Page 101: Assembleur et binaire

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

Page 102: Assembleur et binaire

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

Page 103: Assembleur et binaire

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

Page 104: Assembleur et binaire

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

Page 105: Assembleur et binaire

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

Page 106: Assembleur et binaire

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

Page 107: Assembleur et binaire

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