AND
Sintaxă:
and <regd>, <regs>; <regd> ← <regd> AND <regs>
and <reg>, <mem>; <reg> ← <reg> AND <mem>
and <mem>, <reg>; <mem> ← <mem> AND <reg>
and <reg>, <con>; <reg> ← <reg> AND <con>
and <mem>, <con>; <mem> ← <mem> AND <con>
Semantică:
- Execută operația logică AND asupra operanzilor, punând rezultatul în primul operand.
Exemplu:
and EAX, 0Fh; EAX ← EAX AND 0Fh, are loc zerorizarea tuturor biților din EAX cu excepția ultimilor patru
OR
Sintaxă:
or <regd>, <regs>; <regd> ← <regd> OR <regs>
or <reg>, <mem>; <reg> ← <reg> OR <mem>
or <mem>, <reg>; <mem> ← <mem> OR <reg>
or <reg>, <con>; <reg> ← <reg> OR <con>
or <mem>, <con>; <mem> ← <mem> OR <con>
Semantică:
- Execută operația logică OR asupra operanzilor, punând rezultatul în primul operand.
Exemplu:
or EAX, 0Fh; EAX ← EAX OR 0Fh, ultimii 4 biți din EAX vor fi setați la 1, restul rămânând neschimbați
XOR
Sintaxă:
xor <regd>, <regs>; <regd> ← <regd> XOR <regs>
xor <reg>, <mem>; <reg> ← <reg> XOR <mem>
xor <mem>, <reg>; <mem> ← <mem> XOR <reg>
xor <reg>, <con>; <reg> ← <reg> XOR <con>
xor <mem>, <con>; <mem> ← <mem> XOR <con>
Semantică:
- Execută operația logică XOR asupra operanzilor, punând rezultatul în primul operand.
Exemplu:
xor EDX, EDX; zerorizează conținutul lui EDX
TEST
Sintaxă:
test <regd>, <regs>; <regd> AND <regs>
test <reg>, <mem>; <reg> AND <mem>
test <mem>, <reg>; <mem> AND <reg>
test <reg>, <con>; <reg> AND <con>
test <mem>, <con>; <mem> AND <con>
Semantică:
- Execută operația logică AND asupra operanzilor, fără să pună rezultatul în primul operand.
Exemplu:
TEST AL, 01h; se poate testa în acest mod dacă numărul e par sau impar
NOT
Sintaxă:
not <reg>
not <mem>
Semantică:
- Execută operația logică NOT asupra operandului (inversează fiecare bit).
Exemplu:
not BYTE PTR [var] ; se inversează fiecare bit din [var]
SHL
Sintaxă:
shl <reg>, <con8>
shl <mem>, <con8>
shl <reg>, CL
shl <mem>, CL
Semantică:
- Biții stocați în destinație se deplasează număr poziții (modulo 32) spre stânga. Bitul (sau biții) cel mai din dreapta se completează cu 0. Ultimul bit care iese în stânga se pastrează în CF.
Exemplu:
mov al, 00110011b
mov cl, 2
shl al, cl ; → al = 11001100b, CF = 0
SHR
Sintaxă:
shr <reg>, <con8>
shr <mem>, <con8>
shr <reg>, CL
shr <mem>, CL
Semantică:
- Biții stocați în destinație se deplasează număr poziții (modulo 32) spre dreapta. Bitul (sau biții) cel mai din stânga se completează cu 0. Ultimul bit care iese în dreapta se pastrează în CF.
Exemplu:
mov al, 01011110b
mov cl, 2
shr al, cl ; → al = 00010111b, CF = 1
SAL
Sintaxă:
sal <reg>, <con8>
sal <mem>, <con8>
sal <reg>, CL
sal <mem>, CL
Semantică:
- Biții stocați în destinație se deplasează număr poziții (modulo 32) spre stânga. Bitul (sau biții) cel mai din dreapta se completează cu 0. Ultimul bit care iese în stânga se pastrează în CF.
- Efectul instrucțiunii SAL este identic cu cel al instrucțiunii SHL
Exemplu:
mov al, 00110011b
mov cl, 2
sal al, cl ; → al = 11001100b, CF = 0
SAR
Sintaxă:
sar <reg>, <con8>
sar <mem>, <con8>
sar <reg>, CL
sar <mem>, CL
Semantică:
- Biții stocați în destinație se deplasează număr poziții (modulo 32) spre dreapta. Bitul (sau biții) cel mai din stânga se completează cu bitul de semn (bitul cel mai din stânga înainte de shiftare). Ultimul bit care iese în dreapta se pastrează în CF.
Exemplu:
mov al, 11011110b
mov cl, 2
sar al, cl ; → al = 11110111b, CF = 1
ROL
Sintaxă:
rol <reg>, <con8>
rol <mem>, <con8>
rol <reg>, CL
rol <mem>, CL
Semantică:
- Biții stocați în destinație se rotesc număr pozitii (modulo 32) spre stânga. Odată un bit ieșit în stânga el se adaugă automat în partea dreaptă a destinației. Ultimul bit rotit se păstrează în CF.
Exemplu:
mov al, 00110011b
mov cl, 2
rol al, cl ; → al = 11001100b, CF = 0
ROR
Sintaxă:
ror <reg>, <con8>
ror <mem>, <con8>
ror <reg>, CL
ror <mem>, CL
Semantică:
- Biții stocați în destinație se rotesc număr pozitii (modulo 32) spre dreapta. Odată un bit ieșit în dreapta el se adaugă automat în partea stângă a destinației. Ultimul bit rotit se pastrează în CF.
Exemplu:
mov al, 00111110b
mov cl, 2
ror al, cl ; → al = 10001111b, CF = 1
RCL
Sintaxă:
rcl <reg>, <con8>
rcl <mem>, <con8>
rcl <reg>, CL
rcl <mem>, CL
Semantică:
- Biții stocați în destinație se rotesc număr poziții spre stânga. Odată un bit ieșit în stânga el se păstrează în CF. Valoarea anterioră din CF se adaugă automat în partea dreaptă a destinației.
Exemplu:
stc ; CF = 1 (set carry)
mov al, 00110011b
mov cl, 2
rcl al, cl ; → al = 11001110b, CF = 0
RCR
Sintaxă:
rcr <reg>, <con8>
rcr <mem>, <con8>
rcr <reg>, CL
rcr <mem>, CL
Semantică:
- Biții stocați în destinație se rotesc numar poziții (modulo 32) spre dreapta. Odată un bit ieșit în dreapta el se păstrează în CF. Valoarea anterioară din CF se adaugă automat în partea stângă a destinației.
Exemplu:
stc ; CF = 1 (set carry)
mov al, 00110011b
mov cl, 2
rcr al, cl ; → al = 11001100b, CF = 1