GCC：优化内存加载和存储

Question

编辑 1： 添加了另一个示例（表明 GCC 原则上能够完成我想要实现的目标）并在此问题的末尾进行了更多讨论。

编辑2：找到malloc函数属性，应该做什么。请看问题的最后。

这是一个关于如何告诉编译器存储到内存区域的问题在区域之外不可见（因此可以优化掉）。为了说明我的意思，我们来看看下面的代码

int f (int a)
{
    int v[2];
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
       v[1] += v[0];
    return v[1];
}

gcc -O2 生成以下汇编代码（x86-64 gcc, trunk, on https://godbolt.org）：

f:
        leal    -1(%rdi), %edx
        xorl    %eax, %eax
        testl   %edi, %edi
        jle     .L4
.L3:
        addl    %edx, %eax
        subl    $1, %edx
        cmpl    $-1, %edx
        jne     .L3
        ret
.L4:
        ret

可以看到，数组v的加载和存储在优化后都消失了。

现在考虑以下代码：

int g (int a, int *v)
{
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
       v[1] += v[0];
    return v[1];
}

不同之处在于v 不是在函数中分配（堆栈），而是作为参数提供。在这种情况下gcc -O2 的结果是：

g:
        leal    -1(%rdi), %edx
        movl    $0, 4(%rsi)
        xorl    %eax, %eax
        movl    %edx, (%rsi)
        testl   %edi, %edi
        jle     .L4
.L3:
        addl    %edx, %eax
        subl    $1, %edx
        cmpl    $-1, %edx
        jne     .L3
        movl    %eax, 4(%rsi)
        movl    $-1, (%rsi)
        ret
.L4:
        ret

显然，代码必须将v[0] 和v[1] 的最终值存储在内存中，因为它们可能是可观察到的。

现在，我正在寻找一种方法来告诉编译器第二个示例中v 指向的内存在函数g 返回后不再可访问，以便编译器可以优化远离内存访问。

举个更简单的例子：

void h (int *v)
{
    v[0] = 0;
}

如果v 指向的内存在h 返回后无法访问，应该可以将函数简化为单个ret。

我试图通过使用严格的别名规则来实现我想要的，但没有成功。

在编辑 1 中添加：

GCC 似乎内置了必要的代码，如下例所示：

include <stdlib.h>

int h (int a)
{
    int *v = malloc (2 * sizeof (int));
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
      v[1] += v[0];
    return v[1];
}

生成的代码不包含任何加载和存储：

h:
        leal    -1(%rdi), %edx
        xorl    %eax, %eax
        testl   %edi, %edi
        jle     .L4
.L3:
        addl    %edx, %eax
        subl    $1, %edx
        cmpl    $-1, %edx
        jne     .L3
        ret
.L4:
        ret

换句话说，GCC 知道通过malloc 的任何副作用无法观察到更改v 指向的内存区域。对于这样的目的，GCC 有__builtin_malloc。

所以我也可以问：用户代码（比如malloc 的用户版本）如何使用此功能？

在编辑 2 中添加：

GCC具有以下功能属性：

malloc

这告诉编译器一个函数是类似malloc的，即函数返回的指针P不能为函数返回时任何其他有效的指针起别名，而且在P寻址的任何存储中都不会出现指向有效对象的指针.

使用此属性可以改进优化。编译器预测具有该属性的函数在大多数情况下返回非空值。 malloc 和 calloc 之类的函数具有此属性，因为它们返回指向未初始化或清零存储的指针。然而，像 realloc 这样的函数没有这个属性，因为它们可以返回一个指向包含指针的存储的指针。

它似乎做我想做的事，如下例所示：

__attribute__ (( malloc )) int *m (int *h);

int i (int a, int *h) 
{ 
    int *v = m (h);
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
        v[1] += v[0];
    return v[1];
}

生成的汇编代码没有加载和存储：

i:
        pushq   %rbx
        movl    %edi, %ebx
        movq    %rsi, %rdi
        call    m
        testl   %ebx, %ebx
        jle     .L4
        leal    -1(%rbx), %edx
        xorl    %eax, %eax
.L3:
        addl    %edx, %eax
        subl    $1, %edx
        cmpl    $-1, %edx
        jne     .L3
        popq    %rbx
        ret
.L4:
        xorl    %eax, %eax
        popq    %rbx
        ret

但是，一旦编译器看到m 的定义，它可能会忘记该属性。例如，当给出以下定义时就是这种情况：

__attribute__ (( malloc )) int *m (int *h)
{
    return h;
}

在这种情况下，函数是内联的，编译器会忘记该属性，从而产生与函数 g 相同的代码。

P.S.：最初，我认为restrict 关键字可能会有所帮助，但事实并非如此。

Answer 1

编辑：讨论最后添加的noinline 属性。

使用下面的函数定义，可以达到我的问题的目的：

__attribute__ (( malloc, noinline )) static void *get_restricted_ptr (void *p)
{
    return p;
}

这个函数get_restricted_ptr只是简单地返回它的指针参数，但是通知编译器返回的指针P在函数返回时不能为任何其他有效的指针起别名，而且在P寻址的任何存储中都不会出现指向有效对象的指针。

这里演示了这个函数的使用：

int i (int a, int *h)
{
    int *v = get_restricted_ptr (h);
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
        v[1] += v[0];
    return;
}

生成的代码不包含加载和存储：

i:
        leal    -1(%rdi), %edx
        xorl    %eax, %eax
        testl   %edi, %edi
        jle     .L6
.L5:
        addl    %edx, %eax
        subl    $1, %edx
        cmpl    $-1, %edx
        jne     .L5
        ret
.L6:
        ret

在编辑中添加：如果noinline 属性被忽略，GCC 将忽略malloc 属性。显然，在这种情况下，函数首先被内联，这样 GCC 就不会再检查 malloc 属性的函数调用了。 （可以讨论这种行为是否应该被视为 GCC 中的错误。）使用noinline 属性，该函数不会被内联。然后，由于malloc 属性，GCC 知道对该函数的调用是不必要的，并将其完全删除。

不幸的是，这意味着当由于malloc 属性而没有消除它的调用时（平凡的）函数将不会被内联。

Answer 2

这两个函数都有副作用，无法优化内存读取和存储

void h (int *v)
{
    v[0] = 0;
}

和

int g (int a, int *v)
{
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
       v[1] += v[0];
    return v[1];
}

副作用必须在函数范围之外是可观察的。内联函数可能有另一种行为，因为副作用可能必须在封闭代码之外可见。

inline int g (int a, int *v)
{
    v[0] = a;
    v[1] = 0;
    while (v[0]-- > 0)
       v[1] += v[0];
    return v[1];
}

void h(void)
{
    int x[2],y ;

    g(y,x);
}

这段代码将被优化为一个简单的返回

您可以向编译器保证不会发生任何事情来允许使用关键字限制进行更轻松的优化。当然，你的代码必须遵守这个承诺。

Answer 3

对于 C，唯一的限制是编译器必须确保代码的行为相同。如果编译器可以证明代码行为相同，那么它可以并且将删除存储。

比如我把这个放到https://godbolt.org/:

void h (int *v)
{
    v[0] = 0;
}

void foo() {
    int v[2] = {1, 2};
    h(v);
}

并告诉它使用 GCC 8.2 和“-O3”，并得到以下输出：

h(int*):
        mov     DWORD PTR [rdi], 0
        ret
foo():
        ret

请注意，输出中有两个不同版本的函数 h()。如果其他代码（在其他目标文件中）想要使用该函数（并且可能被链接器丢弃），则存在第一个版本。 h() 的第二个版本直接内联到 foo()，然后优化到完全没有。

如果你把代码改成这样：

static void h (int *v)
{
    v[0] = 0;
}

void foo() {
    int v[2] = {1, 2};
    h(v);
}

然后它告诉编译器不需要只为链接其他目标文件而存在的h()版本，因此编译器只生成h()的第二个版本，输出变为：

foo():
        ret

当然，所有编译器中的所有优化器都不是完美的——对于更复杂的代码（以及不同的编译器，包括不同版本的 GCC），结果可能会有所不同（编译器可能无法进行这种优化）。这纯粹是编译器优化器的限制，而不是 C 本身的限制。

对于编译器优化器不够好的情况，有4种可能的解决方案：

• 获得更好的编译器

• 改进编译器的优化器（例如，向编译器的开发人员发送一封电子邮件，其中包含一个最小的示例并让您放心）

• 修改代码以使编译器的优化器更容易（例如，将输入数组复制到本地数组，如“void h(int *v) { int temp[2]; temp[0] = v[0]; temp[1] = v[1]; ...”）。

• 耸耸肩说“哦，真可惜”，什么也不做