GCC and devirtualization inlining

Question

Why, in the following code, compiler, knowing exact type, can't inline virtual function?

using namespace std;

struct Base{
    void fire(){
        show();
    }

    virtual void show() =0;/*{
        cout << "base";
    }*/
};

struct A : Base{
    inline __attribute__((__always_inline__)) void show() {
        cout << "a";
    }
};

int main() {
    A a;
  for (int i=0;i<1000;i++){
    a.fire();
  }
    //a.fire();

    return 0;
}

Can I do something about this, without CRTP?

Possible duplicate of [Are inline virtual functions really a non-sense?](http://stackoverflow.com/questions/733737/are-inline-virtual-functions-really-a-non-sense) — πάντα ῥεῖ, Sep 25 '15 at 19:36
@πάνταῥεῖ At first, That is 6 years old answer. At second, all conditions for devirtualization/inling are met. — tower120, Sep 25 '15 at 19:49
That's why I _"proposed "_ it, instead of hammering your question out. — πάντα ῥεῖ, Sep 25 '15 at 19:57
Perhaps I misunderstand something, but where's a non-inlined call to `show` in your example? — n. m. could be an AI, Sep 25 '15 at 21:01

score 4 · Accepted Answer · answered Sep 25 '15 at 21:02

I'm not good at reading assembler code, but the way I see your example, when in main:

1000 is loaded into a register
1 is substracted,
the address of "a" is loaded and
the output operator is called before the
jump back to the beginning of the loop.

I don't see a call to fire or show. It keeps the implementation for show, but it is not used. That is correct because it has external linkage.

If you put everything in an anonymous namespace, the implementation can be omitted.

Could you put your reasoning with the assembler code in your question? For reference, here is the generated assembler code from the provides link:

.LC0:
    .string "a"
A::show():
    movl    $1, %edx
    movl    $.LC0, %esi
    movl    std::cout, %edi
    jmp std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
main:
    pushq   %rbx
    movl    $1000, %ebx
.L3:
    movl    $1, %edx
    movl    $.LC0, %esi
    movl    std::cout, %edi
    call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
    subl    $1, %ebx
    jne .L3
    xorl    %eax, %eax
    popq    %rbx
    ret
    subq    $8, %rsp
    movl    std::__ioinit, %edi
    call    std::ios_base::Init::Init()
    movl    $__dso_handle, %edx
    movl    std::__ioinit, %esi
    movl    std::ios_base::Init::~Init(), %edi
    addq    $8, %rsp
    jmp __cxa_atexit

You're right it's inlined indeed. There is just excess code with A::show() which is never called. Here is how it should be https://goo.gl/hZ3qE3 — tower120, Sep 27 '15 at 22:28
@tower120 I think the compiler is right because the function has external linkage. It could be called from another compilation unit. You can put it in an anonymous namespace, or - I have not tested it - use whole-program optimization switch for gcc. — Jens, Sep 28 '15 at 05:08

GCC and devirtualization inlining

1 Answers1