When passing a struct in C/C++ by value the struct contents must be copied. How do compilers achieve that? I.e., which assembly instructions are usually emitted for this copy?
How fast are these, when, e.g. compared to a call to memcpy?
Now consider this code:
struct X { int i, j, k; };
void foo(X x);
void foo( int i, int j, int k);
Is there any difference between calling foo(X) and foo(int,int,int) or might the generated assembly code be the same (considering the passing of parameters)?
How do compilers achieve that?
They call the copy constructor for that class/structure. The implicitly generated one if you don't provide one or the one you provide.
How fast are these, when, e.g. compared to a call to
memcpy?
Depends on the class and its members. Profiling should give you a clearer picture.
However, using memcpy to copy class instances should be avoided.
How do compilers achieve that?
They perform a shallow copy for that structure. For all practical purposes you can consider it same as memcpy.
Obviously, if there is a constructor for the struct or class, then the constructor is called.
If there isn't a constructor, it is entirely up to the compiler, but most likely, for three integer sized objects, it will probably be three individual mov instructions. For larger structures, it's either a call to memcpy or an inlined version similar to memcpy.
It is also quite likely that if the structure is VERY large (several megabytes), that true memcpy is faster than the inlined version, and the compiler may not realize this and use the inlined version anyway. But most of us don't use megabytes large structs, so I don't think generally that's something to worry too much about. Copying structs onto the stack as arguments, if the struct is megabytes large, is probably not a great idea in the first place, given the restricted size of a typical stack.
There are two distint cases.
If your struct is POD, the copy is optimized and will be as fast as memcpy (with proper optimization level).
If your struct is not POD, C++ has to call the copy constructor for your object. The copy constructor may call other functions, new operators, etc. so it will be slower than memcpy. But memcpy will not copy the struct correcty, using memcpy on a non-POD type results in undefined behaviour!
Note that e.g. in g++ the call to memcpy will be inlined and optimized out. As the intention between a struct copy and a memcpy call is exactly the same (copy X bytes from location Y to Z), I do not think that the generated assembly code will differ.
Anyway, to be sure, find it out by analyzing the assembly of your code.
Edit: just read the end of the question about the function parameters. Please note that function parameter passing is usually (especially in x64) done in registers and it is much faster than memcpy.
I've checked the assembly code and they do differ. The exact code will depend on the calling convention your current compiler uses. For me the struct is not passed in registers, rather it's passed on the stack and an actual copy is made. The three ints are passed in %ecx, %edx and %r8d. I've tried this on Windows GCC. It seems to use the Windows x64 calling convetion.
For more information on how the parameters are passed look at the specifications of your calling convention. All the details and corner cases are worked out. E.g. for x64 GCC look at System V AMD64 ABI Chapter 3.2.3 Parameter passing. For Visual Studio look here.
See another answer by Alok Save for c++. In c, it can be memcpy (or equivalent) or an inlined version of it (up to one mov instuction for structures with a good size).
