Compile time elimination of virtual tables?

Question

Assuming i have this hierarchy :

class Super
{
 public:
    virtual void bar();
};

class Sub : public Super
{
 public:
    virtual void bar() override;
};

is there a way for me to avoid vtables despite using the virtual key word? (curiosity) i have read something about a compiler optimization that eliminates vtables when the object is known during compile time, I'm not really sure, been digging around google for a while, but could't find any answers, so does it mean these?

Sub sb;
sb.bar(); //avoids vtable?
Super& sr = sb;
sr.bar(); //avoids vtable?
Super* srp = &sb;
srp->bar(); //avoids vtable? 

Answer 1

One of the gcc developers has a whole series of blog posts about devirtualization. I think he is also active on SO, so there may be a chance that he responses.

However, devirtualization deals mostly with eliminating virtual dispatch by analyzing the program flow and possible types. I don't think it removes the virtual table in general, but there is an example in the second article where a virtual gets inlined and can then be evaluated completely at compile time through constant propagation. In that case, the compiler/linker transformed the program to not use the class at all, and thus it should not contain any object or vtable.

Answer 2

Sub sb;
sb.bar(); //avoids vtable?

The above will never need to use a vtable for dispatch, as the runtime type is known (i.e. it's known to be the same as the compile-time/static type, namely Sub).

Super& sr = sb;
sr.bar(); //avoids vtable?


Super* srp = &sb;
srp->bar(); //avoids vtable? 

In these cases, if the pointer/reference and usage appear in the same function, the optimiser may well be smart enough to avoid dispatch via a vtable. If the pointer or reference is passed to some other out-of-line function that migth be called with other types of pointers, then vtable-based dispatch will normally be needed.

More generally, the C++ Standard doesn't make any stipulations about how runtime polymorphism is implemented, so there is no guaranteed, portable way to eliminate "vtables".

That said, your best bets to minimise use of the vtable for dispatch are:

• to mark overrides final when the freedom to override further is not actually required, and

• to keep the implementation inline (even if implicitly - by having the function implementation in the class definition)

To see if either/both help, you'll have to experiment with or read the docs for your own compiler / tool-chain, optimisation flags etc..

An unused vtable may or may not be removed by the linker: you may want to experiment with cross-object linker optimisation flags if you have multiple translation units.