为什么数组访问和指针算术不等同于完全优化？

Question

为什么这段代码没有生成相同的程序集？ (g++ -O3) 我对汇编知之甚少，但似乎案例 2 访问指令较少，所以应该是首选，对吧？我问这个是因为我想用一个访问运算符 returns 一个指针 int* p = a[i] 来实现一个包装器 class （所以访问是 a[i][j]，而不是 a[i*3+j] )，但不知道是否值得。感谢您的帮助。

#include <iostream>

int main() {
    
    int a[9];
    int i, j, k;

    // Case 1
    std::cin >> i >> j >> k;
    *(a + i*3 + j) = k;

    std::cin >> i >> j >> k;
    (&a[i*3])[j] = k;

    std::cin >> i >> j >> k;
    *((&a[i*3])+j) = k;

    // Case 2
    std::cin >> i >> j >> k;
    a[i*3 + j] = k;

    std::cout << a[0];

    return 0;
}

https://godbolt.org/z/13arxcPqz

编辑：为了完整起见，a 向右移动的更改与情况 2 完全相同，因为运算符 + 现在关联到左侧。

// Case 2 again
std::cin >> i >> j >> k;
        *(i*3 + j + a) = k;

https://godbolt.org/z/x89453aK4

Answer 1

表达式 *(a + i*3 + j) 和 a[i*3 + j] 在 C++ 级别不等价。由于二进制+从左到右关联，前者相当于*((a + i*3) + j)而后者相当于*(a + (i*3 + j))。例如，如果 i*3 + j 中的总和会溢出 int.

，它们会产生不同的结果

举个具体的例子，考虑一个 64 位机器和 32 位机器 int 就像你的 x86-64 系统，假设我们有 i == 600'000'000 和 j == 2'000'000'000。假设 a 不是长度为 9 的数组，而是指向 64 位上的一个非常大的数组。第一个表达式将 1'800'000'000 和 2'000'000'000 添加到 a，得到 a+3'800'000'000。第二个首先添加 1'800'000'000+2'000'000'000 ，这会溢出并导致未定义的行为。在某些编译器上，行为可能是“环绕”，产生 a+(-494'967'296)，一个与另一个地址相距 16 GB 的完全不同的地址。

生成的程序集反映了这种区别。在第二种情况下，加法 i*3 + j 是作为普通 32 位加法完成的，它会在溢出时回绕。由于 j 在内存中，一旦我们在寄存器中得到 i，我们就可以使用普通的 add r32, m32 指令来进行加法。但在第一种情况下，i*3 + j 必须作为 64 位加法来生成正确的指针算法。所以 j 必须在添加之前符号扩展到 64 位，而这不能在单个内存源添加指令中完成。相反，我们首先使用 movsx r64, m32 将 j 加载到带符号扩展的寄存器中，然后使用 add r64, r64 进行 64 位加法。这解释了为什么需要额外的指令。

这两个“应该首选”中的哪一个与效率无关，而与您的代码是否可以用会溢出的参数调用以及您希望在这种情况下发生什么有关。在优化之前担心正确的行为。

只是为了突出显示我正在谈论的代码：*(a + i*3 + j) = k; 在 the asm code linked in the question 中的第 12-13 行和第 16-20 行执行：

        mov     eax, DWORD PTR [rsp+4]        ; eax = i, zero-extend
        movsx   rdx, DWORD PTR [rsp+8]        ; rdx = (int64_t)j, sign-extend to 64 bits
        ;;; lea     rsi, [rsp+4]              ; unrelated, set up args for next cin
        ;;; mov     edi, OFFSET FLAT:_ZSt3cin ; unrelated, set up args for next cin
        lea     eax, [rax+rax*2]              ; eax = i*3, still 32 bits
        cdqe                                  ; rax = (int64_t)i*3, sign-extended
        add     rax, rdx                      ; rax = (int64_t)(i*3) + (int64_t)j
        mov     edx, DWORD PTR [rsp+12]       ; edx = k
        mov     DWORD PTR [rsp+16+rax*4], edx ; perform the store

那么接下来两个版本的代码，(&a[i*3])[j] = k;（28-29和30-36）和*((&a[i*3])+j) = k;（44-45和48-52）是一样的；这些也对应于两个“指针加索引”步骤，并且从不执行 int 添加。

而 a[i*3 + j] = k; 位于第 60-65 行：

        mov     eax, DWORD PTR [rsp+4]        ; eax = i
        mov     edx, DWORD PTR [rsp+12]       ; edx = k
        lea     eax, [rax+rax*2]              ; eax *= 3
        add     eax, DWORD PTR [rsp+8]        ; eax += j (32 bit add!)
        cdqe                                  ; rax = (int64_t)(i*3+j)
        mov     DWORD PTR [rsp+16+rax*4], edx ; do the store

Answer 2

请仔细检查程序集输出。按颜色排序。

输出是一样的。

对于最后一种情况，IO 操作的程序集不同。

但基本上都一样

甚至，如果 C++ 语言和规则需要不同的实现，优化编译器将生成优化后的相同代码。

// 1.
        mov     eax, DWORD PTR [rsp+4]
        movsx   rdx, DWORD PTR [rsp+8]
        lea     eax, [rax+rax*2]
        cdqe
        add     rax, rdx
        mov     edx, DWORD PTR [rsp+12]
        mov     DWORD PTR [rsp+16+rax*4], edx
// 2.
        mov     eax, DWORD PTR [rsp+4]
        movsx   rdx, DWORD PTR [rsp+8]
        lea     eax, [rax+rax*2]
        cdqe
        add     rax, rdx
        mov     edx, DWORD PTR [rsp+12]
        mov     DWORD PTR [rsp+16+rax*4], edx
// 3.
        mov     eax, DWORD PTR [rsp+4]
        movsx   rdx, DWORD PTR [rsp+8]
        lea     eax, [rax+rax*2]
        cdqe
        add     rax, rdx
        mov     edx, DWORD PTR [rsp+12]
        mov     DWORD PTR [rsp+16+rax*4], edx

为什么数组访问和指针算术不等同于完全优化？

Why aren't array access and pointer arithmetic equivalent with full optimization?

c++

assembly

pointer-arithmetic

arrayaccess

c++20