[Bug c++/104597] New: LTO does not inline indirect call

[Bug c++/104597] New: LTO does not inline indirect call

[m.cencora at gmail dot com]

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

            Bug ID: 104597
           Summary: LTO does not inline indirect call
           Product: gcc
           Version: 11.2.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: m.cencora at gmail dot com
  Target Milestone: ---

Given following files:
// main.cpp
using intfunc = int (*)();

intfunc getIntFunc(int i);

namespace
{
int test()
{
   auto func = getIntFunc(1);
   return func();
}
}

int main()
{
   return test();
}


// lib1.cpp
namespace
{

int getInt0()
{
   return 0;
}

int getInt1()
{
   return 1;
}

int getInt2()
{
   return 2;
}

}

using intfunc = int (*)();

intfunc getIntFunc(int i)
{
   if (i == 0)
   {
      return getInt0;
   }
   else if (i == 1)
   {
      return getInt1;
   }
   else if (i == 2)
   {
      return getInt2;
   }
   __builtin_abort();
}


and compilation with:
g++ -std=c++20 -Wall -Wextra -O3 -flto -fvisibility=hidden
-fvisibility-inlines-hidden -ffunction-sections -Wl,-gc-sections main.cpp
lib1.cpp -o test

Call to getInt1 does not get inlined:
Dump of assembler code for function main:
   0x0000000000001040 <+0>:     endbr64 
   0x0000000000001044 <+4>:     jmp    0x1140 <_ZN12_GLOBAL__N_17getInt1Ev>

[Bug c++/104597] LTO does not inline indirect call

[m.cencora at gmail dot com]

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

--- Comment #1 from m.cencora at gmail dot com ---
clang-12 optimizes it to:
Dump of assembler code for function main:
   0x0000000000401110 <+0>:     mov    $0x1,%eax
   0x0000000000401115 <+5>:     ret

[Bug c++/104597] LTO does not inline indirect call

[m.cencora at gmail dot com]

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

--- Comment #2 from m.cencora at gmail dot com ---
Similarly when indirect call is a result of virtual function call, gcc cannot
optimize it, while clang can:

// main.cpp
struct foo
{
   virtual int getInt0() const = 0;
   virtual int getInt1() const = 0;
};

const foo& getFooInstance();

namespace
{
int test()
{
   auto& foo = getFooInstance();
   return foo.getInt1();
}
}

int main()
{
   return test();
}

// lib1.cpp

struct foo
{
   virtual int getInt0() const = 0;
   virtual int getInt1() const = 0;
};

namespace
{

struct bar final : foo
{
   int getInt0() const override
   {
      return 0;
   }

   int getInt1() const override
   {
      return 1;
   }
};

constexpr bar b;

}

const foo& getFooInstance()
{
   return b;
}


gcc-11 output:
Dump of assembler code for function main:
   0x0000000000001040 <+0>:     endbr64 
   0x0000000000001044 <+4>:     lea    0x2d75(%rip),%rdi        # 0x3dc0
<_ZN12_GLOBAL__N_1L1bE>
   0x000000000000104b <+11>:    jmp    0x1150
<_ZNK12_GLOBAL__N_13bar7getInt1Ev>


clang-12 output:
Dump of assembler code for function main:
   0x0000000000401110 <+0>:     mov    $0x1,%eax
   0x0000000000401115 <+5>:     ret

[Bug ipa/104597] LTO does not inline indirect call

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |lto, missed-optimization
           Severity|normal                      |enhancement
                 CC|                            |marxin at gcc dot gnu.org
          Component|c++                         |ipa

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I suspect this is just the standard issue where we don't inline again after
some optimizations. There is another bug like that before.

clang does though.

[Bug ipa/104597] LTO does not inline indirect call

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2022-02-21
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW
                 CC|                            |hubicka at gcc dot gnu.org,
                   |                            |jamborm at gcc dot gnu.org

--- Comment #4 from Richard Biener <rguenth at gcc dot gnu.org> ---
Maybe with return functions we could have a local "jump function" from the
return to the indirect call and then (speculatively) devirtualize it.