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
; 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
; 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
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
; 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 usar
XCHGinstrucciones 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ón | Función | Ejemplo |
|---|---|---|
| SHL | Desplazamiento lógico a la izquierda (el bit sale por la izquierda, se rellena con 0 a la derecha) | shl eax, 1(multiplicar por 2) |
| SHR | Desplazamiento 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) |
| SAL | Desplazamiento aritmético a la izquierda (igual que SHL) | sal eax, 1 |
| SAR | Desplazamiento 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
; 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ón | Función |
|---|---|
| ROL | Rotación a la izquierda (sin pasar por CF) |
| ROR | Rotación a la derecha (sin pasar por CF) |
| RCL | Rotación a la izquierda con acarreo (a través de CF) |
| RCR | Rotación a la derecha con acarreo (a través de CF) |
Ejemplo
; 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
; 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
Otras extensionesLas 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.