Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Assembleur 80386 Le langage Assembleur (ASM) est un langage de bas niveau perme

Assembleur 80386 Le langage Assembleur (ASM) est un langage de bas niveau permettant l’écriture de programmes rapides et d’interfaces vers des périphériques (drivers). Il est utilisé pour écrire les drivers, les portions optimisées de programme,… Un programme en ASM peut fonctionner en deux modes : 1. Le mode réel : le programme peut adresser n’importe quel endroit en mémoire. C’est le cas des PC originels 8086 créés en 1981. 2. Le mode protégé : ce mode supporte les fonctionnalités que les systèmes d'exploitation modernes offrent, comme la mémoire virtuelle et la protection mémoire (Windows et Linux). Dans ce cours, nous avons choisi le mode protégé. Les TP se feront dans l’environnement Linux (fédora). Les programmes en ASM ont une extension .S et sont compilés avec la commande gcc –o sortie prog.S. et puis exécuté an tapant sortie à l’invite de commande. Comme toute programmation, la programmation en ASM nécessite une méthodologie : • Définir une méthode de résolution en décrivant l'algorithme de résolution du problème ; • Définir les fonctions et les procédures • Choisir les paramètres en entrée et en sortie de chaque fonction ou procédure • Choisir les variables globales, et les variables locales • Écrire les corps des fonctions et procédures Dans ce cours, on supposera que ces étapes de résolution d'un problème sont réalisées, puis on ne s'intéressera qu'à la traduction du l'algorithme final en un programme ASM. Explication des instructions:exemples Les bases du langage Assembleur Structure générale d’un programme ASM Un programme ASM a la structure suivante : .intel_syntax noprefix # Directive indiquant le type du processeur .data #Indication du début de la zone de déclaration des variables // Liste des variables // définitions des procédures. .global main #Indication du programme principal main: #Etiquette du début du programme principal //Liste des instructions du programme principal push 0 call exit # Sortie du programme principal (arrêt) // Définitions éventuelles des procédures Les variables En ASM, les variables sont déclarées dans la zone indiquée par la directives .data. La syntaxe de déclaration est : variable .type : valeur initiale Le nom d’une variable commence toujours par une lettre. Les différents types utilisés sont :  byte : entiers sur un octet (8 bits)  word : entiers sur un mot (16 bits)  int : entiers sur un double-mot (32 bits)  ascii : chaînes de caractère  asciz : chaînes de caractère terminées par l’octet 0  space <rep>,<val> : répète <rep> fois la valeur <val> codée sur 1 octet  fill <rep>,<taille>,<val> : répète <rep> fois la valeur <val> codée sur <taille> octets Pour utiliser la variable n, il faut écrire tout simplement n. Mais pour utiliser l’adresse de n, on peut écrire offset n ou [n]. Les commentaires Un commentaire commence par le caractère ‘#’ suivi du texte. Les étiquettes Les étiquettes sont les noms que l’on donne à une instruction permettant de faire un saut à cette instruction à partir de n’importe quel endroit du programme. Dans un programme, une étiquette est utilisée pour nommer une seule instruction. La syntaxe de déclaration est : nom_étiquette : Les registres Ce sont des zones internes au processeur permettant de stocker de manière temporaire les données. Le programmeur peut utiliser les registres EAX, EBX, ECX, EDX, EDI, ESI, ESP et EBP dans un programme. Les registres EAX, EBX, ECX et EDX peuvent être utilisés par le programmeur. Il peut y affecter n’importe quelle donnée. La taille de ces registres est de 4 octets. La partie basse de ces registres peut être utilisé pour les données de 16 bits. Pour le faire, il faut simplement supprimer la lettre E. Le registre de 16 bits ainsi obtenu peut être aussi divisé en deux parties et chaque partie utilisée pour les données de 8 bits. Par AX=AH+AL. Les registres EDI et ESI peuvent aussi être utilisés pour stocker n’importe quelle donnée, mais le programmeur n’a pas le droit de les diviser. Les registres ESP et EBP sont utilisés pour manipuler la pile. ESP désigne toujours le sommet de la pile. EBP est utilisé dans des sous programmes pour parcourir la pile. La pile C’est la partie de la mémoire de l’ordinateur, permettant de :  sauvegarder temporairement des informations,  passer des paramètres aux sous-programmes,  créer des variables locales,  sauvegarder le contexte lors de l’appel aux sous-programmes, La pile est manipulée avec les instructions PUSH (empiler) et POP (dépiler). On la manipule aussi avec les registres ESP et EBP. Les instructions  La plupart des instructions assembleur (aussi appelées mnémoniques) ont 0, 1 ou 2 arguments (opérandes).  Ces opérandes sont soit un label (pour les instructions de saut uniquement), soit un registre, soit un accès à la mémoire (suivant les différents modes d’adressage).  En général pour une même instruction, il ne peut y avoir plus d’un accès à la mémoire.  En général les opérandes doivent être de même taille (1, 2 ou 4 octets). Les appels système Ce sont les instructions qui permettent d’exécuter les opérations du système d’exploitation comme les instructions de lecture, d’écriture, … Un premier programme ASM : faire la somme a=b+c ; .intel_syntax noprefix .data a : .int b : .int 10 c : .int 5 .global main main: mov eax, b add eax, c mov a, eax push 0 call exit Les instructions composées Instructions de condition (if, switch. . . ) Forme 1 (pas de sinon) : ‘si a<b alors inst finsi’ se traduit : Cmp a,b Jge finsi inst finsi : Forme 2 (avec sinon) : ‘si a<b alors inst1 sinon inst2 finsi’ se traduit par Cmp a,b Jge sinon Inst1 Jmp finsi Sinon : inst2 finsi Forme 3 : connecteur ET si (x <= z et y <= z) inst 1 sinon inst 2 finsi cmp x,z; jg sinon cmp y,z jg sinon inst 1 jmp finsi sinon: inst 2 finsi: Forme 4 : connecteur OU si (x <= z ou y <= z) inst 1 sinon inst 2 finsi cmp x,z; jle alors cmp y,z; jg sinon alors: inst 1 jmp finsi; sinon : inst 2 finsi: Forme 5 : les cas cas (lettre) { case ’a’: code=2; break; case ’b’: code=5; break; case ’c’: code=3; break; default: code=0;} cmp lettre,’a’; je cas_a; cmp lettre,’b’; je cas_b; cmp lettre,’c’; je cas_c; jmp default; cas_a: mov code,2; jmp fin_cas; cas_b: mov code,5; jmp fin_cas; cas_c: mov code,3; jmp fin_cas; default: mov code,0; fin_cas: Instructions de boucle (for, while, . . . ) Forme 1 : boucle pour Pour i allant de 1 à valeur_finale faire Inst Finpour Mov ecx,1 Pour : cmp ecx, valeur_finale jg finpour inst inc ecx jmp pour Finpour : Forme 2 : boucle tant que Tant que (i<n) faire Inst Fintantque mov ecx, i tantque: cmp ecx,i jge fintantque inst jmp tantque fintantque: Forme 3 : répéter … jusqu’à condition Répéter Inst Jusqu’à (a>b) Repeter : Inst Cmp a,b Jle repeter Jusqua : Les procédures Le code d’une procédure commence par une étiquette et s’achève par l’instruction ret. Ce code peut être écrit avant ou après le programme principal main. L’appel de la procédure se fait par l’instruction call procedure. L’instruction call empile la valeur du registre EIP (compteur ordinal) Passage des paramètres Le passage de paramètre peut se faire de deux manières : 1. Utilisation des registres : les paramètres sont placés dans les registres avant l’instruction call. 2. Utilisation de la pile : les paramètres sont empilés avant l’appel de la procédure. Après la procédure, il faut les dépiler. Chaque empilement augmente le sommet de la pile (ESP) de la taille du paramètre. Le dépilement doit tenir compte de ces tailles avec l’instruction ADD ESP, nombre. Variables locales Contrairement au langage du haut niveau, pour créer les variables dans une procédure, on utilise : 1. Les registres 2. La pile : pour créer une variable, il faut simplement augmenter le registre ESP de la taille de la variable. Pour une variable de type int, il faut faire ADD ESP, 4. Avec la pile, il faut toujours supprimer ces variables à la fin de la procédure en diminuant ESP de la taille (en octets) des variables créées. L’accès aux variables créées se fait avec le registre EBP. Le corps d’une procédure aura toujours la forme : Procedure: Push ebp Mov ebp, esp Corps de la procedure Pop ebp Ret. Les macros Les macros ne sont pas réellement des sous-programmes : ils permettent de simplifier l’écriture d’un programme et disparaissent après la compilation. Le contenu d’une macro est recopié à l’endroit ou on l’appelle. La macro peut être placée n’importe où dans le code, mais doit précéder l’endroit où on l’appelle. Le code de la macro disparaît après la compilation Une macro possède un nom, et accepte des arguments. Forme générale d’une macro : .macro nom_macro arg1,arg2,...,argn ......... Instructions ......... .endm .macro add3 val1,val2,val3 mov eax,\val1 add eax,\val2 add eax,\val3 .endm …………………………………….. add3 10,15,30 add3 eax,notes[10],45 Les instructions systèmes Moyen de communiquer avec le système d’exploitation. L’instruction int sert à déclencher une uploads/S4/ support-asm.pdf