bridges: Add support for linux mips64.

Change-Id: I71fd2f7d8bfd1b1511dec91f23b61b9f55d21472
Reviewed-on: https://gerrit.libreoffice.org/16845
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
Tested-by: Stephan Bergmann <sbergman@redhat.com>

7 files changed, 1853 insertions, 0 deletions

diff --git a/bridges/Library_cpp_uno.mk b/bridges/Library_cpp_uno.mk
index 34ecf045c13f..2f67535038dd 100644
--- a/bridges/Library_cpp_uno.mk
+++ b/bridges/Library_cpp_uno.mk
@@ -99,6 +99,15 @@ bridge_noopt_objects := cpp2uno uno2cpp
 bridge_exception_objects := except
 endif
 
+else ifeq ($(CPUNAME),GODSON64)
+
+ifneq ($(filter ANDROID LINUX,$(OS)),)
+bridges_SELECTED_BRIDGE := gcc3_linux_mips64
+bridge_asm_objects := call
+bridge_noopt_objects := cpp2uno uno2cpp
+bridge_exception_objects := except
+endif
+
 else ifeq ($(OS)-$(CPUNAME),LINUX-POWERPC)
 
 bridges_SELECTED_BRIDGE := gcc3_linux_powerpc
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/call.hxx b/bridges/source/cpp_uno/gcc3_linux_mips64/call.hxx
new file mode 100644
index 000000000000..0be88ee62587
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/call.hxx
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_MIPS64_CALL_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_MIPS64_CALL_HXX
+
+#include <sal/config.h>
+
+#include <sal/types.h>
+
+namespace {
+
+  extern "C" typelib_TypeClass cpp_vtable_call(
+      sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+      void ** gpreg, void ** fpreg, void ** ovrflw,
+      sal_uInt64 * pRegisterReturn /* space for register return */ );
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/call.s b/bridges/source/cpp_uno/gcc3_linux_mips64/call.s
new file mode 100644
index 000000000000..578772541e95
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/call.s
@@ -0,0 +1,132 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+        .text
+        .globl	privateSnippetExecutor
+.LFB0 = .
+        .cfi_startproc
+        .cfi_personality 0x80,DW.ref.__gxx_personality_v0
+        .cfi_lsda 0,.LLSDA0
+        .ent	privateSnippetExecutor
+        .type	privateSnippetExecutor, @function
+privateSnippetExecutor:
+        .set	noreorder
+        daddiu	$sp,$sp,-160
+        .cfi_def_cfa_offset 160
+        sd	$ra,152($sp)
+        .cfi_offset 31, -8
+.LEHB0 = .
+        // Save the float point registers
+        sdc1	$f12,80($sp)
+        sdc1	$f13,88($sp)
+        sdc1	$f14,96($sp)
+        sdc1	$f15,104($sp)
+        sdc1	$f16,112($sp)
+        sdc1	$f17,120($sp)
+        sdc1	$f18,128($sp)
+        sdc1	$f19,136($sp)
+        // Save the general purpose registers
+        sd	$a0,16($sp)
+        sd	$a1,24($sp)
+        sd	$a2,32($sp)
+        sd	$a3,40($sp)
+        sd	$a4,48($sp)
+        sd	$a5,56($sp)
+        sd	$a6,64($sp)
+        sd	$a7,72($sp)
+        // Load arguemtns
+        // a0=index
+        move	$a0,$v0
+        // a1=offset
+        move	$a1,$v1
+        // a2=gpregptr
+        daddiu	$a2,$sp,16
+        // a3=fpregptr
+        daddiu	$a3,$sp,80
+        // a4=ovrflw
+        daddiu	$a4,$sp,160
+        // Call cpp_vtable_call
+        jalr	$t9
+        // a5=retregptr
+        move	$a5,$sp
+
+.LEHE0 = .
+        // Perform return value
+        li	$v1,10
+        beq	$v0,$v1,.Lfloat
+        li	$v1,11
+        beq	$v0,$v1,.Lfloat
+        ldc1	$f0,0($sp)
+        ldc1	$f2,8($sp)
+        ld	$v0,0($sp)
+        b	.Lfinish
+        ld	$v1,8($sp)
+.Lfloat:
+        ldc1	$f0,0($sp)
+        ldc1	$f2,8($sp)
+
+.Lfinish:
+        ld	$ra,152($sp)
+        jr	$ra
+        daddiu	$sp,$sp,160
+
+        .set	reorder
+        .end	privateSnippetExecutor
+        .cfi_endproc
+.LFE0:
+        .globl	__gxx_personality_v0
+        .section	.gcc_except_table,"aw",@progbits
+        .align	3
+.LLSDA0:
+        .byte	0xff
+        .byte	0x80
+        .uleb128 .LLSDATT0-.LLSDATTD0
+.LLSDATTD0:
+        .byte	0x1
+        .uleb128 .LLSDACSE0-.LLSDACSB0
+.LLSDACSB0:
+        .uleb128 .LEHB0-.LFB0
+        .uleb128 .LEHE0-.LEHB0
+        .uleb128 0
+        .uleb128 0
+.LLSDACSE0:
+        .byte	0x7f
+        .byte	0
+        .align	3
+        .8byte	DW.ref._ZTIi
+.LLSDATT0:
+        .byte	0x1
+        .byte	0
+        .text
+        .size	privateSnippetExecutor, .-privateSnippetExecutor
+        .hidden	DW.ref._ZTIi
+        .weak	DW.ref._ZTIi
+        .section	.data.DW.ref._ZTIi,"awG",@progbits,DW.ref._ZTIi,comdat
+        .align	3
+        .type	DW.ref._ZTIi, @object
+        .size	DW.ref._ZTIi, 8
+DW.ref._ZTIi:
+        .dword	_ZTIi
+        .hidden	DW.ref.__gxx_personality_v0
+        .weak	DW.ref.__gxx_personality_v0
+        .section	.data.DW.ref.__gxx_personality_v0,"awG",@progbits,DW.ref.__gxx_personality_v0,comdat
+        .align	3
+        .type	DW.ref.__gxx_personality_v0, @object
+        .size	DW.ref.__gxx_personality_v0, 8
+DW.ref.__gxx_personality_v0:
+        .dword	__gxx_personality_v0
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_mips64/cpp2uno.cxx
new file mode 100644
index 000000000000..068bc55d9fe9
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/cpp2uno.cxx
@@ -0,0 +1,707 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#include <com/sun/star/uno/genfunc.hxx>
+#include <sal/log.hxx>
+#include <typelib/typedescription.hxx>
+#include <uno/data.h>
+#include <osl/endian.h>
+#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 "call.hxx"
+#include "share.hxx"
+
+#include <stdio.h>
+#include <string.h>
+
+using namespace com::sun::star::uno;
+
+//#define BRDEBUG
+
+#ifdef BRDEBUG
+#include <rtl/strbuf.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/mutex.hxx>
+using namespace ::std;
+using namespace ::osl;
+using namespace ::rtl;
+#endif
+
+#ifndef ANDROID
+#include <sys/sysmips.h>
+#endif
+
+#ifdef ANDROID
+#include <unistd.h>
+#endif
+
+using namespace ::com::sun::star::uno;
+
+namespace CPPU_CURRENT_NAMESPACE
+{
+  bool is_complex_struct(const typelib_TypeDescription * type)
+  {
+      const typelib_CompoundTypeDescription * p
+          = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
+      for (sal_Int32 i = 0; i < p->nMembers; ++i)
+      {
+          if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT ||
+              p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION)
+          {
+              typelib_TypeDescription * t = 0;
+              TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);
+              bool b = is_complex_struct(t);
+              TYPELIB_DANGER_RELEASE(t);
+              if (b) {
+                  return true;
+              }
+          }
+          else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass))
+              return true;
+      }
+      if (p->pBaseTypeDescription != 0)
+          return is_complex_struct(&p->pBaseTypeDescription->aBase);
+      return false;
+  }
+
+  bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
+  {
+      if (bridges::cpp_uno::shared::isSimpleType(pTypeRef))
+          return false;
+      else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT ||
+               pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
+      {
+          typelib_TypeDescription * pTypeDescr = 0;
+          TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
+
+          //A Composite Type not larger than 16 bytes is returned in up to two GPRs
+          bool bRet = pTypeDescr->nSize > 16 || is_complex_struct(pTypeDescr);
+
+          TYPELIB_DANGER_RELEASE( pTypeDescr );
+          return bRet;
+      }
+      return true;
+  }
+}
+
+namespace
+{
+
+  static typelib_TypeClass 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 ** gpreg, void ** fpreg, void ** ovrflw,
+      sal_uInt64 * pRegisterReturn /* space for register return */ )
+  {
+    /*  Most MIPS ABIs view the arguments as a struct, of which the
+        first N words go in registers and the rest go on the stack.  If I < N, the
+        Ith word might go in Ith integer argument register or the Ith
+        floating-point one.  For these ABIs, we only need to remember the number
+        of words passed so far.  We are interested only in n64 ABI,so it is the
+        case.
+        */
+    unsigned int nREG = 0;
+
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp2uno_call:begin\n");
+#endif
+
+    // return
+    typelib_TypeDescription * pReturnTypeDescr = 0;
+    if (pReturnTypeRef)
+      TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
+
+    void * pUnoReturn = 0;
+    void * pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
+
+    if (pReturnTypeDescr)
+    {
+      if (CPPU_CURRENT_NAMESPACE::return_in_hidden_param( pReturnTypeRef ) )
+      {
+        pCppReturn = gpreg[nREG]; // complex return via ptr (pCppReturn)
+        nREG++;
+
+        pUnoReturn = ( bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
+            ? alloca( pReturnTypeDescr->nSize )
+            : pCppReturn); // direct way
+#ifdef BRDEBUG
+        fprintf(stderr, "cpp2uno_call:complexreturn\n");
+#endif
+      }
+      else
+      {
+        pUnoReturn = pRegisterReturn; // direct way for simple types
+#ifdef BRDEBUG
+        fprintf(stderr, "cpp2uno_call:simplereturn\n");
+#endif
+      }
+    }
+
+    // pop this
+    nREG++;
+
+    // stack space
+    static_assert(sizeof(void *) == sizeof(sal_Int64), "### unexpected size!");
+    // parameters
+    void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
+    void ** pCppArgs = pUnoArgs + nParams;
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // type descriptions for reconversions
+    typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
+
+    sal_Int32 nTempIndices   = 0;
+
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp2uno_call:nParams=%d\n", nParams);
+#endif
+    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+    {
+      const typelib_MethodParameter & rParam = pParams[nPos];
+
+      typelib_TypeDescription * pParamTypeDescr = 0;
+      TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+
+      if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr )) // value
+      {
+#ifdef BRDEBUG
+        fprintf(stderr, "cpp2uno_call:Param %u, type %u\n", nPos, pParamTypeDescr->eTypeClass);
+#endif
+        switch (pParamTypeDescr->eTypeClass)
+        {
+          case typelib_TypeClass_FLOAT:
+          case typelib_TypeClass_DOUBLE:
+            if (nREG < MAX_FP_REGS) {
+#ifdef BRDEBUG
+              fprintf(stderr, "cpp2uno_call:fpr=%p\n", fpreg[nREG]);
+#endif
+              pCppArgs[nPos] = &(fpreg[nREG]);
+              pUnoArgs[nPos] = &(fpreg[nREG]);
+            } else {
+#ifdef BRDEBUG
+              fprintf(stderr, "cpp2uno_call:fpr=%p\n", ovrflw[nREG - MAX_FP_REGS]);
+#endif
+              pCppArgs[nPos] = &(ovrflw[nREG - MAX_FP_REGS]);
+              pUnoArgs[nPos] = &(ovrflw[nREG - MAX_FP_REGS]);
+            }
+            nREG++;
+            break;
+
+
+          default:
+            if (nREG < MAX_GP_REGS) {
+#ifdef BRDEBUG
+              fprintf(stderr, "cpp2uno_call:gpr=%p\n", gpreg[nREG]);
+#endif
+              pCppArgs[nPos] = &(gpreg[nREG]);
+              pUnoArgs[nPos] = &(gpreg[nREG]);
+            } else {
+#ifdef BRDEBUG
+              fprintf(stderr, "cpp2uno_call:gpr=%p\n", ovrflw[nREG - MAX_GP_REGS]);
+#endif
+              pCppArgs[nPos] = &(ovrflw[nREG - MAX_GP_REGS]);
+              pUnoArgs[nPos] = &(ovrflw[nREG - MAX_GP_REGS]);
+            }
+            nREG++;
+            break;
+
+        }
+        // no longer needed
+        TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+      }
+      else // ptr to complex value | ref
+      {
+#ifdef BRDEBUG
+        fprintf(stderr,"cpp2uno_call:ptr|ref\n");
+#endif
+        void *pCppStack;
+        if (nREG < MAX_GP_REGS) {
+          pCppArgs[nPos] = pCppStack = gpreg[nREG];
+        } else {
+          pCppArgs[nPos] = pCppStack = ovrflw[nREG - MAX_GP_REGS];
+        }
+        nREG++;
+#ifdef BRDEBUG
+        fprintf(stderr, "cpp2uno_call:pCppStack=%p\n", pCppStack);
+#endif
+
+        if (! rParam.bIn) // is pure out
+        {
+          // uno out is unconstructed mem!
+          pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
+          pTempIndices[nTempIndices] = nPos;
+          // will be released at reconversion
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+        }
+        // is in/inout
+        else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
+        {
+          uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+              pCppStack, pParamTypeDescr,
+              pThis->getBridge()->getCpp2Uno() );
+          pTempIndices[nTempIndices] = nPos; // has to be reconverted
+          // will be released at reconversion
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+#ifdef BRDEBUG
+          fprintf(stderr, "cpp2uno_call:related to interface,%p,%d,pUnoargs[%d]=%p\n",
+                          pCppStack, pParamTypeDescr->nSize, nPos, pUnoArgs[nPos]);
+#endif
+        }
+        else // direct way
+        {
+          pUnoArgs[nPos] = pCppStack;
+#ifdef BRDEBUG
+          fprintf(stderr, "cpp2uno_call:direct,pUnoArgs[%d]=%p\n", nPos, pUnoArgs[nPos]);
+#endif
+          // no longer needed
+          TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+      }
+    }
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp2uno_call2,%p,unoargs=%p\n", pThis->getUnoI()->pDispatcher, pUnoArgs);
+#endif
+
+    // ExceptionHolder
+    uno_Any aUnoExc; // Any will be constructed by callee
+    uno_Any * pUnoExc = &aUnoExc;
+
+    // invoke uno dispatch call
+    (*pThis->getUnoI()->pDispatcher)( pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp2uno_call2,after dispatch\n");
+#endif
+
+    // in case an exception occurred...
+    if (pUnoExc)
+    {
+      // destruct temporary in/inout params
+      for ( ; nTempIndices--; )
+      {
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+
+        if (pParams[nIndex].bIn) // is in/inout => was constructed
+          uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
+      }
+      if (pReturnTypeDescr)
+        TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+
+      CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc, pThis->getBridge()->getUno2Cpp() );
+      // has to destruct the any
+      // is here for dummy
+      return typelib_TypeClass_VOID;
+    }
+    else // else no exception occurred...
+    {
+      // temporary params
+      for ( ; nTempIndices--; )
+      {
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
+
+        if (pParams[nIndex].bOut) // inout/out
+        {
+          // convert and assign
+          uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+          uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
+              pThis->getBridge()->getUno2Cpp() );
+        }
+        // destroy temp uno param
+        uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
+
+        TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+      }
+      // return
+      if (pCppReturn) // has complex return
+      {
+        if (pUnoReturn != pCppReturn) // needs reconversion
+        {
+          uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
+              pThis->getBridge()->getUno2Cpp() );
+          // destroy temp uno return
+          uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
+        }
+        // complex return ptr is set to return reg
+        *(void **)pRegisterReturn = pCppReturn;
+      }
+      if (pReturnTypeDescr)
+      {
+        typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;
+        TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+        return eRet;
+      }
+      else
+        return typelib_TypeClass_VOID;
+    }
+  }
+
+
+  /**
+   * is called on incoming vtable calls
+   * (called by asm snippets)
+   */
+  typelib_TypeClass cpp_vtable_call(
+      sal_Int32 nFunctionIndex,
+      sal_Int32 nVtableOffset,
+      void ** gpreg, void ** fpreg, void ** ovrflw,
+      sal_uInt64 * pRegisterReturn /* space for register return */ )
+  {
+    static_assert( sizeof(sal_Int64)==sizeof(void *), "### unexpected!" );
+
+#ifdef BRDEBUG
+    fprintf(stderr, "in cpp_vtable_call nFunctionIndex is %d\n", nFunctionIndex);
+    fprintf(stderr, "in cpp_vtable_call nVtableOffset is %d\n", nVtableOffset);
+    fprintf(stderr, "in cpp_vtable_call gp=%p, fp=%p, ov=%p\n", gpreg, fpreg, ovrflw);
+#endif
+
+    // gpreg:  [ret *], this, [other gpr params]
+    // fpreg:  [fpr params]
+    // ovrflw: [gpr or fpr params (properly aligned)]
+    void * pThis;
+    if (nFunctionIndex & 0x80000000 )
+    {
+      nFunctionIndex &= 0x7fffffff;
+      pThis = gpreg[1];
+    }
+    else
+    {
+      pThis = gpreg[0];
+    }
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call, pThis=%p, nFunctionIndex=%d, nVtableOffset=%d\n",
+                pThis, nFunctionIndex, nVtableOffset);
+#endif
+
+    pThis = static_cast< char * >(pThis) - nVtableOffset;
+    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
+        bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy( pThis );
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call, pCppI=%p\n", pCppI);
+#endif
+
+    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
+
+    if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
+    {
+      SAL_WARN(
+          "bridges",
+          "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
+              << " vtable index " << nFunctionIndex << "/"
+              << pTypeDescr->nMapFunctionIndexToMemberIndex);
+      throw RuntimeException(
+          ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
+           + " vtable index " + OUString::number(nFunctionIndex) + "/"
+           + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
+          (XInterface *)pThis);
+    }
+
+    // determine called method
+    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
+    assert(nMemberPos < pTypeDescr->nAllMembers);
+
+    TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
+
+#ifdef BRDEBUG
+    OString cstr( OUStringToOString( aMemberDescr.get()->pTypeName, RTL_TEXTENCODING_ASCII_US ) );
+    fprintf(stderr, "calling %s, nFunctionIndex=%d\n", cstr.getStr(), nFunctionIndex );
+#endif
+    typelib_TypeClass eRet;
+    switch (aMemberDescr.get()->eTypeClass)
+    {
+      case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+        {
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call interface attribute\n");
+#endif
+          typelib_TypeDescriptionReference *pAttrTypeRef =
+              reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( aMemberDescr.get() )->pAttributeTypeRef;
+
+          if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
+          {
+            // is GET method
+            eRet = cpp2uno_call( pCppI, aMemberDescr.get(), pAttrTypeRef,
+                0, 0, // no params
+                gpreg, fpreg, ovrflw, pRegisterReturn );
+          }
+          else
+          {
+            // is SET method
+            typelib_MethodParameter aParam;
+            aParam.pTypeRef = pAttrTypeRef;
+            aParam.bIn      = sal_True;
+            aParam.bOut     = sal_False;
+
+            eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
+                0, // indicates void return
+                1, &aParam,
+                gpreg, fpreg, ovrflw, pRegisterReturn );
+          }
+          break;
+        }
+      case typelib_TypeClass_INTERFACE_METHOD:
+        {
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call interface method\n");
+#endif
+          // is METHOD
+          switch (nFunctionIndex)
+          {
+            case 1: // acquire()
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call method acquire\n");
+#endif
+              pCppI->acquireProxy(); // non virtual call!
+              eRet = typelib_TypeClass_VOID;
+              break;
+            case 2: // release()
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call method release\n");
+#endif
+              pCppI->releaseProxy(); // non virtual call!
+              eRet = typelib_TypeClass_VOID;
+              break;
+            case 0: // queryInterface() opt
+              {
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call method query interface opt\n");
+#endif
+                typelib_TypeDescription * pTD = 0;
+                TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( gpreg[2] )->getTypeLibType() );
+                if (pTD)
+                {
+                  XInterface * pInterface = 0;
+                  (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)
+                      ( pCppI->getBridge()->getCppEnv(),
+                      (void **)&pInterface,
+                      pCppI->getOid().pData,
+                      reinterpret_cast<typelib_InterfaceTypeDescription *>( pTD ) );
+
+                  if (pInterface)
+                  {
+                    ::uno_any_construct( reinterpret_cast< uno_Any * >( gpreg[0] ),
+                                         &pInterface, pTD, cpp_acquire );
+
+                    pInterface->release();
+                    TYPELIB_DANGER_RELEASE( pTD );
+
+                    reinterpret_cast<void **>( pRegisterReturn )[0] = gpreg[0];
+                    eRet = typelib_TypeClass_ANY;
+                    break;
+                  }
+                  TYPELIB_DANGER_RELEASE( pTD );
+                }
+              } // else perform queryInterface()
+            default:
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call method query interface\n");
+#endif
+              typelib_InterfaceMethodTypeDescription *pMethodTD =
+                  reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( aMemberDescr.get() );
+
+              eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
+                  pMethodTD->pReturnTypeRef,
+                  pMethodTD->nParams,
+                  pMethodTD->pParams,
+                  gpreg, fpreg, ovrflw, pRegisterReturn );
+          }
+          break;
+        }
+      default:
+        {
+#ifdef BRDEBUG
+    fprintf(stderr, "cpp_vtable_call no member\n");
+#endif
+          throw RuntimeException( "no member description found!", (XInterface *)pThis );
+        }
+    }
+
+    return eRet;
+  }
+
+  extern "C" void privateSnippetExecutor( ... );
+
+  int const codeSnippetSize = 0x44;
+
+  unsigned char *  codeSnippet( unsigned char * code,
+      sal_Int32 functionIndex, sal_Int32 vtableOffset,
+      bool bHasHiddenParam) SAL_THROW(())
+  {
+#ifdef BRDEBUG
+     fprintf(stderr,"in codeSnippet functionIndex is %d\n", functionIndex);
+     fprintf(stderr,"in codeSnippet vtableOffset is %d\n", vtableOffset);
+     fflush(stderr);
+#endif
+
+    if ( bHasHiddenParam )
+      functionIndex |= 0x80000000;
+
+    unsigned int * p = (unsigned int *) code;
+
+    assert((((unsigned long)code) & 0x3) == 0 );  //aligned to 4 otherwise a mistake
+
+    /* generate this code */
+    /*
+       # index
+        0:   3c020000        lui     v0,0x0
+        4:   34420000        ori     v0,v0,0x0
+       # privateSnippetExecutor
+        8:   3c0c0000        lui     t0,0x0
+        c:   358c0000        ori     t0,t0,0x0
+       10:   000c6438        dsll    t0,t0,0x10
+       14:   358c0000        ori     t0,t0,0x0
+       18:   000c6438        dsll    t0,t0,0x10
+       1c:   358c0000        ori     t0,t0,0x0
+       # cpp_vtable_call
+       20:   3c190000        lui     t9,0x0
+       24:   37390000        ori     t9,t9,0x0
+       28:   0019cc38        dsll    t9,t9,0x10
+       2c:   37390000        ori     t9,t9,0x0
+       30:   0019cc38        dsll    t9,t9,0x10
+       34:   37390000        ori     t9,t9,0x0
+       # offset
+       38:   3c030000        lui     v1,0x0
+       3c:   01800008        jr      t0
+       40:   34630000        ori     v1,v1,0x0
+     */
+
+    * p++ = 0x3c020000 | ((functionIndex>>16) & 0x0000ffff);
+    * p++ = 0x34420000 | (functionIndex & 0x0000ffff);
+    * p++ = 0x3c0c0000 | ((((unsigned long)privateSnippetExecutor) >> 48) & 0x0000ffff);
+    * p++ = 0x358c0000 | ((((unsigned long)privateSnippetExecutor) >> 32) & 0x0000ffff);
+    * p++ = 0x000c6438;
+    * p++ = 0x358c0000 | ((((unsigned long)privateSnippetExecutor) >> 16) & 0x0000ffff);
+    * p++ = 0x000c6438;
+    * p++ = 0x358c0000 | (((unsigned long)privateSnippetExecutor) & 0x0000ffff);
+    * p++ = 0x3c190000 | ((((unsigned long)cpp_vtable_call) >> 48) & 0x0000ffff);
+    * p++ = 0x37390000 | ((((unsigned long)cpp_vtable_call) >> 32) & 0x0000ffff);
+    * p++ = 0x0019cc38;
+    * p++ = 0x37390000 | ((((unsigned long)cpp_vtable_call) >> 16) & 0x0000ffff);
+    * p++ = 0x0019cc38;
+    * p++ = 0x37390000 | (((unsigned long)cpp_vtable_call) & 0x0000ffff);
+    * p++ = 0x3c030000 | ((vtableOffset>>16) & 0x0000ffff);
+    * p++ = 0x01800008;
+    * p++ = 0x34630000 | (vtableOffset & 0x0000ffff);
+    return (code + codeSnippetSize);
+
+  }
+
+}
+
+
+void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const *bptr, unsigned char const *eptr)
+{
+#ifndef ANDROID
+  (void) bptr;
+  (void) eptr;
+  sysmips(FLUSH_CACHE, 0, 0, 0);
+#else
+  cacheflush((long) bptr, (long) eptr, 0);
+#endif
+}
+
+struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
+
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
+{
+    return static_cast< Slot * >(block) + 2;
+}
+
+
+sal_Size bridges::cpp_uno::shared::VtableFactory::getBlockSize(
+    sal_Int32 slotCount)
+{
+    return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
+}
+
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::initializeBlock(
+    void * block, sal_Int32 slotCount, sal_Int32,
+    typelib_InterfaceTypeDescription *)
+{
+    Slot * slots = mapBlockToVtable(block);
+    slots[-2].fn = 0; //null
+    slots[-1].fn = 0; //destructor
+    return slots + slotCount;
+}
+
+unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
+    typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
+    sal_Int32 functionCount, sal_Int32 vtableOffset)
+{
+   (*slots) -= functionCount;
+    Slot * s = *slots;
+
+#ifdef BRDEBUG
+   fprintf(stderr, "in addLocalFunctions functionOffset is %d\n", functionOffset);
+   fprintf(stderr, "in addLocalFunctions vtableOffset is %d\n", vtableOffset);
+   fprintf(stderr, "nMembers=%d\n", type->nMembers);
+   fflush(stderr);
+#endif
+
+  for (sal_Int32 i = 0; i < type->nMembers; ++i) {
+    typelib_TypeDescription * member = 0;
+    TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
+    assert(member != 0);
+    switch (member->eTypeClass) {
+      case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+        // Getter:
+        (s++)->fn = code + writetoexecdiff;
+        code = codeSnippet(
+            code, functionOffset++, vtableOffset,
+            CPPU_CURRENT_NAMESPACE::return_in_hidden_param(
+              reinterpret_cast<
+              typelib_InterfaceAttributeTypeDescription * >(
+                member)->pAttributeTypeRef));
+
+        // Setter:
+        if (!reinterpret_cast<
+            typelib_InterfaceAttributeTypeDescription * >(
+              member)->bReadOnly)
+        {
+          (s++)->fn = code + writetoexecdiff;
+          code = codeSnippet(code, functionOffset++, vtableOffset, false);
+        }
+        break;
+
+      case typelib_TypeClass_INTERFACE_METHOD:
+        (s++)->fn = code + writetoexecdiff;
+        code = codeSnippet(
+            code, functionOffset++, vtableOffset,
+            CPPU_CURRENT_NAMESPACE::return_in_hidden_param(
+              reinterpret_cast<
+              typelib_InterfaceMethodTypeDescription * >(
+                member)->pReturnTypeRef));
+        break;
+
+      default:
+        assert(false);
+        break;
+    }
+    TYPELIB_DANGER_RELEASE(member);
+  }
+  return code;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/except.cxx b/bridges/source/cpp_uno/gcc3_linux_mips64/except.cxx
new file mode 100644
index 000000000000..339bd27433da
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/except.cxx
@@ -0,0 +1,300 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#include <stdio.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <cxxabi.h>
+#include <rtl/strbuf.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <osl/mutex.hxx>
+
+#include <com/sun/star/uno/genfunc.hxx>
+#include <typelib/typedescription.hxx>
+#include <uno/any2.h>
+
+#include <unordered_map>
+#include "share.hxx"
+
+
+using namespace ::std;
+using namespace ::osl;
+using namespace ::com::sun::star::uno;
+using namespace ::__cxxabiv1;
+
+
+namespace CPPU_CURRENT_NAMESPACE
+{
+
+void dummy_can_throw_anything( char const * )
+{
+}
+
+static OUString toUNOname( char const * p )
+{
+#if defined BRIDGES_DEBUG
+    char const * start = p;
+#endif
+
+    // example: N3com3sun4star4lang24IllegalArgumentExceptionE
+
+    OUStringBuffer buf( 64 );
+    assert( 'N' == *p );
+    ++p; // skip N
+
+    while ('E' != *p)
+    {
+        // read chars count
+        long n = (*p++ - '0');
+        while ('0' <= *p && '9' >= *p)
+        {
+            n *= 10;
+            n += (*p++ - '0');
+        }
+        buf.appendAscii( p, n );
+        p += n;
+        if ('E' != *p)
+            buf.append( '.' );
+    }
+
+#if defined BRIDGES_DEBUG
+    OUString ret( buf.makeStringAndClear() );
+    OString c_ret( OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ) );
+    fprintf( stderr, "> toUNOname(): %s => %s\n", start, c_ret.getStr() );
+    return ret;
+#else
+    return buf.makeStringAndClear();
+#endif
+}
+
+class RTTI
+{
+    typedef std::unordered_map< OUString, type_info *, OUStringHash > t_rtti_map;
+
+    Mutex m_mutex;
+    t_rtti_map m_rttis;
+    t_rtti_map m_generatedRttis;
+
+    void * m_hApp;
+
+public:
+    RTTI();
+    ~RTTI();
+
+    type_info * getRTTI( typelib_CompoundTypeDescription * );
+};
+
+RTTI::RTTI()
+    : m_hApp( dlopen( 0, RTLD_LAZY ) )
+{
+}
+
+RTTI::~RTTI()
+{
+    dlclose( m_hApp );
+}
+
+
+type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr )
+{
+    type_info * rtti;
+
+    OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;
+
+    MutexGuard guard( m_mutex );
+    t_rtti_map::const_iterator iRttiFind( m_rttis.find( unoName ) );
+    if (iRttiFind == m_rttis.end())
+    {
+        // RTTI symbol
+        OStringBuffer buf( 64 );
+        buf.append( "_ZTIN" );
+        sal_Int32 index = 0;
+        do
+        {
+            OUString token( unoName.getToken( 0, '.', index ) );
+            buf.append( token.getLength() );
+            OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );
+            buf.append( c_token );
+        }
+        while (index >= 0);
+        buf.append( 'E' );
+
+        OString symName( buf.makeStringAndClear() );
+        rtti = (type_info *)dlsym( m_hApp, symName.getStr() );
+
+        if (rtti)
+        {
+            pair< t_rtti_map::iterator, bool > insertion(
+                m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
+            assert(insertion.second && "### inserting new rtti failed?!");
+        }
+        else
+        {
+            // try to lookup the symbol in the generated rtti map
+            t_rtti_map::const_iterator iFind( m_generatedRttis.find( unoName ) );
+            if (iFind == m_generatedRttis.end())
+            {
+                // we must generate it !
+                // symbol and rtti-name is nearly identical,
+                // the symbol is prefixed with _ZTI
+                char const * rttiName = symName.getStr() +4;
+#if defined BRIDGES_DEBUG
+                fprintf( stderr,"generated rtti for %s\n", rttiName );
+#endif
+                if (pTypeDescr->pBaseTypeDescription)
+                {
+                    // ensure availability of base
+                    type_info * base_rtti = getRTTI(
+                        (typelib_CompoundTypeDescription *)pTypeDescr->pBaseTypeDescription );
+                    rtti = new __si_class_type_info(
+                        strdup( rttiName ), (__class_type_info *)base_rtti );
+                }
+                else
+                {
+                    // this class has no base class
+                    rtti = new __class_type_info( strdup( rttiName ) );
+                }
+
+                pair< t_rtti_map::iterator, bool > insertion(
+                    m_generatedRttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
+                assert(insertion.second && "### inserting new generated rtti failed?!");
+            }
+            else // taking already generated rtti
+            {
+                rtti = iFind->second;
+            }
+        }
+    }
+    else
+    {
+        rtti = iRttiFind->second;
+    }
+
+    return rtti;
+}
+
+
+static void deleteException( void * pExc )
+{
+    __cxa_exception const * header = ((__cxa_exception const *)pExc - 1);
+    typelib_TypeDescription * pTD = 0;
+    OUString unoName( toUNOname( header->exceptionType->name() ) );
+    ::typelib_typedescription_getByName( &pTD, unoName.pData );
+    assert(pTD && "### unknown exception type! leaving out destruction => leaking!!!");
+    if (pTD)
+    {
+        ::uno_destructData( pExc, pTD, cpp_release );
+        ::typelib_typedescription_release( pTD );
+    }
+}
+
+void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )
+{
+#if defined BRIDGES_DEBUG
+    OString cstr(
+        OUStringToOString(
+            OUString::unacquired( &pUnoExc->pType->pTypeName ),
+            RTL_TEXTENCODING_ASCII_US ) );
+    fprintf( stderr, "> uno exception occurred: %s\n", cstr.getStr() );
+#endif
+    void * pCppExc;
+    type_info * rtti;
+
+    {
+    // construct cpp exception object
+    typelib_TypeDescription * pTypeDescr = 0;
+    TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );
+    assert(pTypeDescr);
+    if (! pTypeDescr)
+    {
+        throw RuntimeException(
+            OUString("cannot get typedescription for type ") +
+            OUString::unacquired( &pUnoExc->pType->pTypeName ) );
+    }
+
+    pCppExc = __cxa_allocate_exception( pTypeDescr->nSize );
+    ::uno_copyAndConvertData( pCppExc, pUnoExc->pData, pTypeDescr, pUno2Cpp );
+
+    // destruct uno exception
+    ::uno_any_destruct( pUnoExc, 0 );
+    // avoiding locked counts
+    static RTTI * s_rtti = 0;
+    if (! s_rtti)
+    {
+        MutexGuard guard( Mutex::getGlobalMutex() );
+        if (! s_rtti)
+        {
+#ifdef LEAK_STATIC_DATA
+            s_rtti = new RTTI();
+#else
+            static RTTI rtti_data;
+            s_rtti = &rtti_data;
+#endif
+        }
+    }
+    rtti = (type_info *)s_rtti->getRTTI( (typelib_CompoundTypeDescription *) pTypeDescr );
+    TYPELIB_DANGER_RELEASE( pTypeDescr );
+    assert(rtti && "### no rtti for throwing exception!");
+    if (! rtti)
+    {
+        throw RuntimeException(
+            OUString("no rtti for type ") +
+            OUString::unacquired( &pUnoExc->pType->pTypeName ) );
+    }
+    }
+
+    __cxa_throw( pCppExc, rtti, deleteException );
+}
+
+void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping * pCpp2Uno )
+{
+    if (! header)
+    {
+        RuntimeException aRE( "no exception header!" );
+        Type const & rType = cppu::UnoType<decltype(aRE)>::get();
+        uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
+        SAL_WARN("bridges", aRE.Message);
+        return;
+    }
+
+    typelib_TypeDescription * pExcTypeDescr = 0;
+    OUString unoName( toUNOname( header->exceptionType->name() ) );
+#if defined BRIDGES_DEBUG
+    OString cstr_unoName( OUStringToOString( unoName, RTL_TEXTENCODING_ASCII_US ) );
+    fprintf( stderr, "> c++ exception occurred: %s\n", cstr_unoName.getStr() );
+#endif
+    typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );
+    if (0 == pExcTypeDescr)
+    {
+        RuntimeException aRE( OUString("exception type not found: ") + unoName );
+        Type const & rType = cppu::UnoType<decltype(aRE)>::get();
+        uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
+        SAL_WARN("bridges", aRE.Message);
+    }
+    else
+    {
+        // construct uno exception any
+        uno_any_constructAndConvert( pUnoExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );
+        typelib_typedescription_release( pExcTypeDescr );
+    }
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/share.hxx b/bridges/source/cpp_uno/gcc3_linux_mips64/share.hxx
new file mode 100644
index 000000000000..03badeb2e096
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/share.hxx
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_MIPS64_SHARE_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_MIPS64_SHARE_HXX
+
+#include "uno/mapping.h"
+
+#include <typeinfo>
+#include <exception>
+#include <cstddef>
+
+#define MAX_GP_REGS    (8)
+#define MAX_FP_REGS    (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
+{
+    unsigned exception_class __attribute__((__mode__(__DI__)));
+    void * exception_cleanup;
+    unsigned private_1 __attribute__((__mode__(__word__)));
+    unsigned private_2 __attribute__((__mode__(__word__)));
+} __attribute__((__aligned__));
+
+struct __cxa_exception
+{
+    ::std::type_info *exceptionType;
+    void (*exceptionDestructor)(void *);
+
+    ::std::unexpected_handler unexpectedHandler;
+    ::std::terminate_handler terminateHandler;
+
+    __cxa_exception *nextException;
+
+    int handlerCount;
+
+    int handlerSwitchValue;
+    const unsigned char *actionRecord;
+    const unsigned char *languageSpecificData;
+    void *catchTemp;
+    void *adjustedPtr;
+
+    _Unwind_Exception unwindHeader;
+};
+
+extern "C" void *__cxa_allocate_exception(
+    std::size_t thrown_size ) throw();
+extern "C" void __cxa_throw (
+    void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) ) __attribute__((noreturn));
+
+struct __cxa_eh_globals
+{
+    __cxa_exception *caughtExceptions;
+    unsigned int uncaughtExceptions;
+};
+extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
+
+
+void raiseException(
+    uno_Any * pUnoExc, uno_Mapping * pUno2Cpp );
+
+void fillUnoException(
+    __cxa_exception * header, uno_Any *, uno_Mapping * pCpp2Uno );
+
+bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef );
+}
+
+#endif
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_mips64/uno2cpp.cxx
new file mode 100644
index 000000000000..e7cd63fc6fd1
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_linux_mips64/uno2cpp.cxx
@@ -0,0 +1,576 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <malloc.h>
+#include <cstring>
+
+#include <com/sun/star/uno/genfunc.hxx>
+#include <uno/data.h>
+
+#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"
+
+//#define BRDEBUG
+#ifdef BRDEBUG
+#include <stdio.h>
+#endif
+
+#define INSERT_FLOAT_DOUBLE( pSV, nr, pFPR, pDS ) \
+    if ( nr < MAX_FP_REGS ) \
+        pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!
+
+#define INSERT_INT64( pSV, nr, pGPR, pDS ) \
+    if ( nr < MAX_GP_REGS ) \
+        pGPR[nr++] = *reinterpret_cast<sal_Int64 *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_Int64 *>( pSV );
+
+#define INSERT_INT32( pSV, nr, pGPR, pDS ) \
+    if ( nr < MAX_GP_REGS ) \
+        pGPR[nr++] = *reinterpret_cast<sal_Int32 *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_Int32 *>( pSV );
+
+#define INSERT_INT16( pSV, nr, pGPR, pDS ) \
+    if ( nr < MAX_GP_REGS ) \
+        pGPR[nr++] = *reinterpret_cast<sal_Int16 *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_Int16 *>( pSV );
+
+#define INSERT_UINT16( pSV, nr, pGPR, pDS ) \
+    if ( nr < MAX_GP_REGS ) \
+        pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
+
+#define INSERT_INT8( pSV, nr, pGPR, pDS ) \
+    if ( nr < MAX_GP_REGS ) \
+        pGPR[nr++] = *reinterpret_cast<sal_Int8 *>( pSV ); \
+    else \
+        *pDS++ = *reinterpret_cast<sal_Int8 *>( pSV );
+
+using namespace ::com::sun::star::uno;
+
+namespace
+{
+
+  bool isReturnInFPR(const typelib_TypeDescription * pTypeDescr, sal_uInt32 & nSize)
+  {
+      const typelib_CompoundTypeDescription *p =
+                  reinterpret_cast<const typelib_CompoundTypeDescription*>( pTypeDescr );
+
+      for (sal_Int32 i = 0; i < p->nMembers; ++i)
+      {
+          typelib_TypeDescriptionReference *pTypeInStruct = p->ppTypeRefs[ i ];
+
+          switch (pTypeInStruct->eTypeClass)
+          {
+          case typelib_TypeClass_STRUCT:
+          case typelib_TypeClass_EXCEPTION:
+              {
+                  typelib_TypeDescription * t = 0;
+                  TYPELIB_DANGER_GET(&t, pTypeInStruct);
+                  bool isFPR = isReturnInFPR(t, nSize);
+                  TYPELIB_DANGER_RELEASE(t);
+                  if (!isFPR)
+                    return false;
+              }
+              break;
+          case typelib_TypeClass_FLOAT:
+          case typelib_TypeClass_DOUBLE:
+              if (nSize >= 16)
+                return false;
+              nSize += 8;
+              break;
+          default:
+              return false;
+              break;
+          }
+      }
+      return true;
+  }
+
+  void fillReturn(const typelib_TypeDescription * pTypeDescr,
+                    sal_Int64 * gret, double * fret, void * pRegisterReturn)
+  {
+      sal_uInt32 nSize = 0;
+      if (isReturnInFPR(pTypeDescr, nSize))
+      {
+          reinterpret_cast<double *>( pRegisterReturn )[0] = fret[0];
+          reinterpret_cast<double *>( pRegisterReturn )[1] = fret[1];
+      }
+      else
+      {
+          reinterpret_cast<sal_Int64 *>( pRegisterReturn )[0] = gret[0];
+          reinterpret_cast<sal_Int64 *>( pRegisterReturn )[1] = gret[1];
+      }
+  }
+
+  static void callVirtualMethod(
+      void * pAdjustedThisPtr,
+      sal_Int32 nVtableIndex,
+      void * pRegisterReturn,
+      typelib_TypeDescriptionReference * pReturnTypeRef,
+      bool bSimpleReturn,
+      sal_uInt64 *pStack,
+      sal_uInt32 nStack,
+      sal_uInt64 *pGPR,
+      double *pFPR,
+      sal_uInt32 nREG)
+  {
+    // Should not happen, but...
+    static_assert( MAX_GP_REGS == MAX_FP_REGS );
+    if ( nREG > MAX_GP_REGS )
+        nREG = MAX_GP_REGS;
+
+    // Get pointer to method
+    sal_uInt64 pMethod = *((sal_uInt64 *)pAdjustedThisPtr);
+    pMethod += 8 * nVtableIndex;
+    void *mfunc = (void *) *((sal_uInt64 *)pMethod);
+#ifdef BRDEBUG
+    fprintf(stderr, "calling function %p\n", mfunc);
+#endif
+
+    // Load parameters to stack, if necessary
+    sal_uInt64* pCallStack = NULL;
+    if ( nStack )
+    {
+        // 16-bytes aligned
+        sal_uInt32 nStackBytes = ( ( nStack + 1 ) >> 1 ) * 16;
+        pCallStack = (sal_uInt64 *) __builtin_alloca( nStackBytes );
+        std::memcpy( pCallStack, pStack, nStackBytes );
+    }
+
+    sal_Int64 gret[2];
+    double fret[2];
+    asm volatile (
+        ".set push \n\t"
+        ".set mips64 \n\t"
+        // Fill the general purpose registers
+        "ld $4, 0(%[gpr]) \n\t"
+        "ld $5, 8(%[gpr]) \n\t"
+        "ld $6, 16(%[gpr]) \n\t"
+        "ld $7, 24(%[gpr]) \n\t"
+        "ld $8, 32(%[gpr]) \n\t"
+        "ld $9, 40(%[gpr]) \n\t"
+        "ld $10, 48(%[gpr]) \n\t"
+        "ld $11, 56(%[gpr]) \n\t"
+        // Fill the floating pointer registers
+        "ldc1 $f12, 0(%[fpr]) \n\t"
+        "ldc1 $f13, 8(%[fpr]) \n\t"
+        "ldc1 $f14, 16(%[fpr]) \n\t"
+        "ldc1 $f15, 24(%[fpr]) \n\t"
+        "ldc1 $f16, 32(%[fpr]) \n\t"
+        "ldc1 $f17, 40(%[fpr]) \n\t"
+        "ldc1 $f18, 48(%[fpr]) \n\t"
+        "ldc1 $f19, 56(%[fpr]) \n\t"
+        // Perform the call
+        "jalr %[mfunc] \n\t"
+        // Fill the return values
+        "move %[gret1], $2 \n\t"
+        "move %[gret2], $3 \n\t"
+        "mov.d %[fret1], $f0 \n\t"
+        "mov.d %[fret2], $f2 \n\t"
+        ".set pop \n\t"
+        :[gret1]"=r"(gret[0]), [gret2]"=r"(gret[1]),
+         [fret1]"=f"(fret[0]), [fret2]"=f"(fret[1])
+        :[gpr]"r"(pGPR), [fpr]"r"(pFPR), [mfunc]"c"(mfunc),
+         [stack]"m"(pCallStack) // dummy input to prevent the compiler from optimizing the alloca out
+        :"$2", "$3", "$4", "$5", "$6", "$7", "$8",
+         "$9", "$10", "$11", "$31",
+         "$f0", "$f2", "$f12", "$f13", "$f14", "$f15",
+         "$f16", "$f17", "$f18", "$f19", "memory"
+    );
+
+    switch (pReturnTypeRef->eTypeClass)
+    {
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+    case typelib_TypeClass_ENUM:
+    case typelib_TypeClass_CHAR:
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+    case typelib_TypeClass_BOOLEAN:
+    case typelib_TypeClass_BYTE:
+        *reinterpret_cast<sal_Int64 *>( pRegisterReturn ) = gret[0];
+        break;
+    case typelib_TypeClass_FLOAT:
+    case typelib_TypeClass_DOUBLE:
+        *reinterpret_cast<double *>( pRegisterReturn ) = fret[0];
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        {
+            sal_Int32 const nRetSize = pReturnTypeRef->pType->nSize;
+            if (bSimpleReturn && nRetSize <= 16 && nRetSize > 0)
+            {
+                typelib_TypeDescription * pTypeDescr = 0;
+                TYPELIB_DANGER_GET( &pTypeDescr, pReturnTypeRef );
+                fillReturn(pTypeDescr, gret, fret, pRegisterReturn);
+                TYPELIB_DANGER_RELEASE( pTypeDescr );
+            }
+            break;
+        }
+    default:
+#ifdef BRDEBUG
+        fprintf(stderr,"unhandled return type %u\n", pReturnTypeRef->eTypeClass);
+#endif
+        break;
+    }
+  }
+
+
+  static void cpp_call(
+      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 )
+  {
+    // max space for: [complex ret ptr], values|ptr ...
+    sal_uInt64 *pStack = (sal_uInt64 *)__builtin_alloca( ((nParams+3) * sizeof(sal_Int64)) );
+    sal_uInt64 *pStackStart = pStack;
+
+    sal_uInt64 pGPR[MAX_GP_REGS];
+    double pFPR[MAX_FP_REGS];
+    sal_uInt32 nREG = 0;
+
+#ifdef BRDEBUG
+  fprintf(stderr, "in cpp_call\n");
+#endif
+
+    // return
+    typelib_TypeDescription * pReturnTypeDescr = 0;
+    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
+    assert( pReturnTypeDescr, "### expected return type description!" );
+
+    void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
+
+    bool bSimpleReturn = true;
+    if (pReturnTypeDescr)
+    {
+      if ( CPPU_CURRENT_NAMESPACE::return_in_hidden_param( pReturnTypeRef ) )
+      {
+        bSimpleReturn = false;
+        // complex return via ptr
+        pCppReturn = bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )?
+                     __builtin_alloca( pReturnTypeDescr->nSize ) : pUnoReturn;
+        INSERT_INT64( &pCppReturn, nREG, pGPR, pStack );
+      }
+      else
+      {
+        pCppReturn = pUnoReturn; // direct way for simple types
+      }
+    }
+
+    // push this
+    void* pAdjustedThisPtr = reinterpret_cast< void **>( pThis->getCppI() ) + aVtableSlot.offset;
+    INSERT_INT64( &pAdjustedThisPtr, nREG, pGPR, pStack );
+
+    // args
+    void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
+    // type descriptions for reconversions
+    typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
+
+    sal_Int32 nTempIndices   = 0;
+
+    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+    {
+      const typelib_MethodParameter & rParam = pParams[nPos];
+      typelib_TypeDescription * pParamTypeDescr = 0;
+      TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+
+      if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+      {
+        uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,
+            pThis->getBridge()->getUno2Cpp() );
+
+        switch (pParamTypeDescr->eTypeClass)
+        {
+          case typelib_TypeClass_LONG:
+          case typelib_TypeClass_UNSIGNED_LONG:
+          case typelib_TypeClass_ENUM:
+            INSERT_INT32( pCppArgs[nPos], nREG, pGPR, pStack );
+            break;
+          case typelib_TypeClass_CHAR:
+          case typelib_TypeClass_SHORT:
+            INSERT_INT16( pCppArgs[nPos], nREG, pGPR, pStack );
+            break;
+          case typelib_TypeClass_UNSIGNED_SHORT:
+            INSERT_UINT16( pCppArgs[nPos], nREG, pGPR, pStack );
+            break;
+          case typelib_TypeClass_BOOLEAN:
+          case typelib_TypeClass_BYTE:
+            INSERT_INT8( pCppArgs[nPos], nREG, pGPR, pStack );
+            break;
+          case typelib_TypeClass_FLOAT:
+          case typelib_TypeClass_DOUBLE:
+            INSERT_FLOAT_DOUBLE( pCppArgs[nPos], nREG, pFPR, pStack );
+            break;
+          case typelib_TypeClass_HYPER:
+          case typelib_TypeClass_UNSIGNED_HYPER:
+            INSERT_INT64( pCppArgs[nPos], nREG, pGPR, pStack );
+            break;
+          default:
+            break;
+        }
+
+        // no longer needed
+        TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+      }
+      else // ptr to complex value | ref
+      {
+        if (! rParam.bIn) // is pure out
+        {
+          // cpp out is constructed mem, uno out is not!
+          uno_constructData(
+              pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+              pParamTypeDescr );
+          pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
+          // will be released at reconversion
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+        }
+        // is in/inout
+        else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
+        {
+          uno_copyAndConvertData(
+              pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+              pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
+
+          pTempIndices[nTempIndices] = nPos; // has to be reconverted
+          // will be released at reconversion
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+        }
+        else // direct way
+        {
+          pCppArgs[nPos] = pUnoArgs[nPos];
+          // no longer needed
+          TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+        INSERT_INT64( &(pCppArgs[nPos]), nREG, pGPR, pStack );
+      }
+    }
+
+    try
+    {
+      callVirtualMethod(
+          pAdjustedThisPtr, aVtableSlot.index,
+          pCppReturn, pReturnTypeRef, bSimpleReturn,
+          pStackStart, ( pStack - pStackStart ),
+          pGPR, pFPR, nREG);
+      // NO exception occurred...
+      *ppUnoExc = 0;
+
+      // reconvert temporary params
+      for ( ; nTempIndices--; )
+      {
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
+
+        if (pParams[nIndex].bIn)
+        {
+          if (pParams[nIndex].bOut) // inout
+          {
+            uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
+            uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+                pThis->getBridge()->getCpp2Uno() );
+          }
+        }
+        else // pure out
+        {
+          uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+              pThis->getBridge()->getCpp2Uno() );
+        }
+        // destroy temp cpp param => cpp: every param was constructed
+        uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+
+        TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+      }
+      // return value
+      if (pCppReturn && pUnoReturn != pCppReturn)
+      {
+        uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
+            pThis->getBridge()->getCpp2Uno() );
+        uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
+      }
+    }
+    catch (...)
+    {
+      // fill uno exception
+      fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions,
+          *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
+
+      // temporary params
+      for ( ; nTempIndices--; )
+      {
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+        // destroy temp cpp param => cpp: every param was constructed
+        uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
+      }
+      // return type
+      if (pReturnTypeDescr)
+        TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+    }
+  }
+
+}
+
+
+namespace bridges { namespace cpp_uno { namespace shared {
+
+void unoInterfaceProxyDispatch(
+    uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
+    void * pReturn, void * pArgs[], uno_Any ** ppException )
+{
+  // is my surrogate
+  bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
+    = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI);
+  //typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
+
+#ifdef BRDEBUG
+  fprintf(stderr, "in dispatch\n");
+#endif
+
+  switch (pMemberDescr->eTypeClass)
+  {
+    case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+      {
+
+        VtableSlot aVtableSlot(
+            getVtableSlot(
+              reinterpret_cast<
+              typelib_InterfaceAttributeTypeDescription const * >(
+                pMemberDescr)));
+
+        if (pReturn)
+        {
+          // dependent dispatch
+          cpp_call(
+              pThis, aVtableSlot,
+              ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
+              0, 0, // no params
+              pReturn, pArgs, ppException );
+        }
+        else
+        {
+          // is SET
+          typelib_MethodParameter aParam;
+          aParam.pTypeRef =
+            ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
+          aParam.bIn        = sal_True;
+          aParam.bOut       = sal_False;
+
+          typelib_TypeDescriptionReference * pReturnTypeRef = 0;
+          OUString aVoidName("void");
+          typelib_typedescriptionreference_new(
+              &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
+
+          // dependent dispatch
+          aVtableSlot.index += 1; //get then set method
+          cpp_call(
+              pThis, aVtableSlot,
+              pReturnTypeRef,
+              1, &aParam,
+              pReturn, pArgs, ppException );
+
+          typelib_typedescriptionreference_release( pReturnTypeRef );
+        }
+
+        break;
+      }
+    case typelib_TypeClass_INTERFACE_METHOD:
+      {
+
+        VtableSlot aVtableSlot(
+            getVtableSlot(
+              reinterpret_cast<
+              typelib_InterfaceMethodTypeDescription const * >(
+                pMemberDescr)));
+        switch (aVtableSlot.index)
+        {
+          // standard calls
+          case 1: // acquire uno interface
+            (*pUnoI->acquire)( pUnoI );
+            *ppException = 0;
+            break;
+          case 2: // release uno interface
+            (*pUnoI->release)( pUnoI );
+            *ppException = 0;
+            break;
+          case 0: // queryInterface() opt
+            {
+              typelib_TypeDescription * pTD = 0;
+              TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
+              if (pTD)
+              {
+                uno_Interface * pInterface = 0;
+                (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(pThis->pBridge->getUnoEnv(),
+                                                                       (void **)&pInterface, pThis->oid.pData,
+                                                                       (typelib_InterfaceTypeDescription *)pTD );
+
+                if (pInterface)
+                {
+                  ::uno_any_construct(
+                      reinterpret_cast< uno_Any * >( pReturn ),
+                      &pInterface, pTD, 0 );
+                  (*pInterface->release)( pInterface );
+                  TYPELIB_DANGER_RELEASE( pTD );
+                  *ppException = 0;
+                  break;
+                }
+                TYPELIB_DANGER_RELEASE( pTD );
+              }
+            } // else perform queryInterface()
+          default:
+            // dependent dispatch
+            cpp_call(
+                pThis, aVtableSlot,
+                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
+                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
+                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
+                pReturn, pArgs, ppException );
+        }
+        break;
+      }
+    default:
+      {
+        ::com::sun::star::uno::RuntimeException aExc(
+            OUString("illegal member type description!"),
+            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
+
+        Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
+        // binary identical null reference
+        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
+      }
+  }
+}
+}}}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */