3

为什么这段代码不产生相同的程序集？(g++ -O3) 我对汇编知之甚少，但似乎情况 2 访问的指令较少，所以应该首选，对吧？我问这个是因为我想用一个返回指针的访问运算符实现一个包装类int* p = a[i]（所以访问是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 中的完全一样，因为 operator+ 现在与左侧相关联。

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

https://godbolt.org/z/x89453aK4

4

2 回答 2

5

表达式*(a + i*3 + j)和a[i*3 + j]在 C++ 级别上是不等价的。由于二进制+从左到右关联，因此前者等价于，*((a + i*3) + j)而后者等价于*(a + (i*3 + j)). 例如，如果 in 中的总和i*3 + j会溢出，它们会产生不同的结果int。

举一个具体的例子，考虑一个 32 位的 64 位机器，int比如你的 x86-64 系统，假设我们有i == 600'000'000和j == 2'000'000'000. 假设，而不是长度为 9 的数组，它a指向 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 位加法。这解释了为什么它需要额外的指令。

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

只是为了突出我正在谈论的代码：在问题中链接的 asm 代码的*(a + i*3 + j) = k;第 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
于 2021-06-20T08:19:33.057 回答
-1

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

输出是一样的。

对于最后一种情况，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
于 2021-06-20T08:36:23.430 回答