For a polymorphic type T, how to obtain the pointer to the virtual table of T without an instance of type T

Question

I have an inheritance hierarchy with single inheritance and I want to check if the object pointed to by a pointer to base is exactly of derived type T.

I have written two ways and compared the assembly code:

template <typename T>
void const * vtable_ptr(T const & t)
{
    return reinterpret_cast<void const * const &>(t);
}

template <typename T>
void const * vtable_ptr()
{
    T t;
    return vtable_ptr(t);
}

struct Base
{
    virtual ~Base() = default;
};

struct Derived : Base
{

};

bool test(Base const * p)
{
    return vtable_ptr(*p) == vtable_ptr<Derived>();
}

bool test2(Base const * p)
{
    return typeid(*p) == typeid(Derived);
}

If we compare the assembly code of test and test2, we can see the following:

Clang 9.0.0 at -O3

test(Base const*):                         # @test(Base const*)
        mov     eax, offset vtable for Derived+16
        cmp     qword ptr [rdi], rax
        sete    al
        ret
test2(Base const*):                        # @test2(Base const*)
        push    rax
        test    rdi, rdi
        je      .LBB1_7
        mov     rax, qword ptr [rdi]
        mov     rax, qword ptr [rax - 8]
        mov     rdi, qword ptr [rax + 8]
        mov     eax, offset typeinfo name for Derived
        cmp     rdi, rax
        je      .LBB1_2
        cmp     byte ptr [rdi], 42
        jne     .LBB1_5
        xor     eax, eax
        pop     rcx
        ret
.LBB1_2:
        mov     al, 1
        pop     rcx
        ret
.LBB1_5:
        mov     esi, offset typeinfo name for Derived
        call    strcmp
        test    eax, eax
        sete    al
        pop     rcx
        ret
.LBB1_7:
        call    __cxa_bad_typeid

MSVC 19.22 at /O2 is even worse, since it is not even able to inline the call to typeid comparison.

bool test(Base const *) PROC                            ; test, COMDAT
        lea     rax, OFFSET FLAT:const Derived::`vftable'
        cmp     QWORD PTR [rcx], rax
        sete    al
        ret     0
bool test(Base const *) ENDP                            ; test

p$ = 48
bool test2(Base const *) PROC                     ; test2, COMDAT
$LN7:
        sub     rsp, 40                             ; 00000028H
        call    __RTtypeid
        lea     rdx, OFFSET FLAT:Derived `RTTI Type Descriptor'+8
        lea     rcx, QWORD PTR [rax+8]
        call    __std_type_info_compare
        test    eax, eax
        sete    al
        add     rsp, 40                             ; 00000028H
        ret     0

The problem seems to be that typeid is forced, by design, to do things that I don't need to do in my specific context, such as null pointer test (and error handling through exceptions) or actually having a type info structure in memory and loading that to compare.

However vtable_ptr does not work if T is not default constructible, may not be that fast if the optimizer is not able to compile the instantiation of T away, and will behave in surprising ways if the constructor or destructor of T have side effects.

The question is, is there any way of implementing template <typename T> void const * vtable_ptr() that does not require instantiating a T? This information is obviously known by the compiler. You just need to look at the assembly it is generating (mov eax, offset vtable for Derived+16). The thing is, do I have access to this information as a programmer?

Answer 1

typeid operator does what you want, if you think you can do this better than compiler does it, then you should make your own compiler as "improving" on existing ones will not get you any guarantees of correctness

Also i think you need to use std::type_index for comparing typeid