GCC:优化内存加载和存储

编辑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];
}

不同的是 五 在这种情况下:

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] 在记忆中,因为它们可能是可见的。

现在,我要寻找的是告诉编译器 在第二个例子中,在函数之后就不能再访问了 g 已返回,以便编译器可以优化内存访问。

举个更简单的例子:

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

五 之后无法访问 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知道 五 不能通过药物的任何副作用观察到 马洛克 __builtin_malloc .

马洛克 )利用这个功能?

马洛克

这告诉编译器函数类似malloc,也就是说,当函数返回时,函数返回的指针P不能别名任何其他有效的指针,而且在由P寻址的任何存储中都不会出现指向有效对象的指针。

使用此属性可以改进优化。编译器预测在大多数情况下,具有该属性的函数返回非null。像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;
}

在这种情况下,函数是内联的,编译器会忘记属性,从而生成与函数相同的代码 .

附笔。: 起初,我认为 restrict 关键字可能有帮助,但似乎不是这样。