Язык ассемблера - Логические инструкции
Логические инструкции используются для операций на уровне битов в программировании на ассемблере; широко применяются для маскирования, извлечения битов, установки флагов и эффективного умножения/деления.
AND - Побитовое AND
ANDВыполняет побитовую операцию AND над двумя операндами (результат равен 1, только когда оба бита равны 1).
Пример
; Пример инструкции AND
section .text
global _start
_start:
; Базовое побитовое AND
mov eax, 0x0F0F ; 0000 1111 0000 1111
and eax, 0x00FF ; 0000 0000 1111 1111
; Результат: eax = 0x000F ; 0000 0000 0000 1111
; Распространённый приём 1: маскировать младшие 4 бита (оставить младшие 4 бита)
mov eax, 0xAB ; 1010 1011
and eax, 0x0F ; 0000 1111
; eax = 0x0B ; 0000 1011
; Распространённый приём 2: проверка чётности (AND с 1)
mov eax, 42 ; Чётное
and eax, 1 ; eax = 0 (чётное)
; Двоичное представление числа 42 заканчивается на 0, 42 & 1 = 0
mov eax, 43 ; Нечётное
and eax, 1 ; eax = 1 (нечётное)
; Двоичное представление числа 43 заканчивается на 1, 43 & 1 = 1
; Распространённый приём 3: обнуление регистра
xor eax, eax ; Эквивалентно mov eax, 0, но быстрее и короче
; AND устанавливает флаги: CF=0, OF=0, ZF и SF зависят от результата
mov eax, 1
mov ebx, 0
int 0x80
OR — побитовое ИЛИ
ORВыполняет побитовую операцию ИЛИ над двумя операндами (результат равен 1, если хотя бы один бит равен 1).
Пример
; Объединение битов флагов
mov eax, 0x0F00 ; 0000 1111 0000 0000
or eax, 0x00FF ; 0000 0000 1111 1111
; eax = 0x0FFF ; 0000 1111 1111 1111
; Установить конкретный бит (установить бит 3 в 1)
mov eax, 0 ; 0000 0000
or eax, 0x08 ; 0000 1000
; eax = 0x8 ; 0000 1000
; Преобразование регистра: из верхнего в нижний
mov al, 'A' ; al = 0x41 (0100 0001)
or al, 0x20 ; 0x20 = 0010 0000
; al = 0x61 = 'a' ; 0110 0001
NOT — побитовое НЕ
NOTИнвертирует каждый бит операнда (0 становится 1, 1 становится 0).
Пример
mov eax, 0x0F0F0F0F ; 0000 1111 0000 1111 ...
not eax ; 1111 0000 1111 0000 ...
; eax = 0xF0F0F0F0
; NOT не влияет на флаги (в отличие от AND/OR/XOR)
XOR — побитовое XOR
XORВыполняет побитовую операцию XOR над двумя операндами (результат равен 1, если биты различаются, и 0, если они одинаковы).
Пример
; Пример инструкции XOR
section .text
global _start
_start:
; Базовый XOR
mov eax, 0x0F0F ; 0000 1111 0000 1111
xor eax, 0x00FF ; 0000 0000 1111 1111
; Результат: eax = 0x0FF0 ; 0000 1111 1111 0000
; Классический приём 1: обнуление регистра (эффективнее, чем mov reg, 0)
xor eax, eax ; eax = 0, занимает всего 2 байта
xor ebx, ebx
xor ecx, ecx
; Классический приём 2: обмен значениями двух регистров (третий временный регистр не нужен)
mov eax, 100 ; eax = 100
mov ebx, 200 ; ebx = 200
xor eax, ebx ; eax = 100 xor 200
xor ebx, eax ; ebx = 200 xor (100 xor 200) = 100
xor eax, ebx ; eax = (100 xor 200) xor 100 = 200
; Теперь eax = 200, ebx = 100 (обмен завершён!)
; Классический приём 3: простое шифрование/расшифровка
mov al, 'A' ; Исходный символ 'A' = 0x41
xor al, 0x55 ; Шифрование: al = 'A' xor 0x55
; al теперь содержит некоторое искажённое значение
xor al, 0x55 ; Расшифровка: снова XOR с 0x55 для восстановления
; al = 'A' снова на месте!
mov eax, 1
mov ebx, 0
int 0x80
Трюк с XOR-обменом — классный, но на современных процессорах он менее эффективен, чем использование
XCHGкоманды или временного регистра. Это полезно знать, но не стоит настаивать на его использовании.
Команды сдвига
Команды сдвига перемещают двоичные биты влево или вправо; обычно используются для эффективного умножения и деления (умножение на 2, деление на 2 и т. д.).
| Инструкция | Функция | Пример |
|---|---|---|
| SHL | Логический сдвиг влево (биты выходят слева, нули заполняют справа) | shl eax, 1(умножение на 2) |
| SHR | Логический сдвиг вправо (биты выходят справа, слева добавляются нули) | shr eax, 1(беззнаковое деление на 2) |
| SAL | Арифметический сдвиг влево (то же, что SHL) | sal eax, 1 |
| SAR | Арифметический сдвиг вправо (биты выходят справа, знаковый бит сохраняется слева) | sar eax, 1(знаковое деление на 2) |
Пример
; Пример инструкции сдвига
section .text
global _start
_start:
; SHL: логический сдвиг влево = умножение на степень двойки
mov eax, 10 ; eax = 10 (1010)
shl eax, 1 ; eax = 20 (10100), т.е. 10×2
shl eax, 2 ; eax = 80 (1010000), т.е. 20×4
; SHR: логический сдвиг вправо = беззнаковое деление на степень 2
mov eax, 80 ; eax = 80
shr eax, 3 ; eax = 10, т.е. 80÷8
; SAR: арифметический сдвиг вправо = знаковое деление на степень 2 (сохраняет знаковый бит)
mov eax, -16 ; eax = -16 (0xFFFFFFF0)
sar eax, 2 ; eax = -4 (0xFFFFFFFC), т.е. -16÷4
; SAR против SHR:
; Если eax = 0xFFFFFFF0 (-16), SHR даёт 0x3FFFFFFC (очень большое положительное число)
; тогда как SAR даёт 0xFFFFFFFC (-4), сохраняя знаковый бит
; Последний выдвинутый бит попадает во флаг CF
mov eax, 5 ; 0101
shr eax, 1 ; eax = 2, CF = 1 (младший бит 1 был сдвинут за пределы)
jc carry_was_set ; Если CF=1, исходное число было нечётным
carry_was_set:
mov eax, 1
mov ebx, 0
int 0x80
Инструкции циклического сдвига
Циклические сдвиги возвращают выдвинутый бит обратно в другой конец, замыкая цикл:
| Инструкция | Описание |
|---|---|
| ROL | Циклический сдвиг влево (минуя CF) |
| ROR | Циклический сдвиг вправо (минуя CF) |
| RCL | Циклический сдвиг влево через перенос (задействует CF) |
| RCR | Циклический сдвиг вправо через перенос (участвует CF) |
Пример
; ROL: циклический сдвиг влево
mov al, 0x85 ; 1000 0101
rol al, 1 ; Сдвиг влево на 1 бит: 0000 1011
; CF = 1 (старший бит сдвигается в CF)
; В то же время исходная 1 в CF сдвигается в младший бит, образуя циклический сдвиг
; Фактический эффект ROL: сдвиг влево на 1 бит, старший бит попадает и в CF, и в младший бит
; 1000 0101 -> ROL 1 -> 0000 1011
; RCL: циклический сдвиг влево через перенос (CF участвует в циклическом сдвиге)
clc ; Сбросить CF = 0
mov al, 0x85 ; 1000 0101
rcl al, 1 ; CF участвует: CF bit7...bit0 -> CF
; Результат: 0000 1010, CF = 1
; Циклические сдвиги обычно используются в алгоритмах шифрования и битовых манипуляциях
Практическое применение логических операций
Комплексный пример — реализация простой системы битовых флагов с использованием логических операций:
Пример
; Реализация системы битовых флагов с использованием логических операций
section .data
flags db 0 ; 8 битов флагов, изначально все 0
; bit0: активен ли
; bit1: видим ли
; bit2: нужно ли сохранять
; bit3: изменён ли
FLAG_ACTIVE equ 1 ; 0000 0001
FLAG_VISIBLE equ 2 ; 0000 0010
FLAG_NEED_SAVE equ 4 ; 0000 0100
FLAG_MODIFIED equ 8 ; 0000 1000
section .text
global _start
_start:
; Установка битов флагов: OR
mov al, [flags]
or al, FLAG_ACTIVE ; Установить бит 0
or al, FLAG_VISIBLE ; Установить бит 1
; al = 0000 0011 = 3
mov [flags], al
; Проверка битов флагов: AND + TEST
test byte [flags], FLAG_ACTIVE ; Проверить, равен ли бит 0 1
jnz is_active ; ZF=0 означает, что бит равен 1
is_active:
; Очистка битов флагов: AND + NOT
mov al, [flags]
and al, ~FLAG_VISIBLE ; Очистить бит 1 (остальные биты не изменять)
; al = 0000 0001 = 1
mov [flags], al
; Переключение битов флагов: XOR
mov al, [flags]
xor al, FLAG_MODIFIED ; Переключить бит 3
; Если он был 0, он становится 1; если он был 1, он становится 0
mov eax, 1
mov ebx, 0
int 0x80
Другие расширенияМанипулирование битовыми флагами чрезвычайно распространено в системном программировании. Ядра ОС, драйверы устройств и встраиваемые системы широко используют эту технику для управления состоянием.