Unité A4: Modes d’adressage et instructions de base Objectifs : À la fin de cette unité, vous saurez comment on réfère aux opérandes mémoire et connaîtrez quelques instructions de base du Pentium. ©Pierre Marchand, 2001 110 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Adressage immédiat mov eax,0122Bh ; la valeur 0x122B (465110) est placée ; dans eax Adressage registre mov ebx,eax Adressage direct mov eax,variable ©Pierre Marchand, 2001 ; le contenu de eax est copié dans ebx. ; variable est interprété comme une ; adresse ; ce mode est rarement utilisé en mode ; protégé 111 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Adressage implicite Certaines instructions n’ont pas d’opérande explicite et la description de l’adresse est contenue dans l’instruction ellemême ou dans des registres prédéfinis : • • • • mul bx loop etiq ret xlat ©Pierre Marchand, 2001 ; utilise AX comme opérande et comme destination ; décrémente cx et si cx ≠ 0, saute à etiq. ; dépile l’adresse de retour ; utilise EBX et AL 112 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Adressage implicite Certaines instructions n’ont pas d’opérande explicite et la description de l’adresse est contenue dans l’instruction ellemême ou dans des registres prédéfinis : • • • • ret xlat mul bx loop etiq ©Pierre Marchand, 2001 ; dépile l’adresse de retour ; utilise EBX et AL ; utilise AX comme opérande et comme destination ; décrémente cx et si cx ≠ 0, saute à etiq. 113 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Indirection registre mov edx,[ebx] ; adresse dans ebx; contenu copié dans edx. Les registres suivants peuvent servir de registre de base : eax edi ebx esi ecx ebp edx esp Pour spécifier la taille des transferts, on utilisera généralement la forme : mov dword ptr [ebx], 32 mov word ptr [ebx], 1000 mov byte ptr [ebx], 27 ©Pierre Marchand, 2001 114 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Indirection registre avec offset mov eax,[ebx + 8] ; adresse = ebx + 8 Indirection registre avec offset registre (index) mov [ebx + edi * k], eax ©Pierre Marchand, 2001 115 ; adresse = ebx + edi * k Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Indirection registre avec index + offset mov ax,[ebx + esi * k + 2] ; adresse= ebx + esi*k + 2 Les registres suivants peuvent servir d’index : eax edi ebx esi ecx ebp edx Dans ce mode d’adressage, la constante k permet d’ajuster l’instruction à la taille de l’opérande, de façon à accéder directement au ieme élément d’un tableau. ©Pierre Marchand, 2001 116 Unité A4: Modes d’adressage et instructions de base 6. Modes d’adressage Pour des octets (char, byte, Boolean), k = 1, pour des short, k = 2, pour des long, k = 4, pour des double, k = 8. Exemple: .data tableau dw 50, 75, 342, 9, … .code ... lea ebx, tableau mov esi, i mov ax, [ebx + esi * 2] ... ©Pierre Marchand, 2001 117 ; ax = tableau[i] Unité A4: Modes d’adressage et instructions de base 7. Instructions de base mov L'instruction la plus utilisée est l'instruction mov, qui copie la valeur d'un opérande source dans un opérande destination. La syntaxe est la suivante : mov mov mov mov mov ©Pierre Marchand, 2001 reg, reg reg, mem mem, reg reg, immed mem, immed 118 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base lea lea calcule l'adresse effective de l'opérande source et place le résultat dans l'opérande destination. lea reg, mem C'est la façon de mettre dans un registre l'adresse d'une variable. Par exemple, l'instruction : lea eax, toto place dans eax l'adresse mémoire de la variable toto. Ceci n’a généralement d’intérêt que si toto est une variable de type tableau. ©Pierre Marchand, 2001 119 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base lea L'instruction lea permet aussi d'obtenir une multiplication, une addition et une assignation en un cycle : lea ebx, [esi*4+7] Quand doit-on utiliser lea au lieu de mov ? • Pour les paramètres d'une fonction, on utilise toujours mov. • Pour les variables, on utilise lea lorsqu'il s'agit d'une variable de type tableau, mais on utilise mov lorsqu'il s'agit d'un pointeur ou d'un type simple. ©Pierre Marchand, 2001 120 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Variantes de mov : movzx et movsx Supposons que bl contient 0x94 movzx ax, bl -> ax = 0094 movsx ax, bl -> ax = FF94 movzx movsx eax, bl eax, bl = + 148 sur 16 bits = –108 sur 16 bits -> eax = 00000094 -> eax = FFFFFF94 Permettent de changer le type d’une variable ©Pierre Marchand, 2001 121 = + 148 sur 32 bits = – 108 sur 32 bits Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base Définition de variables .data db db dw dw dd dd .data? db dw 0 "Toto", 0 100 1, 2, 3 0F70ABCDh 10 dup(0) ; définit un octet initialisé à 0 ; définit une chaîne de caractères terminée par un NULL ; définit un mot initialisé à 100 (0x64) ; définit un tableau de trois mots initialisés à 1, 2, 3 ; définit un mot double initialisé à 0xF70ABCD ; définit un tableau de 10 valeurs initialisées à 0 ? 10 dup(?) ; définit un octet non initialisé ; définit un tableau de 10 mots non initialisés ©Pierre Marchand, 2001 122 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base Définition de constantes .const dix equ 10 Type de processeur .386, .486, ou .586 Début du programme .code Appel d'une fonction ou d'une procédure ou d'un sous-programme : invoke fonction a, b, c ; appelle fonction(a, b, c) Le résultat d'une fonction est toujours dans al, ax ou eax, selon que la taille du résultat est 8, 16 ou 32 bits. ©Pierre Marchand, 2001 123 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base Inclusion de fonctions de librairie include includelib \masm32\include\kernel32.inc \masm32\lib\kernel32.lib Fin du programme end ©Pierre Marchand, 2001 124 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base Tous vos programmes assembleur devront donc avoir la structure suivante : .586 ; processeur = Pentium .model flat, stdcall ; un seul segment de 4Go, appel standard option casemap: none ; l'assembleur respecte les majuscules et minuscules ;-----------------------------------------------------------------------------------------------include \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib ; librairie où se trouve ExitProcess ;-----------------------------------------------------------------------------------------------maFonction PROTO: a:DWORD ; prototype de maFonction ;-----------------------------------------------------------------------------------------------.data ; variables globales initialisées … .data? ; variables globales non initialisées … ©Pierre Marchand, 2001 125 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base .code ;-----------------------------------------------------------------------------------------------start: invoke maFonction, 100 ; appel de maFonction(100) invoke ExitProcess, 0 ; retour à Windows ;-----------------------------------------------------------------------------------------------maFonction proc a:DWORD ; déclaration de maFonction(a) LOCAL b:WORD ; variable locale LOCAL c[10]:BYTE ; tableau local … maFonction endp ;-----------------------------------------------------------------------------------------------end start ; fin du programme ©Pierre Marchand, 2001 126 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.1 Directives de base Votre programme principal doit commencer à start et se terminer par ExitProcess(0). Les sous-programmes appelés par ce programme sont définis entre ExitProcess et end start. Ces fonctions doivent avoir un prototype avant les déclarations de données .data et .data?. On peut déclarer des variables locales dans les fonctions comme c'est le cas pour b et c ci-dessus. b est un mot, c est une chaîne de 10 octets. Au besoin, on pourra inclure d'autres fichiers d'en-tête, telles que windows.inc, user32.inc, gdi32.inc et masm32.inc et les librairies correspondantes user32.lib, gdi32.lib et masm32.lib. ©Pierre Marchand, 2001 127 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.2 Un premier exemple : addition de deux nombres .586 ; processeur = Pentium .model flat, stdcall ; un seul segment de 4Go, appel standard option casemap: none ; l'assembleur respecte les majuscules et minuscules ;-----------------------------------------------------------------------------------------------include \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib ; librairie où se trouve ExitProcess ;-----------------------------------------------------------------------------------------------.data ; variables globales initialisées x dw 175 y dw 150 .data? ; variable globale non initialisée z dw ? ©Pierre Marchand, 2001 128 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.2 Un premier exemple .code ;-----------------------------------------------------------------------------------------------start: ; programme principal mov ax, x ; on utilise ax parce que x = word = 16 bits add ax, y mov z, ax ;z=x+y invoke ExitProcess, 0 ;-----------------------------------------------------------------------------------------------end start ©Pierre Marchand, 2001 129 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.3 Un deuxième exemple : conversion majuscule à minuscule .586 ; processeur = Pentium .model flat, stdcall ; un seul segment de 4Go, appel standard option casemap: none ; l'assembleur respecte les majuscules et minuscules ;-----------------------------------------------------------------------------------------------include \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib ; librairie où se trouve ExitProcess ;-----------------------------------------------------------------------------------------------.data ; variables globales initialisées monTexte db "Chaine A CONvertIR",0 ; chaîne terminée par un NULL .data? ; variables globales non initialisées … ©Pierre Marchand, 2001 130 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.3 Un deuxième exemple .code ;-----------------------------------------------------------------------------------------------start: lea esi, monTexte ; adresse du texte à convertir repete: mov al, [esi] ; lire un caractère cmp al, 0 ; si c'est un NULL, terminé jz endWhile si: cmp al, 'A' ; si c'est une majuscule (entre A et Z) jb finSi cmp al, 'Z' ja finSi add al, 'a'-'A' ; convertir en minuscule mov [esi], al ; récrire le caractère modifié où on l'avait pris finSi: inc esi ; pointer sur caractère suivant ©Pierre Marchand, 2001 131 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.3 Un deuxième exemple jmp repete endWhile: invoke ExitProcess, 0 ; retour à Windows ;-----------------------------------------------------------------------------------------------end start ; fin du programme ©Pierre Marchand, 2001 132 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum Nous passons à un exemple un peu plus élaboré, qui comporte un programme principal qui appelle un sous-programme appelé FindMax. Une telle fonction serait définie ainsi en C : short FindMax(short * nombres, short n) et serait appelée comme suit pour trouver le maximum d'un tableau de 6 nombres de 16 bits appelé Liste et place le résultat dans Max : Max = FindMax(Liste, 6); ©Pierre Marchand, 2001 133 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum .586 ; processeur = Pentium .model flat, stdcall ; un seul segment de 4Go, appel standard option casemap: none ; l'assembleur respecte les majuscules et minuscules include \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib ; librairie où se trouve ExitProcess Findmax PROTO :DWORD, :WORD ; prototype de notre fonction ;------------------------------------------------------------------------------------------------.data ; données initialisées Liste dw 100, 326, -7, 21, 4, 8 ; 6 mots initialisés = données à traiter .data? ; données non initialisées Max dw ? ; espace pour résultat ©Pierre Marchand, 2001 134 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum .code ;------------------------------------------------------------------------------------------------start: invoke Findmax, ADDR Liste, n ; programme principal mov Max, ax ; écriture du résultat invoke ExitProcess, 0 ; retour à Windows ;-------------------------------------------------------------------------------------------------FindMax proc nombres:DWORD, n:WORD mov esi, nombres ; adresse de nombres = List mov cx, n ; n est word et doit être ≥ 0 mov ax,[esi] ; max = premier élément add esi,2 ; pointer sur l'élément suivant dec cx ; on a déjà lu un élément ©Pierre Marchand, 2001 135 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum wh: cmp jz cmp jge mov add dec jmp finWh: cx, 0 finWh ax, [esi] next ax, [esi] esi, 2 cx wh ; répéter tant que compteur != 0 ; max < élément ? ; ou encore ja pour non signé ; si oui, prendre comme nouveau maximum ; incrémenter pointeur ; décrémenter compteur ; le résultat est dans ax ; retour au programme principal ret Findmax endp ;-------------------------------------------------------------------------------------------------end start ©Pierre Marchand, 2001 136 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.5 Entrées/sorties en mode console Les librairies fournies avec Masm32 contiennent des fonctions élémentaires pour l'entrée de données et l'affichage de résultats. La fonction StdIn permet de lire une chaîne de caractères au clavier. La fonction StdOut permet d'afficher une chaîne de caractères à l'écran. Pour pouvoir afficher des nombres, il faut les convertir en caractères avant de passer le résultat à StdOut. À cette fin, la fonction dwtoa convertit un nombre binaire de 32 bits en chaîne de caractères. Pour entrer des nombres, il faut convertir en nombre les caractères lus avec StdIn. On peut utiliser la fonction atodw, qui convertit une chaîne de caractères en nombre de 32 bits. ©Pierre Marchand, 2001 137 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.5 Entrées/sorties en mode console Ainsi, dans l'exemple précédent, on aurait pu afficher le résultat en ajoutant au début : include \masm32\include\masm32.inc includelib \masm32\lib\masm32.lib Ajouter dans la section .data? monMsg db 10 dup(?) ; 10 octets pour caractères Puis, juste avant invoke ExitProcess, 0 movzx eax, word ptr Max ; convertir Max sur 32 bits invoke dwtoa , eax, ADDR monMsg ; convertir eax en caractères invoke StdOut, ADDR monMsg ; afficher monMsg ici: jmp ici ; attendre CTL-C avant de quitter Finalement, il faut compiler au moyen de Console Assemble & Link. ©Pierre Marchand, 2001 138 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.5’ Programmation Windows On n’utilise plus la console dans les applications contemporaines, mais plutôt une fenêtre avec menus, boutons, bandes de défilement, case de fermeture, etc. Par exemple : Pour réaliser de telles applications, il faut faire appel aux libraires de Windows (API). La programmation Windows dépasse le cadre de ce cours, mais vous trouverez des exemples dans les travaux pratiques. ©Pierre Marchand, 2001 139 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère • la chaîne C, qui contient les codes ASCII des caractères et se termine par un octet NULL (0x00 ou \0) ; Exemple : char chaine[ ] = {”Toto”}; sera définie en assembleur : chaine db ‘Toto’, 0 T o ©Pierre Marchand, 2001 t 54 6F 74 6F 00 o \0 140 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère • la chaîne Pascal, qui débute par un octet de longueur suivi des codes ASCII des caractères ; cette chaîne est limitée à 255 caractères ; 04 54 6F 74 6F chaineP db 4, ‘Toto’ ©Pierre Marchand, 2001 141 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère • la chaîne PC, qui combine la chaîne Pascal avec la chaîne C : un octet de longueur au début et un octet NULL à la fin ; cette chaîne est également limitée à 255 caractères ; 04 54 6F 74 6F 00 chainePC db 4, ’Toto’, 0 ©Pierre Marchand, 2001 142 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère • la chaîne ASIS ou telle quelle, qui n'a ni octet de longueur, ni caractère de fin de chaîne ; l'information sur sa longueur doit être conservée ailleurs. chaine db ‘Toto’ ©Pierre Marchand, 2001 143 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère L’instruction scas : scasb/scasw/scasd : scan string byte/word/double strlen proc src:LPSTR ou DWORD mov al, 0 ; al = 0 = caractère à trouver mov edi, src ; edi = adresse de src mov ecx, 0xffffffff ; longueur maximale = 4294967295 cld ; direction vers le haut repne scasb ; scan tant que pas égal à al (0) fin: neg ecx lea eax, -2 [ecx] ; 2 de trop ret ; résultat dans eax strlen endp ©Pierre Marchand, 2001 144 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère L’instruction scas : scasb, scasw, scasd • Pour chaque élément de la chaîne, l'élément pointé par edi est soustrait de la valeur de l'accumulateur et les indicateurs sont mis à jour pour refléter le résultat, bien que ce dernier ne soit pas enregistré. • Le registre edi est automatiquement ajusté de la bonne quantité à chaque itération. Incrémenté si DF est 0, décrémenté si DF = 1. La quantité est 1 pour scasb, 2 pour scasw et 4 pour scasd. • Le préfixe repne ou repnz indique qu’il faut répéter tant que le résultat de l ’instruction scas ne donne pas ZF = 1. • Après l’exécution, edi pointe sur l’élément suivant la dernière comparaison. ©Pierre Marchand, 2001 145 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère L’instruction cmpsb/cmpsw/cmpsd : compare string byte/word/double • permet de comparer deux chaînes élément par élément afin de trouver la premier élément différent (avec repe) ou encore le premier élément égal (avec repne). • esi doit pointer vers la chaîne source et edi vers la chaîne destination. ecx doit contenir le maximum d'éléments à comparer. À chaque comparaison, edi et esi sont ajustés de la taille d'un élément : incrémentés si DF = 0 et décrémentés si DF = 1. • Après l’exécution, edi et esi pointent sur les éléments suivant la dernière comparaison. ©Pierre Marchand, 2001 146 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.2 Chaînes de caractère L’instruction cmpsb/cmpsw/cmpsd : compare string byte/word/double strcmp str1:LPSTR, str2:LPSTR mov esi, str1 mov edi, str2 mov ecx, 0xffffffff cld repe cmpsb sub esi, 1 ; 1 de trop sub esi, str1 ; nb de caractères comparés mov eax, esi ; résultat dans eax Ret strcmp endp ©Pierre Marchand, 2001 147 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère Les instructions ldsb/ldsw/ldsd et stosb/stosw/stosd : load string byte/word/double et store string byte/word/double • stos peut être utilisée avec un préfixe rep pour remplir une partie de la mémoire avec une même valeur. • Ceci n’est pas possible avec lds, car il n’y a aucune raison de vouloir remplir le même registre avec des valeurs de mémoire. ©Pierre Marchand, 2001 148 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère Les instructions ldsb/ldsw/ldsd et stosb/stosw/stosd : strcpy proc dst:LPSTR, src:LPSTR mov edi,dst ; adresse de la destination mov esi,src ; adresse de la source cld ; direction vers le haut While: lodsb ; copier un octet stosb cmp al, 0 jnz While ; tant que le car ≠ 0 ret strcpy endp ©Pierre Marchand, 2001 149 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère Les instructions ldsb/ldsw/ldsd et stosb/stosw/stosd : Sous-programme de concaténation de chaînes : Chaîne destination Ceci est un test\0 Chaîne source important\0 Résultat Ceci est un test important\0 ©Pierre Marchand, 2001 150 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère Les instructions ldsb/ldsw/ldsd et stosb/stosw/stosd : Sous-programme de concaténation de chaînes : • 1e étape : trouver la longueur de la chaîne destination pour savoir où placer la chaîne source. • 2e étape : soustraire 1 pour écrire par-dessus le \0 de la destination. • 3e étape : copier la chaîne source avec son \0 à la fin de la chaîne destination. ©Pierre Marchand, 2001 151 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.6 Chaînes de caractère Les instructions ldsb/ldsw/ldsd et stosb/stosw/stosd : strcat proc dst:LPSTR, src:LPSTR mov edi, dest mov esi, src xor eax, eax mov ecx, 0xffffffff cld repne scasb dec edi While: lodsb stosb test al, al jne While ret strcat endp ©Pierre Marchand, 2001 152 ; adresse de la destination ; adresse de la source ; on va chercher un caractère NULL ; longueur maximale ; direction vers le haut ; trouver la fin de la chaîne dest ; éliminer le \0 à la fin ; copier octets de src ; vers dest ; tant que != 0 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Les fonctions que nous venons de voir impliquent la copie de données d'un endroit à l'autre de la mémoire. Ceci semble ne pas présenter de problèmes, mais il faut en général prendre certaines précautions. En effet, considérons une fonction que nous pouvons appeler Blockmove, qui déplace un certain nombre d'octets d'une adresse à une autre. void BlockMove(Source , Destination, Octets) Par exemple, soit 0x1000 l'adresse de la Source et 0x1003 celle de la Destination, et soit Octets = 5, comme suit : Adresse : 1000 Contenu: 1 ©Pierre Marchand, 2001 1001 2 1002 3 153 1003 4 1004 5 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Adresse : Contenu: 1000 1 1001 2 1002 3 1003 4 1004 5 On voudrait avoir : 1 2 3 4 5 -> 1 2 3 1 2 3 4 5 Essayons l'implémentation suivante : BlockMove proc source:LPBYTE, destination:LPBYTE, octets:WORD mov esi, source mov edi, destination movzx ecx,word ptr octets ; compteur = nb. d'octets à copier cld ; Direction vers le haut rep movsb ; copier les octets ret BlockMove endp ©Pierre Marchand, 2001 154 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base On obtient : 1 2 3 1 5 1 1 1 1 2 2 2 2 3 3 3 3 1 1 1 1 2 2 3 2 3 1 2 3 1 2 Ceci n'est pas le résultat escompté qui était : 1 2 3 1 2 3 4 5 ©Pierre Marchand, 2001 155 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Par contre, on n’aurait pas de problème si on partait de la fin : BlockMove proc destination:LPBYTE, source: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 ©Pierre Marchand, 2001 156 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 1 2 3 4 5 . . 5 1 2 3 4 5 . 4 5 1 2 3 4 5 3 4 5 1 2 3 4 2 3 4 5 1 2 3 1 2 3 4 5 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. ©Pierre Marchand, 2001 157 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Tels quels, ces deux programmes seraient trop lents. Il vaudrait mieux transférer les données en blocs plus grands, au moyen, par exemple, de l’instruction movsd. Toutefois, le programme devient un peu plus compliqué si le nombre d’octets à transférer n’est pas un multiple de 4. ©Pierre Marchand, 2001 158 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.7 Comparaison de chaînes Comparaison de deux chaînes de caractères string1 et string2 et retourne dans ax : -1, si string1 < string2, 0, si string1 = string2 1, si string1 > string2 StrCmp proc string1:LPSTR, string2:LPSTR cld ; on compare vers le haut mov edi, string2 mov ecx, -1 mov al, 0 ; on va déterminer la longueur de string2 repne scasb neg ecx ©Pierre Marchand, 2001 ; rendre positif 159 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.7 Comparaison de chaînes inf: lea ecx, [ecx-1] ; résultat dans ecx, pointe après le null. mov esi, string1 repe cmpsb ; comparer tant qu'il y a égalité je egal ; indicateurs affectés par cmpsb ja sup mov ax, -1 ; string1 < string2 ax, ax ; string1 = string2 ax, 1 ; string1 > string2 ret egl: xor ret sup: mov ret StrCmp endp ©Pierre Marchand, 2001 160 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.8 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. Notre programme sera plus général si on donne une longueur. Le programme sera donc appelé comme suit : invoke StrSrch, source, longueur, destination, plage où longueur est la longueur de la chaîne source et plage est la longueur du texte à parcourir. Si la chaîne source est trouvée dans le texte, la fonction retournera dans eax l'adresse où elle débute, sinon elle retournera -1. ©Pierre Marchand, 2001 161 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.8 Recherche d ’une chaîne dans une autre StrSrch proc source:LPSTR, longueur:WORD, destination:LPSTR, plage:WORD cld ; comparer vers le haut xor ecx, ecx mov esi, source mov edi, destination mov bx, plage sub bx, longueur jl pasla ; si longueur > plage, pas trouvé inc bx ; compteur mov edx, edi ; sauver edi, car cmps le modifie mov eax, esi ; idem pour esi ©Pierre Marchand, 2001 162 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.8 Recherche d ’une chaîne dans une autre lp: mov repe je inc mov mov dec jne pasla: mov ret trouv: xor ret StrSrch endp cx, longueur cmpsb trouv edx edi, edx esi, eax bx lp eax, -1 ; comparer sur longueur caractères max ; et tant qu'il y a égalité ; si toujours égalité, source trouvée dans dest ; sinon se déplacer dans destination ; restaurer edi ; restaurer esi à chaque tour ; tant que compteur > 0 eax, edx ; trouvé, retourner adresse ©Pierre Marchand, 2001 ; pas trouvé, retourner -1 163 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d ’une matrice Soit m une matrice de r rangées et c colonnes. Avec r = 3 et c = 4, on aurait, par exemple : m= 1 2 3 4 5 6 7 8 9 10 11 12 Sa transposée n est : n= ©Pierre Marchand, 2001 1 2 3 4 5 9 6 10 7 11 8 12 164 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d ’une matrice En mémoire, la matrice est unidimensionnelle et est définie comme suit en assembleur : m dw 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 m dw dw dw 1, 2, 3, 4 5, 6, 7, 8 9, 10, 11, 12 ou Le résultat désiré est : 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 qu'on placera dans la matrice n : n dw 12 dup(?) ©Pierre Marchand, 2001 165 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d ’une matrice La fonction Transpose aura la syntaxe suivante : invoke Transpose, 3, 4, m, n Une réalisation possible est la suivante : 1 2 3 4 5 6 7 8 9 101112 1 5 9 2 6 10 3 7 11 4 8 12 3 3 3 ©Pierre Marchand, 2001 166 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d’une matrice 1 2 3 4 5 6 7 8 9 101112 1 5 9 2 6 10 3 7 11 4 8 12 3 3 3 1 2 3 4 5 6 7 8 9 101112 1 5 9 2 6 10 3 7 11 4 8 12 3 3 3 ©Pierre Marchand, 2001 167 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d’une matrice Transpose proc r:WORD, c:WORD, m:DWORD, n:DWORD mov esi, m mov edi, n mov cx, c ; compteur = nombre de colonnes mov bx, r xor edx, edx movzx ebx, cx lp: lodsw ; charger un élément de m mov [edi], ax ; stocker dans n lea edi,[edi+ebx*2] ; destination += 2 * r (word = 2 octets) dec cx jnz lp ; répéter c fois ©Pierre Marchand, 2001 168 Unité A4: Modes d’adressage et instructions de base 7. Instructions de base 7.9 Transposée d’une matrice mov cx, c mov edi, n inc edx lea edi, [edi+edx*2] cmp dx, r jne lp ret Transpose endp ©Pierre Marchand, 2001 169 ; restaurer compteur ; repartir au début ; décaler de 1 élément ; répéter r fois Unité A4: Modes d’adressage et instructions de base 7. Instructions de base Le code de la plupart de ces exemples est disponible sur le site du cours. http://www.ift.ulaval.ca/~marchand/ift17583/Assembleur/Code.zip Il est fourni sous la forme de projets compilables et exécutables. Ceux qui ne sont pas dans des dossiers séparés doivent être compilés avec la commande Console Assemble & Link. Ceux qui sont dans des dossiers individuels doivent être compilés avec la commande Build All. ©Pierre Marchand, 2001 170