Virtual Inheritance Performance Impact

[chsalvia]

Is virtual inheritance ambiguity resolution ever performed statically,
i.e. at compiler time? Or is it always resolved at runtime?

In other words, if you use virtual inheritance, but don't use
polymorphism (pointers to derived classes), is there any overhead?
Take the following example:

class Base {
public:
int x;
void func1() { x = 2; }
};

class A : public virtual Base {
public:
int y;
};

class B : public virtual Base {
public:
int z;
};

class Derived : public A, public B {
public:
};

int main() {
Derived d;
d.func1(); // does this function call entail additional
overhead?
}

 

[Markus Schoder]

class Base {
public:
int x;
void func1() { x = 2; }
};

class A : public virtual Base {
public:
int y;
};

class B : public virtual Base {
public:
int z;
};

class Derived : public A, public B {
public:
};

int main() {
Derived d;
d.func1(); // does this function call entail additional
overhead?
}

Here is the generated assembler code of g++-4.2:

main:
pushq %rbp
movq %rsp, %rbp
subq $32, %rsp
leaq -32(%rbp), %rdi
call _ZN7DerivedC1Ev # This call only with virtual inheritance
leaq -32(%rbp), %rax
leaq 28(%rax), %rdi
call _ZN4Base5func1Ev # call member function
movl $0, %eax
leave
ret

So there is additional overhead.

On the other hand with optimization enabled the result is:

main:
xorl %eax, %eax
ret

Probably it is possible to create an example that cannot optimize away
the additional overhead.