Assembly 在汇编语言中实现MUL指令

我需要乘法，但不使用汇编8086中的MUL指令

例如：

mov bx, 2
bx -> bx * 41; code instead this line

有什么帮助吗？

简单的解决方案使用重复添加。 使用其中一个数字作为计数器，并将另一个数字的倍数添加到结果中

这里重要的是，结果需要标注为原始数字大小的两倍。如果两个数字都是16位，则结果必须是32位

其次，最好使用两个数字中最小的一个作为计数器。这将减少迭代次数

如果计数器为零，也不要忘记不要启动循环。显然乘积是零

 mov  bx, [Num1]
 mov  cx, [Num2]
 cmp  cx, bx
 jb   ClearResult
 xchg bx, cx        ;Puts smaller number in CX
ClearResult:
 xor  ax, ax        ;Clear 32-bit result
 cwd
 jcxz OK
AddAgain:
 add  ax, bx
 adc  dx, 0
 dec  cx
 jnz  AddAgain
OK:

---

这里的乘积在

DX:AX

中。要将变量乘以常数，您可以在方便的时候将常数分解为2的幂；例如，AX=AX*320，320=2^8+2^6。

---

然后对每个幂和一个和进行向左移位。AX=AX*320变成：AX=ax41*2=41+41=82，41*3=41+41+41=123你卡在哪里？为什么不能使用

mul

指令？你还有什么其他的限制？可能是一个家庭作业，用来解开base-10的大脑（为什么你不能使用mul）。我们每个学期都会从许多人那里看到这个问题……形式各异……n*7=n*0b111=n*（0b100+0b010+0b011）=（n*0b100）+（n*0b010）+n*0b001）=（n（从技术上讲，移位也适用于基数10，就像基数2一样，你只需用零填充，但你还必须进行乘法，这是两者之间的区别）你为什么不把你的例子依次编号呢？“1,2,3”第二个例子是错误的！128是2^7，因此只需要额外的一个移位，而不是你写的2。还有一个问题。当

AX

中的数字不是一个很小的数字时会发生什么？（第一个例子中的AX=210）移位操作将毫无怨言地溢出，产生错误的产品。这就是为什么我在回答中写道“结果的大小需要是原始数字的两倍”。好的。但是这个新版本应该可以（与

MUL RX

相比，至少节省67个CPU周期）。

Function Mul41(Inp:Integer):LongInt; Assembler;

Asm

     Mov   AX,Inp

    {     DX:AX=AX*41; 41=32+8+1.
         BX, CX=TEMP}

{05} CWD             {DX:AX<-INPUT}

{02} Mov   BX,AX
{02} Mov   CX,DX

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<3}

{03} Add   BX,AX
{03} AdC   CX,DX

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<5}

{03} Add   AX,BX
{03} AdC   DX,CX     {DX:AX<-INPUT*(32+8+1)}

{41 CPU clock-cycles}

{128-154 CPU clock-cycles for IMUL RX}

End;

Function MulM41(Inp:Integer):LongInt; Assembler;

Asm

     Mov   AX,Inp

    {     DX:AX=AX*-41; 41=32+8+1.
         BX, CX=TEMP}

{05} CWD             {DX:AX<-INPUT}

{03} Not   AX        {Because NEG AX before CWD ...}
{03} Not   DX        {... is wrong for AX=-32768 ...}
{03} Add   AX,1      {... it does a two complement of DX:AX}
{03} AdC   DX,0      {DX:AX<- -INPUT}

{02} Mov   BX,AX
{02} Mov   CX,DX     {CX:BX<- -INPUT}

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<- -INPUT<<3}

{03} Add   BX,AX
{03} AdC   CX,DX     {CX:BX<- -INPUT*(8+1)}

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<- -INPUT<<5}

{03} Add   AX,BX
{03} AdC   DX,CX     {DX:AX<- -INPUT*(32+8+1)}

{53 CPU clock-cycles}

{128-154 CPU clock-cycles for IMUL RX}

End;

Function Mul320(Inp:Integer):LongInt; Assembler;

Asm

     Mov   AX,Inp

    {     DX:AX=AX*320; 320=256+64.
         BX, CX=TEMP}

{02} ShL   AX,1
{03} SBB   DX,DX
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<6}

{02} Mov   BX,AX
{02} Mov   CX,DX     {CX:BX<-INPUT<<6}

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<8}

{03} Add   AX,BX
{03} AdC   DX,CX     {DX:AX<-INPUT*(256+64)}

{43 CPU clock-cycles}

{128-154 CPU clock-cycles for IMUL RX}

End;

Function Mul200(Inp:Integer):LongInt; Assembler;

Asm

     Mov   AX,Inp

    {     DX:AX=AX*200; 200=128+64+8.
         BX, CX=TEMP}

{02} ShL   AX,1
{03} SBB   DX,DX
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<3}

{02} Mov   BX,AX
{02} Mov   CX,DX     {CX:BX<-INPUT<<3}

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<6}

{03} Add   BX,AX
{03} AdC   CX,DX     {CX:BX<-INPUT*(64+8)}

{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<7}

{03} Add   AX,BX
{03} AdC   DX,CX     {DX:AX<-INPUT*(128+64+8)}

{45 CPU clock-cycles}

{128-154 CPU clock-cycles for IMUL RX}

End;

Function Mul100(Inp:Integer):LongInt; Assembler;

Asm

     Mov   AX,Inp

    {     DX:AX=AX*100; 100=64+32+4.
         BX, CX=TEMP}

{02} ShL   AX,1
{03} SBB   DX,DX
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<2}

{02} Mov   BX,AX
{02} Mov   CX,DX     {CX:BX<-INPUT<<2}

{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1
{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<5}

{03} Add   BX,AX
{03} AdC   CX,DX     {CX:BX<-INPUT*(32+4)}

{02} ShL   AX,1
{02} RCL   DX,1      {DX:AX<-INPUT<<6}

{03} Add   AX,BX
{03} AdC   DX,CX     {DX:AX<-INPUT*(64+32+4)}

{41 CPU clock-cycles}

{128-154 CPU clock-cycles for IMUL RX}

End;

{    AX=AX*320; 320=256+64.
 BX, CL=TEMP}

 Mov   CL,6
 ShL   AX,CL {AX<-INPUT<<6}

 Mov   BX,AX

 Mov   CL,2
 ShL   AX,CL {AX<-INPUT<<8}

 Add   AX,BX {AX<-AX*(256+64)}

{    AX=AX*200; 200=128+64+8.
 BX, CL=TEMP}

 Mov   CL,3
 ShL   AX,CL {AX<-INPUT<<3}

 Mov   BX,AX

 ShL   AX,CL {AX<-INPUT<<6}

 Add   BX,AX

 ShL   AX,1  {AX<-INPUT<<7}

 Add   AX,BX {AX<-AX*(128+64+8)}

{    AX=AX*100; 100=64+32+4.
 BX, CL=TEMP}

 Mov   CL,2
 ShL   AX,CL {AX<-INPUT<<2}

 Mov   BX,AX

 Mov   CL,3
 ShL   AX,CL {AX<-INPUT<<5}

 Add   BX,AX

 ShL   AX,1  {AX<-INPUT<<6}

 Add   AX,BX {AX<-AX*(64+32+4)}