Язык ассемблера - Логические инструкции

Логические инструкции используются для операций на уровне битов в программировании на ассемблере; широко применяются для маскирования, извлечения битов, установки флагов и эффективного умножения/деления.


AND - Побитовое AND

ANDВыполняет побитовую операцию AND над двумя операндами (результат равен 1, только когда оба бита равны 1).

Пример

; Путь к файлу: and_demo.asm
; Пример инструкции 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).

Пример

; пример инструкции OR

    ; Объединение битов флагов
    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).

Пример

; Пример инструкции NOT

    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_demo.asm
; Пример инструкции 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)

Пример

; Путь к файлу: shift_demo.asm
; Пример инструкции сдвига

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

    ; Циклические сдвиги обычно используются в алгоритмах шифрования и битовых манипуляциях

Практическое применение логических операций

Комплексный пример — реализация простой системы битовых флагов с использованием логических операций:

Пример

; Путь к файлу: bit_flags.asm
; Реализация системы битовых флагов с использованием логических операций

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

Манипулирование битовыми флагами чрезвычайно распространено в системном программировании. Ядра ОС, драйверы устройств и встраиваемые системы широко используют эту технику для управления состоянием.

Другие расширения