Assemblage - Instructions logiques

Le jeu d'instructions du processeur fournit les instructions de logique booléenne AND, OR, XOR, TEST et NOT, qui teste, définit et efface les bits en fonction des besoins du programme.

Le format de ces instructions -

N ° Sr.	Instruction	Format
1	ET	ET opérande1, opérande2
2	OU	OU opérande1, opérande2
3	XOR	Opérande XOR1, opérande2
4	TESTER	TEST opérande1, opérande2
5	NE PAS	NOT opérande1

Le premier opérande dans tous les cas peut être soit en registre, soit en mémoire. Le deuxième opérande peut être soit dans le registre / mémoire, soit dans une valeur immédiate (constante). Cependant, les opérations de mémoire à mémoire ne sont pas possibles. Ces instructions comparent ou correspondent aux bits des opérandes et définissent les indicateurs CF, OF, PF, SF et ZF.

L'instruction AND

L'instruction AND est utilisée pour prendre en charge les expressions logiques en exécutant l'opération AND au niveau du bit. L'opération AND au niveau du bit renvoie 1, si les bits correspondants des deux opérandes sont 1, sinon elle renvoie 0. Par exemple -

Operand1: 	0101
             Operand2: 	0011
----------------------------
After AND -> Operand1:	0001

L'opération ET peut être utilisée pour effacer un ou plusieurs bits. Par exemple, disons que le registre BL contient 0011 1010. Si vous devez effacer les bits de poids fort à zéro, vous ET avec 0FH.

AND	BL,   0FH   ; This sets BL to 0000 1010

Prenons un autre exemple. Si vous voulez vérifier si un nombre donné est pair ou impair, un test simple serait de vérifier le bit le moins significatif du nombre. Si c'est 1, le nombre est impair, sinon le nombre est pair.

En supposant que le nombre est dans le registre AL, nous pouvons écrire -

AND	AL, 01H     ; ANDing with 0000 0001
JZ    EVEN_NUMBER

Le programme suivant illustre cela -

Exemple

section .text
   global _start            ;must be declared for using gcc
	
_start:                     ;tell linker entry point
   mov   ax,   8h           ;getting 8 in the ax 
   and   ax, 1              ;and ax with 1
   jz    evnn
   mov   eax, 4             ;system call number (sys_write)
   mov   ebx, 1             ;file descriptor (stdout)
   mov   ecx, odd_msg       ;message to write
   mov   edx, len2          ;length of message
   int   0x80               ;call kernel
   jmp   outprog

evnn:   
  
   mov   ah,  09h
   mov   eax, 4             ;system call number (sys_write)
   mov   ebx, 1             ;file descriptor (stdout)
   mov   ecx, even_msg      ;message to write
   mov   edx, len1          ;length of message
   int   0x80               ;call kernel

outprog:

   mov   eax,1              ;system call number (sys_exit)
   int   0x80               ;call kernel

section   .data
even_msg  db  'Even Number!' ;message showing even number
len1  equ  $ - even_msg 
   
odd_msg db  'Odd Number!'    ;message showing odd number
len2  equ  $ - odd_msg

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Even Number!

Changez la valeur dans le registre de la hache avec un chiffre impair, comme -

mov  ax, 9h                  ; getting 9 in the ax

Le programme afficherait:

Odd Number!

De même, pour effacer tout le registre, vous pouvez ET avec 00H.

L'instruction OR

L'instruction OR est utilisée pour prendre en charge l'expression logique en exécutant une opération OR au niveau du bit. L'opérateur OR au niveau du bit renvoie 1, si les bits correspondants de l'un ou des deux opérandes sont un. Il renvoie 0, si les deux bits sont nuls.

Par exemple,

Operand1:     0101
             Operand2:     0011
----------------------------
After OR -> Operand1:    0111

L'opération OR peut être utilisée pour définir un ou plusieurs bits. Par exemple, supposons que le registre AL contient 0011 1010, vous devez définir les quatre bits de poids faible, vous pouvez OU avec une valeur 0000 1111, c'est-à-dire FH.

OR BL, 0FH                   ; This sets BL to  0011 1111

Exemple

L'exemple suivant illustre l'instruction OR. Stockons respectivement la valeur 5 et 3 dans les registres AL et BL, puis l'instruction,

OR AL, BL

devrait stocker 7 dans le registre AL -

section .text
   global _start            ;must be declared for using gcc
	
_start:                     ;tell linker entry point
   mov    al, 5             ;getting 5 in the al
   mov    bl, 3             ;getting 3 in the bl
   or     al, bl            ;or al and bl registers, result should be 7
   add    al, byte '0'      ;converting decimal to ascii
	
   mov    [result],  al
   mov    eax, 4
   mov    ebx, 1
   mov    ecx, result
   mov    edx, 1 
   int    0x80
    
outprog:
   mov    eax,1             ;system call number (sys_exit)
   int    0x80              ;call kernel
	
section    .bss
result resb 1

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

7

L'instruction XOR

L'instruction XOR implémente l'opération XOR au niveau du bit. L'opération XOR met le bit résultant à 1, si et seulement si les bits des opérandes sont différents. Si les bits des opérandes sont identiques (tous les deux 0 ou les deux 1), le bit résultant est remis à 0.

Par exemple,

Operand1:     0101
             Operand2:     0011
----------------------------
After XOR -> Operand1:    0110

XORing un opérande avec lui-même change l'opérande en 0. Ceci est utilisé pour effacer un registre.

XOR     EAX, EAX

L'instruction TEST

L'instruction TEST fonctionne de la même manière que l'opération AND, mais contrairement à l'instruction AND, elle ne change pas le premier opérande. Donc, si nous avons besoin de vérifier si un nombre dans un registre est pair ou impair, nous pouvons également le faire en utilisant l'instruction TEST sans changer le nombre d'origine.

TEST    AL, 01H
JZ      EVEN_NUMBER

L'instruction NOT

L'instruction NOT implémente l'opération NOT au niveau du bit. L'opération NOT inverse les bits d'un opérande. L'opérande peut être dans un registre ou dans la mémoire.

Par exemple,

Operand1:    0101 0011
After NOT -> Operand1:    1010 1100