[Bug middle-end/93487] Missed tail-call optimizations

[Bug middle-end/93487] Missed tail-call optimizations

[pskocik at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93487

--- Comment #3 from pskocik at gmail dot com ---
The gist of this along with https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93540
is "please make trivial aggregates (i.e., aggregates, which are ultimately a
native type) a true zero-cost abstraction".

I feel like we shouldn't have to pay for `struct Int { int _; };` (or a union
of int with some <= types) over `int`, but on gcc (contrast with clang), you
effectively have to:

/////////////////////
int intfunc(void);
int intfuncwrap(void) { return intfunc(); }

=>
jmp    5 <intfuncwrap+0x5>

/////////////////////
struct Int { int x; };
struct Int intfuncwrap2(void) { return (struct Int){intfunc()}; }

=>
push   rax
call   6 <intfuncwrap2+0x6>
pop    rdx
ret
/////////////////////

Clang has been doing this right since clang 3 (and Compiler Explorer doesn't
have an older version):  https://gcc.godbolt.org/z/VSUHs_ .

Here's a related, but opposite, example where a trivial (one-member) union gets
optimized better than its contained type when used directly: 
https://gcc.godbolt.org/z/egXRjJ . 

These trivial type wrappings shouldn't affect codegen positively or negatively,
but they do on gcc.

[Bug middle-end/93487] Missed tail-call optimizations

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93487

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-08-22
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1
             Blocks|                            |101926

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Confirmed.


Referenced Bugs:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101926
[Bug 101926] [meta-bug] struct/complex argument passing and return should be
improved

[Bug middle-end/93487] Missed tail-call optimizations

[pskocik at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93487

--- Comment #5 from Petr Skocik <pskocik at gmail dot com> ---
Another case of a missed tailcall which might warrant a separate mention:

    struct big{ long _[10]; };
    void takePtr(void *);
    void takeBigAndPassItsAddress(struct big X){ takePtr(&X); }

This should ideally compile to just `lea 8(%rsp), %rdi; jmp takePtr;`.

The compiler might be tempted here to use the taking of an address of a local
here
as a reason not to tail call, and clang misses this optimization too, probably
for this reason,
but tailcalling here is fine as the particular local here isn't
allocated by the function but rather the callee during the call.

Icc does do this optimization: https://godbolt.org/z/a6coTzPjz