reference or stack?

[ugluk]

I'm writing some number crunching function for the CPU and I was wonder how the two function below would compare

inline void fa(float& t)
{
  t = t * t * t;
}
 
inline float fb(float t)
{
  return t * t * t;
}

Both functions do the same, but I wonder which one usually results in faster code (say, when using g++). I've read that probably fb, as it takes t from the stack, while fa dereferences a reference. On the other hand the reference from fa might be "compiled away" by the compiler, but the same might be true for fb. What do you think?

EDIT: I should have tested it myself and I did:

#include <cstdio>
 
inline void fa(float&amp; t)
{
  t = t * t * t;
}
 
inline float fb(float t)
{
  return t * t * t;
}
 
int main(int argc, char* argv[])
{
  float a(2);
  fa(a);
 
  float b(fb(2));
 
  std::printf("%f %f", a, b);
}

g++ tmp.cpp -g -O3 -march=native -o tmp

Produced this code:

Dump of assembler code for function main(int, char**):
   0x0000000000400650 <+0>:     sub    $0x8,%rsp
   0x0000000000400654 <+4>:     mov    $0x40076c,%esi
   0x0000000000400659 <+9>:     movsd  0x117(%rip),%xmm0        # 0x400778
   0x0000000000400661 <+17>:    mov    $0x1,%edi
   0x0000000000400666 <+22>:    movapd %xmm0,%xmm1
   0x000000000040066a <+26>:    mov    $0x2,%eax
   0x000000000040066f <+31>:    callq  0x400528 <__printf_chk@plt>
   0x0000000000400674 <+36>:    xor    %eax,%eax
   0x0000000000400676 <+38>:    add    $0x8,%rsp
   0x000000000040067a <+42>:    retq

It seems as if the compiler calculated t^3 internally and both functions produce the same code. I consider the syntax of fb clearer though and think that maybe it is therefore better.

I wonder what would happen if we were dealing with a custom floating point type (say a float with an arbitrary precision, like those provided by GMP).

[tksuoran]

You call your function with a constant value. Compiler can determine the result during compile time. You probably should go through some effort to make sure the compiler can not determine the values at compile time.