How do C compilers implement functions that return large structures?

by

None; no copies are done.

The address of the caller’s Data return value is actually passed as a hidden argument to the function, and the createData function simply writes into the caller’s stack frame.

This is known as the named return value optimisation. Also see the c++ faq on this topic.

commercial-grade C++ compilers implement return-by-value in a way that lets them eliminate the overhead, at least in simple cases

…

When yourCode() calls rbv(), the compiler secretly passes a pointer to the location where rbv() is supposed to construct the “returned” object.

You can demonstrate that this has been done by adding a destructor with a printf to your struct. The destructor should only be called once if this return-by-value optimisation is in operation, otherwise twice.

Also you can check the assembly to see that this happens:

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

here’s the assembly:

__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:

Curiously, it allocated enough space on the stack for the data item subl $1032, %esp, but note that it takes the first argument on the stack 8(%ebp) as the base address of the object, and then initialises element 6 of that item. Since we didn’t specify any arguments to createData, this is curious until you realise this is the secret hidden pointer to the parent’s version of Data.

More Related Contents:

  1. Why does clang produce inefficient asm with -O0 (for this simple floating point sum)?
  2. C loop optimization help for final assignment (with compiler optimization disabled)
  3. What registers to save in the ARM C calling convention?
  4. Disable all optimization options in GCC
  5. C optimisation of string literals
  6. Is it possible to tell the branch predictor how likely it is to follow the branch?
  7. What is __stdcall?
  8. What is the format of the x86_64 va_list structure?
  9. How are variable arguments implemented in gcc?
  10. Does C have a standard ABI?
  11. Is the compiler allowed to recycle freed pointer variables?
  12. How to turn off gcc compiler optimization to enable buffer overflow
  13. Why can’t C compilers rearrange struct members to eliminate alignment padding? [duplicate]
  14. Are there any downsides to passing structs by value in C, rather than passing a pointer?
  15. Are floating point operations in C associative?
  16. Why can a T* be passed in register, but a unique_ptr cannot?
  17. C++ on x86-64: when are structs/classes passed and returned in registers?
  18. Why does gcc use movl instead of push to pass function args?
  19. How to optimize these loops (with compiler optimization disabled)?
  20. What kind of C11 data type is an array according to the AMD64 ABI
  21. How do I make an infinite empty loop that won’t be optimized away?
  22. Order of evaluation of arguments in function calling?
  23. How does C return a structure? [duplicate]
  24. Compiler changes printf to puts
  25. Why is 0 moved to stack when using return value?
  26. Why is gcc allowed to speculatively load from a struct?
  27. How can I optimize these loops (with compiler optimization disabled)?
  28. In clang, how do you use per-function optimization attributes?
  29. Behaviour of printf when printing a %d without supplying variable name
  30. atoi vs atol vs strtol vs strtoul vs sscanf

Leave a Comment