C 编译器如何实现返回大型结构的函数？

Question

函数的返回值通常存储在堆栈或寄存器中。但对于大型结构，它必须位于堆栈上。对于这段代码，在真实的编译器中需要进行多少复制？还是已经优化掉了？

例如：（

struct Data {
    unsigned values[256];
};

Data createData() 
{
    Data data;
    // initialize data values...
    return data;
}

假设函数不能内联..）

Answer 1

没有任何;没有完成任何副本。

调用者的 Data 返回值的地址实际上作为隐藏参数传递给函数，并且 createData 函数只是写入调用者的堆栈帧。

这称为命名返回值优化。另请参阅有关此主题的 c++ 常见问题解答。

商业级 C++ 编译器实现按值返回的方式可以消除开销，至少在简单的情况下是如此

...

当 yourCode() 调用 rbv() 时，编译器会秘密传递一个指针，指向 rbv() 应该构造“返回”对象的位置。

您可以通过向结构中添加带有 printf 的析构函数来证明这是已完成的。如果按值返回优化正在运行，则析构函数只能调用一次，否则调用两次。

您还可以检查程序集以查看是否发生这种情况：

Data createData() 
{
    Data data;
    // initialize data values...
    data.values[5] = 6;
    return data;
}

这是程序集：

__Z10createDatav:
LFB2:
        pushl   %ebp
LCFI0:
        movl    %esp, %ebp
LCFI1:
        subl    $1032, %esp
LCFI2:
        movl    8(%ebp), %eax
        movl    $6, 20(%eax)
        leave
        ret     $4
LFE2:

奇怪的是，它在堆栈上为数据项 subl $1032, %esp 分配了足够的空间，但请注意，它采用第一个参数放在堆栈上 8(%ebp) 作为对象的基地址，然后初始化该项目的元素 6。由于我们没有为 createData 指定任何参数，因此这很奇怪，直到您意识到这是指向父级数据版本的秘密隐藏指针。

Answer 2

给出的例子很多，但基本上

这个问题没有明确的答案。这取决于编译器。

C 没有指定从函数返回多大的结构。

以下是针对某个特定编译器的一些测试，x86 RHEL 5.4

gcc 上的 gcc 4.1.2 简单情况，不复制

[00:05:21 1 ~] $ gcc -O2 -S -c t.c
[00:05:23 1 ~] $ cat t.s
        .file   "t.c"
        .text
        .p2align 4,,15
.globl createData
        .type   createData, @function
createData:
        pushl   %ebp
        movl    %esp, %ebp
        movl    8(%ebp), %eax
        movl    $1, 24(%eax)
        popl    %ebp
        ret     $4
        .size   createData, .-createData
        .ident  "GCC: (GNU) 4.1.2 20080704 (Red Hat 4.1.2-46)"
        .section        .note.GNU-stack,"",@progbits

gcc 更现实的情况，在堆栈上分配，memcpy 到调用者

#include <stdlib.h>
struct Data {
    unsigned values[256];
};
struct Data createData()
{
    struct Data data;
    int i;
    for(i = 0; i < 256 ; i++)
        data.values[i] = rand();
    return data;
}

[00:06:08 1 ~] $ gcc -O2 -S -c t.c
[00:06:10 1 ~] $ cat t.s
        .file   "t.c"
        .text
        .p2align 4,,15
.globl createData
        .type   createData, @function
createData:
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %edi
        pushl   %esi
        pushl   %ebx
        movl    $1, %ebx
        subl    $1036, %esp
        movl    8(%ebp), %edi
        leal    -1036(%ebp), %esi
        .p2align 4,,7
.L2:
        call    rand
        movl    %eax, -4(%esi,%ebx,4)
        addl    $1, %ebx
        cmpl    $257, %ebx
        jne     .L2
        movl    %esi, 4(%esp)
        movl    %edi, (%esp)
        movl    $1024, 8(%esp)
        call    memcpy
        addl    $1036, %esp
        movl    %edi, %eax
        popl    %ebx
        popl    %esi
        popl    %edi
        popl    %ebp
        ret     $4
        .size   createData, .-createData
        .ident  "GCC: (GNU) 4.1.2 20080704 (Red Hat 4.1.2-46)"
        .section        .note.GNU-stack,"",@progbits

gcc 4.4.2### 增长了很多，并且不复制对于上述非平凡的情况。

        .file   "t.c"
        .text
        .p2align 4,,15
.globl createData
        .type   createData, @function
createData:
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %edi
        pushl   %esi
        pushl   %ebx
        movl    $1, %ebx
        subl    $1036, %esp
        movl    8(%ebp), %edi
        leal    -1036(%ebp), %esi
        .p2align 4,,7
.L2:
        call    rand
        movl    %eax, -4(%esi,%ebx,4)
        addl    $1, %ebx
        cmpl    $257, %ebx
        jne     .L2
        movl    %esi, 4(%esp)
        movl    %edi, (%esp)
        movl    $1024, 8(%esp)
        call    memcpy
        addl    $1036, %esp
        movl    %edi, %eax
        popl    %ebx
        popl    %esi
        popl    %edi
        popl    %ebp
        ret     $4
        .size   createData, .-createData
        .ident  "GCC: (GNU) 4.1.2 20080704 (Red Hat 4.1.2-46)"
        .section        .note.GNU-stack,"",@progbits

另外，VS2008（上面编译为C）将在createData（）的堆栈上保留struct Data，并执行rep movsd循环将其在调试模式下复制回调用者，在发布模式下它将 rand() (%eax) 的返回值直接移回调用者

Answer 3

但对于大型结构，它必须位于堆堆栈上。

确实如此！声明为局部变量的大型结构在堆栈上分配。很高兴事情已经解决了。

至于避免复制，正如其他人所指出的：

• 大多数调用约定通过传递一个附加参数来处理“函数返回结构”，该参数指向调用者堆栈帧中应放置该结构的位置。这绝对是调用约定的问题，而不是语言的问题。

• 通过这种调用约定，即使是相对简单的编译器也可以注意到代码路径何时肯定会返回结构，并修复对该结构成员的赋值，以便它们直接进入调用者的框架并且不必复制。关键是编译器要注意通过函数的所有终止代码路径都返回相同结构变量。如果是这种情况，编译器可以安全地使用调用者框架中的空间，从而无需在返回点进行复制。

Answer 4

typedef struct {
    unsigned value[256];
} Data;

Data createData(void) {
    Data r;
    calcualte(&r);
    return r;
}

Data d = createData();

msvc(6,8,9) 和 gcc mingw(3.4.5,4.4.0) 将生成类似以下伪代码的代码

void createData(Data* r) {
      calculate(&r)
}
Data d;
createData(&d);

Answer 5

Linux 上的 gcc 将发出 memcpy() 将结构复制回调用者的堆栈上。如果该函数具有内部链接，则可以进行更多优化。