Your SlideShare is downloading. ×
  • Like
Assembleur et binaire
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Assembleur et binaire

  • 3,276 views
Published

 

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
3,276
On SlideShare
0
From Embeds
0
Number of Embeds
3

Actions

Shares
Downloads
183
Comments
0
Likes
1

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur SommairePROCÉDURE DASSEMBLAGE...................................................................................5 COMMENT ÉCRIRE UN PROGRAMME ASSEMBLEUR ?.................................................................5 Saisie.................................................................................................................5 Assemblage.........................................................................................................6 Références croisées..............................................................................................7 Création dun fichier .EXE.....................................................................................7 Création dun fichier .COM.....................................................................................8LE 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 dun caractère.................................................................18 Fonction 03 : Prêt à émettre ?.............................................................................18 Fonction 03 : Caractère reçu ?.............................................................................18 Envoi des caractères saisis au clavier sur le port série............................................18 LANGAGE C.............................................................................................................19 Fonction 01 : Envoi dun caractère.......................................................................19 Fonction 02 : Réception dun caractère.................................................................19 Fonction 03 : Prêt à recevoir ?.............................................................................20 Fonction 04 : Prêt à émettre ?.............................................................................20COMPARAISON LANGAGE DASSEMBLAGE / LANGAGE ÉVOLUÉ............................21 TABLES UTILISÉES PAR LES ASSEMBLEURS.........................................................................21 Table des symboles (ou des identificateurs) :........................................................21 Table des codes opératoires :..............................................................................21 Table des constantes :........................................................................................22 ASSEMBLEUR À DEUX PASSES........................................................................................22 ERREURS LES PLUS COURANTES EN LANGAGE DASSEMBLAGE...................................................24ROUTINES DINTÉRÊT GÉNÉRAL...........................................................................25 MODIFIER UNE FONCTION DUNE INTERRUPTION...................................................................25 Modifier ladresse dune pile.................................................................................25 INTERRUPTION 08H...................................................................................................26 Lecture de lheure sur lhorloge............................................................................26 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 1 / 109
  • 2. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur INTERRUPTION 10H...................................................................................................27 Fonction 00h - Sélection de mode daffichage........................................................27 Fonction 01h - Sélection du format du curseur......................................................27 INTERRUPTION 11H....................................................................................................27 Détermination de la configuration........................................................................27 INTERRUPTION 12H...................................................................................................29 INTERRUPTION 16H...................................................................................................29 Fonction 01h - Y a-t-il un caractère dans le buffer ?...............................................29 INTERRUPTION 17H....................................................................................................29 Fonction 00h - Imprimer un caractère en testant si tout sest bien passé.................29 Limprimante est-elle prête ?...............................................................................30RÉFÉRENCES..........................................................................................................31 BROCHAGES.............................................................................................................31 8088.................................................................................................................31 Registres et instructions.....................................................................................32LES DISQUES.........................................................................................................37 LES DESSOUS DE LA DISQUETTE 360 KO..........................................................................37 Secteur 0 - Zone dinitialisation ( Boot Sector)......................................................38 secteur 1-4 - Table dallocation de fichiers (FAT = File Allocation Table)..................38 Secteur 5-11 - Répertoire (Directory)...................................................................39 LE DISQUE DUR.........................................................................................................39 LORGANISATION DUNE DISQUETTE.................................................................................39 Présentation......................................................................................................39 Zone dinitialisation, Boot Sector..........................................................................40 Table dallocation de fichier, FAT = File Allocation Table.........................................41 Répertoire (Directory).........................................................................................42 Le préfixe de segment de programme (PSP)..........................................................43LIBM PC/XT JUSQUÀ SES RACINES.....................................................................45 PRÉSENTATION DES ÉLÉMENTS CONSTITUANT LUNITÉ CENTRALE DE LIBM PC/XT..........................45 LUnité dExécution (EU).....................................................................................45 LUnité dInterface de Bus...................................................................................46 ARCHITECTURE GÉNÉRALE.............................................................................................47 Le micro-processeur 8088...................................................................................47 LES VECTEURS DINTERRUPTION......................................................................................48 Les interruptions de type INTR (INTerrupt Request)...............................................48 Linterruption NMI (Non Masquable Interrupt).......................................................49 Linterruption RESET (remise à zéro)....................................................................49 NOTATION...............................................................................................................49LARITHMÉTIQUE BINAIRE...................................................................................50 PRÉSENTATION..........................................................................................................50 Laddition binaire................................................................................................52 La soustraction binaire........................................................................................52 La multiplication et la division binaire...................................................................52 LES FONCTIONS LOGIQUES DE BASE.................................................................................53 Présentation......................................................................................................53 La logique combinatoire......................................................................................53 Le système des portes........................................................................................54 Le décodeur.......................................................................................................56 Le multiplexeur..................................................................................................56 Ladditioneur complet.........................................................................................56 INTERRUPTION 21H....................................................................................................56 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 2 / 109
  • 3. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Fonction 09h - Affichage dune chaîne de caractères..............................................56 Fonction 0Ah - Lecture dune ligne au clavier........................................................57 Fonction 12 - Vider le buffer du clavier.................................................................57 Fonction 25 - Installer une nouvelle interruption...................................................57 Fonction 3Dh - Création de répertoire...................................................................57 Fonction 3Dh - Changement de répertoire.............................................................58 Fonction 4Ch - Rendre la main à MS-DOS.............................................................58LA VIDÉO...............................................................................................................60 ATTRIBUTS..............................................................................................................60 Définition..........................................................................................................60 Adaptateur monochrome.....................................................................................60 Adaptateur graphique couleur..............................................................................61COURS D’ASSEMBLEUR..........................................................................................62 GÉNÉRALITÉS...........................................................................................................62 Rappels sur le fonctionnement de l’ordinateur.......................................................62 La syntaxe.........................................................................................................63 LES DONNÉES...........................................................................................................63 Généralités........................................................................................................63 Registres...........................................................................................................64 Données et mémoire..........................................................................................66 LES MODES D’ADRESSAGE............................................................................................67 LE JEU D’INSTRUCTIONS...............................................................................................69 Les instructions de base......................................................................................69 Les instructions arithmétiques.............................................................................70 Les instructions logiques.....................................................................................72 Les instructions de décalage et de rotation............................................................73 Les instructions de pile.......................................................................................74 Les instructions de manipulation de chaînes de caractères......................................75 Les instructions de saut conditionnel....................................................................77 Les instructions de saut inconditionnel.................................................................77 Les tests d’identificateur.....................................................................................77 Les tests arithmétiques.......................................................................................78 Les tests de nombres non signés.........................................................................78 Les tests de nombres signés................................................................................79 Les instructions de boucle...................................................................................80 Les procédures (sous-programmes)......................................................................80 Les paramètres et les sous-programmes...............................................................81 Les instructions de gestion des adresses...............................................................82 TECHNIQUES DE PROGRAMMATION...................................................................................82 Organisation d’un programme..............................................................................83 Utilisation de plusieurs segments : la directive Assume..........................................84 La programmation modulaire...............................................................................84 Les fichiers Exe..................................................................................................85POINTS PARTICULIERS.........................................................................................86 ADRESSAGE DE LA MÉMOIRE.........................................................................................86 INTERRUPTIONS LOGICIELLES.........................................................................................86 PRÉSENTATION DE L’IBM PC/XT....................................................................................88 PRÉSENTATION DES ÉLÉMENTS CONSTITUANT L’UNITÉ CENTRALE DU PC.......................................88 LUnité dExécution (EU).....................................................................................88 LUnité dInterface de Bus...................................................................................89 ARCHITECTURE GÉNÉRALE.............................................................................................90 LE MICRO-PROCESSEUR 8088.......................................................................................90 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 3 / 109
  • 4. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Notion de segment.............................................................................................90 LISTE DES REGISTRES.................................................................................................91 Registres généraux.............................................................................................91 Pointeurs...........................................................................................................92 Segment...........................................................................................................92 Registre détat et de commande...........................................................................93 LES VECTEURS D’INTERRUPTION......................................................................................94 BRÈVE PRÉSENTATION DU 6502.....................................................................................95 LANGAGE MACHINE OU LANGAGE DE LA MACHINE...............................................................101 LES OPÉRATEURS ET LES ATTRIBUTS...............................................................................101AIDE SUR L’ASSEMBLEUR....................................................................................104 INFORMATIONS SUR LE 8088......................................................................................104 REGISTRES............................................................................................................104 Pile.................................................................................................................104 Drapeaux.........................................................................................................104 OPÉRATIONS ARITHMÉTIQUES.......................................................................................106 Addition..........................................................................................................106 Soustraction....................................................................................................106 Multiplication...................................................................................................106 Division...........................................................................................................106 Decalage.........................................................................................................106 Rotation..........................................................................................................107 Logique...........................................................................................................107 DIVERS................................................................................................................107 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 4 / 109
  • 5. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurProcédure dassemblage 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 Lextension 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 dajouter 48 au code ASCII !) • ADD DL,48 • déclenchement de linterruption 21H (sélection de laffichage 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 linterruption 21H (retour au DOS par stockage de 4CH dans le registre AH) • MOV AH,4CH (préparation) • INT 21H (déclenchement proprement dit) Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 5 / 109
  • 6. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • fin de la procédure ADDITION • ADDITION ENDP • fin du segment PROG • PROG ENDS • fin du programme avec indication du point dentrée (ADDITION) • END ADDITION Assemblage Admettons que le fichier (dit fichier source) sappelle ADD.ASM. Vous lancez lassembleur (MASM suivi de ENTREE pour le Macro-Assembleur). Lordinateur 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 lextension ASM (il lajoute 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). Lordinateur vous propose donc un nom de fichier. A vous de valider (ENTREE) ou dinvalider (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 sagit du listage du source mais avec lassemblage. • 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 sagit de la liste des références croisées. Puis lassemblage commence. Lordinateur affiche alors le nombre derreurs davertissement (warning errors) : il a rencontré des erreurs de compréhension (ambiguïtés dans le programme). Cependant, lassemblage sest tout de même effectué. Puis cest au tour des erreurs fatales (severe erreors). Lassemblage 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 • lassemblage (valeurs numériques) à gauche : ce sont les instructions correspondantes en langage machineEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 6 / 109
  • 7. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Les lignes sont numérotées afin de permettre un rapide repérage dans le programme. Sur chaque ligne : • le numéro de ligne • le champ adresse (quatre chiffres), en commençant à 0000 • le champ opération (2 ou 4 chiffres) : ce sont les instructions en langage machine (code) • le champ opérande : il contient les données ou adresses (parfois) Enfin figure indiquant létat du programme (erreurs éventuelles, avec leur type, ...). Références croisées Regardez maintenant le contenu du fichier de références croisées (.CRF). Pour cela, utilisez le programme CREF. Il vous demande : • le nom du fichier Cref (avec lextension CRF) : • Cref filename [.CRF]: • le nom du fichier de listage des références croisées (il recevra lextension .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. • Lorsquil sagit dune première référence (cest-à-dire de leur définition), le numéro de immédiatement suivi de #. Très utile pour la détection derreur et pour la correction dun programme, nest-il pas ? Création dun fichier .EXE On va maintenant créer un fichier exécutable, cest-à-dire de suffixe EXE. Pour cela, lancez le programme LINK. Lordinateur vous demande : • les modules objets (le fichier de suffixe OBJ) • (Object Modules [.OBJ]:) • le nom du fichier de suffixe EXE à créer • (Run File [xxx.EXE]:)Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 7 / 109
  • 8. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • le nom du fichier de listage (de suffixe MAP) : NUL pour pas de fichier, un autre nom de fichier pour en créer un (List File [NUL.MAP]:) • le nom du fichier de bibliothèque : ne nous concerne pas encore ! • (Libraries [.LIB]:) • Le fichier xxx.MAP (ici ADD.MAP) contient : - ladresse de départ des segments (un seul dans notre cas présent) - ladresse darrêt de ces mêmes segments - leur longueur - leur nom Il sagit toujours dadresses relatives (à 0000). Ce sera DOS, au moment du chargement, qui sélectionnera ladresse 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 dun fichier .COM Nous allons maintenant nous donner pour tâche la conversion dun 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é lordre : "ORG 100H" juste avant les premières instructions (cest-à-dire juste après la définition de procédure ADDITION). Dun fichier dorigine 0 (fichier EXE), on « passe » à un fichier dorigine 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, lordinateur sélectionne le suffixe BIN !) Vous obtenez donc le fichier xxx.COM (ou ADD.COM).Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 8 / 109
  • 9. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurLe 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 dimpulsion ERP, 1 changement détat de DSR, 0 changement détat de CTS. Initialisation des ports (AH = 00h) En entrée : AL est loctet de configuration. Bit Description 0,1 Taille du mot : 10 = 7 bits 11 = 8 bits 2 Bits darrêt : 0 = 1 bit darrêt 1 = 2 bits darrêt Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 9 / 109
  • 10. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 3,4 Bits de parité : 00 = pas de parité 01 = parité impaire 10 = pas de parité 11 = parité paire 5-7 Vitesse de transmission : 000 = 110 bauds 001 = 150 bauds 010 = 300 bauds 011 = 600 bauds 100 = 1200 bauds 101 = 2400 bauds 110 = 4800 bauds 111 = 9600 bauds, En sortie : AH est loctet 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 dun caractère dans AL (AH = 02h) En cas derreur, les bits 1 à 4 et 7 de AH sont mis à un. En entrée : Pas de paramètre. En sortie : AL = caractère lu, AH = octet détat. Lecture de létat du port de communication (AH = 03h) En entrée : Pas de paramètres. En sortie : AH = mot détat de la ligne, AL = mot détat du modem. AH : Bit Description 0 donnée prête, 1 erreur de tassement des données,Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 10 / 109
  • 11. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 2 erreur de parité, 3 erreur dencadrement, 4 détection dun Break, 5 registre dattente 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 ladresse 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 dun caractère (-> SEND_CHAR), • 2 alors réception dun caractère (-> RECEIVE_CHAR), • 3 alors état du modem (-> STATUS_MODEM). Fonction initialisation du port (INIT_RS232). • indiquer que lon 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 - 00Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 11 / 109
  • 12. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 300 01 - 80 600 00 - C0 1200 00 - 60 2400 00 - 30 4800 00 - 18 9600 00 - 0C • Mettre le code dans les registres en 2F8 - 2F9. • Indiquer à la carte la parité et la longueur de mot choisies (Registre de contrôle de la ligne). • Remettre à 0 le registre dautorisation dactivation des interruptions. Fonction émission dun caractère (SEND_CHAR). • Signaler que lordinateur est prêt. • Envoyer le signal de demande démissionn de caractère. • Contrôle du time out (temps maximal alloué) : - si le modem nest pas prêt ou si aucune sonnerie nest détectée alors on va à sortie. - sil ny a eu pas décrasement de données. • Envoi effectif du code par écriture dans le registre de transmission. Fonction réception dun caractère (RECEIVE_CHAR). • Indiquer que lordinateur est prêt (DTR). • Si le modem nest pas prêt ou si aucun caractère nest disponible alors sortie. • Indique pour la suite que : - Aucune donnée nest prête. - Registre dattente 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 linterruption STIEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 12 / 109
  • 13. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur ; Sauvegarder les registres modifiésEmpile afin de ne pas PUSH BXperturber le programme PUSH CXcourant. PUSH DX PUSH DI PUSH DS ; Accès à la zone de communication du BIOSSe place en segment 40. CALL SEGMENT_40 ; Ladresse de chaque carte est repérée à laide de la formule suivante : Adresse = (400 + 2 * Numéro de la carte)BX = DX = n° carte MOV BX,DXDécalage dune fois à SHL BL,1gauche. ; On effectue en fait une multiplication par 2 (BH est nul !). On lit ladresse du port de la carte correspondante.DX vaut ladresse 400 + 2 * MOV DX,[BX+0000]BX ; Soit ladresse du port de la carte concernée. Si loctet lu vaut 0 alors cest quil ny a pas de carte ! Sinon, on appelle la fonction sélectionnée.Sert à tester si DX vaut 0 ou OR DX,DXnon.Si DX = 0 (pas de carte) JZ SORTIEalors aller à SORTIE.Aappel du sous-programme CALL FONCTIONSqui effectue lexécution de lafonction sélectionnée. ; Au retour de lexécution de la fonction, on restaure les registres modifiés et inutiles au programme appelant. SORTIE :Dépile les registres afin de POP DSrestaurer les conditions POP SIinitiales dappel. POP DI POP DX POP CX POP BXFin de routine de traitement IRETdinterruption. Subroutines fonctions Pour la routine de sélection de fonction, se référer au paragraphe correspondant figurant en début de chapitre. Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 13 / 109
  • 14. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Cette routine oriente le programme vers la routine INIT_RS_232 (fonction 0), SEND_CHAR (fonction 1), RECEIVE_CHAR (fonction 2), ou STATUS_MODEM (fonction 3). On prend comme exemple le cas oû la carte sélectionnée est COM1, dont le port est situé à partir de 2F8. Subroutine STATUS_MODEM ; Pointe sur le registre détat de la ligne (2FD)DX = DX + 5 ADD DX,+05 ; Lecture du registreLecture du registre et stocke IN AL,DXloctet dans AL. ; On le met de côtéAH = AL MOV AH,AL ; Maintenant, pointe le registre détat de la ligneDX = DX + 1 INC DX ; Lecture du registreLecture du port de base + 6 IN AL,DXet stocke loctet dans AL. ; Fin ...Fin de sous-programme. RET Subroutine SEND_CHAR ; Met de côté loctet à envoyerCL = AL MOV CL,AL ; Pointe sur le registre de contrôle des signaux modemDX = DX + 4 ADD DX,+04 ; Met à 1 les bits RTS (demande pour émettre) et DTR (ordinateur prêt)AL = 03 MOV AL,03Ecrit 3 = 00000011 = AL OUT DX,ALdans le registre. ; Pointe sur le registre détat des signaux modemDX = 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,30Appel du sous-programme CALL STATUSSTATUS.Si pas égal alors saut au sous JNZ SSPROG1programme SSPROG1. ; Pointe sur le registre détat de la ligne Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 14 / 109
  • 15. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurDX = DX - 1 DEC DX ; Si le bit 1 du registre pointé (écrasement de donnée) pas à 1 alors on sort en se branchant à SSPROG1.BH = 20 MOV BH,20Aappel du sous-programme CALL STATUSSTATUS.Si pas égal alors saut au JNZ SSPROG1sous-programme SSPROG1. ; Pointe sur le registre de réception et de transmission de données.DX = DX - 5 SUB DX,+05 ; Envoi loctet à envoyer qui a été mis de côté au début du sous- programme.AL = CL (retour à la valeur MOV AL,CLinitiale de AL)Sortie du caractère contenu OUT DX,ALdans AL sur le port de base. ; Et voilà, cest fini ...Fin de sous-programme. RET Subroutine RECEIVE_CHAR ; Pointe sur le registre de contrôle des signaux modemDX = DX + 4 ADD DX,+04 ; Met à 1 le bit DTR (ordinateur prêt)AL = 1 MOV AL,01Ecriture de 1 sur le port de OUT DX,ALbase + 4. ; Pointe sur le registre détat des signaux modemDX = DX + 2 ADD DX,+02 ; Teste si le bit Modem Prêt est à 1 ou nonBH = 20 MOV BH,20Appel du sous-programme CALL STATUSSTATUS.Si pas égal alors saut au JNZ SSPROG1_1sous-programmeSSPROG1_1. ; Pointe sur le registre détat de la ligneDX = DX - 1 DEC DX ; Teste si un caractère est disponible ou nonBH = 1 MOV BH,01Appel du sous-programme CALL STATUSSTATUS. Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 15 / 109
  • 16. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurSi pas égal alors saut au JNZ SSPROG1_1sous-programmeSSPROG1_1. ; Pointe sur le registre de réception et de transmission de données.DX = DX - 5 SUB DX,+05 ; Adapter loctet détat à la situation : forcer à 0 les bits 0 et 5 à 7 de loctet détatEt entre AH et 1E AND AH,1E ;(00011110) => remise à zérodes bits 0, 5 à 7. ; Lecture de loctet contenu dans le portLit le port de base et stocke IN AL,DXloctet en AL. ; Fin ...Fin de sous-programme. RET Subroutine SSPROG1AH = CL MOV AL,CL JMP SSPROG1_1 Subroutine SSPROG1_1 ; Mise à 1 du port 80Ou entre AH et 80 OR AH,80(10000000). ; Fin de la routineFin du sous-programme. RET Subroutine STATUS ; Lecture de loctet de Time_Out correspondant à la carteBL = contenu de ladresse ; MOV BL,[DI+007C][47C + numéro de la carte] ; On sauvegarde les registres modifiés par cette routineEmpile DX. PUSH CX ; On initialise le compteur de boucle REPRISE :CX = 0 SUB CX,CX BOUCLE : ; Lecture du registre détat sélectionnéLecture du port de base et IN AL,DXstocke loctet lu dans AL. MOV AH,AL ; AH = AL Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 16 / 109
  • 17. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur ; Si les bits (indiqués dans BH) du registre détat lu sont à 1 alors cest la fin du sous-programme.Et entre AL et BH. AND AL,BHEst-ce que AL = BH ? CMP AL,BHSi oui, alors saut à JZ FIN_STATUSFIN_STATUS => fin de sous-programme. ; On recommence au point marqué BOUCLESaut à BOUCLE tant que CX LOOP BOUCLEdifférent de 0 décrémenteCX. ; 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 = 0Si BL est différent de 0, on va JNZ REPRISEà REPRISE. ; On restaure la valeur de BXBX = BX + 1 INC BX ; Arrivé ici, on CX = BL = 0 ; Fin du sous-programme ... FIN_STATUS :Dépile. POP CXFin de sous-programme. RET Applications Assembleur Fonction 00 : Initialisation du port série. init :Sélection du port COM1. MOV DX,0Octet de configuration. MOV AL,11010111BInitialisation du port. MOV AH,0Série COM1. INT 14 RET Fonction 01 : Transmission de caractère. send :Sélection du port COM1. MOV DX,0Pour envoyer le caractère de MOV AL,48code ASCII 48.Fonction transmission de MOV AH,01caractère ... Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 17 / 109
  • 18. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur... par linterruption 14 INT 14 RET Fonction 02 : Réception dun caractère. receive :Sélection du port COM1. MOV DX,0Lecture de loctet reçu. MOV AH,02Sur le port COM1. INT 14Fin de la routine. RET Fonction 03 : Prêt à émettre ? send_? :Pour COM1. MOV DX,0Fonction de lecture de létat. MOV AH,3Appel de linterruption. INT 14Masque AND AH,01000000BVrai MOV AX,1Saut à la fin JNZ finFaux DEC AL ... fin :Fin de la routine RET Fonction 03 : Caractère reçu ? receive_? :Sélection du port COM1 MOV DX,0Fonction lecture de létat MOV AH,03Appel de linterruption INT 14Masque pour caractère reçu AND AH,01Vrai MOV AX,1Saut JNZ finFaux 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,0Initialisation du port série. MOV AH,0En 1200 bauds, sans parité, MOV AL,10000011B1 bit darrêt, sur 8 bits INT 14 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 18 / 109
  • 19. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur entrée :Entrée dun caractère ... MOV AH,0... au clavier INT 16Si on a entré $ alors on ... CMP AL,$... arrête là JNZ envoiFin ... RET envoi :Nombre maximum dessais. MOV CX,15 encore :Transmission du caractère. MOV AH,1Frappé au clavier. INT 14En cas de problème, ... TEST AH,80... On remet ça ! Pas plus de LOOPZ encore15 fois tout de même.Si le compteur dessais est à CMP CX,00.Cest quil y a une erreur ! JZ erreurSinon, on reprend au JMP entreecaractère suivant. erreur :Fin de la routine. RET Langage C Fonction 01 : Envoi dun 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 dun caractère. Unsigned Char Input () { Unsigned Char C; Int Var; Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 19 / 109
  • 20. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Union REGS InRegs, OutRegs;Sélection du port COM1 InRegs.x.dx = 0;Réception de caractère InRegs.h.ah = 2; Var = Int86 (20,&InRegs,&OutRegs); OutRegs.h.ah = 0; Return (c=OutRegs.h.al); } Fonction 03 : Prêt à recevoir ? Int Input_Ready (); { Int Var, Bool; Union REGS InRegs, OutRegs;Sélection du port COM1 InRegs.x.dx = 0;Eétat du port InRegs.h.ah = 3; Var = Int86(20,&InRegs,&OutRegs); If (OutRegs.h.ah & 01) Bool = 1; Else Bool = 0; Return (Bool); } Fonction 04 : Prêt à émettre ? Int Output_Ready (); { Int Var, Bool; Union REGS InRegs, OutRegs;Ssélection du port COM1 InRegs.x.dx = 0;Etat du port InRegs.h.ah = 3; Var = Int86(20,&InRegs,&OutRegs); If (OutRegs.h.ah == 1) Bool = 0; Else Bool = 1; Return (Bool); } Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 20 / 109
  • 21. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurComparaison langage dassemblage / 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 quune instruction dun langage évolué est équivalente à plusieurs instructions en langage dassemblage, la productivité dun programmeur en langage évolué est dautant supérieure à celle dun programmeur en langage dassemblage. 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 dexé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 davoir une vue plus globale des problèmes et peut ainsi obtenir des améliorations de performance spectaculaires, tandis quen langage dassemblage, on essaie de jongler sur des micro-secondes. Pourquoi conserver le langage dassemblage ? • pour pouvoir ré-écrire une partie critique dun programme • parfois, le langage dassemblage est le seul langage disponible • un compilateur peut parfois produire de lassembleur 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 lassembleur ?) - Le symbole est-il ou non accesible en dehors de la procédure. Table des codes opératoires : • Code opération : - symbolique Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 21 / 109
  • 22. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur - hexadécimal • Longueur des instructions en octets • Classe dinstructions (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 = 99Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 22 / 109
  • 23. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Then Begin Encore := False; { Finir; } Preparer_Entree_Passe2; Trier_Table_Identificateurs; Epurer_Indentificateurs_Redondants; End; End; End; End; Procedure Deuxieme_Passe; Var Compteur_Emplacementn Classe, Longueur, Valeur : Integer; Encore : Boolean; Identificateur, Symbole, OpCode : Array [1..20] Of Integer; Ligne : String [80]; Begin Compteur_Emplacement := 0; Encore := True; { Initialisation_Des_Tables; } While Encore Do Begin Prendre_Instruction (Ligne); { Lire_Instruction (Ligne); } { Garder_Pour_Passe_2 (Ligne); } If Pas_Commentaire (Ligne) Then Begin { Tester_Symbole (Ligne, Symbole); } { If Symbole [1] <> } { Then Entrer_Symbole (Symbole, Emplacement); } { Chercher_Indentificateur (Ligne, Indentificateur); } { If Identificateur [1] <> } { Then Entrer_Indentificateur (Identificateur); } Extraire_Operateur (Ligne, OpCode); Chercher_Operateur (OpCode, Classe, Valeur); If Classe < 0 Then Essayer_Pseudo_Instruction (OpCode, Classe, Valeur); Longueur := 0; If Classe < 0 Then Erreur_Operateur; Case Classe Of 0 : Longueur := Type0 (Ligne); 1 : Longueur := Type1 (Ligne); End; Assembler_Morceaux (Code, Classe, Valeur, Operande); Sortir_Code (Code); Compteur_Emplacement := Compteur_Emplacement + Longueur; If Classe = 99 Then Begin Encore := False; Finir;Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 23 / 109
  • 24. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur { Preparer_Entree_Passe2; } { Trier_Table_Identificateurs; } { Epurer_Indentificateurs_Redondants; } End; End; End; End; Erreurs les plus courantes en langage dassemblage • symbole non défini • plusieurs définitions de symbole • nom de code opératoire invalide • pas assez (ou trop) dopérandes compte tenu du code opération • nombre octet contenant un 8 ou un 9 • utilisation dun registre interdite (exemple : saut vers un registre) • pas dinstruction ENDEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 24 / 109
  • 25. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurRoutines dintérêt général Modifier une fonction dune interruption.Pour modifier la fonction 0 CMP AH,00par exemple.On exécute la nouvelle JZ modiffonction. PUSHFPour les autres fonctions, CALL ancien_INT_17rien de nouveau. IRET modif : ... nouvelle fonction ... IRET Modifier ladresse dune pile debut_pile_off DW ? debut_pile_seg DW ?Offset de ladresse de la XCHG SP,CS:debut_pile_offnouvelle pile. MOV AX,SSSegment de ladresse de la XCHG AX,CS:debut_pile_segnouvelle pile. MOV SS,AX STI RET ; Et maintenant, retour à la normale. CLIOffset de ladresse de XCHG SP,CS:debut_pile_offlancienne pile. MOV AX,SSSegment de ladresse de XCHG AX,CS:debut_pile_seglancienne pile. MOV SS,AX Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 25 / 109
  • 26. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur STI RET Interruption 08H Lecture de lheure sur lhorloge Note : heures, minutes, secondes doivent être remplacées par trois adresses différentes ; Initialisation : lecture de TIMER_HIGH et TIMER_LOWSrtout conserver DS PUSH DSSélection du segment 40 pour MOV AX,40...... accès à la zone de MOV DS,AXcommunication du BIOS.TIMER_HIGH est situé en MOV DX,[6E]0046ETIMER_LOW est situé en MOV AX,[6C]0046C POP DS ; Calcul des heures.65520 = heure - 60*60*18,2 MOV BX,65520DX contient le reste, et AX le DIV BXquotient de la division deDX,AX par BX (65520) AHest forcément nul, comptetenu du fait que le nombredheures est limité à 24 !)HEURES contient lheure de MOV heures,ALlhorloge. ; Calcul des minutes.On soccupe maintenant du MOV AX,DXreste.DX = 0 SUB DX,DXBX = 1092 MOV BX,1092Division du reste (DX,AX) DIV BXpar 1092 afin dobtenir lenombre de minutes (AX).AH est forcément nul, puis MOV minutes,ALque le nombre de minutes estlimité à 60.MINUTES contient lesminutes de lhorloge. ; Calcul des minutes.Reste dans AX MOV AX,DX Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 26 / 109
  • 27. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurBL = 18 (au lieu de 18,2 MOV BL,18pour être plus précis)Idem mais divisé cette fois DIV BLpar 18AL contient le nombre de MOV secondes,ALsecondes de lhorloge ; et voilà, cest fini ... RET Interruption 10H Fonction 00h - Sélection de mode daffichageMODE = numéro du mode MOV AL,modedaffichageFonction 0 ... MOV AH,00... de linterruption 10H INT 10 RET Fonction 01h - Sélection du format du curseurLIGNE_DEBUT indique la MOV CH,ligne_debutligne de début du curseur MOV CL,ligne_fin Interruption 11h Détermination de la configuration ; Stocker le mot de configuration dans AXAppel de linterruption INT 11H ; On soccupe de loctet de poids faible (AL). Le bit 0 concerne la présence ou labsence dunité de disquette.AX est le mot de MOV BL,ALconfigurationOn ne garde que le bit 0 AND BL,1DISK prend la valeur 0 sil MOV disk,BLny a pas dunité de disquette,ou 1 sil en a au moins une.Décalage dun bit à droite SHR AX,1puisque linformationprécédente occupe 1 bit (depoids faible). ; Le bit 1 concerne la présence ou non du co-processeur 8087. MOV BL,AL AND BL,1 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 27 / 109
  • 28. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurCo-processeur arithmétique MOV coproc,BL8087 présent ou non ? 1 pouroui, 0 pour nonDécalage dun bit à droite SHR AX,1 ; Les bits 2 à 3 indiquent la quantité de mémoire présente sur la carte système. MOV BL,ALOn ne garde que les bits 2 et AND BL,33MEM indique la quantité de MOV mem,BLmémoire sur la carte système MOV CL,2Décalage de deux fois à SHR AX,CLdroite ; Les bits 4 et 5 indiquent la carte vidéo initiale MOV BL,ALOn ne garde que les bits 4 et AND BL,35VIDEO indique le mode MOV video,BLvidéo commuté lors de lamise en route de lordinateurEncore décalage de deux bits SHR AX,CLà droite ; Les bits 6 et 7 indiquent le nombre dunités de disquettes présentes. MOV BL,ALOn ne conserve que les bits 6 AND BL,3et 7.DISKS indique le nombre MOV disks,BLdunités de disquettesprésentesCette fois, décalage de MOV CL,3trois ...... bits car le bit 8 est SHR AX,CLinutilisé les bits 9 à 11indiquent le nombre desorties RS-232 présentes. MOV BL,ALOn ne conserve que les bits 9 AND BL,7à 11.RS232 indique le nombre de MOV rs232,BLsorties séries installéesDécalage de trois bits à SHR AX,CLdroite le bit 12 indique laprésence ou non dunemanette de jeu Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 28 / 109
  • 29. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur MOV BL,ALOn ne conserve que le bit 12 AND BL,1JOYST vaut 1 sil y a une MOV joyst,BLmanette de jeu, 0 sinon MOV CL,2Décalage de deux bits à SHR AX,CLdroite puisque le bit 13 estinutilisé ; Les bits 14 et 15 indiquent le nombre dimprimantes connectées. Il ny a plus dinformations après, tous les bits à gauche sont donc à 0.PRINTER indique le nombre MOV printer,ALdimprimantes connectées RET Interruption 12HDéclenchement de INT 12 ;linterruption (déterminationde la taille mémoire) sanspasser aucun paramètre.E sortie, AX contient le MOV mem,AXnombre de K contenus sur lacarte système. RET Interruption 16H Fonction 01h - Y a-t-il un caractère dans le buffer ? MOV AH,1 INT 16 JE vide JMP réaction Interruption 17h Fonction 00h - Imprimer un caractère en testant si tout sest bien passéNuméro de limprimante MOV DX,00Appel de la fonction 0 ... SUB AH,AH... de linterruption 17H : INT 17 ;impression du caractère.En cas derreur, ... JNZ erreur... ça continue ... ... pas derreur ... Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 29 / 109
  • 30. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Limprimante est-elle prête ?DX = n° de limprimante MOV DX,00Sélection de la fonction 02 ... MOV AH,02... de linterruption 17H : INT 17lecture de loctet détat delimprimante.90H = 10010000 CMP AH,90Va à PAS_PRETE si elle JZ pas_prêtenest pas prête ...Si elle est prête, ça ... ;continue... Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 30 / 109
  • 31. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurRé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 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 31 / 109
  • 32. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 33 MN//MX 34 /SS0 35 A19/S6 36 A18/S5 37 A17/S4 38 A16/S3 39 A15 40 +5V Registres et instructions Registre/Instruction Description Registres généraux AX (AH+AL) Accumulateur BX (BH+BL) Base CX (CH+CL) Compteur DX (DH+DL) Donnée SP Pointeur de pile BP Pointeur de base SI Index source DI Index destination Registres de segmentation CS Segment du code DS Segment des données SS Segment de la pile ES Segment extra IP Pointeur dinstruction Registres détat et de contrôle CF Retenue PF Parité AF Retenue auxiliaire ZF Zéro TF Piège IF Autorisation dinterruption DF Indicateur de direction OF Débordement SF Signe Modes dadressage Immédiat MOV BL,FFh De registre MOV AX,BX Direct MOV AX,constante avec adresse = DS:constante Indirect de registres MOV BX,[SI] avec adresse = 16 * DS + SI Indirect de registre avec MOV AX,constante [DI] avec adresse = 16 * DS + déplacement constante + DI Indirect de registre avec registre MOV AX,[BX] [DI] avec adresse = 16 * DS + BX de base et registre dindex + DIEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 32 / 109
  • 33. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Indirect de registre avec registre MOV AX, constante [BX] [SI] avec adresse = 16 * de base, dindex plus constante DS + constante + BX + SI Addition AAA Ajustement ASCII pour addition ADC Addition avec retenue ADD Addition sans retenue DAA Correction décimale pour addition INC Incrément de un Division AAD Ajustement ASCII pour division DIV Division non signée. Si octet, division de AX, AH=quotient, AL=reste. Si mot, division de DX,AX,AX=quotient, DX=reste IDIV Division signée. Si octet, division de AX, AL=quotient, AH=reste. Si mot, division de DX,AX,AX=quotient, DX=reste Multiplication AAM Ajustement ASCII pour multiplication IMUL Multiplication signée. Si octet, AX=AL*source. Si mot, DX,AX=AX*source MUL Multiplication non signée. Si octet, AX=AL*source. Si mot, DX,AX=AX*source Soustraction AAS Ajustement ASCII pour soustraction DAS Correction décimale pour soustraction DEC Décrémente le registre ou la mémoire SBB Soustraction avec retenue. Si CF=1, dest=dest- source-1. Si CF=0, dest=dest-source SCAS Soustrait la chaîne pointée par DI de laccumulateur. 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 doctet 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 dune 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ésEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 33 / 109
  • 34. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur STOS Charge laccumulateur vers la chaîne pointée par DI. DI incrémenté XCHG Echange le contenu des deux opérandes XLAT Echange laccumulateur 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 dinstruction au co-processeur HLT Mise à larrêt du 8088 IN Lecture dun port dans laccu INT Déclenche une interruption INTO Déclenche une interruption si OF=1 IRET Retour dinterruption LOCK Vérrouillage du bus NOP Aucune opération OUT Ecriture sur un port dE/S CALL Appel de sous-programme. Sil est éloigné, CALL [FAR], sinon [NEAR] JA Saut si supérieur / CF=0, ZF=0 JAE Saut si supérieur ou égal / CF=0 JB Saut si inférieur / CF=1 JBE Saut si inférieur ou égal / CF=1, ZF=1 JC Saut si retenue / CF=1 JCXZ Saut si CX=0 JE Saut si égal / ZF=1 JG Saut si plus grand / SF=OF, ZF=0 JGE Saut si supérieur ou égal / SF=OF JL Saut si inférieur / SF<>OF JLE Saut si inférieur ou égal / SF<>OF ou ZF=1 JMP Saut inconditionnel. CS et IP mis à jour JNA Saut si non dupérieur / CF=1, ZF=1 JNAE Saut si non supérieur ou égal / CF=1 JNB Saut si non inférieur / CF=0 JNBE Saut si non inférieur ou égal / CF=0, ZF=0 JNC Saut si CF=0Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 34 / 109
  • 35. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur JNE Saut si non égal / ZF=0 JNG Saut si non supérieur / SF<>OF ou ZF=1 JNGE Saut si non inférieur ou égal / SF<>OF JNL Saut si non inférieur / SF=OF JNLE Saut si non inférieur ou égal / SF=OF, ZF=0 JNO Saut si pas de déébordement / OF=0 JNP Saut si pas de parité / PF=0 JNS Saut si SF=0 JNZ Saut si non zéro / ZF=0 JO Saut si OF=1 JP Saut si parité paire / PF=1 JPE Saut si parité égale / PF=1 JPO Saut si parité impaire / PF=0 JS Saut si SF=1 JZ Saut si zéro / ZF=0 RET Retour de sous-programme TEST Et logique / CF=0, OF=0; indicateurs mis à jour Boucle LOOP Boucle tant que CX<> 0. Décrémente CX LOOPE Boucle tant que égal et CX<>0 / ZF=1. Décrémente CX LOOPNE Boucle tant que non égal et CX<>0 / ZF=0. Décrémente CX LOOPNZ Boucle tant que non zéro et CX<>0 / ZF=0. Décrémente CX LOOPZ Boucle tant que zéro et CX<>0 / ZF=1. Décrémente CX REP Répéter tant que CX<>0 REPE Répéter tant quégal / ZF=1 REPNE Répéter tant que non égal / ZF=0 REPNZ Répéter tant que non zéro / ZF=0 REPZ Répéter tant que zéro / ZF=1 Pile POP Dépile un registre général POPF Dépile vers le registre dindicateur PUSH Empile un registre Rotation RCL Rotation de n bits vers la gauche à travers lindicateur de retenue RCR Rotation de n bits vers la droite à travers lindicateur de retenue ROL Rotation de n bits vers la gauche ROR Rotation de n bits vers la droite Décalage SAL Décalage arithmétique de n bits vers la gauche; des zéros sont introduits à droiteEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 35 / 109
  • 36. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur SAR Décalage arithmétique de n bits vers la droite; le bit de poids fort dorigine 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 à gaucheEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 36 / 109
  • 37. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurLes 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 quil y a décrit sur une disquette, vous pouvez lire, le plus souvent : • double face • Le stockage est fait sur les deux faces. • double densité La densité décriture est de 40 pistes par face (ou 48 Tracks Per Inch = 48 TPI). Si une disquette est organisée par soft, la division en secteurs est faite pendant le formatage. Une fois formatée, une disquette de 360 Ko contient les informations suivantes : • 40 pistes • 1 piste = 9 secteurs • 1 face = 360 secteurs • 1 secteur = 512 octets • 1 disquette = 2 faces * 9 secteurs * 40 pistes * 512 octets • soit 1 disquette = 368.640 octets De plus, la disquette est numérotée de façon continue et de la façon suivante : Face 0 de la disquette 0 1 2 3 4 5 6 7 8 Piste 0 0 1 2 3 4 5 6 7 8 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 37 / 109
  • 38. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Piste 1 18 19 20 21 22 23 24 25 26 Piste 2 36 37 38 39 40 41 42 43 44 Piste 39 702 703 704 705 706 707 708 709 710 Face 1 de la disquette 0 1 2 3 4 5 6 7 8 Piste 0 9 10 11 12 13 14 15 16 17 Piste 1 27 28 29 30 31 32 33 34 35 Piste 2 45 46 47 48 49 50 51 52 53 Piste 39 711 712 713 714 715 716 717 718 719 Note importante : un cluster est la plus petite zone de stockage que prend un fichier pour être stocké. Un cluster représente un groupe de deux secteurs, soit 1024 octets. Ainsi, un fichier de 1 octet occupera 1024 octets = 1 cluster ! Une disquette contient 354 clusters. Après formatage dune disquette, la disquette se découpe comme suit : Secteur Contenu secteur 0 Zone dinitialisation (Boot Sector) secteur 1-4 Table dallocation 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 dinitialisation ( Boot Sector) Ce secteur est le premier secteur chargé, avant même le SED lui-même. Cest le Bootstrap (en ROM) qui le charge. Il contient : • le nom du fabricant • le numéro de la version du SED • quelques messages derreur (à la fin) Le 15ème octets (hexa) contient linformation 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 dallocation de fichiers (FAT = File Allocation Table) La FAT soccupe de stocker les informations concernant la place occupée par un fichier, ainsi que les clusters occupés par ce fichier. Plus une disquette a de clusters, plus la FAT doit être grande.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 38 / 109
  • 39. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur En théorie, les fichiers devraient être stockés sur des clusters qui se suivent. En pratique, à cause des fichiers effacés ou des fichiers qui grossissent, ils peuvent parfaitement être dispersés sur toute la disquette. Le cluster de départ est indiqué dans le répertoire. Une zone de stockage libre est repérée par la valeur 0. Secteur 5-11 - Répertoire (Directory) Tous les fichiers (sauf les sous-répertoires) sont mentionnés, avec différents paramètres. Chaque fichier occupe 32 octets, et une disquette 360 Ko autorise au maximum 112 entrées, ce qui représente sept secteurs. Les 32 octets réservés à chaque fichier sont représentés comme suit : Octets Description 0à7 Nom du fichier : huit caractères au maximum 8 à 10 Etension du fichier (ou suffixe, ou nom de famille) : trois caractères au maximum 11 Attribut. Il définit si le fichier est : caché, archive, protégé, nom du disque (volume), protégé en écriture, sous-répertoire (fichier de longueur 0) 12 à 21 Réservé au DOS 22 et 23 Heure de création 24 et 25 Date de création 26 et 27 Pemier cluster du fichier 28 à 31 Taille du fichier Note : les fichiers effacés sont repérés par le fait que le premier caractère de leur nom vaut E5 (hexa) ou 229 (décimal). Mais parallèlement, la FAT est mise à jour. Le disque dur Un disque dur, lors du formatage, est divisé en : • secteurs • pistes • cylindres Un disque dur peut être assimilé à un ensemble de plusieurs disquettes. Un cylindre représente alors une division dans le sens vertical. Les capacités de stockage dépendent du disque dur employé. Lorganisation dune disquette Présentation Après formatage dune disquette, la disquette se découpe comme suit (les pistes sont numérotées de 0 à 39, et les secteurs de 1 à 9) :Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 39 / 109
  • 40. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Piste 0 : secteur 1 Zone dinitialisation (Boot Sector). 1 secteur. secteur 2-5 Table dallocation de fichiers (FAT = File Allocation Table). 2 secteurs. 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 lon est en présence dune disquette système (avec /S) ou non système (sans /S) : xF nb secteurs/piste capacité capacité sans /S 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 lordre : piste n, piste n+1, piste n+2, ... Les lecteurs DF dans lordre : 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 dentrée, redirigeable 0001 unité standard de sortie, redirigeable 0002 unité standard derreur, non redirigeable 0003 unité auxiliaire standard 0004 unité dimpression standard 0005 premier fichier ouvert après le boot Zone dinitialisation, Boot Sector Secteur 1Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 40 / 109
  • 41. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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. Cest 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 derreur (à la fin) 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 dun secteur. Nombre doctets par secteur. 0D Taille dun cluster (unité dallocation). 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 dentré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 dune 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 dallocation de fichier, FAT = File Allocation Table Secteur 2-5 La FAT soccupe 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.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 41 / 109
  • 42. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 dun accès à un fichier, la FAT est chargée en mémoire tampon. Elle indique alors létat de chaque unité dallocation (cluster) afin de gérer lespace de sauvegarde et de regrouper lensemble des clusters. Entrée Octets Description 1 0-1,5 Caractérisique de lunité. = 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) Entrées suivantes de la FAT. (1,5 octet à la fois) = 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).Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 42 / 109
  • 43. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 00 Etat de lentrée. = 00 : vierge, fin du répertoire, = 2E : pointe un sous-répertoire; si loctet 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 !). 0B Attribut. = 00 : fichier normal (en lecture et écriture), = 01 : fichier en lecture seule (Read Only), = 02 : fichier caché (non affiché lors dun DIR), = 04 : fichier système (non affiché lors dun 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 loctet 16 : secondes, Bits 5-8 de loctet 16 : minutes, Bits 0-2 de loctet 17 : minutes Bits 3-8 de loctet 17 : heures. 18-19 Date de création. Bits 0-4 de loctet 18 : jour, Bits 5-8 de loctet 18 : mois, Bits 0 de loctet 19 : mois, Bits 1-8 de loctet 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 linstruction INT 20H (fin dexécution de programme). Pour la compatibilité avec CP/M. 02-03 Limite supérieure de la mémoire. 04 Réservé. 05-09 Point dentrée secondaire. Pour la compatibilité avec CP/M. 0A-0D Adresse de la routine de fin dexé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 denvironnement.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 43 / 109
  • 44. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 2E-2F Routine dappel des fonctions DOS à travers un CALL FAR. 30-4F Réservé. 50-52 Point dentrée auxiliaire. 53-5B Réservé. 5C-7F Contient un FCB (File Control Bloc). 54 Indicateur de lunité (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 lenregistrement courant. 61-62 Taille des enregistrements en octets (128 en standard). Nombre doctets à transférer lorsquun 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 loctet 14 : jours, Bits 5 à 7 de loctet 14 et bit 0 de loctet 15 : mois, Bits 1 à 8 de loctet 15 : année moins 1980. 71-72 Heure de création ou de la dernière écriture du fichier. Bits 0 à 4 de loctet 16 : secondes, Bits 5 à 7 de loctet 16 et bits 0 à 2 de loctet 17 : mois, Bits 3 à 8 de loctet 17 : heures. 73-7A Réservé. 7B Emplacement dun des 128 enregistrements du bloc courant. 7C-7F Position de lenregistrement actuellement sélectionné à partir du début du fichier. F9-FF Extension du FCB.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 44 / 109
  • 45. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur F9 Contient FF pour indiquer la présence dun 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.LIBM PC/XT jusquà ses racines LIBM PC/XT est équipé dun micro-processeur 8 bits (binary digit) Intel 8088. Cest un pseudo 16 bits, cest-à-dire darchitecture dun 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. LIBM a opté pour les codes ASCII (de 1 à 127) et il dispose en outre de codes ASCII étendu non normalisés (128 à 255). Laddition dans le système de numération binaire seffectue 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 dun nombre positif et dun 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 dun nombre positif (le paragraphe au-dessus). Présentation des éléments constituant lunité centrale de lIBM PC/XT LUnité dExécution (EU) Rôle : exécuter les instructions Effets : exécution du contenu de la file dattente Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 45 / 109
  • 46. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Interface : sortie dune adresse logique au BIU Comprend : • une Unité Arithmétique et Logique (ALU) • une Unité de Contrôle (CU) • dix registres généraux LUnité dInterface de Bus Rôle : • réalisation des échanges entre le mico-processeur et lextérieur • contrôle de linterface 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 dattente. Interface : transformation de ladresse logique fournie par le EU en adresse réelle. Comprend : • bus dadresse de 20 bits : communication entre ROM, RAM, et interface dE/S • bus de données de 16 bits : transmission de données entre lEU 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 lEU, 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 dadresse Note : Juste avant lexécution dune 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à !à linstruction suivante, doù lintroduction dune notion de file dattente. Cette dernière a une capacité de 4 octets. Ce système tient compte du fait quen général, le temps dexécution dune instruction est inférieur au temps de recherche dune autre instruction. Une autre partie très importante de lIBM PC/XT est constituée par les slots. Chaque slot comprend 62 lignes de connexion en parallèle, que lon appelle également des canaux dE/S (Input/Output Channel). • 8 lignes de données bidirectionnelles • 20 lignes dadressageEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 46 / 109
  • 47. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • 6 lignes de niveau dinterruption • 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 Larchitecture générale de lIBM PC/XT est la suivante : • 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 dentrées-sorites (contrôleur DMA, monochrome, ...) • slots dextensions • éventuellement un co-processeur arithmétique 8087 Parlons plus en détail du micro-processeur 8088. Le micro-processeur 8088 Le 8088, dancienne référence IAPX 88, tout en ne disposant de bus que de 8 bits, met à la disposition du programmeur des registres 16 bits. Doù sa dénomination de faux 16 bits. Ce circuit possède 20 broches sur 40 en tout pour gérer le bus dadresse. Ce bus permet donc ladressage de 1 Méga-octet de mémoire (220 = 1.048.5786 = 1 Mo). Afin daccé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 ladresse logique sous la forme Segment:Offset (déplacement). Notion de segment Un segment est un espace mémoire de 64K. La valeur de ladresse réelle (sur 20 bits) est obtenue par lopération : adresse de base (segment) * 16 + déplacement (adresse relative) 16 bits 10H 16 bits Les deux premiers termes font passer ladresse de 4 à 5 chiffres. En langage machine, il suffit dopé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 :Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 47 / 109
  • 48. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 0000:0400 équivalent à 0040:0000. Les vecteurs dinterruption Toute interruption déclenchée est transmise au contrôleur dinterruption 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 dinterruption envoit ensuite, codé sur 8 bits, à lunité dexploitation le numéro de linterruption appelée. Là est exécutée la routine de gestion dinterruption dont ladresse se trouve en (n° dinterruption * 4) dans la table des vecteurs dinterruption. En effet, chaque vecteur dinterruption est codé sur 4 octets. Ainsi, pour connaitre lemplacement dans la mémoire de ce vecteur, il suffit de multiplier par quatre le numéro de linterruption. Un point très important : lors de lappel dune interruption, le micro- processeur effectue les opérations suivantes : • SP = SP - 2 (décrémente deux fois SP) • empile lindicateur détat • SP = SP - 2 • empile CS • SP = SP - 2 • empile IP Linstruction assembleur RET utilise ces valeurs pour la poursuite du programme. On discerne trois types dinterruptions : 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 lindicateur IF est à 1 (interruption INTR autorisée); les interruptions sont interdites si IF est à 0 (interruption INTREdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 48 / 109
  • 49. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur interdite). Linstruction assembleur CLI (CLear Interrupt enable flag) met IF à 0 et STI (SeT Interrupt enable flag) à 1. Linterruption NMI (Non Masquable Interrupt) Correspond à la broche 17 du micro-processeur. Les registres détat et de contrôle sont empilés. Linterruption 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 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 TexteEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 49 / 109
  • 50. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurLarithmétique binaire Présentation Larithmétique binaire est un univers où lon effectue des calcul uniquement avec les chiffres 0 et 1, doù le mot binaire. On raisonne en fait en base 2 au lieu de la base 10 (décimale). Cest lunivers du micro- processeur. Lunivers de lhomme, cest la base 10. Mais voilà, la base 2 et 10 ne sentendent que très mal. Doù lutilisation de la base 16. Les chiffres sont alors : 0, 1, ... 9, A, B, ..., F. Lordinateur doit alors disposer de circuits capables de : • transformer les nombres hexadécimaux en nombre binaires • le contraire Il apparaît maintenant évident quil sera nécessaire de maîtriser la logique binaire afin de comprendre comment fonctionne les entrailles dun 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 nimporte quels autres nombres. On rencontre en informatique : • le binaire : utilisation de deux chiffres • loctal : utilisation de huit chiffres • le décimal : utilisation de dix chiffres • lhexadé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) Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 50 / 109
  • 51. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • le chiffre b est dans la colonne des dizaines, et représente donc la quantité c * 10 (poids 10) • 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 laffecter 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 quau-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 quun nombre est négatif, on place un moins devant ce nombre. Il est codé en binaire à laide du bit de signe. On parle dun nombre binaire signé. Ce bitEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 51 / 109
  • 52. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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. Laddition binaire 0+0=0 0+1=1 1+0=1 1 + 1 = 1 plus 1 de retenue Addition dun 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 Lorsquon multiplie 10 par 4, on addition 4 fois le nombre 10. De même, lorsquon 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) ------- 12Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 52 / 109
  • 53. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 12 décalage ------- 132 addition Même chose, mais en binaire, en remarquant que 12 = 1100 et 11 = 1011 : 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 sagit 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 quun ensemble de conditions est réuni. En logique séquentielle, il y a mémorisation de laction 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. • Cest exactement linverse.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 53 / 109
  • 54. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 quen règle générale, cest 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 dun circuit logique, exactement comme sil sagissait dune porte. Une porte logique obéit à une règle primordiale : si les conditions ne sont pas réunies, la porte est fermée. A linverse, elle est ouverte. La porte ET Les interrupteurs A et B sont les variables dentré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 dentré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 ny a pas dexclusivité au niveau des variables dentrée puisque une seule sortie est à 0, et ce quelque soit le nombre de variables dentrée à 1. • une porte OU en logique positive devient une porte ET en logique négative. Linverse est vrai. Linverseur NONEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 54 / 109
  • 55. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur A est la seule variable dentrée. Linverseur réalise donc la fonction logique NON, cest-à-dire quil délivre en sortie le complément du signal dentré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 Les interrupteurs A et B sont les variables dentré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 dentré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 dentré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 1Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 55 / 109
  • 56. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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, cest lopération logique qui est à la base de ladditioneur binaire. Fonction coïncidence (ou comparateur) Les interrupteurs A et B sont les variables dentré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 nest vrai que si les deux variables dentrée sont identiques. Cette porte permet donc la comparaison de deux variables logiques A et B. Equation : X = A + B 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 dune adresse de la mémoire parmi un ensemble important dadresses. Le principe est le suivant. Pour quune 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 laiguillage sur une sortieunique dun signal prélevé parmi plusieurs autres de nature différente. Il remplit, en gros, la fonction inverse dun décodeur. Ladditioneur complet Un additioneur complet est un circuit capable deffectuer laddition de deux variables binaires A et B, auxquelles se rajoute une éventuelle retenue provennat dune opération précédente. A et B sont les deux variables logiques à additioner, C la retenue provenant dune colonne précédente, C0 la retenue de laddition, et X la variable de sortie. Interruption 21h Fonction 09h - Affichage dune chaîne de caractèresEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 56 / 109
  • 57. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurDX pointe sur ladresse où MOV DX,messageest stocké le message àafficher à lécranSsélection de la fonction MOV AH,09daffichage de chaîne decaractèresde linterruption des INT 21Hfonctions MS-DOSFin RET message : DB 0D,0A,"Ca marche !$" Fonction 0Ah - Lecture dune ligne au clavierLimite à 80 caractères (en MOV buffer,80décimal)DX pointe sur ladresse de MOV DX,bufferdébut du bufferSélection de la fonction MOV AH,0Alecture dune ligne au clavier...... de linterruption des INT 21fonctions MS-DOSBX contient le nombre de MOV BX,buffer[1]caractères entrésIndicateur de fin de chaîne MOV buffer[BX+2],00pour un affichage éventuelFin RET Fonction 12 - Vider le buffer du clavierFonction 12H ... MOV AH,12... de linterruption 21h INT 21 RET Fonction 25 - Installer une nouvelle interruptionSsegment courant MOV AX,CS MOV DS,AXNouveau offset MOV AX,100Numéro du segment MOV DX,AXAppel de la fonction 25H MOV AH,25de ...... linterruption 21h INT 21 RET Fonction 3Dh - Création de répertoire Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 57 / 109
  • 58. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurDX contient loffset de MOV DX,ligneladresse où se trouve le nomdu répertoireAappel de la fonction 3DH MOV AH,39de ...... linterruption 21h INT 21En cas derreur ... JC erreurSinon, tout va bien ... ... pas derreur ... ligne : DB WORD,00 Fonction 3Dh - Changement de répertoireDX contient loffset de MOV DX,ligneladresse où se trouve le nomdu répertoireAappel de la fonction 3DH MOV AH,3Dde ...... linterruption 21h INT 21Een cas derreur ... JC erreursinon, tout va bien ... ... pas derreur ... ligne : DB WORD,00 Fonction 4Ch - Rendre la main à MS-DOSPour quitter sans erreur ... MOV AL,00Appel de la fonction 4CH MOV AH,4Cde ...... linterruption 21h INT 21 Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 58 / 109
  • 59. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 59 / 109
  • 60. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurLa vidéo Attributs Définition Un attribut est la caractéristique apparaissant aux adresses impaires de la mémoire écran. Cest donc une indication au système du mode daffichage du caractère correspondant, situé à ladresse paire immédiatement précédente. Ladresse en mémoire dun point situé à lintersection de la ligne l et la colonne c est : • B0000 + 2 * (l * largeur + c) pour ladatateur monochrome, • B8000 + 2 * (l * largeur + c) pour ladatateur couleur, avec largeur valant 40 ou 80 pour respectivement les modes 40 ou 80 colonnes. Adaptateur monochrome Attribut Description 00 noir/noir -> pas daffichage, 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 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 60 / 109
  • 61. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Adaptateur graphique couleur Les attributs sont définis comme lindique 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 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 61 / 109
  • 62. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurCours d’assembleur Généralités Rappels sur le fonctionnement de l’ordinateur Voici les deux seules valeurs que lordinateur 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 ladresse relative (ou déplacement, ou offset) au début du segment de loctet. On définit alors la position dun octet par le couple (segment, offset) que lon 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 indiquent le CS, DS, SS, ES Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 62 / 109
  • 63. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur segment segment de progremme et de données les registres de contiennent des AX, BX, CX, DX travail résultats intermédiaires les registres indiquent SI, DI, IP, BP, SP doffset couplés ladresse dun aux registres de octet en mémoire segment le registre indique les états drapeau (flag en anglais) 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 lensemble + - * / = ( ) [ ] ; . ! , _ : @ $ (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 dune instruction doivent être séparés dau 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 despace. Les données Généralités Les pseudo-instructions sont des instructions que lassembleur doit faire. On distingue trois types de données : • Immédiates (400h, ...) • Constantes : définir lidentificateur et le type de la variable • Zones de mémoire Une donnée peut être : • IdentificateurEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 63 / 109
  • 64. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • Mnémonique de linstruction • Opérande • 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 dun 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 dadressage CX (Compteur Index) utilisé dans les boucles (LOOP) DX (Data indeX) utilisé lors dopé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 prochaineEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 64 / 109
  • 65. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur instruction à exécuter (CS:IP). Ne peut jamais être modifié directement ! BP (Base Pointer) offset de la pile lors de lappel de sous-programmes (CALL) (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 0 = Retenue CF indique d’état (Carry) quil y a eu retenue 2 = Parité PF indique que le résultat contient un nombre pair de 1 4 = Retenue AF auxiliaire 6 = Zéro ZF indique un résultat égal à zéro 7 = Signe SF indique un nombre négatif 11 = OF indique Débordement que le (Overflow) signe a changé alors quil ne devrait pas Registre 8 = Trap TF de contrôle 9 = Interruption IF 10 = Direction DF modifié par STD et CLD 1,5,12,13,14,15 Inutilisés.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 65 / 109
  • 66. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 lassemblage) à un identificateur (doit être défini avant). • 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 lassemblage. DB (Data Byte) Définition et initialisation de valeurs numériques ou de caractères (les séparer par une virgule sil 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" dun élément 0 abc DB 1, 2, 3 zone "abc" de trois éléments 1,2,3 inconnu DB ? zone "inconnu" dun élément (0) table1 DB 5 DUP (?) zone "table1" de 5 éléments (0,0,0,0,0)Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 66 / 109
  • 67. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur table2 DB 5 DUP (1, 2, 3, 4, zone "table2" de 5 éléments 5) (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é à laffichage texte2 DB 07, Rebonjour ! zone "texte2" de 12 caractères dont le code ASCII 07 (beep sonore) 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 lensemble des instructions. Pour cela, nous allons prendre lexemple du chargement dune 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 dun identificateur préalablement défini, soit à partir dune 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 Registre <-- La valeur immédiat valeur immédiate immédiate (constante) est placée dans le registre : MOV AX, 12h Adressage direct Registre <-- Le contenu de mémoire ladresse spécifiée (adressage direct) est placée dans le registre : MOV AX, Ident1Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 67 / 109
  • 68. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Attention : le type de la donnée et du registre doivent être les mêmes. Adressage basé Registre <-- [Bx] Le contenu de adressage basé ladresse DS:[BX] sur DS est placé dans le registre : MOV Registre <-- [BP] BX, 3 et MOV AX, adressage basé [BX]. sur SS (non montré, Attention : le type identique) de la donnée et du registre doivent être les mêmes. Adressaage Registre <-- [SI] Le contenu de indexé ou [DI] adressage ladresse DS:[SI] indexé 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 daccéder à un élément dun tableau. Très utilisé aussi pour le traitement des chaînes de caractères. Adressage indexé Registre <-- [BX] BX désigne le et basé [SI] adressage segment et SI ou indexé et basé sur DI loffset. On DS peut aussi utiliser la notation Registre <-- [BX] Registre <-- [DI] adressage [BX+SI].On a indexé et basé sur aussi : Registre DS <-- [BP][SI] adressage indexé et basé sur SS. Registre <-- [BP] [DI] adressage indexé et basé surEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 68 / 109
  • 69. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur SS Adressage basé et Registre <-- Ceci est une déplacement donnée [BX] combinaison des (direct ou adressage basé modes immédiat) sur DS dadressage précédents. Registre <-- donnée [BP] On peut aussi adressage basé noter : Registre sur SS <-- [BX + donnée] Adressage indexé Registre <-- Ceci est une et déplacement donnée [SI] combinaison des (direct ou adressage indexé modes immédiat) + déplacement dadressage précédents. Registre <-- donnée [DI] On peut aussi adressage indexé noter : Registre + déplacement <-- [SI + donnée] Adressage basé, Registre <-- Ceci est une indexé et donnée [BX][SI] combinaison des déplacement modes Registre <-- (direct ou dadressage donnée [BX][DI] immédiat) précédents. Registre <-- On peut aussi donnée [BP][SI] noter : Registre Registre <-- <-- [BX + SI + donnée [BP][DI] donnée] Enfin, il est nécessaire de spécifier à lordinateur sil doit effectuer des opérations sur 8 ou 16 bits : • si le registre est la seconde opérande, alors le nombre de bits de lopé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 dun identificateur (de forme générale Ident:) qui représente ladresse de stockage de cette instruction. On appelle cet identificateur une étiquette (label en anglais). Debut: MOV AX, 00h INC AXEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 69 / 109
  • 70. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur JMP Debut Linstruction 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 Déplace lopérande de droite dans lopérande de gauche. MOV mem, imm MOV AH, 00h MOV reg, mem Naffecte pas les indicateurs. MOV mem, reg Si un opérande est de type MOV reg, reg indéfini, MOV [AX], 00h -> MOV BYTE PTR [AX], 00h ou -> MOV WORD PTR [AX], 00h Les instructions arithmétiques DEC Décrémente de un le registre spécifié. DEC reg Ne modifie pas CF. DEC mem DEC reg <=> SUB reg, 1 ADC reg Addition et soustraction de deux nombres sur 16 bits ADC mem Voir aussi ADD et SUB. SBB reg Permet laddition et la SBB mem soustraction sur 32 bits (double précision). ADC reg Addition de deux nombres de 16 bits et ajout de la retenue. ADC mem Voir aussi ADC. Permet laddition 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 Soustraction de deux nombres de 16 bits et tient compte de la SUB mem retenue. Voir aussi SUB. Permet la soustraction sur 32 bitsEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 70 / 109
  • 71. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur (double précision). MUL reg Multiplication AX := AL * opérande (8 bits) ou DX:AX := MUL mem 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 Multiplication AX := AL * opérande (8 bits) ou DX:AX := IMUL mem AX * opérande (16 bits) Opère sur des nombres signés. CF et OF sont modifiés. Voir MUL. DIV reg Division AX := opérande * AL + AH (8 bits) ou DX:AX := DIV mem 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 Division AX := opérande * AL + AH (8 bits) ou DX:AX := IDIV mem opérande * AX + DX (16 bits) Opère sur des nombres signés. Indicateurs modifiés et indéfinis. NEG reg Calcul du complément à deux deEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 71 / 109
  • 72. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur NEG mem lopérande spécifiée. Fournit la représentation binaire négative dun 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 Addition avec retenue. En cas de débordement, le bit perdu ADD mem,imm est placé dans CF. ADD reg,mem ADD BX, 1 ADD mem,reg ADD AX, [BX + 2] ADD reg,reg INC reg Incrémentation (ajout de 1) 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 Effectue un ET logique sur les deux opérandes, le résultat est AND mem, imm placé dans la première. AND reg, mem Utilisé pour isoler certains bits AND mem, reg dun ensemble, pour remettre à AND reg, reg zéro certains bits, pour calculer le reste dune division dun nombre par un autre (puissance de 2, prendre alors pour second opérande - 1). Le second opérande est appelé masque. OR reg, imm Effectue un OU logique sur les deux opérandes, le résultat est OR mem, imm placé dans la première. OR reg, mem Utilisé pour mettre à un un ou OR mem, reg plusieurs bits dun ensemble.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 72 / 109
  • 73. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur OR reg, reg Le second opérande est appelé masque. XOR reg, imm Effectue un OU EXCLUSIF logique sur les deux opérandes, XOR mem, imm le résultat est placé dans la XOR reg, mem première. XOR mem, reg Utilisé pour remettre XOR reg, reg rapidement à zéro un registre, pour complémenter (inverser) un ou plusieurs bits dun ensemble. NOT reg Effectue un NON logique sur lopérande, le résultat est placé NOT mem dans cette même opérande. TEST reg, imm Teste la valeur dun ou de plusieurs bits dun ensemble, le TEST mem, imm résultat étant fourni par les TEST reg, mem indicateurs. TEST mem, reg CF et OF sont remise à zéro, AF TEST reg, reg est indéterminé, SF, ZF et PF sont modifiés. Exception faite pour NOT qui ne modifie aucun indicateur. 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 dun certain nombre de positions les bits dun 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 Décale les bits dun certain nombre de positions vers la SHL mem, 1 gauche (décalage logique). SHL reg, CL Seul le registre CL peut être SHL mem, CL utilisé ici. Les bits passent dabord par CF avant dêtre perdus, et les positions libérées sont remplies de zéros. SHR reg, 1 Décale les bits dun certainEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 73 / 109
  • 74. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur SHR mem, 1 nombre de positions vers la droite (décalage logique). SHR reg, CL Seul le registre CL peut être SHR reg, CL utilisé ici. Les bits passent dabord par CF avant dêtre perdus, et les positions libérées sont remplies de zéros. SAR reg, 1 Décale les bits dun certain nombre de positions vers la SAR mem, 1 droite (décalage arithmétique). SAR reg, CL Seul le registre CL peut être SAR mem, CL utilisé ici. Les bits passent dabord 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 Décale les bits dun certain nombre de positions vers la SAL mem, 1 gauche (décalage arithmétique). SAL reg, CL Seul le registre CL peut être SAL mem, CL utilisé ici. Les bits passent dabord par CF 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 quune information à la fois et lélément dépilé à un moment donné est celui qui a été empilé en dernier : cest 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 à loffset SP. A notez que cette pile est remplie à lenvers : le premier élément est situé à une adresse plus haute que le dernier élément. PUSH reg Empile lopérande. PUSH mem SP est décrémenté de 2. POP reg Dépile un élément et le copie dans lopérande. POP memEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 74 / 109
  • 75. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur SP est incrémenté de 2. MOV DS,ES est interdit => PUSH ES et POP DS PUSHF reg Même chose. PUSHF mem PUSHF naffecte pas les indicateurs, POPF les affecte. POPF reg Modifier les indicateurs : MOV AX, drapeau et PUSH AX et POPF mem POPF. Les instructions de manipulation de chaînes de caractères La chaîne source se trouve dans le segment DS et à loffset SI. La chaîne destination se trouve dans le segment ES et à loffset 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 loctet de DS:SI vers ES:DI. Après exécution, SI et DI sont 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 Répéte linstruction précédente CX fois. REP MOVSW Valable que pour les opérations REP ... 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 defEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 75 / 109
  • 76. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur INC DI long EQU $- Texte2 CMPSB Comparaison de chaînes de caractères pointées par DS:SI et CMPSW 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 Comparaison SCASW Compare le caractère en ES:DI avec AL Compare les deux caractères en ES:DI avec AX DI est automatiquement incrémenté (ou décrémenté) de 1 ou 2. MOV BL, ES:[DI] / CMP AL,BL / INC DI <=> SCASB LODSB Chargement dune chaine de caractères dans laccumulateur LODSW 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é) deEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 76 / 109
  • 77. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 1 ou 2. STOSB, STOSW Rangement de laccumulateur 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, lexécution continue normalement à linstruction 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 JMP mem Saut indexé. JMP table [BX] INT mem Appel dune interruption (exécution dune tâche INT imm particulière) Appelle linterruption dont le numéro figure dans lopé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.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 77 / 109
  • 78. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 lexécution dune 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 linstruction de saut, le mieux est de laisser le soin à lassembleur de nous indiquer lorsquun 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 linstruction. Enfin, ces instructions ne font que tester, sans modifier, les indicateurs. CMP reg,imm Comparaison de deux opérandes. Le résultat est placé CMP mem,imm dans les drapeaux (flags). CMP reg,mem CMP A,B <=> (B-A) CMP mem,reg Si le type des opérandes est CMP reg,reg 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.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 78 / 109
  • 79. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur JNBE etiq saut si A > B (« Jump if Not BElow ») JA etiq ou si CF = 0 et ZF = 0 (« Jump if Above ou Equal ») JNB etiq Saut si A >= B (« Jump if Not Below ») JAE etiq ou si CF = 1 et ZF = 1 (« Jump JNC etiq if Above or Equal ») ou si CF <> ZF (« Jump if Not Carry ») JBE etiq Saut A <= B (« Jump if Below or Equal ») JNA etiq ou si CF = 1 et ZF = 1 (« Jump if Not Above ») ou si CF <> ZF JB etiq Saut si A < B (« Jump if Below ») JNAE etiq ou si CF = 1 (« Jump if JC etiq Not Above or Equal ») (« Jump if Carry ») JE etiq Saut si A = B (« Jump if Equal ») JZ etiq ou si ZF = 1 (« Jump if Zero ») JNE etiq Saut si A <> B (« Jump if Not Equal ») JNZ etiq 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. JG etiq saut si A > B (« Jump if Greater ») JNLE etiq ou si ZF = 0 et OF = SF (« Jump si Not Less or Equal ») JGE etiq saut si A >= B (« Jump si Greater ») JNL etiq ou si SF = OF (« Jump si Not Less »)Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 79 / 109
  • 80. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur JNG etiq saut si A <= B (« Jump if Not Geater ») JLE etiq 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 saut si A < B (« Jump if Not Greater or Equal ») JL etiq ou si SF <> OF (« Jump if Less ») JE etiq saut si A = B (« Jump if Equal ») JZ etiq ou si ZF = 1 (« Jump if Zero ») JNE etiq saut si A <> B (« Jump if Not Equal ») JNZ etiq 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 Les indicateurs ne sont pas modifiés ! Les procédures (sous-programmes) PROC Indique le début d’un sous- programmeEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 80 / 109
  • 81. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur nom PROC NEAR ENDP indique la fin dun sous- programme nom PROC FAR LireCar PROC NEAR nom ENDP MOV AH, 00h INT 16h LireCar ENDP CALL nom Exécute le sous-programme indiqué. Une fois celui-ci CALL adresse terminé, lexécution reprendra après le CALL. LireCar PROC NEAR ... ... ... LireCar ENDP Debut: CALL LireCar ... ... ... RET Fait reprendre lexécution après linstruction qui a provoqué lexé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 variables Linstruction qui sera exécutée juste après le sous-programme sera celle qui suit lappel au sous-programme. Il faut donc empiler IP et dans certains cas (sous-programme se trouvant dans un segment différent) CS.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 81 / 109
  • 82. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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). Lordinateur 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 dun sous-programme doit être dépilé à la fin de ce même sous-programme. Sinon, IP et CS éventuellement contiendront nimporte 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 loffset dans un registre. Aucun indicateur nest 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 Charge le contenu dune adresse dans un registre et LDS reg, mem charge le contenu du mot mémoire suivant dans ES (LES) ou DS (LDS). Aucun indicateur nest modifié. Ces instructions permettent donc de charger le segment et loffset dun octet en une seule opération. Techniques de programmation Algorithmie Assembleur If AX = 1 If: CMP AX, 1 Then AX := 255 JNZ Else Else AX := 0; Then: MOV AX, 0ffhEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 82 / 109
  • 83. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur JMP EndIf Else: MOV AX, 00h EndIf:... BX := 1; MOV BX, 01h For k := 0 To 10 Do MOV CX, 00h BX := BX + k; For: CMP CX, 10d JA EndFor ADD BX, CX INC CX JMP For EndFor: BX := 5; MOV BX, 05h While BX > 0 Do While: CMP BX, 00h BX := BX + 1; JLE EndWhile DEC BX JMP While EndWhile: BX := 10; MOV BX, 10d Repeat Repeat: DEC BX BX := BX - 1; CMP BX, 00h Until lBX <=0; JG Repeat EndRepeat: ou encore : MOV BX, 00h MOV CX, 05h Repeat: ADD BX, CX LOOP Repeat FinRepeat: (nombre de répétitions connu et >= 1) Case BX Of Case1: CMP BX, 01h 1 : AX := 1; JNZ Case2 2 : AX := 3; MOV AX, 01h 3 : AX := 5; JMP FinCase Else AX := 0; Case2: CMP BX, 02h End; JNZ FinCase MOV AX, 03; JMP FinCase Autre: MOV AX, 00h FinCase: 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 dentrée, qui est la première instruction à exécuter lors de lexé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 - les paramètres en entrée et en sortie - les registres ou variables modifiésEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 83 / 109
  • 84. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur - 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 dun fichier .COM sont situées dans le même segment, ce qui porte la limite dun tel fichier à 64 Koctets. Lors du chargement dun tel fichier, Ms-Dos initialise CS, DS, SS, ES à la même valeur. SP vaut fffeh, IP 0100h (à cause de la présence dun PSP). Linstruction CS: (2Eh) signale que linstruction suivante fait référence à une donnée, le segment sera CS au lieu de DS. Ceci nest valable que pour linstruction 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 ladresse 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 dentrée ne sont définis que dans le programme principal. Pour relier tous ces fichiers, il suffira dentrer LINK suivi de la liste de tous les fichiers : LINK princip biba biba par exemple. La directive PUBLIC suivie dune liste de procédures indique que ces procédures peuvent être appelées depuis dautres fichiers. Ces procédures doivent être définies avec PROC. La directive EXTRN indique que lon utilise les procédures citées définies dans un autre fichier.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 84 / 109
  • 85. 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 lon 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 dentrée peut se trouver nimporte où, dans une procédure. Spécifier un segment de pile SEGMENT STACK (pour le registre SS). Ne pas soccuper de la relocation (gestion de DS). Au chargement, SS et SP sont initialisés correctement, DS et ES pointent sur le PSP. Lattribut NEAR indique que les procédures se trouvent dans le même segment, FAR indiquant que la procédure peut être appelée dun segment différent : (debut PROC FAR). Il faut empiler DS, linitialiser, exécuter la procédure proprement dite, puis dépiler DS. Le registre CS est automatiquement ajusté lors des CALL et des RET. SS nest pas modifié car le segment de pile est unique.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 85 / 109
  • 86. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurPoints particuliers Adressage de la mémoire Le 8088 peut manipuler des formes de bits qui constituent la mémoire de lordinateur. On peut effectuer un certain nombre dopé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 dune 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 dautres pour loffset, ce qui doit faire en tout 20 bits ! 0040 Segment 0010 Offset ----- 00410Adresse sous la forme segment:offset Interruptions logicielles Je vous présente linsruction INT (interruption software). Le 8088 réserve les 1024 premiers octets de la mémoire pour un ensemble de 256 vecteurs dinterruption. Chacun des vecteurs dinterruptions longs de deux mots est utilisé pour stocker ladresse sous la forme segment:offset dun emplacement en mémoire. Lorsquon exécute une interruption, le 8088 empile ladresse de linstruction suivante de votre programme dans la pile, puis se branche à ladresse mémoire pointée par le vecteur spécifié par linterruption. La raison pour laquelle cela est très important est quun certain nombre de petites routines en langage machine très utiles ont été implantées dans lordinateur, et les vecteurs dinterruption 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 deffectuer des opérations sur disque, sur lécran, sur limprimante, ... Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 86 / 109
  • 87. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Une autre chose : ces vecteurs dinterruptions vous permettent de modifier ces routines. Cest comme cela que le disque virtuel (en RAM) et le spooler fonctionnenet. 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 lappel à 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 ladresse de la chaîne, spécifier la fonction 9 en chargeant 9 dans le registre AH, puis demander à DOS laffichage en exécutant linterruption 21h. Voici le code correspondant : MOV AH, 9 ; spécifier la fonction 9 MOV DX, OFFSET (MESSAGE) ; lit ladresse de la chaîne INT 21h ; appelle le DOS Notez quaucune des lignes ne commence à la marge gauche, afin de ne pas confondre avec une étiquette, et quun 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. Cest 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 Ladresse mémoire est donnée par le nom "MESSAGE" parce que la ligne a commencé avec "MESSAGE" comme étiquette (label en anglais). Maintenant, lassembleur 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 quil rencontre "$". Il sarrête alors. Voici finallement le programme terminé : ;==============================; ; HELLO Version 1.00 ; ; ; ; Fichier source simple. ; ; Affiche un message à lécran ; ;==============================;Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 87 / 109
  • 88. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur MOV AH, 9 ; spécifie la fonction 9 MOV DX, OFFSET [MESSAGE] ; lit ladresse de la chaîne INT 21h ; appelle le DOS MOV AH, 4ch ; spécifie la fonction 4ch INT 21h ; retourne au DOS MESSAGE DB Bonjour !$ ; message à afficher Présentation de l’IBM PC/XT LIBM PC/XT est équipé dun micro-processeur 8 bits (binary digit) Intel 8088. Cest un pseudo 16 bits, cest-à-dire darchitecture dun 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. LIBM a opté pour les codes ASCII (de 1 à 127) et il dispose en outre de codes ASCII étendu non normalisés (128 à 255). Laddition dans le système de numération binaire seffectue 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 dun nombre positif et dun 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 dun nombre positif (le paragraphe au-dessus). Présentation des éléments constituant l’unité centrale du PC LUnité dExécution (EU) Rôle : - exécuter les instructions Effets : - exécution du contenu de la file dattente Interface : - sortie dune adresse logique au BIU Comprend : - une Unité Arithmétique et Logique (ALU)Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 88 / 109
  • 89. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur - une Unité de Contrôle (CU) - dix registres généraux LUnité dInterface de Bus Rôle : - réalisation des échanges entre le mico-processeur et lextérieur - contrôle de linterface 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 dattente Interface : - transformation de ladresse logique fournie par le EU en adresse réelle Comprend : • bus dadresse de 20 bits (communication entre ROM, RAM, et interface dE/S) • bus de données de 16 bits (transmission de données entre lEU 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 lEU, 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 dadresse) Note : Juste avant lexécution dune 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à !à linstruction suivante, doù lintroduction dune notion de file dattente. Cette dernière a une capacité de 4 octets. Ce système tient compte du fait quen général, le temps dexécution dune instruction est inférieur au temps de recherche dune autre instruction. Une autre partie très importante de lIBM PC/XT est constituée par les slots. Chaque slot comprend 62 lignes de connexion en parallèle, que lon appelle également des canaux dE/S (Input/Output Channel). - 8 lignes de données bidirectionnelles - 20 lignes dadressageEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 89 / 109
  • 90. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur - 6 lignes de niveau dinterruption - 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 Larchitecture générale de lIBM PC/XT est la suivante : • 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 dentrées-sorites (contrôleur DMA, monochrome, ...) • slots dextensions • éventuellement un co-processeur arithmétique 8087 Le micro-processeur 8088 Le 8088, dancienne référence IAPX 88, tout en ne disposant de bus que de 8 bits, met à la disposition du programmeur des registres 16 bits. Doù sa dénomination de faux 16 bits. Ce circuit possède 20 broches sur 40 en tout pour gérer le bus dadresse. Ce bus permet donc ladressage de 1 Méga-octet de mémoire (220 = 1.048.5786 = 1 Mo). Afin daccé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 ladresse logique sous la forme Segment:Offset (déplacement). Notion de segment Un segment est un espace mémoire de 64K. La valeur de ladresse réelle (sur 20 bits) est obtenue par lopération : adresse de base (segment) * 16 + déplacement (adresse relative) 16 bits 10H 16 bits Les deux premiers termes font passer ladresse de 4 à 5 chiffres. En langage machine, il suffit dopé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.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 90 / 109
  • 91. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Liste des registres Registres généraux Ce sont les seuls à pouvoir être utilisés à 8 ou à 16 bits. Instructions AH Accumulateur, dE/S, registre haut arithmétiques (High) 8 bits AL Accumulateur, registre bas (Low) - 8 bits AX Accumulateur - 16 bits Seul à pouvoir BH Base, registre être utilisé haut (High) - 8 comme registre bits dindex BL Base, registre bas (Low) - 8 bits BX Base - 16 bits Compteur de CH Compteur, boucle registre haut (High) - 8 bits CL Compteur, registre bas (Low) - 8 bits CX Compteur - 16 bits Valeurs de DH Données, registre déplacement à haut (High) - 8 gauche ou à bits 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 DL Données, registre bas (Low) - 8 bits DX Données - 16 bitsEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 91 / 109
  • 92. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Pointeurs Index : utilisés lors de ladressage étendu pour laddition 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. 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 ladressage pour accéder à un élément de la pile. IP Pointeur dInstruction 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 à lexé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 ExtraEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 92 / 109
  • 93. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Opérations « primitives sur chaînes ». Note : ladresse de début de segment est toujours un multiple de 10H. Registre détat et de commande Bit : 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 (nombre négatif) = 0 : bit de poids ford à 0 (nombre positif) ZF indicateur de zéro (zéro flag) = 1 : résultat de lopération vaut zéro AF indicateur de retenue auxiliaire (auxiliary carry flag) = 1 : retenue (soustraction) des quatre bits de poids faible dans loctet de poids fort, ou emprunt (addition) des quatre bits de poids fort dans loctet de poids faible PF indicateur de parité (parity flag) = 1 : résultat de lopé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 dinterruption pas-à- pas = 1 : génération dinterruption de vecteur 01H DF indicateur de direction (direction flag)Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 93 / 109
  • 94. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur déplacement de plus de plus dun mot dun ensemble doctets = 1 : opérations de décrémentation = 0 : opérations dincrémentation IF autorisation dinterruption (interrupt enable flag) = 0 : interruption interdite = 1 : interruption autorisée Les vecteurs d’interruption Toute interruption déclenchée est transmise au contrôleur dinterruption 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 dinterruption envoit ensuite, codé sur 8 bits, à lunité dexploitation le numéro de linterruption appelée. Là est exécutée la routine de gestion dinterruption dont ladresse se trouve en (n° dinterruption * 4) dans la table des vecteurs dinterruption. En effet, chaque vecteur dinterruption est codé sur 4 octets. Ainsi, pour connaitre lemplacement dans la mémoire de ce vecteur, il suffit de multiplier par quatre le numéro de linterruption. Un point très important : lors de lappel dune interruption, le micro- processeur effectue les opérations suivantes : • SP = SP - 2 (décrémente deux fois SP) • empile lindicateur détat • SP = SP - 2 • empile CSEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 94 / 109
  • 95. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • SP = SP - 2 • empile IP Linstruction assembleur RET utilise ces valeurs pour la poursuite du programme. On discerne trois types dinterruptions : • 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 lindicateur IF est à 1 (interruption INTR autorisée); les interruptions sont interdites si IF est à 0 (interruption INTR interdite). Linstruction assembleur CLI (CLear Interrupt enable flag) met IF à 0 et STI (SeT Interrupt enable flag) à 1. • linterruption NMI (Non Masquable Interrupt). Correspond à la broche 17 du micro-processeur. Les registres détat et de contrôle sont empilés. • linterruption 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 linitiation au traitement de linformation dans lordinateur par la présentation et lexplication de ce quest 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 linstant quun octet est un caractère. Nous verrons plus tard ce que cela représente en réalité. Logiquement, nous allons maintenant expliquer ce quest un bit. Un bit, cest 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.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 95 / 109
  • 96. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Sachant quun 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 ny en que deux, 0 et 1. Pour interpréter un bit en nombre décimal, vous devrez procéder comme suit : 7 10000000 = 10000000 = 2 = 128 5 00100000 = 100000 = 2 = 32 3 00001000 = 1000 = 2 = 8 1 00000010 = 10 = 2 = 2 -------- -------- -- 7 5 3 1 10101010 = 10101010 = 2 +2 +2 +2 = 128 + 32 + 8 + 2 = 170 Ainsi, pour connaitre la valeur décimale positive dun bit, vous naurez 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 = 256Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 96 / 109
  • 97. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Mais lordinateur 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 : • 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 ny a pas de différence si vous linterprétez en entier positif ou en entier relatif Linterprétation en entier relatif est appelée « complément de deux ». Maintenant, voyons un peu ce quest 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 sagit dutiliser 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 0110Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 97 / 109
  • 98. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 quun 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 quavec deux chiffres hexadécimaux, ce sera 16 X 16 = 256 (de 00 à FF) ! La notation hexadécimale est un des fondements du langage dassemblage. 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 ladresse dun 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 dinterpréter une représentation de bits : linstruction dun 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 dun 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. Lapprentissage du langage dassemblage sappuie sur cette puce (micro- processeur). Elle permet deffectuer les opérations dites élémentaires disponibles dans le langage machine. Les sept registres sont appelés :Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 98 / 109
  • 99. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • PC (Program Counter) : registre du compteur du programme sur deux octets • X : registre dindex X • Y : registre dindex 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 linstruction. 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 larticle. Mais remarquons avant de continuer que le signe « $ » désigner un nombre hexadécimal. Ainsi, 10 nest pas ici un nombre décimal, mais un nombre hexadécimal, soit 16 en base 10 (décimale). Voyons maintenant : • ladressage immédiat : le signe # en est le signe particulier. Linstruction LDA #$10 copie le nombre hexa 10 (le nombre suivant immédiatement linstruction LDA) dans laccumulateur. • ladressage absolu (ou adressage direct) : aucun signe particulier. Linstruction LDA $10 copie le nombre contenu à ladresse 0010 (en hexa) dans laccumulateur. On aurait pu utiliser une instruction du type LDA $149A qui aurait copié le contenu de ladresse $149A (octet numéro 94 en hexa, de la page 14, en hexa) dans laccumulateur. • ladressage indexé : signe particulier : « ,X » ou « ,Y ». Admettons que le registre contienne la valeur 02. Dans c cas, linstruction LDA $10,X copie le contenu de ladresse 12 en hexa (10 + 2 = 12) dans laccumulateur. On pourra également utiliser des instructions du type LDA $249F,Y. Remarquez que linterprétation par les entiers positifs est utilisée avec ce mode dadressage (et non pas celui avec les entiers relatifs). Vous ne pouvez utiliser que les registres X et Y (appelés registres dindex, et pour cause !) dans ce mode.Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 99 / 109
  • 100. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur • ladressage 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. Linstruction LDA ($10,X) copiera le contenu de ladresse FF69 (contenue aux adresses 10 + 2 et 10 + 3 soit 12 et 13, en hexa). Vous remarquerez que ladresse est « inversée » : le numéro de la page suit la position dans la page. Supposons maintenant que le registre contienne la valeur 03. Linstruction LDA ($10),Y copiera le contenu de ladresse, donnée par le contenu de ladresse contenu en 0010 et 0011 (soit 1500; e, hexa) ajoutée de 3 (contenu du registre Y), soit au total 1503, dans laccumulateur. Lintérêt de lemploi de ladressage immédiat réside dans lutilisation de constantes, de ladressage absolu (ou direct), celle des variables, de ladressage indexé, celle des tableaux, et enfin de ladressage indirect, pour, par exemple, recopier un programme dun endroit de la mémoire à un autre. Pour écrire un programme avec un assembleur, vous entrez les instructions (comme LDA $110) et lassembleur 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 à ladresse correspondante, selon que le registre détat est à 1 ou à 0 Voyons un exemple, afin de bien comprendre. LDA #$10 CMP #$11 Ces instructions chargent la valeur hexa 10 dans laccumulateur, puis comparent le contenu de laccumulateur (10) à la valeur hexa 11. Le seul effet de CMP est dadapter 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 lexécution du programme à ladresse 2000, si le bit négatif est à 1. Précisons quelques points pour bien comprendre cela : • FF nest 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 lopération ??10 - 0011, où ?? désigne deux chiffres hexa inconnus, et si vous voulez « retenir quelque choseEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 100 / 109
  • 101. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur » aux chiffres ??, alors le bit de retenue sera mis à 0 (il aurait été mis à 1 sil y avait eu besoin de retenir). Nous allons arrêter là linitiation, 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 Lordinateur ne comprend quun langage : le langage machine, qui nest rien dautre quune suite de 0 et de 1. Les instructions de ce langage sont donc très élémentaires. Doù un langage de programmation lourd, fastidieux. La difficulté de ce langage est donc une source derreurs. 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 dassemblage ou assembleur. Ses fonctions sont de vérifier la syntaxe et de signaler les éventuelles erreurs, puis de traduire ce programme source (dorigine) 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 lemploi 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 : • accès souvent mal aisé • très compliqué (dû à lemploi dinstructions élémentaires) • très grande difficulté de modification sans le source (programme pas encore assemblé, cest-à-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 dune expressionEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 101 / 109
  • 102. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 dun bit à gauche. Un 0 est inséré dans la position supplémentaire. Correspond à une multiplication en puissance de 2. SHR Décalage dun bit à droite. Correspond à une division en puissance de 2. XOR Opération logique OU EXCLUSIF entre deux expressions. = Affectation dune valeur ou dun label à une référence. PTR Modification du type de lobjet 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 ladresse de branchement. Exemple : JMP SHORT SUITE HIGH Donner la position de loctet de poids fort dun objet déclaré avec un type WORDL. Lassembleur générera automatique un déplacement de +1. LOW Donner la position de loctet de poids faible dun objet déclaré avec un type WORD. THIS Identification dun objet à la position courante du compteur dassemblage. 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 WORDEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 102 / 109
  • 103. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 dune chaîne de bits au moyen dune opération AND. Exemple : MOV AX, MASK ENREG OFFSET Obtenir le déplacement relatif dun objet dans un segment. Lobjet 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 dun objet. SHIFT Le nom dun champ dune chaîne de bits est pris comme attribut de décalage. La valeur rendue est celle quil faut appliquer à la chaîne de bits après isolement avec cette valeur par lattribut MASK, pour cadrer le champ à droite de la chaîne. Ce décalage doit être fait grâce à linstruction SHR. SIZE Obtenir lencombrement en octets dune allocation globale de variable, structure, ou chaîne de bits. TYPE Obtenir lencombrement en octets dune unité de type de la définition. WIDTH Obtenir la longueur en bits dun champ dune 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 TexteEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 103 / 109
  • 104. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage AssembleurAide 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 dindicateur PUSH Empile un registre Drapeaux Registres généraux : Registre Description Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 104 / 109
  • 105. 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 dinstruction Registres détat et de contrôle : Registre Description CF Retenue PF Parité AF Retenue auxiliaire ZF Zéro TF Piège IF Autorisation dinterruption DF Indicateur de direction OF Débordement SF Signe Modes dadressage : 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 MOV AX,[BX] [DI] et registre dindex adresse = 16 * DS + BX + DI Indirect de registre avec registre de base, MOV AX, constante [BX] [SI] dindex plus constante adresse = 16 * DS + constante + BX + SIEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 105 / 109
  • 106. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur Opérations arithmétiques 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 laccumulateur 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 sontEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 106 / 109
  • 107. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur introduits … droite SAR Décalage arithmétique de n bits vers la droite; le bit de poids fort dorigine 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 lindicateur de retenue RCR Rotation de n bits vers la droite … travers lindicateur 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 doctet 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 dune 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 laccumulateur vers la chaîne pointée par DI. DI incrément‚ XCHG Echange le contenu des deux opérandes XLAT Echange laccumulateur 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--CFEdité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 107 / 109
  • 108. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 dinstruction au co-processeur HLT Mise à larrêt du 8088 IN Lecture dun port dans laccu INT Déclenche une interruption INTO Déclenche une interruption si OF=1 IRET Retour dinterruption LOCK Verrouillage du bus NOP Aucune opération OUT Ecriture sur un port dE/S CALL Appel de sous-programme. Sil 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=1Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 108 / 109
  • 109. Bruno Delb http://www.brunodelb.com Date : 20/11/2000 Le langage Assembleur 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 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=1Edité le 05/09/2012 technique/langages/java_jdbc.pdf (52 Ko) Page 109 / 109