Re: Code gen question

[Joe Buck <jbuck at Synopsys dot COM>]

> Which will cause cc1plus to generate better code?
> 
> inline int myclass::myfunc (int j) { return j*j*j; }
> 
> 
> inline int myclass::myfunc (const int &j) { return j*j*j; }

It depends on the code at the call site, and whether the object passed
to myfunc is in a register or in memory, plus whether the compiler can
optimize away unneeded write-to-memory, read-back-from-memory code.

In many cases, you'll get the exact same code for either of the above
two functions.  In other cases, either one or the other turns out a
bit better, usually because of some missed optimizaton.

If you really want to know, use -S and look at the assembly.

> My guess would be the latter, since the latter when inlined won't make a
> copy of the argument passed.

In principle the two should come out about the same, now that we have
the ADDRESSOF optimization.  Before we had ADDRESSOF the first one
was always better on most processors, since j gets passed in a register
while the second one forces j to be in memory.

> However, it might be that at high -O settings
> cc1plus will spot that the first version doesn't modify j and silently
> compile it like the second version.

That would be bad: what if j is already in a register?  Why would you want
to force it to memory?

> This leads me to ask: when writing short inline functions, is it better for
> code optimization to pass builtin data types (bool, int, double, etc.) and
> pointers by value or by reference?

If it fits in a register, use by-value, though in many cases the
difference is not significant.