在 8086 微处理器上将 32 位两个数字相乘

Question

我有代码示例，用于在 8086 上将两个 16 位数字相乘并尝试更新它以使两个 32 位数字相乘。

start:
 MOV AX,0002h ; 16 bit multiplicand
 MOV BX,0008h ; 16 bit multiplier
 MOV DX,0000h ; high 16 bits of multiplication
 MOV CX,0000h ; low 16 bits of multiplication
 MOV SI,10h ; loop for 16 times

LOOP:
 MOV DI,AX
 AND DI,01h
 XOR DI,01h
 JZ ADD
CONT:
 RCR DX,1
 RCR CX,1
 SHR AX,1
 DEC SI
 CMP SI,0
 JNZ LOOP
 JMP END ; ignore here, it's not about multiplication. 
ADD:
 ADD DX,BX
 JMP CONT

上面的代码语句将两个 16 位数字相乘。

要更新 32 位两个数字，我知道我需要如下更新：

1. 将AX 更改为00000002h 并将BX 更改为00000008h。
2. 多用两个寄存器（我不知道应该用哪个寄存器）来保存第二个和第三个16位乘法（因为乘法将是64位。16位4次。我目前有DX和CX。）
3. 将循环编号更新为20h（在这种情况下为SI）（对于 32 位编号，循环编号为 32 次）

8086 是 16 位微处理器，所以它的寄存器也是。我无法为寄存器分配 32 位长的数字。

8086 的寄存器：

REG: AX, BX, CX, DX, AH, AL, BL, BH, CH, CL, DH, DL, DI, SI, BP, SP.
SREG: DS, ES, SS, and only as second operand: CS.

来源：http://www.electronics.dit.ie/staff/tscarff/8086_instruction_set/8086_instruction_set.html

我的问题是：

1. 如何为一个 32 位数字处理两个不同的寄存器。 （寄存器是 16 位的，所以我必须将数字分成两个寄存器）
2. 我可以为此目的使用哪些寄存器？我可以随意使用any注册吗？

提前致谢。

Answer 1

给男人一条鱼，然后等等等等……

很好，你有一个代码示例。但是你了解算法吗？

好的，让我们通过一个简化的例子一步一步来：将AL和AH中的两个8位寄存器相乘，并将结果存储在DX中。

顺便说一句，你可以使用任何你喜欢的寄存器，除非这个或那个指令需要任何特定的寄存器。例如，SHL reg, CL。

但在我们真正开始之前，我们对您提供的算法进行了一些优化。组装就是优化，你知道的。无论是速度还是尺寸。否则你在 C# 或 smth 中做 bloatware。否则。

MOV DI,AX
AND DI,01h
XOR DI,01h
JZ ADD

这部分所做的只是检查AX 中的第一位（位#0）是否已设置。 你可以简单地做

TEST AX, 1
JNZ ADD

但是您只需要测试一位，因此TEST AL, 1 而不是TEST AX, 1 为您节省了一个字节。

接下来，

RCR DX,1

不需要轮换，所以它可以简单地是SHR DX, 1。但是这两条指令的执行时间相同，而且都是两个字节长，因此在本例中无关紧要。

接下来，

DEC SI
CMP SI,0
JNZ LOOP

永远不要在DEC 之后与零进行比较。这是移动！干脆做

DEC SI
JNZ LOOP

接下来， 不必要的循环拆分

JZ ADD
CONT:
. . .
JMP END
ADD:
ADD DX, BX
JMP CONT
END:
. . .

应该是

JNZ CONT
ADD DX, BX
CONT:
. . .
END:
. . .

在这里，我们使用您拥有的一些优化的例程：

LOOP:
 TEST AL, 1
 JZ SHORT CONT
 ADD DX, BX
CONT:
 RCR DX, 1
 RCR CX, 1
 SHR AX, 1
 DEC SI
 JNZ LOOP
END:

就是这样。现在回到（或前进？）这段小代码的实际作用。以下代码示例完全模仿您的示例，但适用于 8 位寄存器。

 MOV AL,12h   ; 8 bit multiplicand
 MOV AH,34h   ; 8 bit multiplier
 XOR DX, DX   ; result
 MOV CX, 8    ; loop for 8 times

LOOP:
 TEST AL, 1
 JZ SHORT CONT
 ADD DH, AH
CONT:
 SHR DX, 1
 SHR AL, 1
 DEC CX
 JNZ LOOP
END:

这是Long Multiplication algorithm

 12h = 00010010
               x
 34h = 01110100
       --------
       00000000
      01110100
     00000000
    00000000
   01110100
  00000000
 00000000
00000000

将 34h 相加两次：

0000000011101000
+
0000011101000000
----------------
0000011110101000 = 03A8

就是这样！ 现在要使用更多数字，您使用相同的方法。下面是 fasm 语法的实现。结果存储在DX:CX:BX:AX

Num1    dd 0x12345678
Num2    dd 0x9abcdef0

 mov si, word [Num1]
 mov di, word [Num1 + 2]
 xor ax, ax
 xor bx, bx
 xor cx, cx
 xor dx, dx
 mov bp, 32

_loop:
 test si, 1
 jz short _cont
 add cx, word [Num2]
 adc dx, word [Num2 + 2]
_cont:
 rcr dx, 1
 rcr cx, 1
 rcr bx, 1
 rcr ax, 1
 rcr di, 1
 rcr si, 1
 dec bp
 jnz short _loop

干杯 ;)

Answer 2

解决方案 n。如果产品大于 32 位，2 似乎不起作用。 此外，移位指令是错误的。 此解决方案正常工作：

Procedure _PosLongIMul2; Assembler;

{INPUT:

 DX:AX-> First factor (destroyed).
 BX:CX-> Second factor (destroyed).

 OUTPUT:

 BX:CX:DX:AX-> Multiplication result.

 TEMP:

 BP, Di, Si}

Asm

     Jmp   @Go

 @VR:DD    0      {COPY of RESULT     (LOW)}
     DD    0      {COPY of RESULT    (HIGH)}

 @Go:Push  BP

     Mov   BP,20H {32 Bit Op.}

     XOr   DI,DI  {COPY of first op.  (LOW)}
     XOr   SI,SI  {COPY of first op. (HIGH)}

     Mov   [CS:OffSet @VR  ],Word(0)
     Mov   [CS:OffSet @VR+2],Word(0)
     Mov   [CS:OffSet @VR+4],Word(0)
     Mov   [CS:OffSet @VR+6],Word(0)

 @01:ShR   BX,1
     RCR   CX,1

     JAE   @00

     Add   [CS:OffSet @VR  ],AX
     AdC   [CS:OffSet @VR+2],DX
     AdC   [CS:OffSet @VR+4],DI
     AdC   [CS:OffSet @VR+6],SI

 @00:ShL   AX,1
     RCL   DX,1
     RCL   DI,1
     RCL   SI,1

     Dec   BP
     JNE   @01

     Mov   AX,[CS:OffSet @VR]
     Mov   DX,[CS:OffSet @VR+2]
     Mov   CX,[CS:OffSet @VR+4]
     Mov   BX,[CS:OffSet @VR+6]

     Pop   BP

End;

这适用于两个无符号整数。

如果要将 32 位无符号整数与 16 位无符号整数相乘，可以使用 Mul 指令，如下所示：

Function Mul32Bit(M1:LongInt;M2:Word):LongInt; Assembler;

Asm
 LEA   SI,M1
 Mov   AX,[SS:SI]
 Mov   CX,[SS:SI+2]
{CX:AX contains number to multiply by}
 Mov   BX,M2
{BX contains number that multiply}
 Mul   BX
 XChG  AX,CX
 Mov   SI,DX
 Mul   BX
 Add   AX,SI
 AdC   DX,0
{DX:AX:CX contains the result of multiplication}
 Mov   DX,AX
 Mov   AX,CX
{DX:AX contains the partial result of m. and is the function's result}
End;

Answer 3

据记录，8086 有一个mul instruction，这使得这变得更容易（并且在具有快速mul 的后来的 CPU 上更有效）。在最初的 8086 上它真的很慢，但运行RCL 多精度移位循环 32 次在所有 CPU 上都吸了很多！这个版本有更少的静态代码，这很好。

您只需要三个mul 指令即可获得low*low、low*high 和high*low 产品。 （如果您想要完整的 64 位结果，high*high 产品的另一个结果）。

8086 缺少高效的imul reg, reg 形式，它不需要 DX:AX 作为隐式输出，并且不会浪费时间将高半部分放在任何地方。所以不幸的是，我们需要比编译器在 32 位模式下进行 64x64 => 64 乘法更多的寄存器改组，否则这就是完全相同的问题。 （见https://godbolt.org/z/ozSkt_）

x_lo、x_hi、y_lo 和 y_hi 可以是相对于 bp 的内存，作为局部变量或函数参数或标签。或者其中一些可能位于此函数不使用的寄存器中，如果您更改语法使其不是寻址模式。

;; untested
;; inputs: uint32_t x, y in memory
;; clobbers: CX, SI, DI

    mov     ax, [y_lo]
    mov     cx, ax
    mul     word ptr [x_hi]
    mov     si, ax            ; save  y_lo * x_hi

    mov     ax, [x_lo]
    mov     di, ax
    mul     word ptr [y_hi]
    add     si, ax            ; sum of the cross products

    mov     ax, di
    mul     cx                ; DX:AX = y_lo * x_lo
    add     dx, si            ; add the cross products into the high half
;; Result: uint32_t DX:AX = X * Y

要使用更少的 tmp 寄存器，您可以只从内存中重新加载 x_lo 和 y_lo 两次，而不是将它们保存在 DI 和 CX 中。

（相关：64x64 => 64-bit multiply in 32-bit mode 是相同的问题，操作数大小不同，从寄存器中的所有 4 个值开始，使用 xchg 管理事物。）

请注意，我们不保存lo * hi 产品的高半 DX 结果，因为我们只需要 32 位结果，而不是完整的 32x32 => 64 位结果。这些产品的低 16 位添加到我们最终 32 位产品的上半部分。 （而且我们不需要将它们进位到 64 位结果的最高 16 位字中，因此我们可以在最后一个 mul 之前添加它们。）

• Assembly multiplication of 16-bit x 32-bit => 48-bit 展示了 adc 如何传播结果
• multiply two 32-bit numbers to get a 64-bit number, on a 8086 (32x32 => 64-bit with 16-bit multiplies) 如果您确实需要高半部分。
• Multiplying 64-bit number by a 32-bit number in 8086 asm 显示更大的情况，这些部分如何适合总和。

16 * 32 => 32 位乘法会更容易，只需两个 mul 和一个 add（加上一堆 mov 以将数据放入正确的位置）。例如，请参阅执行此操作的阶乘循环：multiply two consecutive times in assembly language program（该答案还显示了扩展精度乘法数学的工作原理，就像您为纸和铅笔算法添加术语以对多个十进制数字进行乘法一样。）