RFC: Inlines, LTO and GCC

[Jeff Law]

On 09/09/2013 02:45 PM, Andrew MacLeod wrote:
> A number of header files have inline functions declared in them. Some of
> these functions are actually quite large, and I doubt that inlining them
> is the right thing.   For instance, tree-flow-inline.h has some quite
> large functions.  Many of the op_iter* functions are 30-40 lines long,
> and get_addr_base_and_unit_offset_1() is 130 lines.  Doesn't seem like
> it should be static inline! :-P
>
> During the process of re-factoring header files, it could be worthwhile
> to also move  functions like this to a .c file...
>
> I know a lot of work has  going in to the inliner and LTO, and I was
> wondering what its state was with regards to the current gcc source base.
>
> My questions are:
>
> 1) is everyone in favour of moving these largish inlines out of header
> files and making them not inline,
> 2) what size of function is rationale for inlining. Small one obviously,
> but where does the line start to get vague, and what would be a good
> rationale litmus test for an inline?  Functions which "do a lot" and
> look like they would use a number of registers seem like candidates to
> move..   I think we have a lot of functions that end up being compiled
> quite large because they inline functions which inline functions which
> inline functions....
> 3) The significance of moving these out would be greatly reduced if GCC
> were produced with LTO.. have we tried or considered doing this and
> possibly releasing gcc compiled this way?  It seems to me we could have
> significantly  less stuff in header files tagged as inline, but still
> see the benefit in our final product...   maybe all we'd need is the
> teeny tiny ones... and let the machinery figure it all out.  Now that
> would be sweet...
Unless we have evidence to show inlining a nontrivial function is a 
performance win, my inclination is to not have them in .h files and 
decorate them with inline directives.  Instead put them back in a .c 
file where they belong and let LTO do its thing.

I haven't done any research, but I suspect once you go beyond the 
trivial functions size is no longer a good indicator of whether or not 
something should be inlined.  Instead I suspect the question should be, 
if I inline this nontrivial code, how much code either in the caller or 
the inlined callee gets simplified away.   Of course, that's not always 
an easy question to answer :-)

Jeff