how do I use the sign extension from multiplication?

Question

I'm learning assembly right now and I'm completely lost on how the sign extension is used. I understand that if you have a value in AX and do MUL value it multiplies the value times AX and the result is in DX:AX, but how do I access and use the upper portion? It makes no sense to me whatsoever.

Answer 1

16bit registers preserve unsigned numbers in the range 0000h..FFFFh. The result of adding or subtracting such numbers may overflow this range by one bit, this bit is mediated by CarryFlag.
For instance FFFFh + FFFFh = CF + FFFEh.

The situation is different with multiplication: it may overflow by sixteen bits,
for instance FFFFh * FFFFh = FFFE0001h.
This is why another register (hardwired as DX) is used to hold the upper 16 bits of the result.

Even the old 16bit processor 8086 can add|subtract 32bit numbers using only legacy 16bit registers, but each operation requires two machine instructions, and CarryFlag must be taken into account. The lower halves of 32bit numbers are calculated with ADD|SUB and the upper halves with ADC|SBB.

Let's calculate for instance (a*b)+(c*d) where a,b,c,d are 16bit numbers 000Ah, 000Bh, 000Ch, 000Dh, respectively.

MOV AX,000Ah ;
MOV CX,000Bh ; Let CX=000Bh
MUL CX       ; Let DX:AX= a * b = 0000:006Eh
MOV SI,AX  ; Save temporary result DX:AX
MOV DI,DX  ;   into another pair DI:SI.
MOV AX,000Ch
MOV CX,000Dh
MUL CX     ; Let DX:AX = c * d = 0000:009Ch
; Add the temporary result DI:SI to DX:AX.
ADD AX,SI  ; Let AX = 009Ch + 006Eh = 010Ah. CF = 0.
ADC DX,DI  ; Let DX = 0000h + 0000h + CF = 0. CF = 0.

Result of (a*b)+(c*d), which is 0000:010Ah, is now in DX:AX, CF=0.

We may also treat 16bit value as a signed integer in the range -32768..+32767, i.e. 8000h..7FFFh. Intel CPU 8086 couldn't multiply signed numbers, the instruction IMUL was introduced with 80186 and later. In the absence of IMUL we have to convert each number to its absolute value, perform the unsigned multiplication and, if exactly one of multiplicant was negative, convert the unsigned product to its negative value.
Conversion between a negative value and its absolute (positive) value is provided by the instruction NEG. To negate 32bit number in two joined 16bit register CarryFlag must be taken into account again:

; Negate DX:AX
NEG DX
NEG AX
SBB DX,0

or, alternatively and less effective

; Negate DX:AX
NOT AX
NOT DX
ADD AX,1
ADC DX,0

However, all Intel/AMD processors made in the last three decades can compute signed multiplication directly with IMUL so you'd better to use it, as Peter Cordes suggests in his comment.

Answer 2

On an 8086 where you don't have 32-bit registers, you'd do 32-bit add with add ax, si / adc dx, di to do DX:AX += DI:SI, for example. This is how you work with integers larger than the widest register.

But normally you don't want your number split up between multiple registers in the first place, when a single register is wide enough. Since you're writing 32-bit code, don't get create this DX:AX split problem in the first place by not using mul r/m16.

Instead, simply use 32-bit operand-size for imul r, r/m or the 3-operand immediate form, like a compiler would. (zero-extend or sign-extend narrow inputs to the desired destination width).

Then you're not even forced to use EDX:EAX, and you don't destroy EDX for no reason when you only want a 32x32 => 32-bit multiply, not 32x32 => 64-bit. (Only the high half of a full-multiply depends on signedness, that's why there's only imul, not other forms of unsigned mul).

For example:

  movsx   edx, word ptr [esp+4]    ; sign-extend a 16-bit stack arg
  movzx   ecx, [esp+8]             ; zero-extend another 16-bit arg
  imul    edx, ecx                 ; edx = i16 * (int)u16
  imul    edx, [esp+12]            ; and multiply by a 32-bit stack arg, edx *= an int

  mov  eax, 123
  imul ecx,  eax, 456            ; ecx = eax*456, leaving EAX unmodified.

  add   edx, ecx

  lea   eax, [edx + edx*4 + 789]   ; eax = edx * 5 + 789 ; more math using the power of 32-bit addressing modes.

---

BTW, as @Michael pointed out in comments, you can do something like this to merge DX:AX into a single 32-bit int in EDX.

   shl edx, 16
   mov dx, ax

If you know the upper 16 bits of EAX were zero, you'd use or edx, eax instead of partial-register shenanigans. Why doesn't GCC use partial registers?)