Lenguaje ensamblador - Instrucciones lógicas

Las instrucciones lógicas se utilizan en programación ensamblador para operaciones a nivel de bit, ampliamente usadas en operaciones de máscara, extracción de bits, establecimiento de banderas y multiplicación/división eficiente.


AND - Y bit a bit

ANDRealiza la operación 'Y' bit a bit entre dos operandos (el resultado es 1 solo si ambos son 1).

Ejemplo

; Ruta del archivo: and_demo.asm
; Ejemplo de la instrucción AND

section .text
    global _start

_start:
    ; Y bit a bit básico
    mov eax, 0x0F0F             ; 0000 1111 0000 1111
    and eax, 0x00FF             ; 0000 0000 1111 1111
    ; Resultado: eax = 0x000F ; 0000 0000 0000 1111

    ; Técnica común 1: enmascarar los 4 bits bajos (conservar los 4 bits bajos)
    mov eax, 0xAB               ; 1010 1011
    and eax, 0x0F               ; 0000 1111
    ; eax = 0x0B                ; 0000 1011

    ; Técnica común 2: comprobar paridad (hacer AND con 1)
    mov eax, 42                 ; par
    and eax, 1                  ; eax = 0 (par)
    ; El bit final de 42 en binario es 0, 42 & 1 = 0

    mov eax, 43                 ; impar
    and eax, 1                  ; eax = 1 (impar)
    ; El bit final de 43 en binario es 1, 43 & 1 = 1

    ; Técnica común 3: poner a cero un registro
    xor eax, eax                ; Equivale a mov eax, 0, pero es más rápido y más corto

    ; AND establece los indicadores: CF=0, OF=0, ZF y SF según el resultado
    mov eax, 1
    mov ebx, 0
    int 0x80

OR - O bit a bit

ORRealiza la operación 'O' bit a bit entre dos operandos (el resultado es 1 si al menos uno es 1).

Ejemplo

; Ejemplo de la instrucción OR

    ; Combinar indicadores
    mov eax, 0x0F00             ; 0000 1111 0000 0000
    or  eax, 0x00FF             ; 0000 0000 1111 1111
    ; eax = 0x0FFF              ; 0000 1111 1111 1111

    ; Establecer un bit (poner el bit 3 a 1)
    mov eax, 0                  ; 0000 0000
    or  eax, 0x08               ; 0000 1000
    ; eax = 0x8                 ; 0000 1000

    ; Conversión de mayúsculas a minúsculas
    mov al, 'A'                 ; al = 0x41 (0100 0001)
    or  al, 0x20                ; 0x20 = 0010 0000
    ; al = 0x61 = 'a'          ; 0110 0001

NOT - Complemento bit a bit

NOTInvierte cada bit del operando (0 se convierte en 1, y 1 en 0).

Ejemplo

; Ejemplo de la instrucción NOT

    mov eax, 0x0F0F0F0F        ; 0000 1111 0000 1111 ...
    not eax                     ; 1111 0000 1111 0000 ...
    ; eax = 0xF0F0F0F0

    ; NOT no afecta a ningún indicador (a diferencia de AND/OR/XOR)

XOR - O exclusiva bit a bit

XORRealiza la operación 'O exclusiva' bit a bit entre dos operandos (resultado 1 si son diferentes, 0 si son iguales).

Ejemplo

; Ruta del archivo: xor_demo.asm
; Ejemplo de la instrucción XOR

section .text
    global _start

_start:
    ; O exclusiva básica
    mov eax, 0x0F0F             ; 0000 1111 0000 1111
    xor eax, 0x00FF             ; 0000 0000 1111 1111
    ; Resultado: eax = 0x0FF0 ; 0000 1111 1111 0000

    ; Técnica clásica 1: poner a cero un registro (más eficiente que mov reg, 0)
    xor eax, eax                ; eax = 0, solo ocupa 2 bytes
    xor ebx, ebx
    xor ecx, ecx

    ; Técnica clásica 2: intercambiar dos registros (no se necesita un tercer registro temporal)
    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
    ; Ahora eax = 200, ebx = 100 (¡intercambio completado!)

    ; Técnica clásica 3: cifrado/descifrado simple
    mov al, 'A'                 ; Carácter original 'A' = 0x41
    xor al, 0x55                ; Cifrado: al = 'A' xor 0x55
    ; al ahora es un valor ilegible
    xor al, 0x55                ; Descifrado: aplicar xor 0x55 nuevamente para recuperar
    ; ¡al = 'A' ha vuelto!

    mov eax, 1
    mov ebx, 0
    int 0x80

El truco de intercambio con XOR es interesante, pero en las CPU modernas no es tan eficiente como usarXCHGinstrucciones o un registro temporal. Solo conócelo, no es necesario insistir en usarlo.


Instrucciones de desplazamiento

Las instrucciones de desplazamiento mueven los bits de un número binario hacia la izquierda o la derecha, comúnmente utilizadas para multiplicación y división eficiente (multiplicar por 2, dividir por 2, etc.).

InstrucciónFunciónEjemplo
SHLDesplazamiento lógico a la izquierda (el bit sale por la izquierda, se rellena con 0 a la derecha)shl eax, 1(multiplicar por 2)
SHRDesplazamiento lógico a la derecha (el bit sale por la derecha, se rellena con 0 a la izquierda)shr eax, 1(división sin signo entre 2)
SALDesplazamiento aritmético a la izquierda (igual que SHL)sal eax, 1
SARDesplazamiento aritmético a la derecha (el bit sale por la derecha, la izquierda conserva el bit de signo)sar eax, 1(división con signo entre 2)

Ejemplo

; Ruta del archivo: shift_demo.asm
; Ejemplo de instrucciones de desplazamiento

section .text
    global _start

_start:
    ; SHL: desplazamiento lógico a la izquierda = multiplicar por una potencia de 2
    mov eax, 10                 ; eax = 10 (1010)
    shl eax, 1                  ; eax = 20 (10100), es decir, 10×2
    shl eax, 2                  ; eax = 80 (1010000), es decir, 20×4

    ; SHR: desplazamiento lógico a la derecha = división sin signo entre una potencia de 2
    mov eax, 80                 ; eax = 80
    shr eax, 3                  ; eax = 10, es decir, 80÷8

    ; SAR: desplazamiento aritmético a la derecha = división con signo entre una potencia de 2 (conserva el bit de signo)
    mov eax, -16                ; eax = -16 (0xFFFFFFF0)
    sar eax, 2                  ; eax = -4 (0xFFFFFFFC), es decir, -16÷4
    ; SAR comparado con SHR:
    ; Si eax = 0xFFFFFFF0 (-16), SHR daría 0x3FFFFFFC (un número positivo muy grande)
    ; Mientras que SAR daría 0xFFFFFFFC (-4), conservando el bit de signo

    ; El último bit desplazado fuera pasa al indicador CF
    mov eax, 5                  ; 0101
    shr eax, 1                  ; eax = 2, CF = 1 (el 1 final se desplazó fuera)
    jc carry_was_set            ; Si CF=1, significa que el número original es impar

carry_was_set:
    mov eax, 1
    mov ebx, 0
    int 0x80

Instrucciones de rotación

La rotación vuelve a introducir el bit desplazado fuera por el otro extremo, formando un ciclo:

InstrucciónFunción
ROLRotación a la izquierda (sin pasar por CF)
RORRotación a la derecha (sin pasar por CF)
RCLRotación a la izquierda con acarreo (a través de CF)
RCRRotación a la derecha con acarreo (a través de CF)

Ejemplo

; Ejemplo de rotación

    ; ROL: rotación a la izquierda
    mov al, 0x85                ; 1000 0101
    rol al, 1                   ; Desplazar 1 bit a la izquierda: 0000 1011
    ; CF = 1 (el bit más significativo se desplaza a CF)
    ; Al mismo tiempo, el 1 original de CF se introduce en el bit menos significativo, formando el ciclo

    ; Efecto real de ROL: desplaza 1 bit a la izquierda, el bit más significativo entra a la vez en CF y en el bit menos significativo
    ; 1000 0101 -> ROL 1 -> 0000 1011

    ; RCL: rotación a la izquierda con acarreo (CF participa en el ciclo)
    clc                         ; Limpiar CF = 0
    mov al, 0x85                ; 1000 0101
    rcl al, 1                   ; CF participa: CF bit7...bit0 -> CF
    ; Resultado: 0000 1010, CF = 1

    ; La rotación se usa frecuentemente en algoritmos de cifrado y operaciones de bits

Usos prácticos de las operaciones lógicas

Un ejemplo completo: usar operaciones lógicas para implementar un sistema simple de indicadores de bits:

Ejemplo

; Ruta del archivo: bit_flags.asm
; Implementar un sistema de indicadores de bits usando operaciones lógicas

section .data
    flags db 0                  ; 8 indicadores, inicialmente todos en 0
    ; bit0: si está activado
    ; bit1: si es visible
    ; bit2: si necesita guardarse
    ; bit3: si ha sido modificado

    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:
    ; Establecer indicadores: OR
    mov al, [flags]
    or  al, FLAG_ACTIVE         ; Establecer bit0
    or  al, FLAG_VISIBLE        ; Establecer bit1
    ; al = 0000 0011 = 3
    mov [flags], al

    ; Comprobar indicadores: AND + TEST
    test byte [flags], FLAG_ACTIVE    ; Probar si bit0 es 1
    jnz is_active                     ; ZF=0 indica que el bit es 1

is_active:
    ; Limpiar indicadores: AND + NOT
    mov al, [flags]
    and al, ~FLAG_VISIBLE       ; Limpiar bit1 (conservar los demás bits sin cambios)
    ; al = 0000 0001 = 1
    mov [flags], al

    ; Cambiar indicadores: XOR
    mov al, [flags]
    xor al, FLAG_MODIFIED       ; Cambiar bit3
    ; Si originalmente era 0 se convierte en 1, si era 1 se convierte en 0

    mov eax, 1
    mov ebx, 0
    int 0x80

Las operaciones con indicadores de bits son muy comunes en programación de sistemas. Los núcleos de sistemas operativos, los controladores de dispositivos y los sistemas embebidos utilizan ampliamente esta técnica para gestionar estados.

Otras extensiones