vtable_disassm.cpp

class Vec
{
  public:
    virtual ~Vec()
    {
        std::cout << "Call ~Vec" << std::endl;
    }
};

class VecL : public Vec
{
  public:
    explicit VecL(int x) : _x{x} {}

    ~VecL()
    {
        std::cout << "Call ~VecL" << std::endl;
    }

  private:
    int _x;
};

class VecR : public VecL
{
  public:
    VecR(int x, int y) : VecL{x}, _y{y} {}

    ~VecR()
    {
        std::cout << "Call ~VecR" << std::endl;
    }

  private:
    int _y;
};

int main()
{
    Vec *vec{new VecR{10, 20}};
    delete vec;
}

/*
typeinfo name for Vec:
        .asciz  "3Vec"

typeinfo for Vec:
        .quad   vtable for __cxxabiv1::__class_type_info+16
        .quad   typeinfo name for Vec

vtable for Vec:
        .quad   0
        .quad   typeinfo for Vec
        .quad   Vec::~Vec() [base object destructor]
        .quad   Vec::~Vec() [deleting destructor]

Vec::Vec() [base object constructor]:                            # @Vec::Vec() [base object constructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        movabs  rax, offset vtable for Vec
        add     rax, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        mov     qword ptr [rdi], rax
        pop     rbp
        ret

Vec::~Vec() [base object destructor]:                            # @Vec::~Vec() [base object destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        mov     qword ptr [rbp - 8], rdi
        pop     rbp
        ret

Vec::~Vec() [deleting destructor]:                            # @Vec::~Vec() [deleting destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        mov     qword ptr [rbp - 16], rdi # 8-byte Spill
        call    Vec::~Vec() [base object destructor]
        mov     rdi, qword ptr [rbp - 16] # 8-byte Reload
        call    operator delete(void*)
        add     rsp, 16
        pop     rbp
        ret

******************************************************************************

typeinfo name for VecL:
        .asciz  "4VecL"

typeinfo for VecL:
        .quad   vtable for __cxxabiv1::__si_class_type_info+16
        .quad   typeinfo name for VecL
        .quad   typeinfo for Vec

vtable for VecL:
        .quad   0
        .quad   typeinfo for VecL
        .quad   VecL::~VecL() [base object destructor]
        .quad   VecL::~VecL() [deleting destructor]

VecL::VecL(int):                           # @VecL::VecL(int)
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     qword ptr [rbp - 8], rdi
        mov     dword ptr [rbp - 12], esi
        mov     rdi, qword ptr [rbp - 8]
        mov     rax, rdi
        mov     qword ptr [rbp - 24], rdi # 8-byte Spill
        mov     rdi, rax
        call    Vec::Vec() [base object constructor]
        movabs  rax, offset vtable for VecL
        add     rax, 16
        mov     rdi, qword ptr [rbp - 24] # 8-byte Reload
        mov     qword ptr [rdi], rax
        mov     esi, dword ptr [rbp - 12]
        mov     dword ptr [rdi + 8], esi
        add     rsp, 32
        pop     rbp
        ret

VecL::~VecL() [base object destructor]:                           # @VecL::~VecL() [base object destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        call    Vec::~Vec() [base object destructor]
        add     rsp, 16
        pop     rbp
        ret
                                        # -- End function
VecL::~VecL() [deleting destructor]:                           # @VecL::~VecL() [deleting destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        mov     qword ptr [rbp - 16], rdi # 8-byte Spill
        call    VecL::~VecL() [base object destructor]
        mov     rdi, qword ptr [rbp - 16] # 8-byte Reload
        call    operator delete(void*)
        add     rsp, 16
        pop     rbp
        ret

******************************************************************************

typeinfo name for VecR:
        .asciz  "4VecR"

typeinfo for VecR:
        .quad   vtable for __cxxabiv1::__si_class_type_info+16
        .quad   typeinfo name for VecR
        .quad   typeinfo for VecL

vtable for VecR:
        .quad   0
        .quad   typeinfo for VecR
        .quad   VecR::~VecR() [base object destructor]
        .quad   VecR::~VecR() [deleting destructor]

VecR::VecR(int, int):                          # @VecR::VecR(int, int)
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     qword ptr [rbp - 8], rdi
        mov     dword ptr [rbp - 12], esi
        mov     dword ptr [rbp - 16], edx
        mov     rdi, qword ptr [rbp - 8]
        mov     rax, rdi
        mov     esi, dword ptr [rbp - 12]
        mov     qword ptr [rbp - 24], rdi # 8-byte Spill
        mov     rdi, rax
        call    VecL::VecL(int)
        movabs  rax, offset vtable for VecR
        add     rax, 16
        mov     rdi, qword ptr [rbp - 24] # 8-byte Reload
        mov     qword ptr [rdi], rax
        mov     edx, dword ptr [rbp - 16]
        mov     dword ptr [rdi + 12], edx
        add     rsp, 32
        pop     rbp
        ret
                                        # -- End function
VecR::~VecR() [base object destructor]:                           # @VecR::~VecR() [base object destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        call    VecL::~VecL() [base object destructor]
        add     rsp, 16
        pop     rbp
        ret

VecR::~VecR() [deleting destructor]:                           # @VecR::~VecR() [deleting destructor]
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        mov     qword ptr [rbp - 16], rdi # 8-byte Spill
        call    VecR::~VecR() [base object destructor]
        mov     rdi, qword ptr [rbp - 16] # 8-byte Reload
        call    operator delete(void*)
        add     rsp, 16
        pop     rbp
        ret
 */

/*
main:                                   # @main
# %bb.0:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 64
        mov     dword ptr [rbp - 4], 0
        mov     edi, 16
        call    operator new(unsigned long)
        mov     rdi, rax
        mov     rcx, rax
        mov     esi, 10
        mov     edx, 20
        mov     qword ptr [rbp - 40], rdi # 8-byte Spill # this
        mov     rdi, rax
        mov     qword ptr [rbp - 48], rcx # 8-byte Spill # this
        call    VecR::VecR(int, int)
        jmp     .LBB1_1
.LBB1_1:
        mov     rax, qword ptr [rbp - 48] # 8-byte Reload
        mov     qword ptr [rbp - 16], rax
        mov     rax, qword ptr [rbp - 16]
        cmp     rax, 0
        mov     qword ptr [rbp - 56], rax # 8-byte Spill # this
        je      .LBB1_3
# %bb.2:
        mov     rax, qword ptr [rbp - 56] # 8-byte Reload
        mov     rcx, qword ptr [rax]
        mov     rdi, rax
        call    qword ptr [rcx + 8]
.LBB1_3:
        mov     eax, dword ptr [rbp - 4]
        add     rsp, 64
        pop     rbp
        ret
        mov     ecx, edx
        mov     qword ptr [rbp - 24], rax
        mov     dword ptr [rbp - 28], ecx
        mov     rdi, qword ptr [rbp - 40] # 8-byte Reload
        call    operator delete(void*)
# %bb.5:
        mov     rdi, qword ptr [rbp - 24]
        call    _Unwind_Resume
 */