virtual function overhead when deterministic (c++)

Question

I know that virtual functions are essentially function pointers contained on a vtable, which makes polymorphic calls slower because of indirection etc. But I'm wondering about compiler optimisation when call is deterministic. By deterministic, I mean the following cases:

1. The object is a value and not a reference, so there is no polymorphism possible:

struct Foo
{
    virtual void DoSomething(){....}
};

int main()
{
    Foo myfoo;
    myfoo.DoSemthing();
    return 0;
}

2. The reference is to a childless class:

struct Foo
{
    virtual void DoSomething();
};
struct Bar : public Foo
{
   virtual void DoSomething();
};

int main()
{
    Foo* a = new Foo();
    a->DoSomething(); //Overhead ? a doesn't seem to be able to change nature.

    Foo* b = new Bar();
    b->DoSomething(); //Overhead ? It's a polymorphic call, but b's nature is deterministic.

    Bar* c = new Bar();
    c->DoSomething(); //Overhead ? It is NOT possible to have an other version of the method than Bar::DoSomething
    return 0;
}

Answer 1

In the first case, this will not be a virtual call. The compiler will issue a call straight to Foo::DoSomething().

In the second case, it's more complicated. For one, it's at-best a link time optimization, since for a specific translation unit, the compiler doesn't know who else might inherit from that class. The other problem you get is with shared libraries which might also inherit without your executable knowing anything about it.

In general, though, this a compiler optimization known as virtual function call elimination, or devirtualization, and is somewhat of an active field of research. Some compilers do it to some extent, others don't do it at all.

See, in GCC (g++), -fdevirtualize and -fdevirtualize-speculatively. The names kind of hint at the guaranteed level of quality.