Use FreeBSD/i386 files for NetBSD/i386.

6 files changed, 555 insertions, 332 deletions

diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/call.s b/bridges/source/cpp_uno/gcc3_netbsd_intel/call.s
new file mode 100644
index 000000000000..f345e3a764ac
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/call.s
@@ -0,0 +1,268 @@
+    .text
+
+.globl privateSnippetExecutorGeneral
+    .type   privateSnippetExecutorGeneral,@function
+privateSnippetExecutorGeneral:
+.LFBg:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFIg0:
+    movl    %esp,%ebp
+.LCFIg1:
+    subl    $0x4,%esp         # 32bit returnValue
+    pushl   %esp              # 32bit &returnValue
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    movl    16(%esp),%eax     # 32bit returnValue
+    leave
+    ret
+.LFEg:
+    .size   privateSnippetExecutorGeneral,.-privateSnippetExecutorGeneral
+
+.globl privateSnippetExecutorVoid
+    .type   privateSnippetExecutorVoid,@function
+privateSnippetExecutorVoid:
+.LFBv:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFIv0:
+    movl    %esp,%ebp
+.LCFIv1:
+    pushl   $0                # 32bit null pointer (returnValue not used)
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    leave
+    ret
+.LFEv:
+    .size   privateSnippetExecutorVoid,.-privateSnippetExecutorVoid
+
+.globl privateSnippetExecutorHyper
+    .type   privateSnippetExecutorHyper,@function
+privateSnippetExecutorHyper:
+.LFBh:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFIh0:
+    movl    %esp,%ebp
+.LCFIh1:
+    subl    $0x8,%esp         # 64bit returnValue
+    pushl   %esp              # 32bit &returnValue
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    movl    16(%esp),%eax     # 64bit returnValue, lower half
+    movl    20(%esp),%edx     # 64bit returnValue, upper half
+    leave
+    ret
+.LFEh:
+    .size   privateSnippetExecutorHyper,.-privateSnippetExecutorHyper
+
+.globl privateSnippetExecutorFloat
+    .type   privateSnippetExecutorFloat,@function
+privateSnippetExecutorFloat:
+.LFBf:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFIf0:
+    movl    %esp,%ebp
+.LCFIf1:
+    subl    $0x4,%esp         # 32bit returnValue
+    pushl   %esp              # 32bit &returnValue
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    flds    16(%esp)          # 32bit returnValue
+    leave
+    ret
+.LFEf:
+    .size   privateSnippetExecutorFloat,.-privateSnippetExecutorFloat
+
+.globl privateSnippetExecutorDouble
+    .type   privateSnippetExecutorDouble,@function
+privateSnippetExecutorDouble:
+.LFBd:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFId0:
+    movl    %esp,%ebp
+.LCFId1:
+    subl    $0x8,%esp         # 64bit returnValue
+    pushl   %esp              # 32bit &returnValue
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    fldl    16(%esp)          # 64bit returnValue
+    leave
+    ret
+.LFEd:
+    .size   privateSnippetExecutorDouble,.-privateSnippetExecutorDouble
+
+.globl privateSnippetExecutorClass
+    .type   privateSnippetExecutorClass,@function
+privateSnippetExecutorClass:
+.LFBc:
+    movl    %esp,%ecx
+    pushl   %ebp              # proper stack frame needed for exception handling
+.LCFIc0:
+    movl    %esp,%ebp
+.LCFIc1:
+    subl    $0x4,%esp         # 32bit returnValue
+    pushl   %esp              # 32bit &returnValue
+    pushl   %ecx              # 32bit pCallStack
+    pushl   %edx              # 32bit nVtableOffset
+    pushl   %eax              # 32bit nFunctionIndex
+    call    cpp_vtable_call
+    movl    16(%esp),%eax     # 32bit returnValue
+    leave
+    ret     $4
+.LFEc:
+    .size   privateSnippetExecutorClass,.-privateSnippetExecutorClass
+
+    .section .eh_frame,"a",@progbits
+.Lframe1:
+    .long   .LECIE1-.LSCIE1   # length
+.LSCIE1:
+    .long   0                 # CIE_ID
+    .byte   1                 # version
+    .string "zR"              # augmentation
+    .uleb128 1                # code_alignment_factor
+    .sleb128 -4               # data_alignment_factor
+    .byte   8                 # return_address_register
+    .uleb128 1                # augmentation size 1:
+    .byte   0x1B              #  FDE Encoding (pcrel sdata4)
+                              # initial_instructions:
+    .byte   0x0C              #  DW_CFA_def_cfa %esp, 4
+    .uleb128 4
+    .uleb128 4
+    .byte   0x88              #  DW_CFA_offset ret, 1
+    .uleb128 1
+    .align 4
+.LECIE1:
+.LSFDEg:
+    .long   .LEFDEg-.LASFDEg  # length
+.LASFDEg:
+    .long   .LASFDEg-.Lframe1 # CIE_pointer
+    .long   .LFBg-.           # initial_location
+    .long   .LFEg-.LFBg       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIg0-.LFBg
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIg1-.LCFIg0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEg:
+.LSFDEv:
+    .long   .LEFDEv-.LASFDEv  # length
+.LASFDEv:
+    .long   .LASFDEv-.Lframe1 # CIE_pointer
+    .long   .LFBv-.           # initial_location
+    .long   .LFEv-.LFBv       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIv0-.LFBv
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIv1-.LCFIv0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEv:
+.LSFDEh:
+    .long   .LEFDEh-.LASFDEh  # length
+.LASFDEh:
+    .long   .LASFDEh-.Lframe1 # CIE_pointer
+    .long   .LFBh-.           # initial_location
+    .long   .LFEh-.LFBh       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIh0-.LFBh
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIh1-.LCFIh0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEh:
+.LSFDEf:
+    .long   .LEFDEf-.LASFDEf  # length
+.LASFDEf:
+    .long   .LASFDEf-.Lframe1 # CIE_pointer
+    .long   .LFBf-.           # initial_location
+    .long   .LFEf-.LFBf       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIf0-.LFBf
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIf1-.LCFIf0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEf:
+.LSFDEd:
+    .long   .LEFDEd-.LASFDEd  # length
+.LASFDEd:
+    .long   .LASFDEd-.Lframe1 # CIE_pointer
+    .long   .LFBd-.           # initial_location
+    .long   .LFEd-.LFBd       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFId0-.LFBd
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFId1-.LCFId0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEd:
+.LSFDEc:
+    .long   .LEFDEc-.LASFDEc  # length
+.LASFDEc:
+    .long   .LASFDEc-.Lframe1 # CIE_pointer
+    .long   .LFBc-.           # initial_location
+    .long   .LFEc-.LFBc       # address_range
+    .uleb128 0                # augmentation size 0
+                              # instructions:
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIc0-.LFBc
+    .byte   0x0E              #  DW_CFA_def_cfa_offset 8
+    .uleb128 8
+    .byte   0x85              #  DW_CFA_offset %ebp, 2
+    .uleb128 2
+    .byte   0x04              #  DW_CFA_advance_loc4
+    .long   .LCFIc1-.LCFIc0
+    .byte   0x0D              #  DW_CFA_def_cfa_register %ebp
+    .uleb128 5
+    .align 4
+.LEFDEc:
+    .section .note.GNU-stack,"",@progbits
diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_netbsd_intel/cpp2uno.cxx
index 79cda920e7db..5740b27d9871 100644
--- a/bridges/source/cpp_uno/gcc3_netbsd_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/cpp2uno.cxx
@@ -28,39 +28,31 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_bridges.hxx"
 
-#include <hash_map>
-
-#include <sal/alloca.h>
-#include <rtl/alloc.h>
-#include <osl/mutex.hxx>
-
+#include <com/sun/star/uno/genfunc.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
 #include <uno/data.h>
 #include <typelib/typedescription.hxx>
 
-#include <bridges/cpp_uno/bridge.hxx>
-#include <bridges/cpp_uno/type_misc.hxx>
+#include "bridges/cpp_uno/shared/bridge.hxx"
+#include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"
+#include "bridges/cpp_uno/shared/types.hxx"
+#include "bridges/cpp_uno/shared/vtablefactory.hxx"
 
 #include "share.hxx"
 
-
-using namespace ::osl;
-using namespace ::rtl;
 using namespace ::com::sun::star::uno;
 
-namespace CPPU_CURRENT_NAMESPACE
+namespace
 {
 
 //==================================================================================================
-rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT;
-
-//==================================================================================================
-static typelib_TypeClass cpp2uno_call(
-    cppu_cppInterfaceProxy * pThis,
+void cpp2uno_call(
+    bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
     const typelib_TypeDescription * pMemberTypeDescr,
     typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
     sal_Int32 nParams, typelib_MethodParameter * pParams,
     void ** pCallStack,
-    sal_Int64 * pRegisterReturn /* space for register return */ )
+    void * pReturnValue )
 {
     // pCallStack: ret, [return ptr], this, params
     char * pCppStack = (char *)(pCallStack +1);
@@ -75,16 +67,17 @@ static typelib_TypeClass cpp2uno_call(
 
     if (pReturnTypeDescr)
     {
-        if (cppu_isSimpleType( pReturnTypeDescr ))
+        if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
         {
-            pUnoReturn = pRegisterReturn; // direct way for simple types
+            pUnoReturn = pReturnValue; // direct way for simple types
         }
         else // complex return via ptr (pCppReturn)
         {
             pCppReturn = *(void **)pCppStack;
             pCppStack += sizeof(void *);
 
-            pUnoReturn = (cppu_relatesToInterface( pReturnTypeDescr )
+            pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
+                              pReturnTypeDescr )
                           ? alloca( pReturnTypeDescr->nSize )
                           : pCppReturn); // direct way
         }
@@ -110,7 +103,9 @@ static typelib_TypeClass cpp2uno_call(
         typelib_TypeDescription * pParamTypeDescr = 0;
         TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
 
-        if (!rParam.bOut && cppu_isSimpleType( pParamTypeDescr )) // value
+        if (!rParam.bOut
+            && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+            // value
         {
             pCppArgs[nPos] = pCppStack;
             pUnoArgs[nPos] = pCppStack;
@@ -120,6 +115,9 @@ static typelib_TypeClass cpp2uno_call(
             case typelib_TypeClass_UNSIGNED_HYPER:
             case typelib_TypeClass_DOUBLE:
                 pCppStack += sizeof(sal_Int32); // extra long
+                break;
+            default:
+                break;
             }
             // no longer needed
             TYPELIB_DANGER_RELEASE( pParamTypeDescr );
@@ -137,11 +135,12 @@ static typelib_TypeClass cpp2uno_call(
                 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
             }
             // is in/inout
-            else if (cppu_relatesToInterface( pParamTypeDescr ))
+            else if (bridges::cpp_uno::shared::relatesToInterfaceType(
+                         pParamTypeDescr ))
             {
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
-                                        &pThis->pBridge->aCpp2Uno );
+                                        pThis->getBridge()->getCpp2Uno() );
                 pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
                 // will be released at reconversion
                 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
@@ -161,7 +160,8 @@ static typelib_TypeClass cpp2uno_call(
     uno_Any * pUnoExc = &aUnoExc;
 
     // invoke uno dispatch call
-    (*pThis->pUnoI->pDispatcher)( pThis->pUnoI, pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
+    (*pThis->getUnoI()->pDispatcher)(
+        pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
 
     // in case an exception occured...
     if (pUnoExc)
@@ -178,9 +178,9 @@ static typelib_TypeClass cpp2uno_call(
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
 
-        raiseException( &aUnoExc, &pThis->pBridge->aUno2Cpp ); // has to destruct the any
-        // is here for dummy
-        return typelib_TypeClass_VOID;
+        CPPU_CURRENT_NAMESPACE::raiseException(
+            &aUnoExc, pThis->getBridge()->getUno2Cpp() );
+            // has to destruct the any
     }
     else // else no exception occured...
     {
@@ -195,7 +195,7 @@ static typelib_TypeClass cpp2uno_call(
                 // convert and assign
                 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
                 uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
-                                        &pThis->pBridge->aUno2Cpp );
+                                        pThis->getBridge()->getUno2Cpp() );
             }
             // destroy temp uno param
             uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
@@ -208,76 +208,72 @@ static typelib_TypeClass cpp2uno_call(
             if (pUnoReturn != pCppReturn) // needs reconversion
             {
                 uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
-                                        &pThis->pBridge->aUno2Cpp );
+                                        pThis->getBridge()->getUno2Cpp() );
                 // destroy temp uno return
                 uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
             }
             // complex return ptr is set to eax
-            *(void **)pRegisterReturn = pCppReturn;
+            *static_cast< void ** >(pReturnValue) = pCppReturn;
         }
         if (pReturnTypeDescr)
         {
-            typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
-            return eRet;
         }
-        else
-            return typelib_TypeClass_VOID;
     }
 }
 
 
 //==================================================================================================
-static typelib_TypeClass cpp_mediate(
-    sal_Int32 nVtableCall,
-    void ** pCallStack,
-    sal_Int64 * pRegisterReturn /* space for register return */ )
+extern "C" void cpp_vtable_call(
+    int nFunctionIndex, int nVtableOffset, void** pCallStack,
+    void * pReturnValue )
 {
     OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" );
 
     // pCallStack: ret adr, [ret *], this, params
-    // _this_ ptr is patched cppu_XInterfaceProxy object
-    cppu_cppInterfaceProxy * pCppI = NULL;
-    if( nVtableCall & 0x80000000 )
+    void * pThis;
+    if( nFunctionIndex & 0x80000000 )
     {
-        nVtableCall &= 0x7fffffff;
-        pCppI = (cppu_cppInterfaceProxy *)(XInterface *)*(pCallStack +2);
+        nFunctionIndex &= 0x7fffffff;
+        pThis = pCallStack[2];
     }
     else
     {
-        pCppI = (cppu_cppInterfaceProxy *)(XInterface *)*(pCallStack +1);
+        pThis = pCallStack[1];
     }
+    pThis = static_cast< char * >(pThis) - nVtableOffset;
+    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
+        = bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
+            pThis);
 
-    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->pTypeDescr;
+    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
 
-    OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
-    if (nVtableCall >= pTypeDescr->nMapFunctionIndexToMemberIndex)
+    OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
+    if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
     {
         throw RuntimeException(
-            OUString::createFromAscii("illegal vtable index!"),
-            (XInterface *)pCppI );
+            rtl::OUString::createFromAscii("illegal vtable index!"),
+            (XInterface *)pThis );
     }
 
     // determine called method
-    OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
-    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nVtableCall];
+    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
     OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );
 
     TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
 
-    typelib_TypeClass eRet;
     switch (aMemberDescr.get()->eTypeClass)
     {
     case typelib_TypeClass_INTERFACE_ATTRIBUTE:
     {
-        if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nVtableCall)
+        if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
         {
             // is GET method
-            eRet = cpp2uno_call(
+            cpp2uno_call(
                 pCppI, aMemberDescr.get(),
                 ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,
                 0, 0, // no params
-                pCallStack, pRegisterReturn );
+                pCallStack, pReturnValue );
         }
         else
         {
@@ -288,26 +284,24 @@ static typelib_TypeClass cpp_mediate(
             aParam.bIn      = sal_True;
             aParam.bOut     = sal_False;
 
-            eRet = cpp2uno_call(
+            cpp2uno_call(
                 pCppI, aMemberDescr.get(),
                 0, // indicates void return
                 1, &aParam,
-                pCallStack, pRegisterReturn );
+                pCallStack, pReturnValue );
         }
         break;
     }
     case typelib_TypeClass_INTERFACE_METHOD:
     {
         // is METHOD
-        switch (nVtableCall)
+        switch (nFunctionIndex)
         {
         case 1: // acquire()
             pCppI->acquireProxy(); // non virtual call!
-            eRet = typelib_TypeClass_VOID;
             break;
         case 2: // release()
             pCppI->releaseProxy(); // non virtual call!
-            eRet = typelib_TypeClass_VOID;
             break;
         case 0: // queryInterface() opt
         {
@@ -316,9 +310,10 @@ static typelib_TypeClass cpp_mediate(
             if (pTD)
             {
                 XInterface * pInterface = 0;
-                (*pCppI->pBridge->pCppEnv->getRegisteredInterface)(
-                    pCppI->pBridge->pCppEnv,
-                    (void **)&pInterface, pCppI->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
+                (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
+                    pCppI->getBridge()->getCppEnv(),
+                    (void **)&pInterface, pCppI->getOid().pData,
+                    (typelib_InterfaceTypeDescription *)pTD );
 
                 if (pInterface)
                 {
@@ -327,237 +322,169 @@ static typelib_TypeClass cpp_mediate(
                         &pInterface, pTD, cpp_acquire );
                     pInterface->release();
                     TYPELIB_DANGER_RELEASE( pTD );
-                    *(void **)pRegisterReturn = pCallStack[1];
-                    eRet = typelib_TypeClass_ANY;
+                    *static_cast< void ** >(pReturnValue) = pCallStack[1];
                     break;
                 }
                 TYPELIB_DANGER_RELEASE( pTD );
             }
         } // else perform queryInterface()
         default:
-            eRet = cpp2uno_call(
+            cpp2uno_call(
                 pCppI, aMemberDescr.get(),
                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
-                pCallStack, pRegisterReturn );
+                pCallStack, pReturnValue );
         }
         break;
     }
     default:
     {
         throw RuntimeException(
-            OUString::createFromAscii("no member description found!"),
-            (XInterface *)pCppI );
-        // is here for dummy
-        eRet = typelib_TypeClass_VOID;
+            rtl::OUString::createFromAscii("no member description found!"),
+            (XInterface *)pThis );
     }
     }
-
-    return eRet;
 }
 
 //==================================================================================================
-/**
- * is called on incoming vtable calls
- * (called by asm snippets)
- */
-static void cpp_vtable_call( int nTableEntry, void** pCallStack ) __attribute__((regparm(2)));
-
-void cpp_vtable_call( int nTableEntry, void** pCallStack )
+extern "C" void privateSnippetExecutorGeneral();
+extern "C" void privateSnippetExecutorVoid();
+extern "C" void privateSnippetExecutorHyper();
+extern "C" void privateSnippetExecutorFloat();
+extern "C" void privateSnippetExecutorDouble();
+extern "C" void privateSnippetExecutorClass();
+extern "C" typedef void (*PrivateSnippetExecutor)();
+
+int const codeSnippetSize = 16;
+
+unsigned char * codeSnippet(
+    unsigned char * code, sal_Int32 functionIndex, sal_Int32 vtableOffset,
+    typelib_TypeClass returnTypeClass)
 {
-    volatile long nRegReturn[2];
-    typelib_TypeClass aType = cpp_mediate( nTableEntry, pCallStack, (sal_Int64*)nRegReturn );
-
-    switch( aType )
-    {
-        case typelib_TypeClass_HYPER:
-        case typelib_TypeClass_UNSIGNED_HYPER:
-            __asm__( "movl %1, %%edx\n\t"
-                     "movl %0, %%eax\n"
-                     : : "m"(nRegReturn[0]), "m"(nRegReturn[1]) );
-            break;
-        case typelib_TypeClass_FLOAT:
-            __asm__( "flds %0\n\t"
-                     "fstp %%st(0)\n\t"
-                     "flds %0\n"
-                     : : "m"(*(float *)nRegReturn) );
-            break;
-        case typelib_TypeClass_DOUBLE:
-            __asm__( "fldl %0\n\t"
-                     "fstp %%st(0)\n\t"
-                     "fldl %0\n"
-                     : : "m"(*(double *)nRegReturn) );
-            break;
-//      case typelib_TypeClass_UNSIGNED_SHORT:
-//      case typelib_TypeClass_SHORT:
-//          __asm__( "movswl %0, %%eax\n"
-//                   : : "m"(nRegReturn) );
-//      break;
-        default:
-            __asm__( "movl %0, %%eax\n"
-                     : : "m"(nRegReturn[0]) );
-            break;
+    if (!bridges::cpp_uno::shared::isSimpleType(returnTypeClass)) {
+        functionIndex |= 0x80000000;
+    }
+    PrivateSnippetExecutor exec;
+    switch (returnTypeClass) {
+    case typelib_TypeClass_VOID:
+        exec = privateSnippetExecutorVoid;
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        exec = privateSnippetExecutorHyper;
+        break;
+    case typelib_TypeClass_FLOAT:
+        exec = privateSnippetExecutorFloat;
+        break;
+    case typelib_TypeClass_DOUBLE:
+        exec = privateSnippetExecutorDouble;
+        break;
+    case typelib_TypeClass_STRING:
+    case typelib_TypeClass_TYPE:
+    case typelib_TypeClass_ANY:
+    case typelib_TypeClass_SEQUENCE:
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_INTERFACE:
+        exec = privateSnippetExecutorClass;
+        break;
+    default:
+        exec = privateSnippetExecutorGeneral;
+        break;
     }
+    unsigned char * p = code;
+    OSL_ASSERT(sizeof (sal_Int32) == 4);
+    // mov function_index, %eax:
+    *p++ = 0xB8;
+    *reinterpret_cast< sal_Int32 * >(p) = functionIndex;
+    p += sizeof (sal_Int32);
+    // mov vtable_offset, %edx:
+    *p++ = 0xBA;
+    *reinterpret_cast< sal_Int32 * >(p) = vtableOffset;
+    p += sizeof (sal_Int32);
+    // jmp privateSnippetExecutor:
+    *p++ = 0xE9;
+    *reinterpret_cast< sal_Int32 * >(p)
+        = ((unsigned char *) exec) - p - sizeof (sal_Int32);
+    p += sizeof (sal_Int32);
+    OSL_ASSERT(p - code <= codeSnippetSize);
+    return code + codeSnippetSize;
 }
 
+}
 
-//==================================================================================================
-class MediateClassData
-{
-    typedef ::std::hash_map< OUString, void *, OUStringHash > t_classdata_map;
-    t_classdata_map m_map;
-    Mutex m_mutex;
-
-public:
-    void const * get_vtable( typelib_InterfaceTypeDescription * pTD ) SAL_THROW( () );
-
-    inline MediateClassData() SAL_THROW( () )
-        {}
-    ~MediateClassData() SAL_THROW( () );
-};
-//__________________________________________________________________________________________________
-MediateClassData::~MediateClassData() SAL_THROW( () )
-{
-    OSL_TRACE( "> calling ~MediateClassData(): freeing mediate vtables." );
+struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
 
-    for ( t_classdata_map::const_iterator iPos( m_map.begin() ); iPos != m_map.end(); ++iPos )
-    {
-        ::rtl_freeMemory( iPos->second );
-    }
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
+{
+    return static_cast< Slot * >(block) + 2;
 }
-//--------------------------------------------------------------------------------------------------
-static inline void codeSnippet( char * code, sal_uInt32 vtable_pos, bool simple_ret_type ) SAL_THROW( () )
+
+sal_Size bridges::cpp_uno::shared::VtableFactory::getBlockSize(
+    sal_Int32 slotCount)
 {
-    if (! simple_ret_type)
-        vtable_pos |= 0x80000000;
-    OSL_ASSERT( sizeof (long) == 4 );
-    // mov $nPos, %eax
-    *code++ = 0xb8;
-    *(long *)code = vtable_pos;
-    code += sizeof (long);
-    // mov %esp, %edx
-    *code++ = 0x89;
-    *code++ = 0xe2;
-    // jmp cpp_vtable_call
-    *code++ = 0xe9;
-    *(long *)code = ((char *)cpp_vtable_call) - code - sizeof (long);
+    return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
 }
-//__________________________________________________________________________________________________
-void const * MediateClassData::get_vtable( typelib_InterfaceTypeDescription * pTD ) SAL_THROW( () )
+
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::initializeBlock(
+    void * block, sal_Int32 slotCount)
 {
-    void * buffer;
+    Slot * slots = mapBlockToVtable(block);
+    slots[-2].fn = 0;
+    slots[-1].fn = 0;
+    return slots + slotCount;
+}
 
-    // avoiding locked counts
-    OUString const & unoName = *(OUString const *)&((typelib_TypeDescription *)pTD)->pTypeName;
-    {
-    MutexGuard aGuard( m_mutex );
-    t_classdata_map::const_iterator iFind( m_map.find( unoName ) );
-    if (iFind == m_map.end())
-    {
-        // create new vtable
-        sal_Int32 nSlots = pTD->nMapFunctionIndexToMemberIndex;
-        buffer = ::rtl_allocateMemory( ((2+ nSlots) * sizeof (void *)) + (nSlots *20) );
-
-        ::std::pair< t_classdata_map::iterator, bool > insertion(
-            m_map.insert( t_classdata_map::value_type( unoName, buffer ) ) );
-        OSL_ENSURE( insertion.second, "### inserting new vtable buffer failed?!" );
-
-        void ** slots = (void **)buffer;
-        *slots++ = 0;
-        *slots++ = 0; // rtti
-        char * code = (char *)(slots + nSlots);
-
-        sal_uInt32 vtable_pos = 0;
-        sal_Int32 nAllMembers = pTD->nAllMembers;
-        typelib_TypeDescriptionReference ** ppAllMembers = pTD->ppAllMembers;
-        for ( sal_Int32 nPos = 0; nPos < nAllMembers; ++nPos )
-        {
-            typelib_TypeDescription * pTD = 0;
-            TYPELIB_DANGER_GET( &pTD, ppAllMembers[ nPos ] );
-            OSL_ASSERT( pTD );
-            if (typelib_TypeClass_INTERFACE_ATTRIBUTE == pTD->eTypeClass)
-            {
-                bool simple_ret = cppu_isSimpleType(
-                    ((typelib_InterfaceAttributeTypeDescription *)pTD)->pAttributeTypeRef->eTypeClass );
-                // get method
-                *slots++ = code;
-                codeSnippet( code, vtable_pos++, simple_ret );
-                code += 20;
-                if (! ((typelib_InterfaceAttributeTypeDescription *)pTD)->bReadOnly)
-                {
-                    // set method
-                    *slots++ = code;
-                    codeSnippet( code, vtable_pos++, true );
-                    code += 20;
-                }
-            }
-            else
+unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
+    Slot ** slots, unsigned char * code,
+    typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
+    sal_Int32 functionCount, sal_Int32 vtableOffset)
+{
+    (*slots) -= functionCount;
+    Slot * s = *slots;
+    for (sal_Int32 i = 0; i < type->nMembers; ++i) {
+        typelib_TypeDescription * member = 0;
+        TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
+        OSL_ASSERT(member != 0);
+        switch (member->eTypeClass) {
+        case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+            // Getter:
+            (s++)->fn = code;
+            code = codeSnippet(
+                code, functionOffset++, vtableOffset,
+                reinterpret_cast< typelib_InterfaceAttributeTypeDescription * >(
+                    member)->pAttributeTypeRef->eTypeClass);
+            // Setter:
+            if (!reinterpret_cast<
+                typelib_InterfaceAttributeTypeDescription * >(
+                    member)->bReadOnly)
             {
-                bool simple_ret = cppu_isSimpleType(
-                    ((typelib_InterfaceMethodTypeDescription *)pTD)->pReturnTypeRef->eTypeClass );
-                *slots++ = code;
-                codeSnippet( code, vtable_pos++, simple_ret );
-                code += 20;
+                (s++)->fn = code;
+                code = codeSnippet(
+                    code, functionOffset++, vtableOffset,
+                    typelib_TypeClass_VOID);
             }
-            TYPELIB_DANGER_RELEASE( pTD );
-        }
-        OSL_ASSERT( vtable_pos == nSlots );
-    }
-    else
-    {
-        buffer = iFind->second;
-    }
-    }
+            break;
 
-    return ((void **)buffer +2);
-}
+        case typelib_TypeClass_INTERFACE_METHOD:
+            (s++)->fn = code;
+            code = codeSnippet(
+                code, functionOffset++, vtableOffset,
+                reinterpret_cast< typelib_InterfaceMethodTypeDescription * >(
+                    member)->pReturnTypeRef->eTypeClass);
+            break;
 
-//==================================================================================================
-void SAL_CALL cppu_cppInterfaceProxy_patchVtable(
-    XInterface * pCppI, typelib_InterfaceTypeDescription * pTypeDescr ) throw ()
-{
-    static MediateClassData * s_pMediateClassData = 0;
-    if (! s_pMediateClassData)
-    {
-        MutexGuard aGuard( Mutex::getGlobalMutex() );
-        if (! s_pMediateClassData)
-        {
-#ifdef LEAK_STATIC_DATA
-            s_pMediateClassData = new MediateClassData();
-#else
-            static MediateClassData s_aMediateClassData;
-            s_pMediateClassData = &s_aMediateClassData;
-#endif
+        default:
+            OSL_ASSERT(false);
+            break;
         }
+        TYPELIB_DANGER_RELEASE(member);
     }
-    *(void const **)pCppI = s_pMediateClassData->get_vtable( pTypeDescr );
-}
-
+    return code;
 }
 
-extern "C"
-{
-//##################################################################################################
-sal_Bool SAL_CALL component_canUnload( TimeValue * pTime )
-    SAL_THROW_EXTERN_C()
-{
-    return CPPU_CURRENT_NAMESPACE::g_moduleCount.canUnload(
-        &CPPU_CURRENT_NAMESPACE::g_moduleCount, pTime );
-}
-//##################################################################################################
-void SAL_CALL uno_initEnvironment( uno_Environment * pCppEnv )
-    SAL_THROW_EXTERN_C()
-{
-    CPPU_CURRENT_NAMESPACE::cppu_cppenv_initEnvironment(
-        pCppEnv );
-}
-//##################################################################################################
-void SAL_CALL uno_ext_getMapping(
-    uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo )
-    SAL_THROW_EXTERN_C()
-{
-    CPPU_CURRENT_NAMESPACE::cppu_ext_getMapping(
-        ppMapping, pFrom, pTo );
-}
-}
+void bridges::cpp_uno::shared::VtableFactory::flushCode(
+    unsigned char const *, unsigned char const *)
+{}
diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/except.cxx b/bridges/source/cpp_uno/gcc3_netbsd_intel/except.cxx
index be5686af2807..00642270e0bd 100644
--- a/bridges/source/cpp_uno/gcc3_netbsd_intel/except.cxx
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/except.cxx
@@ -32,21 +32,20 @@
 #include <dlfcn.h>
 #include <cxxabi.h>
 #include <hash_map>
+#include <sys/param.h>
 
 #include <rtl/strbuf.hxx>
 #include <rtl/ustrbuf.hxx>
 #include <osl/diagnose.h>
 #include <osl/mutex.hxx>
 
-#include <bridges/cpp_uno/bridge.hxx>
+#include <com/sun/star/uno/genfunc.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
 #include <typelib/typedescription.hxx>
 #include <uno/any2.h>
 
 #include "share.hxx"
 
-#ifndef RTLD_DEFAULT
-#define RTLD_DEFAULT    ((void *) -2)
-#endif
 
 using namespace ::std;
 using namespace ::osl;
@@ -119,7 +118,11 @@ public:
 };
 //__________________________________________________________________________________________________
 RTTI::RTTI() SAL_THROW( () )
-    : m_hApp( dlopen( 0 , RTLD_LAZY ) )
+#if 1
+    : m_hApp( dlopen( 0, RTLD_NOW | RTLD_GLOBAL ) )
+#else
+    : m_hApp( dlopen( 0, RTLD_LAZY ) )
+#endif
 {
 }
 //__________________________________________________________________________________________________
@@ -136,8 +139,8 @@ type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THR
     OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;
 
     MutexGuard guard( m_mutex );
-    t_rtti_map::const_iterator iFind( m_rttis.find( unoName ) );
-    if (iFind == m_rttis.end())
+    t_rtti_map::const_iterator iRttiFind( m_rttis.find( unoName ) );
+    if (iRttiFind == m_rttis.end())
     {
         // RTTI symbol
         OStringBuffer buf( 64 );
@@ -154,7 +157,11 @@ type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THR
         buf.append( 'E' );
 
         OString symName( buf.makeStringAndClear() );
+#if 1 /* #i22253# */
         rtti = (type_info *)dlsym( RTLD_DEFAULT, symName.getStr() );
+#else
+        rtti = (type_info *)dlsym( m_hApp, symName.getStr() );
+#endif
 
         if (rtti)
         {
@@ -201,7 +208,7 @@ type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THR
     }
     else
     {
-        rtti = iFind->second;
+        rtti = iRttiFind->second;
     }
 
     return rtti;
@@ -225,7 +232,7 @@ static void deleteException( void * pExc )
 //==================================================================================================
 void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )
 {
-#if defined DEBUG
+#if OSL_DEBUG_LEVEL > 1
     OString cstr(
         OUStringToOString(
             *reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
@@ -293,7 +300,7 @@ void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping
             Reference< XInterface >() );
         Type const & rType = ::getCppuType( &aRE );
         uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
-#if defined _DEBUG
+#if OSL_DEBUG_LEVEL > 0
         OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
         OSL_ENSURE( 0, cstr.getStr() );
 #endif
@@ -302,7 +309,7 @@ void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping
 
     typelib_TypeDescription * pExcTypeDescr = 0;
     OUString unoName( toUNOname( header->exceptionType->name() ) );
-#if defined DEBUG
+#if OSL_DEBUG_LEVEL > 1
     OString cstr_unoName( OUStringToOString( unoName, RTL_TEXTENCODING_ASCII_US ) );
     fprintf( stderr, "> c++ exception occured: %s\n", cstr_unoName.getStr() );
 #endif
@@ -314,7 +321,7 @@ void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping
             Reference< XInterface >() );
         Type const & rType = ::getCppuType( &aRE );
         uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
-#if defined _DEBUG
+#if OSL_DEBUG_LEVEL > 0
         OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
         OSL_ENSURE( 0, cstr.getStr() );
 #endif
diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/makefile.mk b/bridges/source/cpp_uno/gcc3_netbsd_intel/makefile.mk
index 794501d0b5f3..3f6274fd36c0 100644
--- a/bridges/source/cpp_uno/gcc3_netbsd_intel/makefile.mk
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/makefile.mk
@@ -44,12 +44,17 @@ ENABLE_EXCEPTIONS=TRUE
 CFLAGS += -DLEAK_STATIC_DATA
 .ENDIF
 
+# In case someone enabled the non-standard -fomit-frame-pointer which does not
+# work with the .cxx sources in this directory:
+CFLAGSCXX += -fno-omit-frame-pointer
+
 CFLAGSNOOPT=-O0
 
 SLOFILES= \
     $(SLO)$/except.obj		\
     $(SLO)$/cpp2uno.obj		\
-    $(SLO)$/uno2cpp.obj
+    $(SLO)$/uno2cpp.obj \
+    $(SLO)$/call.obj
 
 SHL1TARGET= $(TARGET)
 
@@ -58,10 +63,8 @@ SHL1IMPLIB=i$(TARGET)
 SHL1VERSIONMAP=..$/..$/bridge_exports.map
 SHL1RPATH=URELIB
 
-SHL1OBJS= \
-    $(SLO)$/except.obj		\
-    $(SLO)$/cpp2uno.obj		\
-    $(SLO)$/uno2cpp.obj
+SHL1OBJS = $(SLOFILES)
+SHL1LIBS = $(SLB)$/cpp_uno_shared.lib
 
 SHL1STDLIBS= \
     $(CPPULIB)			\
@@ -73,3 +76,6 @@ SHL1STDLIBS= \
 
 .INCLUDE :  target.mk
 
+$(SLO)$/%.obj: %.s
+    $(CC) -c -o $(SLO)$/$(@:b).o $<
+    touch $@
diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/share.hxx b/bridges/source/cpp_uno/gcc3_netbsd_intel/share.hxx
index ba6ac7e974cc..930094738b20 100644
--- a/bridges/source/cpp_uno/gcc3_netbsd_intel/share.hxx
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/share.hxx
@@ -25,6 +25,8 @@
  *
  ************************************************************************/
 
+#include "uno/mapping.h"
+
 #include <typeinfo>
 #include <exception>
 #include <cstddef>
@@ -32,6 +34,8 @@
 namespace CPPU_CURRENT_NAMESPACE
 {
 
+void dummy_can_throw_anything( char const * );
+
 // ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h
 
 struct _Unwind_Exception
diff --git a/bridges/source/cpp_uno/gcc3_netbsd_intel/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_netbsd_intel/uno2cpp.cxx
index 873abecd7420..094a1d1d0177 100644
--- a/bridges/source/cpp_uno/gcc3_netbsd_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_netbsd_intel/uno2cpp.cxx
@@ -28,24 +28,25 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_bridges.hxx"
 
-#include <sal/alloca.h>
-#include <rtl/alloc.h>
+#include <stdlib.h>
 
+#include <com/sun/star/uno/genfunc.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
 #include <uno/data.h>
-#include <bridges/cpp_uno/bridge.hxx>
-#include <bridges/cpp_uno/type_misc.hxx>
 
-#include "share.hxx"
+#include "bridges/cpp_uno/shared/bridge.hxx"
+#include "bridges/cpp_uno/shared/types.hxx"
+#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
+#include "bridges/cpp_uno/shared/vtables.hxx"
 
+#include "share.hxx"
 
 using namespace ::rtl;
 using namespace ::com::sun::star::uno;
 
-namespace CPPU_CURRENT_NAMESPACE
+namespace
 {
 
-void dummy_can_throw_anything( char const * );
-
 //==================================================================================================
 // The call instruction within the asm section of callVirtualMethod may throw
 // exceptions.  So that the compiler handles this correctly, it is important
@@ -54,7 +55,7 @@ void dummy_can_throw_anything( char const * );
 // callVirtualMethod is not inlined at its call site (so that any exceptions are
 // caught which are thrown from the instruction calling callVirtualMethod):
 void callVirtualMethod(
-    void * pThis,
+    void * pAdjustedThisPtr,
     sal_Int32 nVtableIndex,
     void * pRegisterReturn,
     typelib_TypeClass eReturnType,
@@ -62,7 +63,7 @@ void callVirtualMethod(
     sal_Int32 nStackLongs ) __attribute__((noinline));
 
 void callVirtualMethod(
-    void * pThis,
+    void * pAdjustedThisPtr,
     sal_Int32 nVtableIndex,
     void * pRegisterReturn,
     typelib_TypeClass eReturnType,
@@ -72,12 +73,12 @@ void callVirtualMethod(
     // parameter list is mixed list of * and values
     // reference parameters are pointers
 
-    OSL_ENSURE( pStackLongs && pThis, "### null ptr!" );
+    OSL_ENSURE( pStackLongs && pAdjustedThisPtr, "### null ptr!" );
     OSL_ENSURE( (sizeof(void *) == 4) && (sizeof(sal_Int32) == 4), "### unexpected size of int!" );
     OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );
 
     // never called
-    if (! pThis) dummy_can_throw_anything("xxx"); // address something
+    if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
 
     volatile long edx = 0, eax = 0; // for register returns
     void * stackptr;
@@ -108,8 +109,8 @@ void callVirtualMethod(
         // cleanup stack
         "mov   %6, %%esp\n\t"
         :
-        : "m"(nStackLongs), "m"(pStackLongs), "m"(pThis), "m"(nVtableIndex),
-          "m"(eax), "m"(edx), "m"(stackptr)
+        : "m"(nStackLongs), "m"(pStackLongs), "m"(pAdjustedThisPtr),
+          "m"(nVtableIndex), "m"(eax), "m"(edx), "m"(stackptr)
         : "eax", "edx" );
     switch( eReturnType )
     {
@@ -136,13 +137,15 @@ void callVirtualMethod(
         case typelib_TypeClass_DOUBLE:
             asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) );
             break;
+        default:
+            break;
     }
 }
 
 //==================================================================================================
 static void cpp_call(
-    cppu_unoInterfaceProxy * pThis,
-    sal_Int32 nVtableCall,
+    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
+    bridges::cpp_uno::shared::VtableSlot aVtableSlot,
     typelib_TypeDescriptionReference * pReturnTypeRef,
     sal_Int32 nParams, typelib_MethodParameter * pParams,
     void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
@@ -161,21 +164,25 @@ static void cpp_call(
 
     if (pReturnTypeDescr)
     {
-        if (cppu_isSimpleType( pReturnTypeDescr ))
+        if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
         {
             pCppReturn = pUnoReturn; // direct way for simple types
         }
         else
         {
             // complex return via ptr
-            pCppReturn = *(void **)pCppStack = (cppu_relatesToInterface( pReturnTypeDescr )
-                                                ? alloca( pReturnTypeDescr->nSize )
-                                                : pUnoReturn); // direct way
+            pCppReturn = *(void **)pCppStack
+                = (bridges::cpp_uno::shared::relatesToInterfaceType(
+                       pReturnTypeDescr )
+                   ? alloca( pReturnTypeDescr->nSize )
+                   : pUnoReturn); // direct way
             pCppStack += sizeof(void *);
         }
     }
     // push this
-    *(void**)pCppStack = pThis->pCppI;
+    void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
+        + aVtableSlot.offset;
+    *(void**)pCppStack = pAdjustedThisPtr;
     pCppStack += sizeof( void* );
 
     // stack space
@@ -195,10 +202,11 @@ static void cpp_call(
         typelib_TypeDescription * pParamTypeDescr = 0;
         TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
 
-        if (!rParam.bOut && cppu_isSimpleType( pParamTypeDescr ))
+        if (!rParam.bOut
+            && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
         {
             uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
-                                    &pThis->pBridge->aUno2Cpp );
+                                    pThis->getBridge()->getUno2Cpp() );
 
             switch (pParamTypeDescr->eTypeClass)
             {
@@ -206,6 +214,9 @@ static void cpp_call(
             case typelib_TypeClass_UNSIGNED_HYPER:
             case typelib_TypeClass_DOUBLE:
                 pCppStack += sizeof(sal_Int32); // extra long
+                break;
+            default:
+                break;
             }
             // no longer needed
             TYPELIB_DANGER_RELEASE( pParamTypeDescr );
@@ -223,11 +234,13 @@ static void cpp_call(
                 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
             }
             // is in/inout
-            else if (cppu_relatesToInterface( pParamTypeDescr ))
+            else if (bridges::cpp_uno::shared::relatesToInterfaceType(
+                         pParamTypeDescr ))
             {
                 uno_copyAndConvertData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                    pUnoArgs[nPos], pParamTypeDescr, &pThis->pBridge->aUno2Cpp );
+                    pUnoArgs[nPos], pParamTypeDescr,
+                    pThis->getBridge()->getUno2Cpp() );
 
                 pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
                 // will be released at reconversion
@@ -247,7 +260,7 @@ static void cpp_call(
     {
         OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic)" );
         callVirtualMethod(
-            pThis->pCppI, nVtableCall,
+            pAdjustedThisPtr, aVtableSlot.index,
             pCppReturn, pReturnTypeDescr->eTypeClass,
             (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
         // NO exception occured...
@@ -265,13 +278,13 @@ static void cpp_call(
                 {
                     uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
                     uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                            &pThis->pBridge->aCpp2Uno );
+                                            pThis->getBridge()->getCpp2Uno() );
                 }
             }
             else // pure out
             {
                 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                        &pThis->pBridge->aCpp2Uno );
+                                        pThis->getBridge()->getCpp2Uno() );
             }
             // destroy temp cpp param => cpp: every param was constructed
             uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
@@ -282,14 +295,14 @@ static void cpp_call(
         if (pCppReturn && pUnoReturn != pCppReturn)
         {
             uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
-                                    &pThis->pBridge->aCpp2Uno );
+                                    pThis->getBridge()->getCpp2Uno() );
             uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
         }
     }
      catch (...)
      {
           // fill uno exception
-        fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, &pThis->pBridge->aCpp2Uno );
+        fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
         for ( ; nTempIndizes--; )
@@ -305,32 +318,32 @@ static void cpp_call(
     }
 }
 
+}
 
-//==================================================================================================
-void SAL_CALL cppu_unoInterfaceProxy_dispatch(
+namespace bridges { namespace cpp_uno { namespace shared {
+
+void unoInterfaceProxyDispatch(
     uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
-    void * pReturn, void * pArgs[], uno_Any ** ppException ) throw ()
+    void * pReturn, void * pArgs[], uno_Any ** ppException )
 {
     // is my surrogate
-    cppu_unoInterfaceProxy * pThis = (cppu_unoInterfaceProxy *)pUnoI;
-    typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
+    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
+        = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
 
     switch (pMemberDescr->eTypeClass)
     {
     case typelib_TypeClass_INTERFACE_ATTRIBUTE:
     {
-        // determine vtable call index
-        sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
-        OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );
-
-        sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];
-        OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
-
+        VtableSlot aVtableSlot(
+            getVtableSlot(
+                reinterpret_cast<
+                    typelib_InterfaceAttributeTypeDescription const * >(
+                        pMemberDescr)));
         if (pReturn)
         {
             // dependent dispatch
             cpp_call(
-                pThis, nVtableCall,
+                pThis, aVtableSlot,
                 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
                 0, 0, // no params
                 pReturn, pArgs, ppException );
@@ -350,8 +363,9 @@ void SAL_CALL cppu_unoInterfaceProxy_dispatch(
                 &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
 
             // dependent dispatch
+            aVtableSlot.index += 1; // get, then set method
             cpp_call(
-                pThis, nVtableCall +1, // get, then set method
+                pThis, aVtableSlot,
                 pReturnTypeRef,
                 1, &aParam,
                 pReturn, pArgs, ppException );
@@ -363,14 +377,12 @@ void SAL_CALL cppu_unoInterfaceProxy_dispatch(
     }
     case typelib_TypeClass_INTERFACE_METHOD:
     {
-        // determine vtable call index
-        sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
-        OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );
-
-        sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];
-        OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
-
-        switch (nVtableCall)
+        VtableSlot aVtableSlot(
+            getVtableSlot(
+                reinterpret_cast<
+                    typelib_InterfaceMethodTypeDescription const * >(
+                        pMemberDescr)));
+        switch (aVtableSlot.index)
         {
             // standard calls
         case 1: // acquire uno interface
@@ -388,8 +400,8 @@ void SAL_CALL cppu_unoInterfaceProxy_dispatch(
             if (pTD)
             {
                 uno_Interface * pInterface = 0;
-                (*pThis->pBridge->pUnoEnv->getRegisteredInterface)(
-                    pThis->pBridge->pUnoEnv,
+                (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
+                    pThis->pBridge->getUnoEnv(),
                     (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
 
                 if (pInterface)
@@ -408,7 +420,7 @@ void SAL_CALL cppu_unoInterfaceProxy_dispatch(
         default:
             // dependent dispatch
             cpp_call(
-                pThis, nVtableCall,
+                pThis, aVtableSlot,
                 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
                 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
                 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
@@ -429,5 +441,4 @@ void SAL_CALL cppu_unoInterfaceProxy_dispatch(
     }
 }
 
-}
-
+} } }