Inlining questions

[Ulf Magnusson <ulfalizer at gmail dot com>]

Hi,

I noticed that GCC 4.5.2 tends to generate smaller/better code when I
return a result from an inline function by reference (to something
non-local, obviously) rather than by value, even if the result is only
used as an rvalue.

Take the following for example:


int *a;

static inline int/*&*/ inl(int x) {
    return x == 1 ? a[7] : a[10];
}

int foo(int x) { return inl(x); }


With -O3, return-by-reference generates the following:

00000000 <_Z3fooi>:
   0:	83 7c 24 04 01       	cmpl   $0x1,0x4(%esp)
   5:	74 09                	je     10 <_Z3fooi+0x10>
   7:	a1 00 00 00 00       	mov    0x0,%eax
   c:	8b 40 28             	mov    0x28(%eax),%eax
   f:	c3                   	ret
  10:	a1 00 00 00 00       	mov    0x0,%eax
  15:	8b 40 1c             	mov    0x1c(%eax),%eax
  18:	c3                   	ret

Return by value generates the following:

00000000 <_Z3fooi>:
   0:	83 7c 24 04 01       	cmpl   $0x1,0x4(%esp)
   5:	74 11                	je     18 <_Z3fooi+0x18>
   7:	a1 00 00 00 00       	mov    0x0,%eax
   c:	83 c0 28             	add    $0x28,%eax
   f:	8b 00                	mov    (%eax),%eax
  11:	c3                   	ret
  12:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
  18:	a1 00 00 00 00       	mov    0x0,%eax
  1d:	83 c0 1c             	add    $0x1c,%eax
  20:	8b 00                	mov    (%eax),%eax
  22:	c3                   	ret


The difference becomes even bigger if you add conditionals or nest
calls to the inline function.

This leads to the following question:

In situations where both return-by-reference and return-by-value would
work, does the optimizer tend to do a better job with the former?

Though slightly unrelated, I'm also curious to what degree inline
functions really are equivalent to c-style macro "inlines"
performance-wise in GCC.

/Ulf