Et vous pouvez vérifier : 5*384 = 1920 ! ;-)

            Mais vous me direz : "pourquoi ne pas faire simplement un MUL ?". Et bien car SHL est beaucoup plus rapide à exécuter. Mais pour des nombres qui ont une décomposition trop longue, mieux vaut bien sur utiliser un MUL.

        E) L'opposé d'un nombre : NEG       

            L'instruction la plus simple à mon avis : NEG sert à rendre un nombre positif en négatif et inversement. Il ne demande qu'une seule opérande : la destination. Si AX = 5, alors un NEG AX mettra AX = -5. Ou si BX = -14 alors après le NEG BX, BX = 14.

    5 ° L es nombres à virgules et les nombres négatifs

        A) Les nombres à virgules    

            Le problème en assembleur c'est qu'on ne peut pas utilisé directement les nombres à virgules. Nous utiliserons les nombres à virgule fixe. Il s'agit simplement d'effectuer des calculs avec des valeurs assez grandes qui seront ensuite, redivisées pour retrouver un résultat dans un certain intervalle.

            Par exemple nous voulons multiplier 20 par 0,25. Comme on ne peut pas mettre 0,25 dans un registre on va le mettre en nombre entier en le multipliant par 256 par exemple. 0.25*256 = 64. On le multipliera à 20 et ensuite ce résultat étant 256 fois trop grand on le redivisera par 256 :

• MOV AX,64    >> On place 0,25*256 dans AX     >> AX = 64

• MOV BX,20    >> On place 20 dans BX                >> BX = 20

• MUL BX          >> On multiplie AX par BX            >> AX = AX*BX = 64*20 = 1280

• SHR AX,8        >> On divise AX par 256 (2^8)      >> AX = AX/256 = 1280/256 = 5

            Le résultat de 20*0,25 est donc bien égal à 5.

            Faîtes bien attention à ne pas effectuer de dépassement, surtout avec les nombres signés ou les grands nombres. En utilisant SHR ou SHL, plus l'opérande est grande et plus le résultat sera précis, car il y aura plus de décimales disponibles.

        B) Les nombres négatifs    

            Un autre problème, c'est qu'en décimal pour un nombre négatif on place un "-" devant le nombre, mais en binaire on ne peut mettre que des 0 ou des 1. Pour pouvoir mettre un nombre en négatif on utilise la méthode du complément à 2. Voici en quoi cela consiste :

• Convertir le nombre en binaire s'il ne l'est pas déjà

• Inverser les bits du nombre (inverser les 0 en 1 et 1 en 0)

• Ajouter 1 au nombre obtenu

            Voici un exemple avec le nombre décimal 5 au format 8 bits (octet) :

• On le convertit en binaire : 5(d) = 00000101(b)

• On inverse : 00000101 --> 11111010 (ici le format, 8 bits, est important car en 4 bits par exemple cela donnera : 1010)

• On ajoute 1 : 11111010 + 00000001 = 11111011

            -5 est donc égal à 11111011 en binaire.

            Pour que le nombre soit négatif il faut qu'il soit signé. En 8 bits en non signé les nombres vont de 0 à 255 et en signé ils vont de -128 à 127.

            Quand le nombre est signé et en 8 bits, on peut savoir s'il est négatif en regardant le 7ème bit (en partant bien sur de la droite). S'il est égal à 1 alors le nombre est négatif. Pour les nombres à 4 bits c'est le 4ème qui compte.

            Pour transformer -5 en hexadécimal, on décompose le nombre binaire en demi-octet (11111011 en 1111 et 1011). 1111b = 15d = Fh et 1011b = 11d = Ah. Donc -5d = FAh. (Petit rappel : d = décimal, b = binaire, h = hexadécimal, pour ceux qui n'aurait pas encore compris).

    6 ° L es instructions logiques

            Les opérations de ces instructions se font bit à bit. Et les opérandes et emplacements mémoires qu'elles utilisent sont en 8 ou 16 bits.

           Petit rappel : pour convertir de tête un nombre binaire en décimal : chaque rang d'un nombre binaire est un multiple de 2.

            Ainsi par exemple 10110110 donnera 128+32+16+4+2 = 182 :

        A) Et logique : AND    

            AND (ET) effectue un ET LOGIQUE sur 2 opérandes et le résultat se retrouvera dans la première opérande. Le ET LOGIQUE donne le résultat 1 uniquement quand les 2 opérandes sont 1, sinon il met 0.

            Exemple avec AX = 15 et BX = 26 :

               AND AX,BX

            Résultat :

                        0000 1111 (AX=15)
        AND        0001 1010 (BX=26)
                       -------------
                        0000 1010 (AX = 10)

        B) Ou logique inclusif : OR    

            OR effectue un OU LOGIQUE INCLUSIF sur 2 opérandes et le résultat se retrouvera dans la première opérande. Le OU LOGIQUE INCLUSIF donne le résultat 0 uniquement quand les 2 opérandes sont 0, sinon il met 1.

            Exemple avec AX = 15 et BX = 26 :

               OR AX,BX

            Résultat :

                        0000 1111 (AX=15)
        OR          0001 1010 (BX=26)
                       -------------
                        0001 1111 (AX = 31)

        C) Ou logique exclusif : XOR    

            XOR effectue un OU LOGIQUE EXCLUSIF  sur 2 opérandes et le résultat se retrouvera dans la première opérande. Le OU LOGIQUE EXCLUSIF donne le résultat 1 quand les 2 opérandes sont différentes, sinon il met 0.

            Exemple avec AX = 15 et BX = 26 :

               XOR AX,BX

            Résultat :

                        0000 1111 (AX=15)
        XOR        0001 1010 (BX=26)
                       -------------
                        0001 0101 (AX = 21)

        D) Non logique : NOT    

            NOT effectue un NON LOGIQUE sur une opérande et le résultat se retrouvera dans l'opérande. Le NON LOGIQUE inverse la valeur de chaque bit.

            Exemple avec AX = 15 :

               NOT AX

            Résultat :

        NOT        0000 1111 (AX=15)
                       -------------
                        1111 0000 (AX = -16 en signé et 240 en non signé)

        E) TEST    

            Cette instruction teste la valeur d’un ou plusieurs bits en effectuant un ET LOGIQUE sur les opérandes. Le résultat ne modifie pas les opérandes mais les indicateurs.

            Exemple :

                TEST AX,1    >> Effectue un ET LOGIQUE sur  le premier bit de AX avec 1, si il est égal à 1, ZF passera à 1 et inversement (si 0 alors ZF=0).

    7 ° La mémoire et ses instructions

        A) LEA  

            Pour placer par exemple la valeur de l'offset de MESSAGE dans SI il suffit de mettre : MOV SI,Offset-Message. Mais on ne peut pas procéder de cette façon pour les registres DS, ES, FS, GS car ceux ci n'acceptent pas les valeurs numériques, ils n'acceptent que les registres. Il faudra donc passer par : MOV AX,Seg-Message puis MOV DS,AX.

            Il existe une autre instruction, LEA, qui permet de placer l'offset dans un registre mais en plus court. Par exemple : LEA SI,MESSAGE placera dans SI  l'offset de Message. L'utilisation de LEA à la place de MOV rend le code plus clair et plus compact.

        B) MOVSx

            Pour déplacer des blocs entiers de mémoires il faut utiliser les instructions : MOVSB, MOVSW ou MOVSD selon le nombre de bits à déplacer.

            Si on veut déplacer 1000 octets (bytes) en utilisant la commande MOVSB il faudra qu'elle se répète 1000 fois. Donc l'instruction REP est utilisée comme une boucle. Il faut  placer auparavant le nombre de boucles à effectuer dans le registre de compteur (CX) :

                MOV CX,1000     >> Nombre de boucles à effectuer dans le compteur CX
                REP MOVSB        >> Déplace un octet

            Pour aller plus vite on peut les déplacer par Mot (Word) :

                MOV CX,500        >> 1000 bytes = 500 words
                REP MOVSW        >> Déplace un mot

            Ou alors en Double Mot (DWord) :

                MOV CX,250        >> 1000 bytes = 500 words = 250 dwords
                REP MOVSD        >> Déplace un Double Mot

            A chaque MOVSx, DI augmente de 1,2 ou 4 bytes

        C) STOSx

            Pour garder des données ou les placer dans un emplacement de la mémoire on utilise les instructions STOSB, STOSW ou STOSD.

            Pareil que les MOVSx, ces instructions servent respectivement à stocker un byte, un word et un dword. Par contre ils utilisent AL, AX (EAX 32bits) comme valeur à stocker. La valeur de AL,AX,EAX sera stockée dans ES:DI. A chaque STOSx, DI est augmenté de 1,2 ou 4 bytes.

            Exemple :

                MOV CX,10    >> nombre de répétitions placés dans CX, ici 10
                MOV AX,0      >> valeur à déplacer, ici 0
                REP STOSB    >> stocker AX dans ES:DI

            Nous aurons donc 10 bytes de 0 dans ES:DI.

    8 ° Fin du cours !

            Voilà c'est la fin du cours ! "Ouf" diront certains, "Oh quel dommage" diront les hypocrites ! ;-) Je félicite ceux qui ont réussi à lire tout ça ! ;-). Avec ça vous devriez vous sentir plus à l'aise (enfin si vous avez compris mon cours).