metode til asm

Nogen bestemt grund til at du vil gøre det i asm ?

Umiddelbart vil jeg tro, at du skal finde det name-manglede navn for funktionen og placere en call instruktion i din __asm blok.
http://www.kegel.com/mangle.html

Hmmm hvis du får asm koden spyttet ud på en eller anden måde kan du vel lave et hop til linjen hvor foo starter?

http://msdn2.microsoft.com/en-us/library/bdd5392d.aspx

antyder at det kan være et stort problem

okay, hvis jeg for eksempel har  disse klasser og bytter rundt på vtable ved at gøre således så vil koden i D::foo() blive kørt istedet for C::foo() efter at linien : ((wrap*)c_obj)->vptr = ((wrap*)stub)->vptr; har byttet om på pointeren til vtable.
class Interface {
public:
    virtual void foo() = 0;
};

class C : public Interface {
public:
    C() {}
    virtual ~C() {}
    void foo() {
        cout << "c impl" << endl;
    }
};

class C_Stub : public Interface {
public:
    C_Stub() {}
    virtual ~C_Stub() {}
    void foo() {
        cout << "stub impl" << endl;
    }
};

struct vtable {
};

struct wrap {
    vtable* vptr;
};

void main() {
  C_Stub* stub = new C_Stub();
  C* c_obj = new C();
  ((wrap*)c_obj)->vptr = ((wrap*)stub)->vptr;
}

Problemet er så at hvis jeg opretter en instans som :
void main() {
  C c;
}
Og prøver at gøre det ssamme vil følgende ikke fungerer.. spørgsmålet ligger så i hvad der er til forskel fra at arbejde med en local instans og en instans oprettet med new operatoren.
( I MSVC 7.0, det er ligemeget om det fungerer på andre kompilerer )

sorry i den tildligerer kommentar refererer jeg til D::foo der mente jeg self. C_Stub::foo()

du bruger

C c;
((wrap*)&c)->vptr = ((wrap*)stub)->vptr;

?

sådan her ser den kode jeg kører ud lige nu:

// vtable_hacking.cpp
#include <iostream>
#include <tchar.h>
#include <iostream>
#include <cstdlib>
#include <iostream>
#include <cstdarg>
using namespace std;

void* addressOf( int dummyarg, ... ) {
    void* ret=0;
    va_list args;
    va_start( args, dummyarg );
    ret = va_arg( args, void* );
    va_end(args);
    return ret;
}

class Interface {
public:
    virtual void foo() = 0;
};

class C : public Interface {
public:
    C() {}
    virtual ~C() {}
    void foo() {
        cout << "virker ikke" << endl;
    }
};

class C_Stub : public Interface {
public:
    C_Stub() {}
    virtual ~C_Stub() {}
    void foo() {
        cout << "virker fint." << endl;
    }
};

struct vtable {
};

struct wrap {
    vtable* vptr;
};


void main() {
    C_Stub* stub = new C_Stub();
   
    // virker fint.
    C* c_obj = new C();
    ((wrap*)c_obj)->vptr = ((wrap*)stub)->vptr;
    c_obj->foo();

    // virker ikke.
    C c_obj2;
    ((wrap*)&c_obj2)->vptr = ((wrap*)stub)->vptr;
    c_obj2.foo();

    // virker fint.
    C* c_obj3 = new C();
    ((wrap*)c_obj3)->vptr = ((wrap*)stub)->vptr;
    (*c_obj3).foo();
    system("PAUSE");
}

hvis man studerer den genererede kode vil man se at:

; 55  :    c_obj->foo();

    mov    edx, DWORD PTR _c_obj$[ebp]
    mov    eax, DWORD PTR [edx]
    mov    ecx, DWORD PTR _c_obj$[ebp]
    call    DWORD PTR [eax]

; 60  :    c_obj2.foo();

    lea    ecx, DWORD PTR _c_obj2$[ebp]
    call    ?foo@C@@UAEXXZ                ; C::foo


; 65  :    (*c_obj3).foo();

    mov    ecx, DWORD PTR _c_obj3$[ebp]
    mov    edx, DWORD PTR [ecx]
    mov    ecx, DWORD PTR _c_obj3$[ebp]
    call    DWORD PTR [edx]

når det er et local objekt og ikke en pointer, så slår den slet ikke op i vtable.

Der er der ingen grund til fordi den kender typen og den tror ikke at der kan ændres
i vtable.

tid at få afsluttet her ?

jeps