Pour mieux comprendre la structure interne d'un ordinateur, nous aborderons la langage d'assemblage d'un processeur contemporain, le Pentium III d'Intel. Le but du cours n'est donc pas de faire de vous des programmeurs en assembleur.
Qu'est-ce que l'assembleur ou le langage d'assemblage ? Pour obtenir une réponse à cette question, nous vous recommandons de lire à ce stade-ci le chapitre 13 du volume de Zanella et Ligier.
Sommaire
1. Introduction ...................................................................................................................1 2. Architecture du Pentium 4 ...............................................................................................3 2.1 Historique.................................................................................................................3 2.2 Registres d'entiers....................................................................................................5 2.3 Registres de virgule flottante ...................................................................................8 2.4 Registres MMX........................................................................................................9 2.5 Registres SIMD........................................................................................................9 2.6 Le registre EFLAGS ................................................................................................9 2.7 Autres registres ......................................................................................................10 3. Outils de programmation ...............................................................................................12 3.1 Masm32..................................................................................................................12 3.2 Déboguage .............................................................................................................13 4. Types de données...........................................................................................................19 4.1 Entiers ....................................................................................................................19 4.2 Virgule flottante .....................................................................................................20 4.3 MMX......................................................................................................................20 4.4 SIMD......................................................................................................................21 4.5 Rangement des données en mémoire.....................................................................21 4.6 Temps d'exécution des instructions.......................................................................22 5. Structures de contrôle ....................................................................................................24 5.1 Principales structures de contrôle ..........................................................................24 5.2 Branchements.........................................................................................................26 6. Modes d'adressage.........................................................................................................31 7. Instructions de base........................................................................................................34 7.1 Directives de base....................................................................................................35 7.2 Un premier exemple : addition de deux nombres....................................................37 7.3 Un deuxième exemple : conversion majuscules-minuscules ..................................38 7.4 Un troisième exemple : recherche du maximum.....................................................39 7.5 Entrées-sorties en mode console .............................................................................40 7.6 Chaînes de caractères ..............................................................................................42 7.7 Comparaison de chaînes..........................................................................................46 7.8 Recherche d'une chaîne dans une autre...................................................................47 7.9 Transposée d'une matrice........................................................................................48 8. Instructions arithmétiques 8.1 Addition...................................................................................................................48 iv Assembleur 8.2 Soustraction .............................................................................................................52 8.3 Multiplication ..........................................................................................................52 8.4 Division ...................................................................................................................55 8.5 Décalages et rotations..............................................................................................56 8.6 Racine carrée par la méthode de Newton................................................................60 9. Conversions....................................................................................................................62 9.1 Conversion décimal à binaire ..................................................................................62 9.2 Conversion binaire à décimal ..................................................................................63 9.3 Conversion binaire à chaîne hexadécimale .............................................................66 10. La pile ..........................................................................................................................69 101 Empilement et dépilement......................................................................................69 10.2 Sous-programmes..................................................................................................71 10.3 Blocs de pile ..........................................................................................................73 10.4 Récursivité.............................................................................................................76 10.5 Tables de sauts.......................................................................................................77 11. Interruptions.................................................................................................................79 11.1 Interruptions logicielles .........................................................................................79 11.2 Interruptions matérielles........................................................................................82 12. Directives d'assemblage et macros..............................................................................89 12.1 Directives d'assemblage........................................................................................89 12.2 Directives d'assemblage conditionnel...................................................................92 12.3 Macros ...................................................................................................................94 12.4 Directives pour structures de contrôle et programmation structurée.....................95 La librairie MASM32 ........................................................................................................97 Corrigé des exercices .........................................................................................................99
Accédez gratuitement au plan de ce document en vous connectant.
Extraits
[...] On obtient : Ceci n'est pas le résultat escompté. Par contre, on n'aurait pas de problème si on partait de la fin : BlockMove proc source:LPBYTE, destination:LPBYTE, octets:WORD mov esi, Source mov edi, Destination movzx ecx, word ptr octets ; compteur = nb. octets à copier mov eax, ecx dec eax add esi, eax ; ajouter octets-1 à esi et edi add edi, eax ; pour partir de la fin std ; direction vers le bas rep movsb ; copier les octets ret BlockMove endp Comme règle générale, si l'adresse de la destination est supérieure à celle de la source, on copie vers le bas à partir de la fin de la source vers la fin de la destination, sinon on copie vers le haut à partir du début de la source vers le début de la destination. [...]
[...] mov esi, string1 repe cmpsb ; comparer tant qu'il y a égalité je egal ja sup inf: mov ax, ; string1 string2 ret StrCmp endp Assembleur Recherche d'une chaîne dans une autre Il s'agit de trouver d'une chaîne de caractères dans une autre, par exemple, trouver un mot ou une phrase dans un texte. Soit source la chaîne à trouver et destination le texte à parcourir. On doit se fixer une longueur maximum ou arrêter lors d'un caractère de fin de chaîne. [...]
[...] À la fin de l'opération R contient le reste et le quotient. Avec un exemple numérique, vous observerez que les opérations sont exactement les mêmes qu'avec la méthode manuelle. / Assembleur 59 Pour illustrer le principe, voici un algorithme pour la division d'un registre de 32 bits par un registre de 32 bits. mov mov mov mov xor rcl rcl clc cmp jb sub stc loop rcl ret Division de précision Supposons qu'on veuille effectuer la division d'un nombre de 128 bits par un nombre de 64 bits. [...]
[...] Avec le Pentium, étant donné le petit nombre de registres disponibles, cette technique n'est utilisable que si on n'a qu'un ou deux paramètres. Passage par la pile Lors d'un passage par la pile, le programme appelant empile d'abord les paramètres. Il exécute ensuite l'instruction call, qui empile l'adresse de retour. Au moment d'entrer dans le sous-programme, la pile a donc l'allure suivante : 0 &retour CALL Param2 Param1 ESP après CALL ESP avant CALL ESP initial : Figure 28 L'ordre d'empilement des paramètres dépend du langage. [...]
[...] Il faut le faire exécuter pas à pas dans le débogueur ou ajouter une sortie comme on va voir dans la section Assembleur Un deuxième exemple : conversion majuscules-minuscules Il s'agit ici de convertir une chaîne de caractères en minuscules ; processeur = Pentium .model flat, stdcall ; un seul segment de 4Go, appel standard option casemap: none ; l'assembleur respecte les majuscules et minuscules \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib ; librairie où se trouve ExitProcess ; variables globales initialisées monTexte db "Chaine A CONvertIR",0 .data? ; variables globales non initialisées . [...]
