©Pierre Marchand, 2001 110 Objectifs : À la fin de cette unité, vous saurez comment on réfère aux opérandes mémoire et connaîtrez quelques instructions.

Présentation au sujet: "©Pierre Marchand, 2001 110 Objectifs : À la fin de cette unité, vous saurez comment on réfère aux opérandes mémoire et connaîtrez quelques instructions."— Transcription de la présentation:

1 ©Pierre Marchand, 2001 110 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. Unité A4: Modes dadressage et instructions de base

2 ©Pierre Marchand, 2001 111 6. Modes dadressage Adressage immédiat moveax,0122Bh; la valeur 0x122B (4651 10 ) est placée ; dans eax Adressage registre movebx,eax; le contenu de eax est copié dans ebx. Adressage direct moveax,variable; variable est interprété comme une ; adresse ; ce mode est rarement utilisé en mode ; protégé Unité A4: Modes dadressage et instructions de base

3 ©Pierre Marchand, 2001 112 6. Modes dadressage Adressage implicite Certaines instructions nont pas dopérande explicite et la description de ladresse est contenue dans linstruction elle- même ou dans des registres prédéfinis : mul bx; utilise AX comme opérande et comme destination loopetiq; décrémente cx et si cx 0, saute à etiq. ret; dépile ladresse de retour xlat; utilise EBX et AL Unité A4: Modes dadressage et instructions de base

4 ©Pierre Marchand, 2001 113 6. Modes dadressage Adressage implicite Certaines instructions nont pas dopérande explicite et la description de ladresse est contenue dans linstruction elle- même ou dans des registres prédéfinis : ret; dépile ladresse de retour xlat; utilise EBX et AL mul bx; utilise AX comme opérande et comme destination loopetiq; décrémente cx et si cx 0, saute à etiq. Unité A4: Modes dadressage et instructions de base

5 ©Pierre Marchand, 2001 114 6. Modes dadressage Indirection registre movedx,[ebx]; adresse dans ebx; contenu copié dans edx. Les registres suivants peuvent servir de registre de base : eaxedi ebxesi ecxebp edxesp Pour spécifier la taille des transferts, on utilisera généralement la forme :movdword ptr [ebx], 32 movword ptr [ebx], 1000 movbyte ptr [ebx], 27 Unité A4: Modes dadressage et instructions de base

6 ©Pierre Marchand, 2001 115 6. Modes dadressage Indirection registre avec offset moveax,[ebx + 8]; adresse = ebx + 8 Indirection registre avec offset registre (index) mov[ebx + edi * k], eax; adresse = ebx + edi * k Unité A4: Modes dadressage et instructions de base

7 ©Pierre Marchand, 2001 116 6. Modes dadressage Indirection registre avec index + offset movax,[ebx + esi * k + 2] ; adresse= ebx + esi*k + 2 Les registres suivants peuvent servir dindex : eaxedi ebxesi ecxebp edx Dans ce mode dadressage, la constante k permet dajuster linstruction à la taille de lopérande, de façon à accéder directement au i eme élément dun tableau. Unité A4: Modes dadressage et instructions de base

8 ©Pierre Marchand, 2001 117 6. Modes dadressage 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 tableaudw50, 75, 342, 9, ….code... leaebx, tableau movesi, i movax, [ebx + esi * 2]; ax = tableau[i]... Unité A4: Modes dadressage et instructions de base

9 ©Pierre Marchand, 2001 118 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 : movreg, reg movreg, mem movmem, reg movreg, immed movmem, immed Unité A4: Modes dadressage et instructions de base

10 ©Pierre Marchand, 2001 119 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. leareg, mem C'est la façon de mettre dans un registre l'adresse d'une variable. Par exemple, l'instruction : leaeax, toto place dans eax l'adresse mémoire de la variable toto. Ceci na généralement dintérêt que si toto est une variable de type tableau. Unité A4: Modes dadressage et instructions de base

11 ©Pierre Marchand, 2001 120 7. Instructions de base lea L'instruction lea permet aussi d'obtenir une multiplication, une addition et une assignation en un cycle : leaebx, [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. Unité A4: Modes dadressage et instructions de base

12 ©Pierre Marchand, 2001 121 7. Instructions de base Variantes de mov : movzx et movsx Supposons que bl contient 0x94 movzxax, bl-> ax = 0094= + 148 sur 16 bits movsxax, bl -> ax = FF94= –108 sur 16 bits movzxeax, bl-> eax = 00000094= + 148 sur 32 bits movsxeax, bl-> eax = FFFFFF94 = – 108 sur 32 bits Permettent de changer le type dune variable Unité A4: Modes dadressage et instructions de base

13 ©Pierre Marchand, 2001 122 7. Instructions de base 7.1 Directives de base Définition de variables.data db0; définit un octet initialisé à 0 db"Toto", 0; définit une chaîne de caractères terminée par un NULL dw100; définit un mot initialisé à 100 (0x64) dw1, 2, 3; définit un tableau de trois mots initialisés à 1, 2, 3 dd0F70ABCDh; définit un mot double initialisé à 0xF70ABCD dd10 dup(0); définit un tableau de 10 valeurs initialisées à 0.data? db?; définit un octet non initialisé dw10 dup(?); définit un tableau de 10 mots non initialisés Unité A4: Modes dadressage et instructions de base

14 ©Pierre Marchand, 2001 123 7. Instructions de base 7.1 Directives de base Définition de constantes.const dixequ10 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. Unité A4: Modes dadressage et instructions de base

15 ©Pierre Marchand, 2001 124 7. Instructions de base 7.1 Directives de base Inclusion de fonctions de librairie include\masm32\include\kernel32.inc includelib\masm32\lib\kernel32.lib Fin du programme end Unité A4: Modes dadressage et instructions de base

16 ©Pierre Marchand, 2001 125 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 … Unité A4: Modes dadressage et instructions de base

17 ©Pierre Marchand, 2001 126 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 Unité A4: Modes dadressage et instructions de base

18 ©Pierre Marchand, 2001 127 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. Unité A4: Modes dadressage et instructions de base

19 ©Pierre Marchand, 2001 128 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 xdw175 ydw150.data?; variable globale non initialisée zdw? Unité A4: Modes dadressage et instructions de base

20 ©Pierre Marchand, 2001 129 7. Instructions de base 7.2 Un premier exemple.code ;------------------------------------------------------------------------------------------------ start:; programme principal movax, x; on utilise ax parce que x = word = 16 bits addax, y movz, ax; z = x + y invoke ExitProcess, 0 ;------------------------------------------------------------------------------------------------ end start Unité A4: Modes dadressage et instructions de base

21 ©Pierre Marchand, 2001 130 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 monTextedb"Chaine A CONvertIR",0 ; chaîne terminée par un NULL.data?; variables globales non initialisées … Unité A4: Modes dadressage et instructions de base

22 ©Pierre Marchand, 2001 131 7. Instructions de base 7.3 Un deuxième exemple.code ;------------------------------------------------------------------------------------------------ start: leaesi, monTexte; adresse du texte à convertir repete:moval, [esi]; lire un caractère cmpal, 0; si c'est un NULL, terminé jzendWhile si:cmpal, 'A'; si c'est une majuscule (entre A et Z) jbfinSi cmpal, 'Z' jafinSi addal, 'a'-'A'; convertir en minuscule mov[esi], al; récrire le caractère modifié où on l'avait pris finSi:incesi; pointer sur caractère suivant Unité A4: Modes dadressage et instructions de base

23 ©Pierre Marchand, 2001 132 7. Instructions de base 7.3 Un deuxième exemple jmprepete endWhile: invoke ExitProcess, 0; retour à Windows ;------------------------------------------------------------------------------------------------ end start; fin du programme Unité A4: Modes dadressage et instructions de base

24 ©Pierre Marchand, 2001 133 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); Unité A4: Modes dadressage et instructions de base

25 ©Pierre Marchand, 2001 134 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 Listedw100, 326, -7, 21, 4, 8; 6 mots initialisés = données à traiter.data? ; données non initialisées Maxdw?; espace pour résultat Unité A4: Modes dadressage et instructions de base

26 ©Pierre Marchand, 2001 135 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum.code ;------------------------------------------------------------------------------------------------- start:invokeFindmax, ADDR Liste, n; programme principal movMax, ax; écriture du résultat invokeExitProcess, 0; retour à Windows ;-------------------------------------------------------------------------------------------------- FindMax proc nombres:DWORD, n:WORD movesi, nombres; adresse de nombres = List movcx, n; n est word et doit être 0 movax,[esi]; max = premier élément addesi,2; pointer sur l'élément suivant deccx; on a déjà lu un élément Unité A4: Modes dadressage et instructions de base

27 ©Pierre Marchand, 2001 136 7. Instructions de base 7.4 Un troisième exemple : recherche du maximum wh:cmpcx, 0 ; répéter tant que compteur != 0 jzfinWh cmpax, [esi]; max < élément ? jgenext; ou encore ja pour non signé movax, [esi]; si oui, prendre comme nouveau maximum addesi, 2; incrémenter pointeur deccx; décrémenter compteur jmpwh finWh:; le résultat est dans ax ret; retour au programme principal Findmax endp ;-------------------------------------------------------------------------------------------------- end start Unité A4: Modes dadressage et instructions de base

28 ©Pierre Marchand, 2001 137 7. Instructions de base 7.5 Entrées/sorties en mode console Les librairies fournies avec Masm32 contiennent des fonctions élémen- taires 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. Unité A4: Modes dadressage et instructions de base

29 ©Pierre Marchand, 2001 138 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 movzxeax, word ptr Max; convertir Max sur 32 bits invokedwtoa, eax, ADDR monMsg; convertir eax en caractères invokeStdOut, ADDR monMsg; afficher monMsg ici:jmpici; attendre CTL-C avant de quitter Finalement, il faut compiler au moyen de Console Assemble & Link. Unité A4: Modes dadressage et instructions de base

30 ©Pierre Marchand, 2001 139 7. Instructions de base 7.5 Programmation Windows On nutilise 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. Unité A4: Modes dadressage et instructions de base

31 ©Pierre Marchand, 2001 140 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 Unité A4: Modes dadressage et instructions de base Toto\0546F746F 00

32 ©Pierre Marchand, 2001 141 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 ; chaineP db 4, Toto Unité A4: Modes dadressage et instructions de base 546F746F04

33 ©Pierre Marchand, 2001 142 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 ; chainePC db 4, Toto, 0 Unité A4: Modes dadressage et instructions de base 546F746F0400

34 ©Pierre Marchand, 2001 143 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 Unité A4: Modes dadressage et instructions de base

35 ©Pierre Marchand, 2001 144 7. Instructions de base 7.6 Chaînes de caractère Linstruction scas : scasb/scasw/scasd : scan string byte/word/double strlen proc src:LPSTR ou DWORD moval, 0; al = 0 = caractère à trouver movedi, src; edi = adresse de src movecx, 0xffffffff; longueur maximale = 4294967295 cld; direction vers le haut repnescasb; scan tant que pas égal à al (0) fin:negecx leaeax, -2 [ecx]; 2 de trop ret; résultat dans eax strlen endp Unité A4: Modes dadressage et instructions de base

36 ©Pierre Marchand, 2001 145 7. Instructions de base 7.6 Chaînes de caractère Linstruction 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 quil faut répéter tant que le résultat de l instruction scas ne donne pas ZF = 1. Après lexécution, edi pointe sur lélément suivant la dernière comparaison. Unité A4: Modes dadressage et instructions de base

37 ©Pierre Marchand, 2001 146 7. Instructions de base 7.6 Chaînes de caractère Linstruction 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 lexécution, edi et esi pointent sur les éléments suivant la dernière comparaison. Unité A4: Modes dadressage et instructions de base

38 ©Pierre Marchand, 2001 147 7. Instructions de base 7.2 Chaînes de caractère Linstruction cmpsb/cmpsw/cmpsd : compare string byte/word/double strcmp str1:LPSTR, str2:LPSTR movesi, str1 movedi, str2 movecx, 0xffffffff cld repecmpsb subesi, 1; 1 de trop subesi, str1; nb de caractères comparés moveax, esi; résultat dans eax Ret strcmp endp Unité A4: Modes dadressage et instructions de base

39 ©Pierre Marchand, 2001 148 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 nest pas possible avec lds, car il ny a aucune raison de vouloir remplir le même registre avec des valeurs de mémoire. Unité A4: Modes dadressage et instructions de base

40 ©Pierre Marchand, 2001 149 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 movedi,dst; adresse de la destination movesi,src; adresse de la source cld; direction vers le haut While:lodsb; copier un octet stosb cmpal, 0 jnzWhile; tant que le car 0 ret strcpy endp Unité A4: Modes dadressage et instructions de base

41 ©Pierre Marchand, 2001 150 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 Chaîne source Résultat Unité A4: Modes dadressage et instructions de base important\0 Ceci est un test\0 Ceci est un test important\0

42 ©Pierre Marchand, 2001 151 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 : 1 e étape : trouver la longueur de la chaîne destination pour savoir où placer la chaîne source. 2 e étape : soustraire 1 pour écrire par-dessus le \0 de la destination. 3 e étape : copier la chaîne source avec son \0 à la fin de la chaîne destination. Unité A4: Modes dadressage et instructions de base

43 ©Pierre Marchand, 2001 152 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 movedi, dest; adresse de la destination movesi, src; adresse de la source xoreax, eax; on va chercher un caractère NULL movecx, 0xffffffff; longueur maximale cld; direction vers le haut repnescasb; trouver la fin de la chaîne dest decedi; éliminer le \0 à la fin While:lodsb; copier octets de src stosb; vers dest testal, al; tant que != 0 jne While ret strcat endp Unité A4: Modes dadressage et instructions de base

44 ©Pierre Marchand, 2001 153 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 :10001001100210031004 Contenu:12345 Unité A4: Modes dadressage et instructions de base

45 ©Pierre Marchand, 2001 154 7. Instructions de base 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 movesi, source mov edi, destination movzxecx,word ptr octets ; compteur = nb. d'octets à copier cld; Direction vers le haut repmovsb; copier les octets ret BlockMove endp Unité A4: Modes dadressage et instructions de base Adresse :10001001100210031004 Contenu:12345

46 ©Pierre Marchand, 2001 155 7. Instructions de base On obtient : Ceci n'est pas le résultat escompté qui était : 1 2 3 1 2 3 4 5 Unité A4: Modes dadressage et instructions de base 1 2 3 1 5 1 2 3 1 2 1 2 3 1 2 3 1 2 3 1 1 2 3 1 2 3 1 2

47 ©Pierre Marchand, 2001 156 7. Instructions de base Par contre, on naurait pas de problème si on partait de la fin : BlockMove proc destination:LPBYTE, source:LPBYTE, octets:WORD movesi, source mov edi, destination movzxecx, word ptr octets ; compteur = nb. octets à copier moveax, ecx deceax addesi, eax; ajouter octets-1 à esi et edi addedi, eax; pour partir de la fin std; direction vers le bas repmovsb; copier les octets ret BlockMove endp Unité A4: Modes dadressage et instructions de base

48 ©Pierre Marchand, 2001 157 7. Instructions de base Comme règle générale, si ladresse 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. Unité A4: Modes dadressage et 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

49 ©Pierre Marchand, 2001 158 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 linstruction movsd. Toutefois, le programme devient un peu plus compliqué si le nombre doctets à transférer nest pas un multiple de 4. Unité A4: Modes dadressage et instructions de base

50 ©Pierre Marchand, 2001 159 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 movedi, string2 movecx, -1 moval, 0; on va déterminer la longueur de string2 repnescasb negecx; rendre positif Unité A4: Modes dadressage et instructions de base

51 ©Pierre Marchand, 2001 160 7. Instructions de base 7.7 Comparaison de chaînes leaecx, [ecx-1]; résultat dans ecx, pointe après le null. movesi, string1 repecmpsb; comparer tant qu'il y a égalité jeegal; indicateurs affectés par cmpsb jasup inf:movax, -1; string1 < string2 ret egl:xorax, ax; string1 = string2 ret sup:movax, 1; string1 > string2 ret StrCmp endp Unité A4: Modes dadressage et instructions de base

52 ©Pierre Marchand, 2001 161 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 : invokeStrSrch, 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. Unité A4: Modes dadressage et instructions de base

53 ©Pierre Marchand, 2001 162 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 xorecx, ecx movesi, source movedi, destination movbx, plage subbx, longueur jlpasla; si longueur > plage, pas trouvé incbx; compteur movedx, edi; sauver edi, car cmps le modifie moveax, esi; idem pour esi Unité A4: Modes dadressage et instructions de base

54 ©Pierre Marchand, 2001 163 7. Instructions de base 7.8 Recherche d une chaîne dans une autre lp:movcx, longueur; comparer sur longueur caractères max repecmpsb; et tant qu'il y a égalité jetrouv; si toujours égalité, source trouvée dans dest incedx; sinon se déplacer dans destination movedi, edx; restaurer edi movesi, eax; restaurer esi à chaque tour decbx; tant que compteur > 0 jnelp pasla:moveax, -1; pas trouvé, retourner -1 ret trouv:xoreax, edx; trouvé, retourner adresse ret StrSrch endp Unité A4: Modes dadressage et instructions de base

55 ©Pierre Marchand, 2001 164 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 = Sa transposée n est : n = Unité A4: Modes dadressage et instructions de base

56 ©Pierre Marchand, 2001 165 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 : mdw1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ou mdw1, 2, 3, 4 dw5, 6, 7, 8 dw9, 10, 11, 12 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 : ndw12 dup(?) Unité A4: Modes dadressage et instructions de base

57 ©Pierre Marchand, 2001 166 7. Instructions de base 7.9 Transposée d une matrice La fonction Transpose aura la syntaxe suivante : invokeTranspose, 3, 4, m, n Une réalisation possible est la suivante : Unité A4: Modes dadressage et instructions de base 1 1 2 5 3456789101112 9261037114812 333

58 ©Pierre Marchand, 2001 167 7. Instructions de base 7.9 Transposée dune matrice Unité A4: Modes dadressage et instructions de base 1 1 2 5 3456789101112 9261037114812 333 1 1 2 5 3456789101112 9261037114812 333

59 ©Pierre Marchand, 2001 168 7. Instructions de base 7.9 Transposée dune matrice Transpose proc r:WORD, c:WORD, m:DWORD, n:DWORD movesi, m movedi, n movcx, c; compteur = nombre de colonnes movbx, r xoredx, edx movzxebx, cx lp:lodsw; charger un élément de m mov[edi], ax; stocker dans n leaedi,[edi+ebx*2]; destination += 2 * r (word = 2 octets) deccx jnzlp; répéter c fois Unité A4: Modes dadressage et instructions de base

60 ©Pierre Marchand, 2001 169 7. Instructions de base 7.9 Transposée dune matrice movcx, c; restaurer compteur movedi, n; repartir au début incedx; décaler de 1 élément leaedi, [edi+edx*2] cmpdx, r; répéter r fois jnelp ret Transpose endp Unité A4: Modes dadressage et instructions de base

61 ©Pierre Marchand, 2001 170 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. Unité A4: Modes dadressage et instructions de base