L4DY_8UG

1. 기본 클래스가 재사용 될 수 있음으로부터, 가상 메소드과 클래스에서 더 적합한

    테이블이 있는 경우에만 가상함수 테이블(_vtable_ 또는 _ vftable_)에 추가한다.

2. 기본 클래스들

3. 클래스 멤버들

class A

    {
      int a1;
    public:
      virtual int A_virt1();
      virtual int A_virt2();
      static void A_static1();
      void A_simple1();
    };

    class B
    {
      int b1;
      int b2;
    public:
      virtual int B_virt1();
      virtual int B_virt2();
    };

    class C: public A, public B
    {
      int c1;
    public:
      virtual int A_virt2();
      virtual int B_virt2();
    };

class A    

    {                                //{vfptr}: 0
      int a1;                        //4
    public:                          //A의 vftable
      virtual int A_virt1();         //0
      virtual int A_virt2();         //4
      static void A_static1();
      void A_simple1();
    };                               //class A의 size : 8

    class B
    {                                //{vfptr}: 0
      int b1;                        //4
      int b2;                        //8
    public:                          //B의 vftable
      virtual int B_virt1();         //0
      virtual int B_virt2();         //4
    };                               //class B의 size : 12

    class C: public A, public B      //기본 클래스 A: {vfptr}: 0, A1: 4,
    {                                // B: {vfptr}: 8, B1: 12, B2: 16,
      int c1;                        // c1: 20  ---> class C의 size : 24
    public:
      virtual int A_virt2();        //A에 대한 C의 vftable: 4
      virtual int B_virt2();        //B에 대한 C의 vftable: 4
    };

call     A::A_static1

    ;pC->A_simple1(1);

    ;esi = pC

    push    1

    mov ecx, esi

    call    A::A_simple1

    ;pC->B_simple1(2,3);

    ;esi = pC

    lea edi, [esi+8] ;adjust this

    push    3

    push    2

    mov ecx, edi

   call    B::B_simple1

    ;pC->A_virt2()

    ;esi = pC

    mov eax, [esi]  ;가상 테이블 포인터를 가져옴

    mov ecx, esi

    call [eax+4]  ;두번째 가상 메소드를 호출

    ;pC->B_virt1()

    ;edi = pC

    lea edi, [esi+8] ;이 포인터를 조절

    mov eax, [edi]   ;가상 테이블 포인터를 가져옴

    mov ecx, edi

    call [eax]       ;첫번째 가상 메소드를 호출

struct RTTICompleteObjectLocator
{
    DWORD signature; //항상 0
    DWORD offset;    //완전한 클래스에서 vtable의 오프셋
    DWORD cdOffset;  //생성자 변위 오프셋
    struct TypeDescriptor* pTypeDescriptor; //전체 클래스의 TypeDescriptor
    struct RTTIClassHierarchyDescriptor* pClassDescriptor; //상속 계층 구조를 설명
};

struct PMD

{
    int mdisp;  //member 변위
    int pdisp;  //vbtable 변위
    int vdisp;  //vbtable 내부의 변위
};

//char* pThis; struct PMD pmd;
    pThis+=pmd.mdisp;
    if (pmd.pdisp!=-1)
    {
      char *vbtable = pThis+pmd.pdisp;
      pThis += *(int*)(vbtable+pmd.vdisp);
    }

    _init_gA1:
        mov     ecx, offset _gA1
        call    A::A()
        push    offset _term_gA1
        call    _atexit
        pop     ecx
        retn
    _term_gA1:
        mov     ecx, offset _gA1
        call    A::~A()
        retn

    unwind_1tobase:  ; state 1 -> -1
        lea     ecx, [ebp+a1]
        jmp     A::~A()

    lea     ecx, [ebp+a1]
    call    A::A()
    mov     [ebp+__$EHRec$.state], 1

    unwind_0tobase: ; state 0 -> -1
        mov     eax, [ebp+pA1]
        push    eax
        call    operator delete(void *)
        pop     ecx
        retn

    ;A* pA1 = new A();
        push    

        call    operator new(uint)
        add     esp, 4
        mov     [ebp+pA1], eax
        test    eax, eax
        mov     [ebp+__$EHRec$.state], 0; state 0: 메모리는 할당됬지만 개체가

                                                   아직 구축되지 않음
        jz      short @@new_failed
        mov     ecx, eax
        call    A::A()
        mov     esi, eax
        jmp     short @@constructed_ok
    @@new_failed:
        xor     esi, esi
    @@constructed_ok:
        mov     [esp+14h+__$EHRec$.state], -1
     ;state -1: 객체가 메모리 할당 성공or 실패
     ;두 경우모두 추가 메모리관리는 사용자에 의해 이루어짐.

    unwind_2to1:
        mov     ecx, [ebp+_this] ; state 2 -> 1
        add     ecx, 4Ch
        jmp     B1::~B1

    A* pA = new A[n];
    
    delete [] pA;

    array = new char(sizeof(A)*n+sizeof(int))
    if (array)
    {
      *(int*)array=n; //저장소 배열 크기
      'eh vector constructor iterator'(array+sizeof(int),sizeof(A),count,&A::A,&A::~A);
    }
    pA = array;
    
    'eh vector destructor iterator'(pA,sizeof(A),count,&A::~A);

    ;pA->'vector deleting destructor'(3);
    mov ecx, pA
    push 3 ; flags: 0x2=deleting an array, 0x1=free the memory
    call A::'vector deleting destructor'

    mov ecx, pA
    push 3
    mov eax, [ecx] ;vtable 포인터 가져옴
    call [eax]     ;deleting destructor 호출

    virtual void * A::'scalar deleting destructor'(uint flags)
    {
      this->~A();
      if (flags&1) A::operator delete(this);
    };

    virtual void * A::'vector deleting destructor'(uint flags)
    {
      if (flags&2) //destructing a vector
      {
        array = ((int*)this)-1; //배열의 크기는 이 포인터 전에, 저장된다.
        count = array[0];
        'eh vector destructor iterator'(this,sizeof(A),count,A::~A);
        if (flags&1) A::operator delete(array);
      }
      else {
        this->~A();
        if (flags&1) A::operator delete(this);
      }
    };