为什么GCC在实现整数除法时使用乘以奇数的乘法？

我一直在阅读div和mul汇编操作，我决定通过用C编写一个简单程序来看到它们的作用：

文件分割

#include <stdlib.h>
#include <stdio.h>

int main()
{
    size_t i = 9;
    size_t j = i / 5;
    printf("%zu\n",j);
    return 0;
}

然后使用以下命令生成汇编语言代码：

gcc -S division.c -O0 -masm=intel

但是查看生成的division.s文件，它不包含任何div操作！取而代之的是，它执行某种带有移位和魔术数字的黑魔法。这是一个计算的代码片段i/5：

mov     rax, QWORD PTR [rbp-16]   ; Move i (=9) to RAX
movabs  rdx, -3689348814741910323 ; Move some magic number to RDX (?)
mul     rdx                       ; Multiply 9 by magic number
mov     rax, rdx                  ; Take only the upper 64 bits of the result
shr     rax, 2                    ; Shift these bits 2 places to the right (?)
mov     QWORD PTR [rbp-8], rax    ; Magically, RAX contains 9/5=1 now, 
                                  ; so we can assign it to j

这里发生了什么？为什么GCC根本不使用div？它是如何产生这个幻数的？为什么一切正常？

整数除法是您可以在现代处理器上执行的最慢的算术运算之一，延迟高达数十个周期，并且吞吐量很差。（对于x86，请参阅Agner Fog的说明表和Microarch指南）。

如果您提前知道除数，则可以通过用一组等效的其他运算（乘法，加法和移位）代替除数来避免除数。即使需要执行几个运算，它通常仍然比整数除法本身快很多。

用/这种方式实现C 运算符，而不是使用涉及多指令序列div的方式，只是GCC进行常数除法的默认方式。它不需要跨操作进行优化，即使调试也不会改变任何内容。（不过，使用-Os较小的代码大小确实可以使GCC使用div。）使用乘法逆而不是除法就像使用lea代替mul和一样。add

结果，只有在编译时不知道除数的情况下，您才倾向于看到div或idiv在输出中。

有关编译器如何生成这些序列的信息，以及使您自己生成它们的代码（除非您使用Braindead编译器，否则几乎可以肯定是不需要的），请参见libdivide。

除以5等于乘以1/5，再次等于乘以4/5并右移2位。相关值CCCCCCCCCCCCCCCD以十六进制表示，如果放在十六进制点之后，则为4/5的二进制表示形式（即，0.110011001100重复出现五分之四的二进制数-有关原因，请参见下文）。我想你可以从这里拿走！您可能想检查定点算法（尽管请注意，最后将其四舍五入为整数。

至于为什么，乘法比除法快，并且当除数固定时，这是一条更快的路线。

请参阅互逆乘法，该教程提供了有关其工作原理的详细文章，并针对定点进行了说明。它显示了求倒数的算法如何工作，以及如何处理有符号除法和模。

让我们考虑一下为什么0.CCCCCCCC...（十六进制）或0.110011001100...二进制为4/5。将二进制表示除以4（右移2位），然后0.001100110011...通过平凡的检查就可以将原始表示形式添加到get中0.111111111111...，显然等于1，0.9999999...十进制中的相同方式等于1。因此，我们知道x + x/4 = 1，所以5x/4 = 1，x=4/5。然后将其表示为CCCCCCCCCCCCD十六进制以进行四舍五入（因为最后一个出现的二进制数字将是1）。

通常，乘法比除法快得多。因此，如果我们可以避免乘以倒数，则可以大大加快除数的速度

皱纹是我们不能精确地表示倒数（除非除以2的幂，但是在那种情况下，我们通常可以将除数转换为位移）。因此，为确保正确答案，我们必须小心，倒数的错误不会导致最终结果的错误。

-3689348814741910323是0xCCCCCCCCCCCCCCCCCD，它的值刚好超过4/5，以0.64定点表示。

当我们将64位整数乘以0.64定点数时，将得到64.64的结果。我们将值截断为64位整数（有效地将其舍入为零），然后执行进一步的移位，将其除以4，然后再次截断。通过查看位级别，很明显，我们可以将这两个截断都视为单个截断。

显然，这至少使我们近似除以5，但是它是否为我们提供了一个正确的答案，正确地将其四舍五入为零？

为了获得准确的答案，误差必须足够小，以免将答案推到舍入边界上。

除以5的确切答案将始终是0、1 / 5、2 / 5、3 / 5或4/5的小数部分。因此，乘和移位后的结果中小于1/5的正误差将永远不会使结果超出舍入边界。

我们常数的误差是（1/5）* 2 ^-64。i的值小于2 ^64，因此相乘后的误差小于1/5。除以4后，误差小于（1/5）* 2 ^-2。

（1/5）* 2 ⁻² <1/5，因此答案将始终等于进行精确除法并舍入为零。

不幸的是，这不适用于所有除数。

如果我们尝试将4/7表示为一个0.64的固定点数，并且四舍五入为零，那么最终将得出（6/7）* 2 ^-64的误差。将i值乘以2 ^64之后，最终得到的误差就在6/7以下，而除以四之后，我们得到的误差就在1.5 / 7以下，即大于1/7。

因此，要正确实现7分频，我们需要乘以0.65的固定点数。我们可以通过乘以固定点数的低64位，然后加上原始数字（这可能会溢出到进位位），然后进行循环进位来实现。

这是一个算法文档的链接，该文档生成我在Visual Studio中看到的值和代码（在大多数情况下），并且我认为在GCC中仍将其用于将变量整数除以常量整数。

http://gmplib.org/~tege/divcnst-pldi94.pdf

在本文中，一个uword有N位，一个udword有2N位，n =分子=被除数，d =分母=除数，ℓ最初设置为ceil（log2（d）），shpre是预移位的（在乘法之前使用） ）= e = d中尾随零位的数量，shpost是后移位（在乘法之后使用），prec是precision = N-e = N-shpre。目标是使用预移位，乘法和后移位优化n / d的计算。

向下滚动至图6.2，该图定义了如何生成udword乘数（最大大小为N + 1位），但没有清楚地说明该过程。我将在下面解释。

图4.2和图6.2显示了对于大多数除数，如何将乘数减小到N位或更少。公式4.5解释了如何得出图4.1和4.2中用于处理N + 1位乘法器的公式。

在现代X86和其他处理器的情况下，乘法时间是固定的，因此预移位对这些处理器无济于事，但仍有助于将乘法器从N + 1位减少到N位。我不知道GCC或Visual Studio是否已消除X86目标的预转换。

回到图6.2。仅当分母（除数）> 2 ^（N-1）时（当ℓ== N => mlow = 2 ^（2N）时），mlow和mhigh的分子（股息）才能大于udword。 n / d的最佳替代是比较（如果n> = d，q = 1，否则q = 0），因此不会生成乘数。mlow和mhigh的初始值为N + 1位，两个udword / uword除法可用于产生每个N + 1位值（mlow或mhigh）。以64位模式下的X86为例：

; upper 8 bytes of dividend = 2^(ℓ) = (upper part of 2^(N+ℓ))
; lower 8 bytes of dividend for mlow  = 0
; lower 8 bytes of dividend for mhigh = 2^(N+ℓ-prec) = 2^(ℓ+shpre) = 2^(ℓ+e)
dividend  dq    2 dup(?)        ;16 byte dividend
divisor   dq    1 dup(?)        ; 8 byte divisor

; ...
        mov     rcx,divisor
        mov     rdx,0
        mov     rax,dividend+8     ;upper 8 bytes of dividend
        div     rcx                ;after div, rax == 1
        mov     rax,dividend       ;lower 8 bytes of dividend
        div     rcx
        mov     rdx,1              ;rdx:rax = N+1 bit value = 65 bit value

您可以使用GCC进行测试。您已经了解了j = i / 5的处理方式。看一下j = i / 7的处理方式（应该是N + 1位乘数的情况）。

在当前大多数处理器上，乘法具有固定的时序，因此不需要预移位。对于X86，对于大多数除数，最终结果是两个指令序列，对于像7一样的除数，最终结果是五个指令序列（以模拟pdf文件的公式4.5和图4.2中所示的N + 1位乘法器）。示例X86-64代码：

;       rax = dividend, rbx = 64 bit (or less) multiplier, rcx = post shift count
;       two instruction sequence for most divisors:

        mul     rbx                     ;rdx = upper 64 bits of product
        shr     rdx,cl                  ;rdx = quotient
;
;       five instruction sequence for divisors like 7
;       to emulate 65 bit multiplier (rbx = lower 64 bits of multiplier)

        mul     rbx                     ;rdx = upper 64 bits of product
        sub     rbx,rdx                 ;rbx -= rdx
        shr     rbx,1                   ;rbx >>= 1
        add     rdx,rbx                 ;rdx = upper 64 bits of corrected product
        shr     rdx,cl                  ;rdx = quotient
;       ...

我将从一个略有不同的角度回答：因为允许这样做。

C和C ++是针对抽象机定义的。编译器在下面的抽象机方面混凝土机械改造这个程序为，如果规则。

• 只要编译器不更改抽象机指定的可观察行为，就可以进行任何更改。没有合理的期望，编译器将以可能最直接的方式转换代码（即使许多C程序员都假定这样做）。通常这样做是因为与直接方法相比，编译器希望优化性能（如其他答案所述）。
• 如果在任何情况下，编译器都会将“正确”程序“优化”为具有不同可观察行为的程序，那就是编译器错误。
• 我们代码中的任何未定义行为（有符号整数溢出是典型示例），并且此合同无效。