Instrucción IMUL en 8086: Mecánica de Multiplicación con Signo

La instrucción IMUL (Integer Multiply) en el 8086/8088 realiza multiplicación con signo de operandos de 8 bits o 16 bits. Es distinta de MUL (multiplicación sin signo). Aquí está la operación precisa:

Formas de Instrucción (8086/8088)

FormaSintaxisOperaciónTamaño del ResultadoBanderas Afectadas
8-bitIMUL r/m8AL × r/m816-bit en AXCF, OF (establecidas si el signo extendido AH ≠ AL); SF, ZF, AF, PF indefinidas
16-bitIMUL r/m16AX × r/m1632-bit en DX:AXCF, OF (establecidas si el signo extendido DX ≠ AX); SF, ZF, AF, PF indefinidas

r/m8 = registro o memoria de 8 bits; r/m16 = registro o memoria de 16 bits.

Ejecución Paso a Paso (Ejemplo de Forma de 16 bits)

  1. Operandos: Origen (registro/memoria) y destino implícito AX.
  2. Extensión de Signo: Ambos operandos tratados como enteros con signo en complemento a 2.
  3. Multiplicación: La ALU calcula AX × src como producto con signo de 32 bits.
  4. Almacenamiento del Resultado:
    • Bajos 16 bits → AX
    • Altos 16 bits → DX
  5. Configuración de Banderas:
    • CF = OF = 1 si la palabra alta (DX) no es la extensión de signo de la palabra baja (AX). Es decir, si el resultado no cabe en 16 bits con signo.
    • CF = OF = 0 si el resultado cabe en 16 bits (DX = extensión de signo de AX).
    • SF, ZF, AF, PF son indefinidas (según el manual de Intel). No confiar en ellas.

Regla de Extensión de Signo

Para que un resultado de 16 bits en AX sea "correctamente con signo," los altos 16 bits (DX) deben ser todos 0s (si es positivo) o todos 1s (si es negativo)—es decir, DX = AX replicado a 16 bits. Si no, ocurrió desbordamiento.

Ejemplo: IMUL de 16 bits

 ; AX = 0x23AF (9,135), src = 0x4567 (17,767) ; Producto = 9,135 × 17,767 = 162,300,345 = 0x09B3 0x10B9 (32-bit) ; DX:AX = 0x09B3:0x10B9 ; Dado que DX (0x09B3) ≠ extensión de signo de AX (0x10B9 → bit de signo 0 → DX debería ser 0x0000), ; CF=1, OF=1 (desbordamiento: resultado > 32,767) 

Ejemplo de 8 bits

 ; AL = 0x7F (127), BL = 0x02 (2) ; IMUL BL ; AX = 0x00FA (254) → ¿Cabe en 8 bits con signo? 254 > 127 → desbordamiento. ; AH = 0x00, AL = 0xFA. AH (0x00) ≠ extensión de signo de AL (0xFA → bit de signo 1 → AH debería ser 0xFF). ; CF=1, OF=1. 

Diferencias Clave: IMUL vs. MUL

  • MUL: Sin signo. Trata operandos como positivos. CF/OF establecidas si el resultado > tamaño del destino (por ejemplo, AX > FFh para 8-bit).
  • IMUL: Con signo. Trata operandos como complemento a 2. CF/OF establecidas si el resultado no cabe en el tamaño con signo del destino.

Extensiones Posteriores (186+ / 386+)

  • Dos operandos: IMUL r16, r/m16 → r16 = r16 × r/m16 (solo bajos 16 bits, sin DX).
  • Tres operandos: IMUL r16, r/m16, imm16 → r16 = r/m16 × imm16.
  • Formas inmediatas: IMUL r16, imm8/imm16.
  • Estos truncan a 16 bits; CF/OF establecidas si los bits truncados ≠ bits de signo.

Notas Prácticas

  • IMUL es más lento que MUL (lógica de signo adicional). ~80–130 ciclos en 8086.
  • Usar CBW (AL→AX) / CWD (AX→DX:AX) antes de IMUL si se extiende el tamaño del operando.
  • Para 8-bit × 8-bit → 16-bit en 8086, el resultado siempre está en AX. No se usa DX.
  • En ensamblado en línea (C), usar intrínsecos del compilador o built-ins (__emulu, __emuls).

IMUL es esencial para aritmética en enteros con signo (coordenadas, física, DSP, cripto) en código de modo real de 16 bits.