Istruzione IMUL in 8086: meccanica della moltiplicazione firmata
L'istruzione IMUL (Integer Multiply) nell'8086/8088 esegue la moltiplicazione firmata di operandi a 8-bit o 16-bit. È distinta da MUL (moltiplicazione senza segno). Ecco l'operazione precisa:
Forme istruzione (8086/8088)
| Forma | Sintassi | Operazione | Dimensione risultato | Flag influenzati |
|---|---|---|---|---|
| 8-bit | IMUL r/m8 | AL × r/m8 | 16-bit in AX | CF, OF (set se AH esteso segno ≠ AL); SF, ZF, AF, PF indefiniti |
| 16-bit | IMUL r/m16 | AX × r/m16 | 32-bit in DX:AX | CF, OF (set se DX esteso segno ≠ AX); SF, ZF, AF, PF indefiniti |
r/m8 = registro o memoria 8-bit; r/m16 = registro o memoria 16-bit.
Esecuzione passo passo (esempio forma 16-bit)
- Operandi: Sorgente (registro/memoria) e destinatario implicito AX.
- Estensione segno: Entrambi gli operandi trattati come interi firmati complemento a 2.
- Moltiplicazione: ALU calcola AX × src come prodotto firmato 32-bit.
- Archiviazione risultato:
- Bassi 16 bit → AX
- Alti 16 bit → DX
- Impostazione flag:
- CF = OF = 1 se la parola alta (DX) non è estensione segno della parola bassa (AX). Cioè, se il risultato non sta in 16 bit firmati.
- CF = OF = 0 se il risultato sta in 16 bit (DX = estensione segno di AX).
- SF, ZF, AF, PF sono indefiniti (secondo manuale Intel). Non farci affidamento.
Regola estensione segno
Per un risultato 16-bit in AX "correttamente firmato", gli alti 16 bit (DX) devono essere tutti 0 (se positivo) o tutti 1 (se negativo)—cioè, DX = AX replicato a 16 bit. Altrimenti, si è verificato overflow.
Esempio: IMUL 16-bit
; AX = 0x23AF (9.135), src = 0x4567 (17.767) ; Prodotto = 9.135 × 17.767 = 162.300.345 = 0x09B3 0x10B9 (32-bit) ; DX:AX = 0x09B3:0x10B9 ; Poiché DX (0x09B3) ≠ estensione segno di AX (0x10B9 → bit segno 0 → DX dovrebbe essere 0x0000), ; CF=1, OF=1 (overflow: risultato > 32.767)
Esempio 8-bit
; AL = 0x7F (127), BL = 0x02 (2) ; IMUL BL ; AX = 0x00FA (254) → sta in 8 bit firmato? 254 > 127 → overflow. ; AH = 0x00, AL = 0xFA. AH (0x00) ≠ estensione segno di AL (0xFA → bit segno 1 → AH dovrebbe essere 0xFF). ; CF=1, OF=1.
Differenze chiave: IMUL vs MUL
- MUL: Senza segno. Tratta operandi come positivi. CF/OF impostati se risultato > dimensione destinatario (es. AX > FFh per 8-bit).
- IMUL: Firmato. Tratta operandi come complemento a 2. CF/OF impostati se risultato non sta nella dimensione destinatario firmata.
Estensioni successive (186+ / 386+)
- Due operandi:
IMUL r16, r/m16→ r16 = r16 × r/m16 (solo bassi 16 bit, niente DX). - Tre operandi:
IMUL r16, r/m16, imm16→ r16 = r/m16 × imm16. - Forme immediate:
IMUL r16, imm8/imm16. - Questi truncano a 16 bit; CF/OF impostati se bit troncati ≠ bit segno.
Note pratiche
- IMUL è più lento di MUL (logica segno aggiuntiva). ~80–130 cicli sull'8086.
- Usa
CBW(AL→AX) /CWD(AX→DX:AX) prima di IMUL se estendi dimensione operando. - Per 8-bit × 8-bit → 16-bit sull'8086, il risultato è sempre in AX. Nessun DX usato.
- In assembly inline (C), usa intrinsics del compiler o built-ins (__emulu, __emuls).
IMUL è essenziale per l'aritmetica su interi firmati (coordinate, fisica, DSP, crypto) nel codice real-mode a 16 bit.