Attachment #177763 for bug #200020

Lines 79-85 Link Here

(-)Makefile (-1 / +6 lines)
79	${LOCALBASE}/share/fonts/LinLibertineG/LinLibertine_DR_G.ttf:x11-fonts/linuxlibertine-g	79	${LOCALBASE}/share/fonts/LinLibertineG/LinLibertine_DR_G.ttf:x11-fonts/linuxlibertine-g
80		80
81	CONFLICTS_INSTALL= libreoffice-5.*	81	CONFLICTS_INSTALL= libreoffice-5.*
82	ONLY_FOR_ARCHS= amd64 i386	82	ONLY_FOR_ARCHS= amd64 i386 powerpc64
83		83
84	_MAKE_JOBS= #	84	_MAKE_JOBS= #
85		85
Lines 101-106 Link Here
101		101
102	EXTRA_PATCHES= ${FILESDIR}/enable-opencollada:-p1	102	EXTRA_PATCHES= ${FILESDIR}/enable-opencollada:-p1
103	WRKSRC= ${WRKDIR}/${PORTNAME}-${LOVERSION}	103	WRKSRC= ${WRKDIR}/${PORTNAME}-${LOVERSION}
		104
		105	.if ${ARCH} == "powerpc64"
		106	EXTRA_PATCHES+= ${FILESDIR}/extra-enable_powerpc64.patch
		107	USE_GCC= 4.8+
		108	.endif
104		109
105	COLLADA_MODS= COLLADABaseUtils COLLADAFramework \	110	COLLADA_MODS= COLLADABaseUtils COLLADAFramework \




--- configure.ac.orig
+++ configure.ac
@@ -4189,6 +4189,11 @@
         CPUNAME=X86_64
         RTL_ARCH=X86_64
         PLATFORMID=freebsd_x86_64
+        ;;
+    powerpc64)
+        CPUNAME=POWERPC64
+        RTL_ARCH=PowerPC_64
+        PLATFORMID=freebsd_powerpc64
         ;;
     *)
         AC_MSG_ERROR([Unsupported host_cpu $host_cpu for host_os $host_os])
--- bridges/Library_cpp_uno.mk.orig
+++ bridges/Library_cpp_uno.mk
@@ -118,6 +118,12 @@
 bridge_asm_objects := call
 bridge_noopt_objects := except
 bridge_exception_objects := cpp2uno uno2cpp
+
+else ifeq ($(OS)-$(CPUNAME),FREEBSD-POWERPC64)
+
+bridges_SELECTED_BRIDGE := gcc3_freebsd_powerpc64
+bridge_noopt_objects := cpp2uno uno2cpp
+bridge_exception_objects := except
 
 else ifeq ($(CPUNAME),X86_64)
 
--- /dev/null
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/cpp2uno.cxx
@@ -0,0 +1,743 @@
+/* -*- 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 <uno/data.h>
+#include <typelib/typedescription.hxx>
+#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 "share.hxx"
+#include <stdio.h>
+#include <string.h>
+
+#ifdef OSL_BIGENDIAN
+#define IS_BIG_ENDIAN 1
+#else
+#define IS_BIG_ENDIAN 0
+#endif
+
+using namespace ::com::sun::star::uno;
+
+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_Int64 * pRegisterReturn /* space for register return */ )
+{
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "as far as cpp2uno_call\n");
+#endif
+
+    int ng = 0; //number of gpr registers used
+    int nf = 0; //number of fpr regsiters used
+
+    // gpreg:  [ret *], this, [gpr params]
+    // fpreg:  [fpr params]
+    // ovrflw: [gpr or fpr params (properly aligned)]
+
+    // 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 (!ppc64::return_in_hidden_param(pReturnTypeRef))
+        {
+            pUnoReturn = pRegisterReturn; // direct way for simple types
+        }
+        else // complex return via ptr (pCppReturn)
+        {
+            pCppReturn = *(void **)gpreg;
+            gpreg++;
+            ng++;
+
+            pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
+                          ? alloca( pReturnTypeDescr->nSize )
+                          : pCppReturn); // direct way
+        }
+    }
+    // pop this
+    gpreg++;
+    ng++;
+
+    // stack space
+    OSL_ENSURE( 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;
+    bool bOverflowUsed = false;
+    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 OSL_DEBUG_LEVEL > 2
+        fprintf(stderr, "arg %d of %d\n", nPos, nParams);
+#endif
+
+        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+        {
+#if OSL_DEBUG_LEVEL > 2
+            fprintf(stderr, "simple\n");
+#endif
+
+            switch (pParamTypeDescr->eTypeClass)
+            {
+                case typelib_TypeClass_FLOAT:
+                case typelib_TypeClass_DOUBLE:
+                    if (nf < ppc64::MAX_SSE_REGS)
+                    {
+                        if (pParamTypeDescr->eTypeClass == typelib_TypeClass_FLOAT)
+                        {
+                            float tmp = (float) (*((double *)fpreg));
+                            (*((float *) fpreg)) = tmp;
+                        }
+                        pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;
+                        nf++;
+                    }
+                    else
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;
+                        bOverflowUsed = true;
+                    }
+                    if (bOverflowUsed) ovrflw++;
+                    break;
+                case typelib_TypeClass_BYTE:
+                case typelib_TypeClass_BOOLEAN:
+                    if (ng < ppc64::MAX_GPR_REGS)
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 7*IS_BIG_ENDIAN);
+                        ng++;
+                        gpreg++;
+                    }
+                    else
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 7*IS_BIG_ENDIAN);
+                        bOverflowUsed = true;
+                    }
+                    if (bOverflowUsed) ovrflw++;
+                    break;
+                case typelib_TypeClass_CHAR:
+                case typelib_TypeClass_SHORT:
+                case typelib_TypeClass_UNSIGNED_SHORT:
+                    if (ng < ppc64::MAX_GPR_REGS)
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 6*IS_BIG_ENDIAN);
+                        ng++;
+                        gpreg++;
+                    }
+                    else
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 6*IS_BIG_ENDIAN);
+                        bOverflowUsed = true;
+                    }
+                    if (bOverflowUsed) ovrflw++;
+                    break;
+        case typelib_TypeClass_ENUM:
+                case typelib_TypeClass_LONG:
+                case typelib_TypeClass_UNSIGNED_LONG:
+                    if (ng < ppc64::MAX_GPR_REGS)
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 4*IS_BIG_ENDIAN);
+                        ng++;
+                        gpreg++;
+                    }
+                    else
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 4*IS_BIG_ENDIAN);
+                        bOverflowUsed = true;
+                    }
+                    if (bOverflowUsed) ovrflw++;
+                    break;
+                default:
+                    if (ng < ppc64::MAX_GPR_REGS)
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;
+                        ng++;
+                    }
+                    else
+                    {
+                        pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;
+                        bOverflowUsed = true;
+                    }
+                    if (bOverflowUsed) ovrflw++;
+                    break;
+                }
+
+                // no longer needed
+                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+        else // ptr to complex value | ref
+        {
+#if OSL_DEBUG_LEVEL > 2
+            fprintf(stderr, "complex, ng is %d\n", ng);
+#endif
+            void *pCppStack; //temporary stack pointer
+
+            if (ng < ppc64::MAX_GPR_REGS)
+            {
+                pCppArgs[nPos] = pCppStack = *gpreg++;
+                ng++;
+            }
+            else
+            {
+                pCppArgs[nPos] = pCppStack = *ovrflw;
+                bOverflowUsed = true;
+            }
+            if (bOverflowUsed) ovrflw++;
+
+            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;
+            }
+            else // direct way
+            {
+                pUnoArgs[nPos] = pCppStack;
+                // no longer needed
+                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+            }
+        }
+    }
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "end of params\n");
+#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 );
+
+    // 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;
+    }
+}
+
+#if _CALL_ELF == 2
+#  define PARAMSAVE 32
+#else
+#  define PARAMSAVE 48
+#endif
+
+static typelib_TypeClass cpp_mediate(
+    sal_uInt64 nOffsetAndIndex,
+        void ** gpreg, void ** fpreg, long sp,
+    sal_Int64 * pRegisterReturn /* space for register return */ )
+{
+    OSL_ENSURE( sizeof(sal_Int64)==sizeof(void *), "### unexpected!" );
+
+    sal_Int32 nVtableOffset = (nOffsetAndIndex >> 32);
+    sal_Int32 nFunctionIndex = (nOffsetAndIndex & 0xFFFFFFFF);
+
+    long sf = *(long*)sp;
+    void ** ovrflw = (void**)(sf + PARAMSAVE + 64);
+
+    // 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];
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "pThis is gpreg[1]\n");
+#endif
+    }
+    else
+    {
+    pThis = gpreg[0];
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "pThis is gpreg[0]\n");
+#endif
+    }
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "pThis is %lx\n", pThis);
+#endif
+
+    pThis = static_cast< char * >(pThis) - nVtableOffset;
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "pThis is now %lx\n", pThis);
+#endif
+
+    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
+        = bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
+            pThis);
+
+    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "indexes are %d %d\n", nFunctionIndex, pTypeDescr->nMapFunctionIndexToMemberIndex);
+#endif
+
+    OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
+    if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
+    {
+        throw RuntimeException(
+            OUString( "illegal vtable index!" ),
+            (XInterface *)pThis );
+    }
+
+    // determine called method
+    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
+    OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "members are %d %d\n", nMemberPos, pTypeDescr->nAllMembers);
+#endif
+
+    TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
+
+    typelib_TypeClass eRet;
+    switch (aMemberDescr.get()->eTypeClass)
+    {
+    case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+    {
+        if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
+        {
+            // is GET method
+            eRet = cpp2uno_call(
+                pCppI, aMemberDescr.get(),
+                ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,
+                0, 0, // no params
+                gpreg, fpreg, ovrflw, pRegisterReturn );
+        }
+        else
+        {
+            // is SET method
+            typelib_MethodParameter aParam;
+            aParam.pTypeRef =
+                ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;
+            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:
+    {
+        // is METHOD
+        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
+        {
+            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,
+                    (typelib_InterfaceTypeDescription *)pTD );
+
+                if (pInterface)
+                {
+                    ::uno_any_construct(
+                        reinterpret_cast< uno_Any * >( gpreg[0] ),
+                        &pInterface, pTD, cpp_acquire );
+                    pInterface->release();
+                    TYPELIB_DANGER_RELEASE( pTD );
+                    *(void **)pRegisterReturn = gpreg[0];
+                    eRet = typelib_TypeClass_ANY;
+                    break;
+                }
+                TYPELIB_DANGER_RELEASE( pTD );
+            }
+        } // else perform queryInterface()
+        default:
+            eRet = cpp2uno_call(
+                pCppI, aMemberDescr.get(),
+                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
+                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
+                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
+                gpreg, fpreg, ovrflw, pRegisterReturn );
+        }
+        break;
+    }
+    default:
+    {
+#if OSL_DEBUG_LEVEL > 2
+        fprintf(stderr, "screwed\n");
+#endif
+
+        throw RuntimeException(
+            OUString( "no member description found!" ),
+            (XInterface *)pThis );
+    }
+    }
+
+#if OSL_DEBUG_LEVEL > 2
+        fprintf(stderr, "end of cpp_mediate\n");
+#endif
+    return eRet;
+}
+
+extern "C" void privateSnippetExecutor( ... )
+{
+    sal_uInt64 gpreg[ppc64::MAX_GPR_REGS];
+    double fpreg[ppc64::MAX_SSE_REGS];
+
+    __asm__ __volatile__ (
+        "std 3,   0(%0)\t\n"
+        "std 4,   8(%0)\t\n"
+        "std 5,  16(%0)\t\n"
+        "std 6,  24(%0)\t\n"
+        "std 7,  32(%0)\t\n"
+        "std 8,  40(%0)\t\n"
+        "std 9,  48(%0)\t\n"
+        "std 10, 56(%0)\t\n"
+        "stfd 1,   0(%1)\t\n"
+        "stfd 2,   8(%1)\t\n"
+        "stfd 3,  16(%1)\t\n"
+        "stfd 4,  24(%1)\t\n"
+        "stfd 5,  32(%1)\t\n"
+        "stfd 6,  40(%1)\t\n"
+        "stfd 7,  48(%1)\t\n"
+        "stfd 8,  56(%1)\t\n"
+        "stfd 9,  64(%1)\t\n"
+        "stfd 10, 72(%1)\t\n"
+        "stfd 11, 80(%1)\t\n"
+        "stfd 12, 88(%1)\t\n"
+        "stfd 13, 96(%1)\t\n"
+    : : "r" (gpreg), "r" (fpreg)
+        : "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",
+          "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9",
+          "fr10", "fr11", "fr12", "fr13"
+    );
+
+    volatile long nOffsetAndIndex;
+
+    //mr %r3, %r11            # move into arg1 the 64bit value passed from OOo
+    __asm__ __volatile__ (
+                "mr     %0,    11\n\t"
+                : "=r" (nOffsetAndIndex) : );
+
+    volatile long sp;
+
+    //stack pointer
+    __asm__ __volatile__ (
+                "mr     %0,    1\n\t"
+                : "=r" (sp) : );
+
+#if _CALL_ELF == 2
+    volatile long nRegReturn[2];
+#else
+    volatile long nRegReturn[1];
+#endif
+
+    typelib_TypeClass aType =
+        cpp_mediate( nOffsetAndIndex, (void**)gpreg, (void**)fpreg, sp, (sal_Int64*)nRegReturn);
+
+    switch( aType )
+    {
+        case typelib_TypeClass_VOID:
+        break;
+        case typelib_TypeClass_BOOLEAN:
+        case typelib_TypeClass_BYTE:
+            __asm__( "lbz 3,%0\n\t"
+                : : "m" (nRegReturn[0]) );
+            break;
+        case typelib_TypeClass_CHAR:
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            __asm__( "lhz 3,%0\n\t"
+                : : "m" (nRegReturn[0]) );
+            break;
+        case typelib_TypeClass_SHORT:
+            __asm__( "lha 3,%0\n\t"
+                : : "m" (nRegReturn[0]) );
+            break;
+        case typelib_TypeClass_ENUM:
+        case typelib_TypeClass_UNSIGNED_LONG:
+            __asm__( "lwz 3,%0\n\t"
+                : : "m"(nRegReturn[0]) );
+            break;
+        case typelib_TypeClass_LONG:
+            __asm__( "lwa 3,%0\n\t"
+                : : "m"(nRegReturn[0]) );
+            break;
+        case typelib_TypeClass_FLOAT:
+            __asm__( "lfs 1,%0\n\t"
+                : : "m" (*((float*)nRegReturn)) );
+            break;
+        case typelib_TypeClass_DOUBLE:
+            __asm__( "lfd 1,%0\n\t"
+                : : "m" (*((double*)nRegReturn)) );
+            break;
+        default:
+            __asm__( "ld 3,%0\n\t"
+                : : "m" (nRegReturn[0]) );
+#if _CALL_ELF == 2
+            __asm__( "ld 4,%0\n\t"
+                : : "m" (nRegReturn[1]) );
+#endif
+            break;
+    }
+}
+
+#if _CALL_ELF == 2
+const int codeSnippetSize = 32;
+#else
+const int codeSnippetSize = 24;
+#endif
+
+unsigned char *  codeSnippet( unsigned char * code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+                              bool bHasHiddenParam)
+{
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr,"in codeSnippet functionIndex is %x\n", nFunctionIndex);
+    fprintf(stderr,"in codeSnippet vtableOffset is %x\n", nVtableOffset);
+#endif
+
+    sal_uInt64 nOffsetAndIndex = ( ( (sal_uInt64) nVtableOffset ) << 32 ) | ( (sal_uInt64) nFunctionIndex );
+
+    if ( bHasHiddenParam )
+        nOffsetAndIndex |= 0x80000000;
+#if _CALL_ELF == 2
+    unsigned int *raw = (unsigned int *)&code[0];
+
+    raw[0] = 0xe96c0018;        /* 0:   ld      11,2f-0b(12)    */
+    raw[1] = 0xe98c0010;        /*      ld      12,1f-0b(12)    */
+    raw[2] = 0x7d8903a6;        /*      mtctr   12              */
+    raw[3] = 0x4e800420;        /*      bctr                    */
+                                /* 1:   .quad   function_addr   */
+                                /* 2:   .quad   context         */
+    *(void **)&raw[4] = (void *)privateSnippetExecutor;
+    *(void **)&raw[6] = (void*)nOffsetAndIndex;
+#else
+    void ** raw = (void **)&code[0];
+    memcpy(raw, (char*) privateSnippetExecutor, 16);
+    raw[2] = (void*) nOffsetAndIndex;
+#endif
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "in: offset/index is %x %x %d, %lx\n",
+    nFunctionIndex, nVtableOffset, bHasHiddenParam, raw[2]);
+#endif
+    return (code + codeSnippetSize);
+}
+
+}
+
+void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const * bptr, unsigned char const * eptr)
+{
+    int const lineSize = 32;
+    for (unsigned char const * p = bptr; p < eptr + lineSize; p += lineSize) {
+        __asm__ volatile ("dcbst 0, %0" : : "r"(p) : "memory");
+    }
+    __asm__ volatile ("sync" : : : "memory");
+    for (unsigned char const * p = bptr; p < eptr + lineSize; p += lineSize) {
+        __asm__ volatile ("icbi 0, %0" : : "r"(p) : "memory");
+    }
+    __asm__ volatile ("isync" : : : "memory");
+}
+
+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)
+{
+    Slot * slots = mapBlockToVtable(block);
+    slots[-2].fn = 0;
+    slots[-1].fn = 0;
+    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;
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "in addLocalFunctions functionOffset is %x\n",functionOffset);
+    fprintf(stderr, "in addLocalFunctions vtableOffset is %x\n",vtableOffset);
+#endif
+
+    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 + writetoexecdiff;
+            code = codeSnippet(
+                code, functionOffset++, vtableOffset,
+                ppc64::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,
+                ppc64::return_in_hidden_param(
+                    reinterpret_cast<
+                    typelib_InterfaceMethodTypeDescription * >(
+                        member)->pReturnTypeRef));
+            break;
+
+        default:
+            OSL_ASSERT(false);
+            break;
+        }
+        TYPELIB_DANGER_RELEASE(member);
+    }
+    return code;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- /dev/null
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/except.cxx
@@ -0,0 +1,274 @@
+/* -*- 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 <boost/unordered_map.hpp>
+
+#include <rtl/strbuf.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <osl/mutex.hxx>
+
+#include <com/sun/star/uno/genfunc.hxx>
+#include <typelib/typedescription.hxx>
+#include <uno/any2.h>
+
+#include "share.hxx"
+
+
+using namespace ::std;
+using namespace ::osl;
+using namespace ::rtl;
+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 ) SAL_THROW(())
+{
+#if OSL_DEBUG_LEVEL > 1
+    char const * start = p;
+#endif
+
+    // example: N3com3sun4star4lang24IllegalArgumentExceptionE
+
+    OUStringBuffer buf( 64 );
+    OSL_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 OSL_DEBUG_LEVEL > 1
+    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 boost::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() SAL_THROW(());
+    ~RTTI() SAL_THROW(());
+
+    type_info * getRTTI( typelib_CompoundTypeDescription * ) SAL_THROW(());
+};
+
+RTTI::RTTI() SAL_THROW(())
+    : m_hApp( dlopen( 0, RTLD_LAZY ) )
+{
+}
+
+RTTI::~RTTI() SAL_THROW(())
+{
+    dlclose( m_hApp );
+}
+
+
+type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THROW(())
+{
+    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 ) ) );
+            OSL_ENSURE( 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 OSL_DEBUG_LEVEL > 1
+                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 ) ) );
+                OSL_ENSURE( 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 );
+    OSL_ENSURE( 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 )
+{
+    void * pCppExc;
+    type_info * rtti;
+
+    {
+    // construct cpp exception object
+    typelib_TypeDescription * pTypeDescr = 0;
+    TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );
+    OSL_ASSERT( pTypeDescr );
+    if (! pTypeDescr)
+        terminate();
+
+    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 );
+    OSL_ENSURE( rtti, "### no rtti for throwing exception!" );
+    if (! rtti)
+        terminate();
+    }
+
+    __cxa_throw( pCppExc, rtti, deleteException );
+}
+
+void fillUnoException( __cxa_exception * header, uno_Any * pExc, uno_Mapping * pCpp2Uno )
+{
+    OSL_ENSURE( header, "### no exception header!!!" );
+    if (! header)
+        terminate();
+
+    typelib_TypeDescription * pExcTypeDescr = 0;
+    OUString unoName( toUNOname( header->exceptionType->name() ) );
+    ::typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );
+    OSL_ENSURE( pExcTypeDescr, "### can not get type description for exception!!!" );
+    if (! pExcTypeDescr)
+        terminate();
+
+    // construct uno exception any
+    ::uno_any_constructAndConvert( pExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );
+    ::typelib_typedescription_release( pExcTypeDescr );
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- /dev/null
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/share.hxx
@@ -0,0 +1,92 @@
+/* -*- 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_FREEBSD_POWERPC64_SHARE_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_FREEBSD_POWERPC64_SHARE_HXX
+
+#include "uno/mapping.h"
+
+#include <typeinfo>
+#include <exception>
+#include <cstddef>
+
+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 );
+}
+
+namespace ppc64
+{
+    enum ppclimits { MAX_GPR_REGS = 8, MAX_SSE_REGS = 13 };
+    bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef );
+}
+
+#endif
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- /dev/null
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx
@@ -0,0 +1,659 @@
+/* -*- 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 <stdlib.h>
+
+#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"
+
+#include <stdio.h>
+#include <string.h>
+
+
+using namespace ::rtl;
+using namespace ::com::sun::star::uno;
+
+namespace ppc64
+{
+#if _CALL_ELF == 2
+    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;
+    }
+#endif
+
+    bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
+    {
+        if (bridges::cpp_uno::shared::isSimpleType(pTypeRef))
+            return false;
+#if _CALL_ELF == 2
+        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;
+        }
+#endif
+        return true;
+    }
+}
+
+void MapReturn(long r3, long r4, double dret, typelib_TypeDescriptionReference* pReturnType, void *pRegisterReturn)
+{
+    switch (pReturnType->eTypeClass)
+    {
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+            *reinterpret_cast<sal_uInt64 *>( pRegisterReturn ) = r3;
+            break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+    case typelib_TypeClass_ENUM:
+            *reinterpret_cast<sal_uInt32 *>( pRegisterReturn ) = r3;
+            break;
+    case typelib_TypeClass_CHAR:
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+            *reinterpret_cast<sal_uInt16 *>( pRegisterReturn ) = (unsigned short)r3;
+            break;
+    case typelib_TypeClass_BOOLEAN:
+    case typelib_TypeClass_BYTE:
+            *reinterpret_cast<sal_uInt8 *>( pRegisterReturn ) = (unsigned char)r3;
+            break;
+    case typelib_TypeClass_FLOAT:
+            *reinterpret_cast<float *>( pRegisterReturn ) = dret;
+        break;
+    case typelib_TypeClass_DOUBLE:
+            *reinterpret_cast<double *>( pRegisterReturn ) = dret;
+            break;
+#if _CALL_ELF == 2
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+            if (!ppc64::return_in_hidden_param(pReturnType))
+            {
+                sal_uInt64 *pRegisters = reinterpret_cast<sal_uInt64*>(pRegisterReturn);
+                pRegisters[0] = r3;
+                if (pReturnType->pType->nSize > 8)
+                    pRegisters[1] = r4;
+            }
+#endif
+    default:
+            break;
+    }
+}
+
+namespace
+{
+
+static void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex,
+    void * pRegisterReturn, typelib_TypeDescription * pReturnTypeDescr,
+        sal_uInt64 *pStack, sal_uInt32 nStack,
+        sal_uInt64 *pGPR, sal_uInt32 nGPR,
+        double *pFPR, sal_uInt32 nFPR)
+{
+    // Stack, if used, must be 16-bytes aligned
+    if ( nStack )
+        nStack = ( nStack + 1 ) & ~1;
+
+    // Should not happen, but...
+    if ( nFPR > ppc64::MAX_SSE_REGS )
+        nFPR = ppc64::MAX_SSE_REGS;
+    if ( nGPR > ppc64::MAX_GPR_REGS )
+        nGPR = ppc64::MAX_GPR_REGS;
+
+#if OSL_DEBUG_LEVEL > 2
+        // Let's figure out what is really going on here
+        {
+                fprintf( stderr, "= callVirtualMethod() =\nGPR's (%d): ", nGPR );
+                for ( int i = 0; i < nGPR; ++i )
+                        fprintf( stderr, "0x%lx, ", pGPR[i] );
+                fprintf( stderr, "\nFPR's (%d): ", nFPR );
+                for ( int i = 0; i < nFPR; ++i )
+                        fprintf( stderr, "0x%lx (%f), ", pFPR[i], pFPR[i] );
+                fprintf( stderr, "\nStack (%d): ", nStack );
+                for ( int i = 0; i < nStack; ++i )
+                        fprintf( stderr, "0x%lx, ", pStack[i] );
+                fprintf( stderr, "\n" );
+        }
+#endif
+
+    // Load parameters to stack, if necessary
+    sal_uInt64 *stack = (sal_uInt64 *) __builtin_alloca( nStack * 8 );
+    memcpy( stack, pStack, nStack * 8 );
+
+    // Get pointer to method
+    sal_uInt64 pMethod = *((sal_uInt64 *)pThis);
+    pMethod += 8 * nVtableIndex;
+    pMethod = *((sal_uInt64 *)pMethod);
+
+#if _CALL_ELF == 2
+    typedef void (* FunctionCall )(...);
+#else
+    typedef void (* FunctionCall )( sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64 );
+#endif
+    FunctionCall pFunc = (FunctionCall)pMethod;
+
+    volatile double dret;
+
+    //  fill registers
+    __asm__ __volatile__ (
+                "ld   3,  0(%0)\n\t"
+                "ld   4,  8(%0)\n\t"
+                "ld   5, 16(%0)\n\t"
+                "ld   6, 24(%0)\n\t"
+                "ld   7, 32(%0)\n\t"
+                "ld   8, 40(%0)\n\t"
+                "ld   9, 48(%0)\n\t"
+                "ld  10, 56(%0)\n\t"
+                "lfd  1,  0(%1)\n\t"
+                "lfd  2,  8(%1)\n\t"
+                "lfd  3, 16(%1)\n\t"
+                "lfd  4, 24(%1)\n\t"
+                "lfd  5, 32(%1)\n\t"
+                "lfd  6, 40(%1)\n\t"
+                "lfd  7, 48(%1)\n\t"
+                "lfd  8, 56(%1)\n\t"
+                "lfd  9, 64(%1)\n\t"
+                "lfd 10, 72(%1)\n\t"
+                "lfd 11, 80(%1)\n\t"
+                "lfd 12, 88(%1)\n\t"
+                "lfd 13, 96(%1)\n\t"
+                : : "r" (pGPR), "r" (pFPR)
+              : "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
+                  "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9",
+                  "fr10", "fr11", "fr12", "fr13"
+    );
+
+    // tell gcc that r3 to r11 are not available to it for doing the TOC and exception munge on the func call
+    register sal_uInt64 r3 asm("r3");
+    register sal_uInt64 r4 asm("r4");
+    register sal_uInt64 r5 asm("r5");
+    register sal_uInt64 r6 asm("r6");
+    register sal_uInt64 r7 asm("r7");
+    register sal_uInt64 r8 asm("r8");
+    register sal_uInt64 r9 asm("r9");
+    register sal_uInt64 r10 asm("r10");
+    register sal_uInt64 r11 asm("r11");
+
+    (*pFunc)(r3, r4, r5, r6, r7, r8, r9, r10);
+
+    // get return value
+    __asm__ __volatile__ (
+                "mr     %1,     3\n\t"
+                "mr     %2,     4\n\t"
+                "fmr    %0,     1\n\t"
+                : "=f" (dret), "=r" (r3), "=r" (r4) : );
+
+    MapReturn(r3, r4, dret, reinterpret_cast<typelib_TypeDescriptionReference *>(pReturnTypeDescr), pRegisterReturn);
+}
+
+// Macros for easier insertion of values to registers or stack
+// pSV - pointer to the source
+// nr - order of the value [will be increased if stored to register]
+// pFPR, pGPR - pointer to the registers
+// pDS - pointer to the stack [will be increased if stored here]
+
+// The value in %xmm register is already prepared to be retrieved as a float,
+// thus we treat float and double the same
+#define INSERT_FLOAT( pSV, nr, pFPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_SSE_REGS ) \
+                pFPR[nr++] = *reinterpret_cast<float *>( pSV ); \
+        else \
+            bOverflow = true; \
+        if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!
+
+#define INSERT_DOUBLE( pSV, nr, pFPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_SSE_REGS ) \
+                pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \
+        else \
+            bOverflow = true; \
+        if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!
+
+#define INSERT_INT64( pSV, nr, pGPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_GPR_REGS ) \
+                pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \
+        else \
+        bOverflow = true; \
+    if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV );
+
+#define INSERT_INT32( pSV, nr, pGPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_GPR_REGS ) \
+                pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
+        else \
+                bOverflow = true; \
+        if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
+
+#define INSERT_INT16( pSV, nr, pGPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_GPR_REGS ) \
+                pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
+        else \
+                bOverflow = true; \
+        if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
+
+#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow ) \
+        if ( nr < ppc64::MAX_GPR_REGS ) \
+                pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
+        else \
+                bOverflow = true; \
+        if (bOverflow) \
+                *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
+
+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 *)alloca( (nParams+3) * sizeof(sal_Int64) );
+      sal_uInt64 * pStackStart = pStack;
+
+    sal_uInt64 pGPR[ppc64::MAX_GPR_REGS];
+    sal_uInt32 nGPR = 0;
+
+    double pFPR[ppc64::MAX_SSE_REGS];
+    sal_uInt32 nFPR = 0;
+
+    // return
+    typelib_TypeDescription * pReturnTypeDescr = 0;
+    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
+    OSL_ENSURE( pReturnTypeDescr, "### expected return type description!" );
+
+    void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
+
+    bool bOverflow = false;
+    bool bSimpleReturn = true;
+
+    if (pReturnTypeDescr)
+    {
+#if OSL_DEBUG_LEVEL > 2
+        fprintf(stderr, "return type is %d\n", pReturnTypeDescr->eTypeClass);
+#endif
+        if (ppc64::return_in_hidden_param(pReturnTypeRef))
+            bSimpleReturn = false;
+
+        if (bSimpleReturn)
+        {
+            pCppReturn = pUnoReturn; // direct way for simple types
+#if OSL_DEBUG_LEVEL > 2
+            fprintf(stderr, "simple return\n");
+#endif
+        }
+        else
+        {
+            // complex return via ptr
+            pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
+                   ? alloca( pReturnTypeDescr->nSize ) : pUnoReturn);
+#if OSL_DEBUG_LEVEL > 2
+            fprintf(stderr, "pCppReturn/pUnoReturn is %lx/%lx", pCppReturn, pUnoReturn);
+#endif
+            INSERT_INT64( &pCppReturn, nGPR, pGPR, pStack, bOverflow );
+        }
+    }
+    // push "this" pointer
+        void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "this pointer is %p\n", pAdjustedThisPtr);
+#endif
+    INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack, bOverflow );
+
+        // 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;
+
+#if OSL_DEBUG_LEVEL > 2
+    fprintf(stderr, "n params is %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 OSL_DEBUG_LEVEL > 2
+        fprintf(stderr, "param %d is %d %d %d\n", nPos, rParam.bOut, bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ),
+            pParamTypeDescr->eTypeClass);
+#endif
+
+        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+        {
+//          uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,
+            uno_copyAndConvertData( pCppArgs[nPos] = pStack, pUnoArgs[nPos], pParamTypeDescr,
+                                    pThis->getBridge()->getUno2Cpp() );
+                switch (pParamTypeDescr->eTypeClass)
+                        {
+                        case typelib_TypeClass_HYPER:
+                        case typelib_TypeClass_UNSIGNED_HYPER:
+#if OSL_DEBUG_LEVEL > 2
+                fprintf(stderr, "hyper is %lx\n", pCppArgs[nPos]);
+#endif
+                                INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );
+                                break;
+                        case typelib_TypeClass_LONG:
+                        case typelib_TypeClass_UNSIGNED_LONG:
+                        case typelib_TypeClass_ENUM:
+#if OSL_DEBUG_LEVEL > 2
+                fprintf(stderr, "long is %x\n", pCppArgs[nPos]);
+#endif
+                                INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );
+                                break;
+                        case typelib_TypeClass_SHORT:
+                        case typelib_TypeClass_CHAR:
+                        case typelib_TypeClass_UNSIGNED_SHORT:
+                                INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );
+                                break;
+                        case typelib_TypeClass_BOOLEAN:
+                        case typelib_TypeClass_BYTE:
+                                INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );
+                                break;
+                        case typelib_TypeClass_FLOAT:
+                                INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, pStack, bOverflow );
+                break;
+                        case typelib_TypeClass_DOUBLE:
+                                INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack, bOverflow );
+                                break;
+                        }
+
+                        // no longer needed
+                        TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+
+        }
+        else // ptr to complex value | ref
+        {
+#if OSL_DEBUG_LEVEL > 2
+            fprintf(stderr, "complex type again %d\n", rParam.bIn);
+#endif
+                        if (! rParam.bIn) // is pure out
+                        {
+#if OSL_DEBUG_LEVEL > 2
+                fprintf(stderr, "complex size is %d\n", pParamTypeDescr->nSize );
+#endif
+                                // 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 ))
+                        {
+#if OSL_DEBUG_LEVEL > 2
+                fprintf(stderr, "this one\n");
+#endif
+                                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
+                        {
+#if OSL_DEBUG_LEVEL > 2
+                fprintf(stderr, "that one, passing %lx through\n", pUnoArgs[nPos]);
+#endif
+                                pCppArgs[nPos] = pUnoArgs[nPos];
+                                // no longer needed
+                                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+                        }
+                        INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack, bOverflow );
+        }
+    }
+
+    try
+    {
+               callVirtualMethod(
+                        pAdjustedThisPtr, aVtableSlot.index,
+                        pCppReturn, pReturnTypeDescr,
+                        pStackStart, ( pStack - pStackStart ),
+                        pGPR, nGPR,
+                        pFPR, nFPR );
+        // 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);
+
+    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 = ::getCppuType( &aExc );
+        // binary identical null reference
+        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
+    }
+    }
+}
+
+} } }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- /dev/null
+++ solenv/gbuild/platform/FREEBSD_POWERPC64_GCC.mk
@@ -0,0 +1,17 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+#please make generic modifications to unxgcc.mk or linux.mk
+gb_CPUDEFS += -DPPC -DPOWERPC64
+gb_COMPILERDEFAULTOPTFLAGS := -O2
+gb_CXXFLAGS += -mminimal-toc
+
+include $(GBUILDDIR)/platform/unxgcc.mk
+
+# vim: set noet sw=4:
--- canvas/source/cairo/cairo_canvashelper.cxx.orig
+++ canvas/source/cairo/cairo_canvashelper.cxx
@@ -17,6 +17,7 @@
  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  */
 
+#include <osl/endian.h>
 #include <canvas/debug.hxx>
 #include <tools/diagnose_ex.h>
 
--- canvas/source/tools/canvastools.cxx.orig
+++ canvas/source/tools/canvastools.cxx
@@ -58,6 +58,8 @@
 #include <vcl/window.hxx>
 #include <vcl/canvastools.hxx>
 
+#include <osl/endian.h>
+
 #include <canvas/canvastools.hxx>
 
 #include <limits>
--- connectivity/source/drivers/odbc/OTools.cxx.orig
+++ connectivity/source/drivers/odbc/OTools.cxx
@@ -26,7 +26,7 @@
 #include <rtl/ustrbuf.hxx>
 #include <boost/static_assert.hpp>
 
-
+#include <osl/endian.h>
 #include <string.h>
 #include <string>
 #include <algorithm>
--- cppcanvas/source/inc/implrenderer.hxx.orig
+++ cppcanvas/source/inc/implrenderer.hxx
@@ -30,6 +30,8 @@
 #include <action.hxx>
 #include <outdevstate.hxx>
 
+#include <osl/endian.h>
+
 #include <vector>
 #include <map>
 
--- desktop/source/deployment/misc/dp_platform.cxx.orig
+++ desktop/source/deployment/misc/dp_platform.cxx
@@ -52,6 +52,7 @@
 #define PLATFORM_SOLARIS_SPARC      "solaris_sparc"
 #define PLATFORM_SOLARIS_SPARC64    "solaris_sparc64"
 #define PLATFORM_SOLARIS_X86        "solaris_x86"
+#define PLATFORM_FREEBSD_POWERPC64  "freebsd_powerpc64"
 #define PLATFORM_FREEBSD_X86        "freebsd_x86"
 #define PLATFORM_FREEBSD_X86_64     "freebsd_x86_64"
 #define PLATFORM_NETBSD_X86         "netbsd_x86"
@@ -158,6 +159,8 @@
             ret = checkOSandCPU("Solaris", "SPARC64");
         else if (token == PLATFORM_SOLARIS_X86)
             ret = checkOSandCPU("Solaris", "x86");
+        else if (token == PLATFORM_FREEBSD_POWERPC64)
+            ret = checkOSandCPU("FreeBSD", "POWERPC64");
         else if (token == PLATFORM_FREEBSD_X86)
             ret = checkOSandCPU("FreeBSD", "x86");
         else if (token == PLATFORM_FREEBSD_X86_64)
--- include/basebmp/rgbmaskpixelformats.hxx.orig
+++ include/basebmp/rgbmaskpixelformats.hxx
@@ -31,6 +31,8 @@
 #include <vigra/numerictraits.hxx>
 #include <vigra/metaprogramming.hxx>
 
+#include <osl/endian.h>
+
 #include <functional>
 
 namespace basebmp
--- include/osl/endian.h.orig
+++ include/osl/endian.h
@@ -80,13 +80,11 @@
 #ifdef FREEBSD
 #   include <sys/param.h>
 #   include <machine/endian.h>
-#if __FreeBSD_version < 500000
-#   if BYTE_ORDER == LITTLE_ENDIAN
-#       define _LITTLE_ENDIAN
-#   elif BYTE_ORDER == BIG_ENDIAN
-#       define _BIG_ENDIAN
-#   endif
-#endif
+#   if BYTE_ORDER == LITTLE_ENDIAN
+#   undef _BIG_ENDIAN
+#   elif BYTE_ORDER == BIG_ENDIAN
+#   undef _LITTLE_ENDIAN
+#   endif
 #endif
 
 #ifdef AIX
--- include/tools/stream.hxx.orig
+++ include/tools/stream.hxx
@@ -27,6 +27,7 @@
 #include <tools/ref.hxx>
 #include <tools/rtti.hxx>
 #include <rtl/string.hxx>
+#include <osl/endian.h>
 
 class StreamData;
 
--- lotuswordpro/source/filter/lwpobjstrm.cxx.orig
+++ lotuswordpro/source/filter/lwpobjstrm.cxx
@@ -61,6 +61,8 @@
 #include "lwpobjstrm.hxx"
 #include "lwptools.hxx"
 #include <boost/scoped_array.hpp>
+
+#include <osl/endian.h>
 
 /**
  * @descr  ctor() from LwpSvStream
--- oox/source/helper/binaryoutputstream.cxx.orig
+++ oox/source/helper/binaryoutputstream.cxx
@@ -23,6 +23,8 @@
 #include <com/sun/star/io/XSeekable.hpp>
 #include <osl/diagnose.h>
 #include <string.h>
+
+#include <osl/endian.h>
 
 namespace oox {
 
--- store/workben/t_page.cxx.orig
+++ store/workben/t_page.cxx
@@ -26,6 +26,7 @@
 
 #include "storbase.hxx"
 
+#include "osl/endian.h"
 #include "osl/file.h"
 #include "rtl/ustring.hxx"
 
--- sw/source/filter/ww8/ww8scan.cxx.orig
+++ sw/source/filter/ww8/ww8scan.cxx
@@ -23,6 +23,7 @@
 #include <functional>
 #include <algorithm>
 
+#include <osl/endian.h>
 #include <string.h>
 #include <i18nlangtag/mslangid.hxx>
 #include <sprmids.hxx>
--- sw/source/filter/ww8/ww8scan.hxx.orig
+++ sw/source/filter/ww8/ww8scan.hxx
@@ -31,6 +31,7 @@
 #include <algorithm>
 
 #include <boost/unordered_map.hpp>
+#include <osl/endian.h>
 #include <tools/solar.h>
 #include <tools/stream.hxx>
 #include <rtl/ustring.hxx>
--- sw/source/core/uibase/dochdl/swdtflvr.cxx.orig
+++ sw/source/core/uibase/dochdl/swdtflvr.cxx
@@ -118,6 +118,8 @@
 #include <swserv.hxx>
 #include <switerator.hxx>
 
+#include <osl/endian.h>
+
 #include <vcl/GraphicNativeTransform.hxx>
 #include <vcl/GraphicNativeMetadata.hxx>
 
--- testtools/CustomTarget_uno_test.mk.orig
+++ testtools/CustomTarget_uno_test.mk
@@ -13,17 +13,17 @@
 .PHONY : $(call gb_CustomTarget_get_target,testtools/uno_test)
 
 $(call gb_CustomTarget_get_target,testtools/uno_test) : \
-		$(call gb_Executable_get_runtime_dependencies,uno) \
-		$(call gb_InternalUnoApi_get_target,bridgetest) \
-		$(call gb_Rdb_get_target,uno_services) \
-		$(call gb_Rdb_get_target,ure/services) \
-		$(call gb_UnoApi_get_target,udkapi)
-	$(call gb_Helper_abbreviate_dirs,\
-		$(call gb_Executable_get_command,uno) \
-		-s com.sun.star.test.bridge.BridgeTest \
-		-- com.sun.star.test.bridge.CppTestObject \
-		-env:LO_BUILD_LIB_DIR=$(call gb_Helper_make_url,$(gb_Library_WORKDIR_FOR_BUILD)) \
-		-env:URE_MORE_SERVICES=$(call gb_Helper_make_url,$(call gb_Rdb_get_target,uno_services)) \
-		-env:URE_MORE_TYPES=$(call gb_Helper_make_url,$(WORKDIR)/UnoApiTarget/bridgetest.rdb))
+#		$(call gb_Executable_get_runtime_dependencies,uno) \
+#		$(call gb_InternalUnoApi_get_target,bridgetest) \
+#		$(call gb_Rdb_get_target,uno_services) \
+#		$(call gb_Rdb_get_target,ure/services) \
+#		$(call gb_UnoApi_get_target,udkapi)
+#	$(call gb_Helper_abbreviate_dirs,\
+#		$(call gb_Executable_get_command,uno) \
+#		-s com.sun.star.test.bridge.BridgeTest \
+#		-- com.sun.star.test.bridge.CppTestObject \
+#		-env:LO_BUILD_LIB_DIR=$(call gb_Helper_make_url,$(gb_Library_WORKDIR_FOR_BUILD)) \
+#		-env:URE_MORE_SERVICES=$(call gb_Helper_make_url,$(call gb_Rdb_get_target,uno_services)) \
+#		-env:URE_MORE_TYPES=$(call gb_Helper_make_url,$(WORKDIR)/UnoApiTarget/bridgetest.rdb))
 
 # vim:set shiftwidth=4 tabstop=4 noexpandtab:
--- vcl/generic/glyphs/gcach_ftyp.cxx.orig
+++ vcl/generic/glyphs/gcach_ftyp.cxx
@@ -36,6 +36,7 @@
 #include "basegfx/matrix/b2dhommatrixtools.hxx"
 #include "basegfx/polygon/b2dpolypolygon.hxx"
 
+#include "osl/endian.h"
 #include "osl/file.hxx"
 #include "osl/thread.hxx"
 
--- vcl/headless/svpvd.cxx.orig
+++ vcl/headless/svpvd.cxx
@@ -18,6 +18,8 @@
  */
 
 #ifndef IOS
+
+#include <osl/endian.h>
 
 #include "headless/svpbmp.hxx"
 #include "headless/svpvd.hxx"
--- vcl/headless/svpgdi.cxx.orig
+++ vcl/headless/svpgdi.cxx
@@ -21,6 +21,8 @@
 #include "headless/svpbmp.hxx"
 #include "saldatabasic.hxx"
 
+#include <osl/endian.h>
+
 #include <vcl/sysdata.hxx>
 #include <basegfx/range/b2drange.hxx>
 #include <basegfx/range/b2ibox.hxx>
--- vcl/headless/svpbmp.cxx.orig
+++ vcl/headless/svpbmp.cxx
@@ -26,6 +26,8 @@
 #include <basebmp/scanlineformats.hxx>
 #include <basebmp/color.hxx>
 
+#include <osl/endian.h>
+
 #include <vcl/salbtype.hxx>
 #include <vcl/bitmap.hxx>
 
--- vcl/source/filter/jpeg/Exif.cxx.orig
+++ vcl/source/filter/jpeg/Exif.cxx
@@ -19,6 +19,7 @@
 
 #include "Exif.hxx"
 #include <boost/scoped_array.hpp>
+#include <osl/endian.h>
 
 Exif::Exif() :
     maOrientation(TOP_LEFT),

Return to bug 200020