DoVTableInfo.hpp

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder


#ifndef VTABLEINFO_HPP
#define VTABLEINFO_HPP

/*
    Note: This file is not part of the 'core' features of DynObj, but rather more 
    experimental. DynObj does not reqire any changes to VTables for normal operation.
*/

/*
    This code is inspired and partly built on the work with FastDelegates by Don Clugston.
    The problem soved here is similar, but opposite in a way. From a bound member function
    pointer he retrieved the address of a function to call (and the adjusted 'this' pointer).
    We don't care about those, but want to find the index of a virtual function in the VTable.
    
    For most compilers, the information is there, in a field in the member function pointer.
    However, for Intel and MSVC compilers, they don't use the offset into the VTable when
    calling it, but rather a fix address to a stub function that has the offset hard coded
    into it (not efficient nor pretty IMHO). We make a special case for that and obtain 
    the function address using some inline assembly. 
    
    Also, DMC (Digital Mars) solves the whole problem with member function pointers using 
    stub callers to a function for the various cases. For DMC, we look for the address
    contained in the function pointer in the VTable.
    
    NOTE: It is quite possible for the compiler to point to stubs that are not in the VTable,
    but rather refer the VTable themselves. The assembly code to extract the function 
    address of a virtual function (VTblSizer::AVfunc) is currently in MSVC syntax but 
    should be straight forward to move to another syntax.
    
    NOTE: The C++ standard ABI has settled on using the GNU solution below, where the 
    index is directly available, so most newer compilers will do that.
    
    Single stepping through assembly code calling member function pointers and looking
    at where the VTable entries are used will help in cases not covered below.
*/

#include <string.h>
#include <pi/compiler.h>

#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
    // For Microsoft & Intel compilers, it is not possible to get VTable
    // index from member function pointer. Get the address of the function
    // by calling it instead, using inline assembly to extract function 
    // address.
    #define GET_ADDR_VIA_CALL
#endif

// This says how many entries to copy from before the VTable start
// It is somewhat arbitrary now.
#define VTP_N_ENTRIES_BEFORE 4

// Avoid calcualtions to get Vtable index in most (all known) cases 
#define VT_VINDEX_IDENTITY_FUNC 1


// Declared in vt_test.cpp
extern void *g_do_TFA;  // Function address (taken from inside function)
extern void *g_do_RA1;  // Return address (inside virtual function) 


// When looking for a function index in a VTable, how long do we go?
#define MAX_VTABLE_SEARCH 256

// Convert index to index inside VTable (usually the same)
int VTableIndex(int ix);

// A class to measure VTable size of Base 

void *VTGetReturnAddress();

// This gives us ability to construct base with one ctor arg
template<class Base,class ARG>
struct VTblSizerBase : public Base {
    VTblSizerBase() : Base( (ARG)0 ) { }
};

// No arg case
template<class Base>
struct VTblSizerBase<Base,void> : public Base {
    VTblSizerBase() : Base() { }
};

template<class Base,class ARG>
struct VTblSizer : public VTblSizerBase<Base,ARG> {
    virtual int  AVFunc( ){
        // We want two things (one is usually enough):
        // - A return address inside this function (call recursively once)
        // - The plain non-virtual address of this function 
        
        // Get a address inside this function 
        g_do_RA1 = VTGetReturnAddress();
        
        //static bool st_inside;
        static int st_counter;
        
        /*if( !st_inside ) {
            // No need for recursive call now
            st_inside = true;
            AVFunc();
            st_inside = false;
        }
        else*/ {
#ifdef MSVC_INLINE_ASM        
            // There are two different symbols: AVFunc and VTblSizer<SomeClass>
            // AVfunc jumps here [VTblSizer<SomeClass>] and AVfunc is the one
            // we find in the VTable. The templating may add some complexity 
            // to function calling, but we're lucky here.
            __asm{
                //mov eax, VTblSizer_VFunc
                mov eax, AVFunc
                mov g_do_TFA, eax
            }
#elif defined(GNU_INLINE_ASM) 
            // How to get the symbol with GCC inline asm?
#else
            // #error No method to find return address
#endif
        }
        
        return ++st_counter;
    }   
};


template <class C>
int GetVIndex( int (C::*mfn)(), void **vtbl ){
    // These are convenient to have later
    void **ppvfn = reinterpret_cast<void**>(&mfn);
    void *pvfn = ppvfn ? *ppvfn : NULL;
    
    // Size of member function pointer, what we have to look through 
    int mfn_size = sizeof(mfn);
    
#if defined(__GNUC__) || defined(__VISAGECPP__) || defined(__xlc__) || defined(__xlC__) 
    // G++ case
    if( mfn_size==sizeof(void*)+sizeof(int) ){
        int i = *(int*)&mfn;
        //return (i>0 && i&1) ? (i+1)/2 : -1;
        // G++ stores the actual offset+1 into the VTable, so we get:
        // entry 0: 1
        // entry 1: 5
        // entry 2: 9 ,...etc
        return (i>0 && i&1) ? i/4 : -1;
    }
    
#elif defined(__BORLANDC__) || defined(__TURBOC__) || defined(__WATCOMC__) 
    if( mfn_size==sizeof(void*)+2*sizeof(int) ){
        // Integer at offset 2 is vindex+1
        int *pi = (int*)(((char*)ppvfn)+sizeof(void*)+sizeof(int));
        return (*pi)-1;
    }
    
#elif defined(__MWERKS__)
    if( mfn_size==sizeof(void*)+2*sizeof(int) ){
        // Integer at offset 1 is vindex
        int *pi = (int*)(((char*)ppvfn)+sizeof(int));
        return *pi;
    }
    
#elif defined (__sgi) || defined (__EDG__) || defined(__COMO__)
    // MrCpp, MIPS Pro, Pro64, Open64 should go here also  // Edison Grouop, Comeau
    if( mfn_size==2*sizeof(short)+sizeof(void*) ){
        // Short at offset 1 is vindex
        int *ps = (short*)(((char*)ppvfn)+sizeof(short));
        return (int)*ps;
    }
    
#elif defined (_MSC_VER) || defined(__INTEL_COMPILER)
    // These apparently behaves similar. We have called the function now and can read
    // the globals it has written to.
#endif

    // The alternative that is left (and rather good) is to search the VTable
    // for an address and when found, return the index. We have up to 3 addresses
    // to look for.
    void *pvs[3];
    pvs[0] = NULL;
    pvs[1] = g_do_TFA;
    pvs[2] = g_do_RA1;
    // If member function pointer is same size as void*, then look directly
    // in supplied VTable for this value
    if( mfn_size==sizeof(void*) ){
        if( vtbl && ppvfn )
            pvs[0] = pvfn;
    }   

    // Iterate
    for( int ix=0; ix<MAX_VTABLE_SEARCH; ix++ ){
        if( !vtbl[ix] ) continue; 
        void *pv = vtbl[ix];
        if( pv==pvs[0] || pv==pvs[1] || pv==pvs[2] || 
            // Found return address is within the first 32 bytes of VTable entry point
            ((char*)pvs[2]>(char*)pv && (char*)pvs[2]<((char*)pv)+0x20) ) // The 'in between' case (inside function body) 
            return ix;
    }

    // Exhausted possibilities for now  
    return -1;
}


template<class C,class ARG>
int GetVTableSizeOf( ){
    VTblSizer<C,ARG> vtbs;              // Object derived from side base
    int (VTblSizer<C,ARG>::*mfn)() = &VTblSizer<C,ARG>::AVFunc;
    
    // Call the virtual function (not always needed, but cheap)
    g_do_TFA = g_do_RA1 = NULL;
    static int st_last_result;  // Force the return value to be valid
    int result = vtbs.AVFunc();
    if( result==st_last_result ) return -1;
    st_last_result = result;
    
    int ix = GetVIndex( mfn, *(void***)&vtbs );
    return ix>=0 ? ix : -1;
}


// 
// Extract VTable index for a member function pointer 
//
// The algorithm works by replacing the given VTable with one that 
// has only two different types of entries: GetNoMatch and GetMatch
// above. We fill the VTable with GetNoMatch, then move one item with
// GetMatch until we find the right index. This all happens using 
// ordinary C++ syntax for calling a pointer to member function. 
// 
// It maybe works even with MSoft thiscall calling convention, (where 
// the called function clears the stack), since we don't use any args. 
// But that remains to be tested. The alternative is to make a second 
// function that just operates on thiscall functions.

#define VT_MATCH    0x2468ACE0
#define VT_NO_MATCH 0x13579BDF

#define VT_NOT_VIRTUAL -1 
#define VT_NOT_FOUND   -2 
#define VT_NO_VTABLE_FOUND   -3
#define VT_ERROR       -4

int GetNoMatch();
int GetMatch();

// Helper to release memory at shutdown
struct VTMemHolder { 
    VTMemHolder() : m_pc(0) { }
    ~VTMemHolder() { delete [] m_pc; }
    bool Alloc( int size ) { 
        delete [] m_pc;
        m_pc = new char[size];
        return m_pc!=0;
    }
    void *Get(){ return m_pc; }
    char *m_pc;
};


template <class C> 
int GetVIndexOf( int (C::*pmf)() ) {
    static int vtbl_size = -2;
    if( vtbl_size==-2 )
        vtbl_size = GetVTableSizeOf<C,void>();
    if( vtbl_size<0 ) return VT_NO_VTABLE_FOUND;
    
    // Alloc and build a fake VTable 
    static void **vtbl;
    if( !vtbl ){
        static VTMemHolder st_mh;
        int sz = VTableIndex(vtbl_size+1);
        if( !st_mh.Alloc(sz*sizeof(void*)) )
            return VT_ERROR;
        vtbl = (void**)st_mh.Get();
        for( int ix=sz-1; ix>=0; ix-- ) 
            vtbl[ix] = (void*)&GetNoMatch;
    }
    
    // Declare fake object and try until the matching index is found 
    C* pc = (C*)&vtbl;
    int ix = 0;
    while( ix<vtbl_size ) {
        vtbl[VTableIndex(ix)] = (void*)GetMatch; 
        int r = (pc->*pmf)();
        vtbl[VTableIndex(ix)] = (void*)GetNoMatch; 
        if( r==VT_MATCH ) {
            return ix;
        }
        else if( r!=VT_NO_MATCH ) {
            return VT_NOT_VIRTUAL;
        }
        ix++;
    }
    
    return VT_NOT_FOUND;
}

// This will extract out the actual target address of a member function pointer.
// If a virtual function, the VTable of the class is used, otherwise, the 
// address is extracted from the member function pointer (according to 
// compiler).  
// 
template<class C>
void *GetMFuncAddr( int (C::*pmf)(), C *pc=NULL ){
    // First see if it's a virtual function 
    int vix = GetVIndexOf(pmf);
    if( vix>=0 ){
        bool did_create = false;
        if( !pc ) {
            pc = new C;
            did_create = true;
        }
        // We have the index, so just look up
        void *pv = (*(void***)pc)[VTableIndex(vix)];
        if( did_create ) delete pc;
        return pv;
    }
    else {
        // Non virtual case (plain function)
        // We have to get address from function pointer object
        // Do it per compiler (info from http://www.codeproject.com/KB/cpp/FastDelegate.aspx)
        
        int *pi = (int*)&pmf;
        void **ppv = (void**)&pmf;
        #if defined(__GNUC__) || defined(__VISAGECPP__) || defined(__xlc__) || defined(__xlC__) 
        // for GNU compatible compilers, code ptr is first member of the member function 
        // pointer, provided its LSB is 0. 
        if( !(pi[0]&1) )
            return ppv[0];
        else
            // Error! (should not be pointer to virtual function)
            return NULL;
        
        #elif defined(__BORLANDC__) || defined(__TURBOC__) || defined(__WATCOMC__) 
        // As far as I understand this should be OK (code ptr first)
        return *ppv;
        
        #elif defined(__MWERKS__)
        // Two integers, then the code pointer
        ppv = (void**)(pi+2);
        return *ppv;
        
        #elif defined (__sgi) || defined (__EDG__) || defined(__COMO__)
        // Two shorts, then the code pointer
        short *ps = (short*)pv;
        ppv = (void**)(ps+2);
        return *ppv;
        
        #elif defined (__DMC__) || defined(__SC__)
        // Digital mars / Symantec - Only one code ptr
        return *ppv;
        
        #elif defined(_MSC_VER)
        // Visual C++ - Code pointer first 
        return *ppv;

        #else
            #error GetMFuncAddr - Compiler not recognized! 
        #endif 
        
        return NULL;
    }
}


// Structure used for keeping original, derived and replacement VTables
//
#define VTP_N_ENTRIES_BEFORE 4
struct DynObjType;

class VTableInfo {
public:
    VTableInfo( void** td, void **to, int sz) : vtbl_d(td), vtbl_o(to), vtbl_r(NULL), size(sz), pdt(NULL) { } 
    ~VTableInfo(){ delete [] (vtbl_r-VTP_N_ENTRIES_BEFORE); }
    bool AllocSoftVTbl(){
        void **vtbl_a = new void*[size+VTP_N_ENTRIES_BEFORE];
        if( !vtbl_a ) return false;
        vtbl_r = vtbl_a+VTP_N_ENTRIES_BEFORE;
        // Copy entries
        memcpy( vtbl_a, vtbl_d-VTP_N_ENTRIES_BEFORE, sizeof(void*)*(size+VTP_N_ENTRIES_BEFORE) );
        return true;
    }
    
    void **vtbl_d;   // Derived VTable
    void **vtbl_o;   // Original VTable
    void **vtbl_r;   // Ram VTable 
    int  size;       // Number of entries in dervied VTable
    DynObjType *pdt;
    //bool operator == (void** vtbl){ return vtbl_d==vtbl || vtbl_o==vtbl || vtbl_r==vtbl; } 
    bool operator == (void** vtbl){ return vtbl_d==vtbl || vtbl_r==vtbl; } 
};

#endif // VTABLEINFO_HPP

---