Jacques Lonchamp IUT Nancy Charlemagne – DUT Informatique 1A

Présentation au sujet: "Jacques Lonchamp IUT Nancy Charlemagne – DUT Informatique 1A"— Transcription de la présentation:

1 Jacques Lonchamp IUT Nancy Charlemagne – DUT Informatique 1A
Le « langage machine » Jacques Lonchamp IUT Nancy Charlemagne – DUT Informatique 1A

2 Langage machine et langage d’assemblage (assembleur)
Langage machine = langage directement exécutable par le processeur. Donc lié à son architecture et aux circuits qui le composent. Différent pour chaque processeur. 2 versions : binaire (langage machine) et codée « en clair » (langage d’assemblage ou langage assembleur)

3 Exemples de langages d’assemblage réels

4 Lien avec les langages évolués (C, C++, COBOL, …)
Il existe aussi des langages interprétés – traduction et exécution immédiate des instructions (ex: javascript, PHP) - et semi compilés-semi interprétés (Java)

5 La machine simulée (sms32v50)
Mémoire centrale : 256 mots de 1 octet. Adresses de 0 à 255, notée [00] à [FF] en hexadécimal. Les [ ] distinguent les adresses des constantes. EX: 1F est la constante 31 alors que [1F] est le mot d’adresse 31. Pas un accumulateur, mais 4 registres d’un octet utilisables indifféremment et notés AL, BL, CL, DL. Le compteur ordinal est initialisé à 0. Les mots peuvent contenir des entiers entre -128 et +127 en complément à 2 ou des codes ASCII.

6

7 MOV destination, source
Les instructions de la machine simulée Instruction de transfert (mémoire vers registre ou registre vers mémoire) MOV destination, source La source est recopiée dans la destination (attention a l'ordre !) Les seules formes autorisées sont les suivantes : MOV AL, 1B ; range 1B (hexa) dans AL MOV BL, [C2] ; copie le mot d'adresse C2 dans BL MOV [15], CL ; copie le registre CL dans le mot d'adresse 15 Les transferts de mémoire à mémoire sont interdits car il faudrait 2 adresses mémoire pour une seule instruction (cf. chapitre sur l'UAL.). Les transferts entre registres sont aussi interdits. Il faut passer par un mot mémoire intermédiaire ou par la pile. La pile est une zone de mémoire ou l'on empile et dépile des valeurs. PUSH AL ; empile la valeur de AL au sommet de la pile POP BL ; dépile la valeur et la range dans BL

8 12 12 12 AL BL Pile PUSH AL POP BL

9 2. Instructions de calcul
Il s'agit de l'addition, de la soustraction, de la multiplication, de la division entière, du reste de la division entière ou modulo, de l'incrémentation de 1, de la décrémentation de 1. Elles utilisent des registres et rangent leur résultat dans le premier registre. ADD AL, BL ; AL = AL + BL SUB BL, CL ; BL = BL - CL MUL CL, DL ; CL = CL DL DIV DL, AL ; DL = DL=AL MOD AL, BL ; AL = AL mod BL INC DL ; DL = DL + 1 DEC AL ; AL = AL 􀀀 1 Dans les 5 instructions à 2 opérandes, l'opérande de droite peut aussi être une constante hexadécimale.

10 CMP destination, source
3. Instructions de comparaison CMP destination, source Compare la source et la destination; soustrait la source à la destination et met 1 dans le « flag » (drapeau) zero (Z) si le résultat est nul et 1 dans le « flag » sign (S) si le résultat est négatif. CMP AL, BL ; met 'Z' a 1 si AL = BL ; met 'S' a 1 si AL < BL CMP BL,13 ; met 'Z' a 1 si BL = 13 ; met 'S' a 1 si BL < 13 CMP CL, [20] ; met 'Z' a 1 si CL = [20] ; met 'S' a 1 si CL < [20]

11 JMP étiquette de destination
4. Instructions de branchement inconditionnel JMP étiquette de destination L‘étiquette vers laquelle se fait le saut occupe une ligne du programme assembleur mais ne prend pas de place en mémoire. Elle représente une certaine adresse. JMP FIN … FIN: (ne pas oublier les : ) Change la valeur du compteur ordinal (IP : Instruction pointer).

12 5. Instructions de branchement conditionnel
Suit une instruction de comparaison (CMP) et réalise le saut en fonction des drapeaux, c'est-à-dire du résultat de la comparaison. Sinon passe à l'instruction suivante. JZ LABAS ; saute à LABAS si le flag Z est à 1 JNZ PLACE ; saute à place si le flag Z est à 0 JS RET ; saute à RET si le flag S est à 1 JNS START ; saute à START si le flag S est à 0 En jouant sur l'ordre des registres on peut réaliser toutes les comparaisons (>, <, >=, <=, =, ! =) comme nous le détaillerons dans la suite.

13 6. Instructions diverses
END ; fin du programme (une seule sur la dernière ; ligne) HALT ; arrêt de l'exécution (éventuellement plusieurs) DB constante ; définit une donnée (« Define Byte »)

14 Exemple de programme Nous prenons l'habitude de placer les données en début de mémoire avec un JMP qui les saute pour aller au début du programme (car le compteur ordinal est initialisé à 0). En effet, si on place les données après le programme on ne peut connaître leurs adresses qu'après avoir écrit tout le programme ce qui n'est guère pratique. JMP debut ; occupe les mots 0 et 1 DB 5 ; mot 2 (donnée 1) DB 2 ; mot 3 (donnée 2) DB 0 ; mot 4 (résultat) debut: MOV AL, [2] ; première instruction du programme MOV BL, [3] ADD AL, BL ; résultat dans AL MOV [4], AL END ; les mots d'adresse 2 et 3 ont étés ; additionnés et le résultat rangé dans le mot 4 Zone des données et résultats

15 Les conditionnelles si condition alors cas_vrai sinon cas_faux fsi où condition s‘écrit : op1 opérateur op2 avec >, <, >=, <=, =, != comme opérateurs. En assembleur, il n'y a pas d'instruction conditionnelle si alors sinon. Il faut la construire avec des branchements conditionnels et inconditionnels. Le schéma de traduction standard, utilisé par les compilateurs pour traduire les conditionnelles en langage machine, est le suivant :

16 MOV BL, op2 ; ou autres registres CMP AL, BL ou BL, AL J?? vrai
MOV AL, op1 MOV BL, op ; ou autres registres CMP AL, BL ou BL, AL J?? vrai ; instructions du cas_faux JMP fin vrai: ; instruction du cas_vrai fin: où J?? est un des branchements possibles (JZ, JNZ, JS ou JNS) en fonction de la condition : condition traduction explication op1 = op2 CMP AL, BL puis JZ op1-op2 = 0 op1 != op2 CMP AL, BL puis JNZ ... op1-op2 != 0 op1 < op2 CMP AL, BL puis JS op1-op2 < 0 op1 > op2 CMP BL, AL puis JS op2-op1 < 0 op1 >= op2 CMP AL, BL puis JNS ... op1-op2 >= 0 op1 <= op2 CMP BL, AL puis JNS ... op2-op1 >= 0

17 Cas particulier du si sans sinon si condition alors cas_vrai fsi
Le schéma général est inutilement compliqué car cas_faux est vide. Il est préférable de prendre la négation de la condition et de sauter à l’étiquette fin si cette négation est vraie (autrement dit « si la condition est fausse alors je ne fais rien »). Le schéma de traduction est le suivant : MOV AL, op1 MOV BL, op ; ou autres registres CMP AL, BL ou BL, AL J?? fin instructions_du_cas_vrai fin: ... où le choix de J?? et l’ordre des opérandes est donnée par le tableau précédent pour la négation de la condition.

18 Les itérations (avec compteur – pour)
pour i de 1 à limite faire bloc_à_répéter fpour L’itération se traduit comme suit : MOV registre1, 1 ; compteur i MOV registre2, limite re: CMP registre2, registre1 JS fin ; limite-compteur<0 c'est à dire ; compteur>limite INC registre1 ; incrémentation de i JMP re fin:

19 Parcours d’un ensemble de données consécutives : l’adressage indirect
Si on veut parcourir et traiter un ensemble de données consécutives en mémoire (un tableau de données), il faut pouvoir désigner successivement tous les éléments de cet ensemble dans une itération. Avec « l’adressage direct » qui donne directement l’adresse du mot voulu (ex: [3]) ce n’est pas possible. On ne peut qu’écrire : ADD AL, [3] ADD AL, [4] ADD AL, [5] etc. L’assembleur offre « l’adressage indirect » pour résoudre ce problème. On utilise la notation [AL] qui signifie « le contenu du mot dont l'adresse est dans le registre AL ». Il suffit de mettre dans AL la première adresse voulue puis d'incrémenter AL de 1 en 1 dans une itération pour accéder, grâce à la notation [AL], successivement à toutes les données de l'ensemble.

20 C'est un des 5 modes d'adressage classiques en assembleur :
- l’adressage immédiat : 8 (constante 8) - l’adressage direct : [8] (mot mémoire d'adresse 8) - l’adressage indirect : [AL] (le registre AL contient l'adresse voulue) - l’adressage basé : [AL+4] (le contenu de AL + 4 est l'adresse voulue) N'existe pas dans la machine simulée. - l’adressage indexé : [AL+BL] (le contenu de AL + le contenu de BL est l’adresse voulue). N'existe pas dans la machine simulée. Attention : dans la machine simulée, l'adressage indirect n'est autorisé que dans les instructions MOV, ce qui est très restrictif ! Ex: MOV DL, [AL] Copie le mot [AL] dans DL MOV [CL], AL Copie AL dans le mot [CL]

21 Les entrées/sorties Les entrées/sorties de base s’effectuent via des ports. Les ports sont des adresses spéciales associées aux périphériques d’entrée/sortie et repérées par des numéros. Un octet peut être lu ou écrit dans ces ports grâce aux instructions IN et OUT qui utilisent le registre AL : IN entrée depuis le port 00 vers AL OUT 01 sortie depuis AL vers le port 01 Dans le simulateur le port de sortie 01 est connecté à 2 feux tricolores ; selon la valeur de l'octet transmis dans AL ces 2 feux s’allument d'une certaine manière : bits rouge orange vert rouge orange vert non utilisés feu de gauche feu de droite Le port d'entrée 00 est connecté au clavier. Le registre AL reçoit le code ASCII de la touche du clavier enfoncée.

22 Cette forme d’entrée/sortie sans condition correspond aux périphériques qui sont toujours disponibles, comme les interrupteurs, les voyants lumineux . . . Dans le cas de périphériques plus complexes il faut recourir aux entrées/sorties avec condition : il faut connaître l’état du périphérique avant d'envoyer ou de lire des informations (ex : réseau, disque ). Comme nous l’avons vu dans la partie sur le matériel, il existe deux approches principales : l’attente active et les entrées/sorties avec interruptions.

23 Les manipulations de bits
Décalage et rotations Ces opérations décalent vers la gauche ou vers la droite les bits d’un registre. Elles peuvent être utilisées pour tester un bit quelconque (on le décale tout à droite, on annule les autres bits et on teste le mot), ou encore pour diviser ou multiplier rapidement un entier par une puissance de 2. SHL CL Décalage à gauche : le bit de poids fort est perdu, le bit de poids faible devient 0 (SHift Left). SHR DL Décalage à droite : le bit de poids faible est perdu, le bit de poids fort devient 0 (SHift Right). ROL AL Rotation à gauche : le bit de poids fort devient le bit de poids faible (ROtate Left). ROR BL Rotation à droite : le bit de poids faible devient le bit de poids fort (ROtate Right).

24 2) Les instructions logiques
Les instructions logiques effectuent des opérations logiques bit à bit (chaque bit est calculé indépendamment des autres). ET, OU et OU exclusif. OU ET OU EX a) L'instruction OR : OR AL, BL ; AL = AL OU BL OR est souvent utilisé pour forcer certains bits à 1 grâce à un « masque » ayant des 1 à ces positions. Exemple : MOV BL, F0 ; masque BL: MOV AL, AL: OR AL, BL Les 4ers bits de AL sont forcés à 1, les 4 autres sont inchangés. b) L'instruction AND : AND AL, BL ; AL = AL ET BL AND est souvent utilisé pour forcer certains bits à 0 grâce à un « masque » ayant des 0 à ces positions.

25 Les 4ers bits de AL sont forcés à 0, les 4 autres sont inchangés.
Exemple : MOV BL, 0F ;masque BL: MOV AL, AL: AND AL, BL Les 4ers bits de AL sont forcés à 0, les 4 autres sont inchangés. c) L'instruction XOR : XOR AL, BL ; AL = AL OU EXCLUSIF BL XOR est souvent utilisé pour inverser certains bits grâce à un « masque » ayant des 1 à ces positions. MOV BL, F0 ;masque BL: MOV AL, AL: XOR AL, BL Les 4ers bits de AL sont inversés, les 4 autres sont inchangés. Remarque : on n'a pas besoin de recourir à l'assembleur pour manipuler des bits; ces opérateurs existent dans beaucoup de langages évolués, comme Java. En Java SHL s‘écrit >>, SHR s‘écrit <<, OR s‘écrit j , AND s‘écrit & et XOR s‘écrit ^. short i = 13; // i a la valeur i = i << 2; // i prend la valeur

26 Les sous programmes (SSP)
Un SSP est une suite d'instructions effectuant un certain traitement et regroupées par commodité : découpage du programme en petits ‘morceaux’, morceau utilisé plusieurs fois, … Un SSP est repéré par l'adresse de sa première instruction. L'exécution du SSP est déclenchée par un programme appelant. Un SSP peut lui même en appeler un autre et ainsi de suite. L'appel du SSP est effectué par l'instruction CALL : CALL adresse (ex: CALL 50) L'exécution se poursuit à l'adresse indiquée dans le CALL. La fin du SSP est marquée par l'instruction : RET Le processeur revient implicitement à l'instruction placée immédiatement après le CALL car l’adresse de retour est empilée.

27 L'adresse de retour, utilisée par RET, est ajoutée sur la pile par l'instruction CALL. Lorsque le processeur exécute l'instruction RET, il dépile l'adresse de la pile et la range dans le compteur ordinal. Ce mécanisme marche même dans le cas des appels imbriqués (un CALL dans un SSP vers un autre SSP) et dans le cas des appels récursifs (un SSP qui s'appelle lui même un certain nombre de fois). 40 pile 4613 CALL 90 RET 13 90 CALL 40 45 46 RET 12 13 13 46 13

28 Le plus souvent, le SSP effectue un traitement sur des données (ou paramètres) qui sont fournies par le programme appelant, et produit un résultat qui est retourné à ce programme. Plusieurs stratégies pour passer les paramètres : a) passage par les registres Les valeurs des paramètres et du résultat sont contenues dans des registres bien définis. Méthode simple qui ne convient que si le nombre de paramètres est faible, car il y a peu de registres. Ex : le SSP à l'adresse hexadécimale 30 calcule le maximum de 2 entiers naturels. On convient que les entiers sont passés par les registres AL et BL, et que le résultat est placé dans le registre AL. L'appel s‘écrit : MOV AL, ... ; donnée1 MOV BL, ... ; donnée2 CALL 30 ; le résultat est disponible dans AL

29 Le SSP s‘écrit : ORG ; directive qui indique que le code qui suit est ; situé à l'adresse 30. Ne prend pas de place ; en mémoire CMP AL, BL JNS saut ; si AL >= BL (AL-BL >= 0) PUSH BL ; sinon échange de AL et BL POP AL ; de telle sorte max soit dans AL saut : RET b) passage par la pile Les valeurs des paramètres sont empilées. Il peut y en avoir un nombre quelconque. Le SSP récupère les valeurs dans la pile. Ex : le SSP à l'adresse 40 utilise la pile pour passer les paramètres et reçoit le résultat dans la pile. L'appel s‘écrit : PUSH AX ; donnée1 préalablement rangée dans AX PUSH BX ; donnée2 préalablement rangée dans BX CALL 40 POP AX ; récupération du résultat dans AX par exemple

30 POP CL ; adresse de retour empilée par le CALL
ad. retour donnée 2 donnée 1 Le SSP peut s‘écrire : ORG 40 POP CL ; adresse de retour empilée par le CALL POP BL ; deuxième paramètre POP AL ; premier paramètre CMP BL, AL JNS saut ; si AL >= BL PUSH BL ; sinon échange de AL et BL POP AL ; de telle sorte que le max soit dans AL saut : PUSH AL ; résultat dans la pile PUSH CL ; adresse de retour dans la pile RET ; dépile l'adresse de retour Le programme apparaît plus complexe. Mais il faut noter que dans les langages d'assemblage réels on peut accéder aux valeurs de la pile sans dépiler, ce qui simplifie le début et la fin du SSP. pile après le CALL résultat pile après le RET