如何使用 x86 汇编语言将两个 64 位数字相乘？

Question

我该怎么做...

• 两个 64 位数字相乘

• 两个 16 位十六进制数字相乘

.. .使用汇编语言。

我只允许使用寄存器 %eax、%ebx、%ecx、%edx 和堆栈。

编辑：哦，我在 x86 上使用 ATT 语法
EDIT2：不允许反编译成程序集...

Answer 1

使用可能应该是你的课程教科书的内容，兰德尔·海德 (Randall Hyde) 的《汇编语言的艺术》。

请参阅4.2.4 - 扩展精度乘法< /a>

尽管 8x8、16x16 或 32x32 乘法通常就足够了，但有时您可能需要将较大的值相乘。 您将使用 x86 单操作数 MUL 和 IMUL 指令进行扩展精度乘法..

执行扩展精度乘法时要记住的最重要的事情可能是，您还必须同时执行多精度加法。 将所有部分乘积相加需要进行多次加法才能产生结果。 以下清单演示了在 32 位处理器上将两个 64 位值相乘的正确方法..

（请参阅链接以获取完整的汇编清单和插图。）

Answer 2

如果这是 64x86，

function(x, y, *lower, *higher)
movq %rx,%rax     #Store x into %rax
mulq %y           #multiplies %y to %rax
#mulq stores high and low values into rax and rdx.
movq %rax,(%r8)   #Move low into &lower
movq %rdx,(%r9)   #Move high answer into &higher

Answer 3

由于您使用的是 x86，因此您需要 4 条 mull 指令。 将 64 位数量拆分为两个 32 位字，并将低字乘以结果的最低字和第二低字，然后将来自不同数字的两对低字和高字（它们分别乘以结果的第二和第三最低字），最后将两个高的单词都变成结果的2个最高的单词。 将它们全部加在一起，不要忘记处理进位。 您没有指定输入和输出的内存布局，因此无法编写示例代码。

Answer 4

此代码假设您需要 x86（而不是 x64 代码），您可能只需要 64 位产品，并且您不关心溢出或有符号数字。 （签名版本类似）。

MUL64_MEMORY:
     mov edi, val1high
     mov esi, val1low
     mov ecx, val2high
     mov ebx, val2low
MUL64_EDIESI_ECXEBX:
     mov eax, edi
     mul ebx
     xch eax, ebx  ; partial product top 32 bits
     mul esi
     xch esi, eax ; partial product lower 32 bits
     add ebx, edx
     mul ecx
     add ebx, eax  ; final upper 32 bits
; answer here in EBX:ESI

这不符合 OP 的确切寄存器限制，但结果完全适合 x86 提供的寄存器。 （这段代码未经测试，但我认为它是正确的）。

[注意：我从另一个已关闭的问题中转移了（我的）这个答案，因为这里的其他“答案”都没有直接回答这个问题]。

Answer 5

这取决于您使用的语言。 根据我学习 MIPS 汇编的记忆，有一个 Move From High 命令和一个 Move From Lo 命令，即 mflo 和 mfhi。 mfhi 存储总数的高 64 位，而 mflo 存储总数的低 64 位。

Answer 6

啊组装，自从我使用它以来已经有一段时间了。 所以我假设这里真正的问题是你正在开发的微控制器（我曾经在汇编中编写代码）没有 64 位寄存器？ 如果是这种情况，您将需要将正在处理的数字分开，并对各个部分执行多次乘法。

从你的措辞来看，这听起来像是一项家庭作业，所以我不会进一步详细说明：P

Answer 7

只需进行正常的长乘法，就像将一对 2 位数字相乘一样，只不过每个“数字”实际上是一个 32 位整数。 如果您将地址 X 和 Y 处的两个数字相乘并将结果存储在 Z 中，那么您想要做的（以伪代码形式）是：

Z[0..3] = X[0..3] * Y[0..3]
Z[4..7] = X[0..3] * Y[4..7] + X[4..7] * Y[0..3]

请注意，我们将丢弃结果的高 64 位（因为 64 位number 乘以 64 位数字等于 128 位数字）。 另请注意，这是假设小尾数法。 另外，请注意有符号乘法与无符号乘法。

Answer 8

找到一个支持 64 位的 C 编译器（GCC 执行 IIRC）编译一个可以执行此操作的程序，然后进行反汇编。 GCC 可以自己将其吐出，您可以使用正确的工具将其从目标文件中取出。

OTOH 他们是 x86 上的 32bX32b = 64b 操作，

a:b * c:d = e:f
// goes to
e:f = b*d;
x:y = a*d;  e += x;
x:y = b*c;  e += x;

其他所有内容都会溢出

（未经测试）

编辑 仅未签名

Answer 9

我敢打赌你是一名学生，所以看看你是否能完成这项工作：逐字逐句地完成，并使用位移位。 想出最有效的解决方案。 当心符号位。

Answer 10

如果你想要 128 位乘法，那么这应该可以工作，这是 AT&T 格式。

__uint128_t FASTMUL128(const __uint128_t TA,const __uint128_t TB)
{
    union
    {
        __uint128_t WHOLE;
        struct
        {
            unsigned long long int LWORDS[2];
        } SPLIT;
    } KEY;
    register unsigned long long int __RAX,__RDX,__RSI,__RDI;
    __uint128_t RESULT;

KEY.WHOLE=TA;
__RAX=KEY.SPLIT.LWORDS[0];
__RDX=KEY.SPLIT.LWORDS[1];
KEY.WHOLE=TB;
__RSI=KEY.SPLIT.LWORDS[0];
__RDI=KEY.SPLIT.LWORDS[1];
__asm__ __volatile__(
    "movq           %0,                             %%rax                   \n\t"
    "movq           %1,                             %%rdx                   \n\t"
    "movq           %2,                             %%rsi                   \n\t"
    "movq           %3,                             %%rdi                   \n\t"
    "movq           %%rsi,                          %%rbx                   \n\t"
    "movq           %%rdi,                          %%rcx                   \n\t"
    "movq           %%rax,                          %%rsi                   \n\t"
    "movq           %%rdx,                          %%rdi                   \n\t"
    "xorq           %%rax,                          %%rax                   \n\t"
    "xorq           %%rdx,                          %%rdx                   \n\t"
    "movq           %%rdi,                          %%rax                   \n\t"
    "mulq           %%rbx                                                   \n\t"
    "xchgq          %%rbx,                          %%rax                   \n\t"
    "mulq           %%rsi                                                   \n\t"
    "xchgq          %%rax,                          %%rsi                   \n\t"
    "addq           %%rdx,                          %%rbx                   \n\t"
    "mulq           %%rcx                                                   \n\t"
    "addq           %%rax,                          %%rbx                   \n\t"
    "movq           %%rsi,                          %%rax                   \n\t"
    "movq           %%rbx,                          %%rdx                   \n\t"
    "movq           %%rax,                          %0                      \n\t"
    "movq           %%rdx,                          %1                      \n\t"
    "movq           %%rsi,                          %2                      \n\t"
    "movq           %%rdi,                          %3                      \n\t"
    : "=m"(__RAX),"=m"(__RDX),"=m"(__RSI),"=m"(__RDI)
    :  "m"(__RAX), "m"(__RDX), "m"(__RSI), "m"(__RDI)
    : "rax","rbx","ecx","rdx","rsi","rdi"
);
KEY.SPLIT.LWORDS[0]=__RAX;
KEY.SPLIT.LWORDS[1]=__RDX;
RESULT=KEY.WHOLE;
return RESULT;
}

Answer 11

如果你想要 128 模式试试这个......

__uint128_t AES::XMULTX(__uint128_t TA,__uint128_t TB)
{
    union
    {
        __uint128_t WHOLE;
        struct
        {
            unsigned long long int LWORDS[2];
        } SPLIT;
    } KEY;
    register unsigned long long int __XRBX,__XRCX,__XRSI,__XRDI;
    __uint128_t RESULT;

    KEY.WHOLE=TA;
    __XRSI=KEY.SPLIT.LWORDS[0];
    __XRDI=KEY.SPLIT.LWORDS[1];
    KEY.WHOLE=TB;
    __XRBX=KEY.SPLIT.LWORDS[0];
    __XRCX=KEY.SPLIT.LWORDS[1];
    __asm__ __volatile__(
                 "movq          %0,             %%rsi           \n\t"       
                 "movq          %1,             %%rdi           \n\t"
                 "movq          %2,             %%rbx           \n\t"
                 "movq          %3,             %%rcx           \n\t"
                 "movq          %%rdi,          %%rax           \n\t"
                 "mulq          %%rbx                           \n\t"
                 "xchgq         %%rbx,          %%rax           \n\t"
                 "mulq          %%rsi                           \n\t"
                 "xchgq         %%rax,          %%rsi           \n\t"
                 "addq          %%rdx,          %%rbx           \n\t"
                 "mulq          %%rcx                           \n\t"
                 "addq          %%rax,          %%rbx           \n\t"
                 "movq          %%rsi,          %0              \n\t"
                 "movq          %%rbx,          %1              \n\t"
                 : "=m" (__XRSI), "=m" (__XRBX)
                 : "m" (__XRSI),  "m" (__XRDI), "m" (__XRBX), "m" (__XRCX)
                 : "rax","rbx","rcx","rdx","rsi","rdi"
                 );
    KEY.SPLIT.LWORDS[0]=__XRSI;
    KEY.SPLIT.LWORDS[1]=__XRBX;
    RESULT=KEY.WHOLE;
    return RESULT;
}